container.ts/modules/process/ChildProcess.d.ts

Modular application framework

import { Observable } from "rxjs/Observable";
import "rxjs/add/observable/fromEvent";
import "rxjs/add/operator/map";
import "rxjs/add/operator/mergeMap";
import "rxjs/add/operator/filter";
import "rxjs/add/operator/timeout";
import "rxjs/add/operator/takeWhile";
import { IContainerLogMessage, IContainerModuleOpts, Container } from "../../container";
import { Process } from "./Process";
/** Process message types. */
export declare enum EProcessMessageType {
    Log = 0,
    Metric = 1,
    CallRequest = 2,
    CallResponse = 3,
    User = 4,
}
/** Process error object. */
export interface IProcessError {
    name?: string;
    message?: string;
    stack?: string;
}
/** Process error class. */
export declare class ProcessError extends Error implements IProcessError {
    constructor(name: string, message: string, stack: string);
}
/** Process call method options. */
export interface IProcessCallOptions {
    timeout?: number;
    args?: any[];
}
/** Process call function signature. */
export declare type ProcessCallType = (...args: any[]) => Observable<any>;
/** Process call request message data. */
export interface IProcessCallRequestData {
    id: number;
    target: string;
    method: string;
    args: any[];
}
/** Process call response message data. */
export interface IProcessCallResponseData {
    id: number;
    next?: any;
    error?: IProcessError;
    complete?: boolean;
}
/** Process data types. */
export declare type ProcessMessageData = IContainerLogMessage | IProcessCallRequestData | IProcessCallResponseData | any;
/** Process message interface. */
export interface IProcessMessage extends Object {
    type: EProcessMessageType;
    data: ProcessMessageData;
}
/** Process send method interface. */
export interface IProcessSend {
    send: (type: EProcessMessageType, data: any) => void;
}
export declare class ChildProcess extends Process implements IProcessSend {
    /** Default call method timeout. */
    static DEFAULT_TIMEOUT: number;
    /** Extract serialisable error properties to object. */
    static serialiseError(error: Error): IProcessError;
    /** Convert serialised error to error instance. */
    static deserialiseError(error: IProcessError): ProcessError;
    /** Handle method call requests. */
    static handleCallRequest(emitter: IProcessSend, container: Container, data: IProcessCallRequestData): void;
    /** Handle method call responses. */
    static handleCallResponse<T>(messageObservable: Observable<IProcessMessage>, id: number, args: any[], timeout: number): Observable<T>;
    private _message;
    /** Messages received from parent process. */
    readonly message: Observable<IProcessMessage>;
    constructor(name: string, opts: IContainerModuleOpts);
    /** Send message to parent process. */
    send(type: EProcessMessageType, data: any): void;
    /** Make call to module.method in parent process. */
    call<T>(target: string, method: string, options?: IProcessCallOptions): Observable<T>;
    /** Handle messages received from parent process. */
    protected handleMessage(message: IProcessMessage): void;
}