sdg/types/interfaces/IConnector.d.ts

pomelo ts

/// <reference types="node" />
import { IObject } from './common';
import { IConnectorOpts } from './opts';
export declare type UID = string;
export declare type SID = number;
export declare type FRONTEND_ID = string;
export interface IHandlerMsg {
    __route__: string;
    [key: string]: any;
}
export declare type IMsgRsp = IObject;
export declare type IRoute = string | number;
export declare type IReqBody = IObject | Buffer;
export declare type IRspData = IObject | Buffer;
export declare type IMsgReqEncode = {
    route: IRoute;
    body: IReqBody;
};
export declare type IMsgRspEncode = {
    route?: IRoute;
    data: IRspData;
    ts: number;
};
export declare type IMsgReqDecode = {
    route: string;
    body: IObject;
};
export declare type IReceiveId = UID | SID;
export interface IRouteRecord {
    route: string;
    serverType: string;
    handler: string;
    method: string;
}
export declare type TransformRsp = (data: any) => any;
export declare type IEncoder = (route: IRoute, msg: IMsgRsp) => IRspData;
export declare type IDecoder = (route: IRoute, msg: IReqBody) => IObject;
export declare type IBlackListFunction = () => Promise<string[]>;
export interface IConnector {
    start(): void;
    stop(force: boolean): void;
    encode?: IEncoder;
    decode?: IDecoder;
    on(evt: 'connection', listener: (socket: IConnectorSocket) => Promise<void>): void;
}
export interface IConnectorComponentOptions extends IConnectorOpts {
    encode?: IEncoder;
    decode?: IDecoder;
    transformRsp?: TransformRsp;
    useCrypto?: boolean;
    useHostFilter?: boolean;
    useAsyncCoder?: boolean;
    blacklistFun?: IBlackListFunction;
    useDict?: boolean;
    useProtobuf?: boolean;
    forwardMsg?: boolean;
}
export interface IConnectorSocket {
    state: number;
    id: number;
    ip: string;
    once(evt: 'disconnect', listener: () => void): void;
    once(evt: 'error', listener: () => void): void;
    on(evt: 'disconnect', listener: (reason: string) => void): void;
    on(evt: 'error', listener: (reason: string) => void): void;
    on(evt: 'message', listener: (msg: any, cb?: (err?: Error | null, result?: any) => void) => void): void;
    on(evt: 'closing', listener: (reason?: string) => void): void;
    send(msg: IMsgRspEncode): void;
    sendRaw(msg: IMsgRspEncode): void;
    disconnect(): void;
    sendBatch(msgs: IMsgRspEncode[]): void;
    emit(evt: 'heartbeat'): void;
    emit(evt: 'message', pkg: any): void;
    emit(evt: 'closing', reason?: string): void;
    emit(evt: 'handshake', pkg: any): void;
    handshakeResponse?: (response: any) => void;
    sendForce?: (response: any) => void;
    remoteAddress?: {
        ip: string;
        port?: number;
    };
}