socket-actions/dist/types/helpers.d.ts

Websocket implementation to simplify communication and queueing of user actions.

/// <reference types="node" />
import ws, { ServerOptions } from 'ws';
import { Server, IncomingMessage } from 'http';

type MessageObject$3 = MessageEvent & {
    requestId?: string;
};
type onOpen$1 = () => Promise<void> | void;
type onClose$3 = () => Promise<void> | void;
type messageReceiver$1 = (message: MessageObject$3) => Promise<void> | void;
type clientOptions$1 = {
    url?: string;
    authentication?: any;
    connectionTryLimit?: number;
    secondsBetweenRetries?: number;
    protocols?: string | string[];
    onOpen?: onOpen$1;
    onClose?: onClose$3;
    onMessage?: messageReceiver$1;
    onAuthResponse?: messageReceiver$1;
    onAuthFailure?: messageReceiver$1;
};
declare class Client$1 {
    private _authentication;
    private _socket;
    private readonly url;
    private readonly protocols;
    private readonly preparedOnAuthResponse;
    private readonly preparedOnMessageResponse;
    private readonly onMessage;
    private readonly onAuthResponse;
    private readonly onOpen;
    private readonly onClose;
    private readonly onAuthFailure;
    private connectionTries;
    private readonly connectionTryLimit;
    private readonly secondsBetweenRetries;
    private _isAuthenticated;
    private _isConnected;
    private requests;
    constructor(options?: clientOptions$1);
    private connect;
    reconnect(): void;
    private opening;
    private closing;
    close(code?: number | undefined, reason?: string | undefined): void;
    private enableMessageReceiver;
    private disableMessageReceiver;
    private authResponse;
    private messageResponse;
    get authentication(): any;
    get isAuthenticated(): boolean;
    get isConnected(): boolean;
    get socket(): WebSocket | null;
    tryAuth(authentication?: any): void;
    sendAction(path: string, data?: Record<string, any>, extraDetails?: Record<string, any>): void;
    sendRequest(path: string, data?: Record<string, any>, timeout?: number): Promise<Record<string, any>>;
}

type DataType$1 = Record<string, any>;
type ClientSocket$1 = ws & {
    userData: DataType$1;
};
type MessageObject$2 = {
    path: string;
    data: DataType$1;
    requestId?: string;
};
type sendMessageToAllOptions$1 = {
    exceptions: ClientSocket$1[] | string[];
};
type onConnection$1 = (socket: ClientSocket$1, req: IncomingMessage) => Promise<void> | void;
type onAuth$1 = (socket: ClientSocket$1, message: Buffer) => Promise<void> | void;
type onAuthSuccess$1 = (socket: ClientSocket$1, message: Buffer) => Promise<void> | void;
type onAuthFailure$1 = (socket: ClientSocket$1, error: Error, message: Buffer) => Promise<void> | void;
type onMessage$1 = (socket: ClientSocket$1, messageObject: MessageObject$2) => Promise<void> | void;
type onClose$2 = (socket: ClientSocket$1) => Promise<void> | void;
type onError$1 = (socket: ClientSocket$1, err: Error) => Promise<void> | void;
type SocketOptions$1 = {
    serverOptions?: ServerOptions;
    actionsPath?: string;
    actions?: Record<string, Action$1>;
    disableAuthentication?: boolean;
    onConnection?: onConnection$1;
    onAuth?: onAuth$1;
    onAuthSuccess?: onAuthSuccess$1;
    onAuthFailure?: onAuthFailure$1;
    onClose?: onClose$2;
    onError?: onError$1;
    onMessage?: onMessage$1;
};
declare class Socket$1 {
    protected _server: Server | undefined;
    protected readonly onConnection: onConnection$1;
    protected readonly onAuth: onAuth$1;
    protected readonly onAuthSuccess: onAuthSuccess$1;
    protected readonly onAuthFailure: onAuthFailure$1;
    protected readonly onClose: onClose$2;
    protected readonly onError: onError$1;
    protected readonly onMessage: onMessage$1;
    protected readonly Actions: Record<string, Action$1>;
    protected readonly disableAuthentication: boolean;
    protected readonly _activeClients: ClientSocket$1[];
    private wsInstance;
    private readonly serverOptions;
    constructor(options: SocketOptions$1);
    initActions({ actions, actionsPath }: SocketOptions$1): Promise<void>;
    start(): Promise<void>;
    restart(): Promise<void>;
    protected prepareAllActions(): Promise<void>;
    protected connecting(socket: ClientSocket$1, req: IncomingMessage): Promise<void>;
    protected authenticating(socket: ClientSocket$1, message: Buffer): Promise<void>;
    protected receivingMessage(socket: ClientSocket$1, message: string): Promise<void>;
    protected reportingError(socket: ClientSocket$1, err: Error): Promise<void>;
    protected closing(socket: ClientSocket$1): Promise<void>;
    closeSocket(cb?: ((err?: Error | undefined) => void) | undefined): void;
    close(socketCallback?: ((err?: Error | undefined) => void) | undefined, expressCallback?: (err?: Error | undefined) => void): void;
    get activeClients(): DataType$1[];
    get server(): Server | undefined;
    sendMessage(socket: ClientSocket$1, data: DataType$1 | string): void;
    sendMessageById(id: string, data: DataType$1 | string): void;
    sendMessageToAll(data: DataType$1 | string, { exceptions }: sendMessageToAllOptions$1): void;
}

type ActionParameters$1 = {
    socket: ClientSocket$1;
    userData: DataType$1;
    requestId: string | undefined;
    data: DataType$1;
};
type OnRunParameters$1 = {
    socket: ClientSocket$1;
    userData: DataType$1;
    data: DataType$1;
    respond: (data: DataType$1) => void;
};
declare abstract class Action$1 {
    protected server: Socket$1 | null;
    prepareAction(server: Socket$1): Promise<void>;
    protected onCheckPermissions(_parameters: ActionParameters$1): Promise<void> | void;
    protected onError(_parameters: ActionParameters$1, err: unknown): Promise<void> | void;
    run(parameters: ActionParameters$1): Promise<void>;
    abstract onRun(data: OnRunParameters$1): Promise<void> | void;
}

type ActionParameters = {
    socket: ClientSocket;
    userData: DataType;
    requestId: string | undefined;
    data: DataType;
};
type OnRunParameters = {
    socket: ClientSocket;
    userData: DataType;
    data: DataType;
    respond: (data: DataType) => void;
};
declare abstract class Action {
    protected server: Socket | null;
    prepareAction(server: Socket): Promise<void>;
    protected onCheckPermissions(_parameters: ActionParameters): Promise<void> | void;
    protected onError(_parameters: ActionParameters, err: unknown): Promise<void> | void;
    run(parameters: ActionParameters): Promise<void>;
    abstract onRun(data: OnRunParameters): Promise<void> | void;
}

type DataType = Record<string, any>;
type ClientSocket = ws & {
    userData: DataType;
};
type MessageObject$1 = {
    path: string;
    data: DataType;
    requestId?: string;
};
type sendMessageToAllOptions = {
    exceptions: ClientSocket[] | string[];
};
type onConnection = (socket: ClientSocket, req: IncomingMessage) => Promise<void> | void;
type onAuth = (socket: ClientSocket, message: Buffer) => Promise<void> | void;
type onAuthSuccess = (socket: ClientSocket, message: Buffer) => Promise<void> | void;
type onAuthFailure = (socket: ClientSocket, error: Error, message: Buffer) => Promise<void> | void;
type onMessage = (socket: ClientSocket, messageObject: MessageObject$1) => Promise<void> | void;
type onClose$1 = (socket: ClientSocket) => Promise<void> | void;
type onError = (socket: ClientSocket, err: Error) => Promise<void> | void;
type SocketOptions = {
    serverOptions?: ServerOptions;
    actionsPath?: string;
    actions?: Record<string, Action>;
    disableAuthentication?: boolean;
    onConnection?: onConnection;
    onAuth?: onAuth;
    onAuthSuccess?: onAuthSuccess;
    onAuthFailure?: onAuthFailure;
    onClose?: onClose$1;
    onError?: onError;
    onMessage?: onMessage;
};
declare class Socket {
    protected _server: Server | undefined;
    protected readonly onConnection: onConnection;
    protected readonly onAuth: onAuth;
    protected readonly onAuthSuccess: onAuthSuccess;
    protected readonly onAuthFailure: onAuthFailure;
    protected readonly onClose: onClose$1;
    protected readonly onError: onError;
    protected readonly onMessage: onMessage;
    protected readonly Actions: Record<string, Action>;
    protected readonly disableAuthentication: boolean;
    protected readonly _activeClients: ClientSocket[];
    private wsInstance;
    private readonly serverOptions;
    constructor(options: SocketOptions);
    initActions({ actions, actionsPath }: SocketOptions): Promise<void>;
    start(): Promise<void>;
    restart(): Promise<void>;
    protected prepareAllActions(): Promise<void>;
    protected connecting(socket: ClientSocket, req: IncomingMessage): Promise<void>;
    protected authenticating(socket: ClientSocket, message: Buffer): Promise<void>;
    protected receivingMessage(socket: ClientSocket, message: string): Promise<void>;
    protected reportingError(socket: ClientSocket, err: Error): Promise<void>;
    protected closing(socket: ClientSocket): Promise<void>;
    closeSocket(cb?: ((err?: Error | undefined) => void) | undefined): void;
    close(socketCallback?: ((err?: Error | undefined) => void) | undefined, expressCallback?: (err?: Error | undefined) => void): void;
    get activeClients(): DataType[];
    get server(): Server | undefined;
    sendMessage(socket: ClientSocket, data: DataType | string): void;
    sendMessageById(id: string, data: DataType | string): void;
    sendMessageToAll(data: DataType | string, { exceptions }: sendMessageToAllOptions): void;
}

type MessageObject = MessageEvent & {
    requestId?: string;
};
type onOpen = () => Promise<void> | void;
type onClose = () => Promise<void> | void;
type messageReceiver = (message: MessageObject) => Promise<void> | void;
type clientOptions = {
    url?: string;
    authentication?: any;
    connectionTryLimit?: number;
    secondsBetweenRetries?: number;
    protocols?: string | string[];
    onOpen?: onOpen;
    onClose?: onClose;
    onMessage?: messageReceiver;
    onAuthResponse?: messageReceiver;
    onAuthFailure?: messageReceiver;
};
declare class Client {
    private _authentication;
    private _socket;
    private readonly url;
    private readonly protocols;
    private readonly preparedOnAuthResponse;
    private readonly preparedOnMessageResponse;
    private readonly onMessage;
    private readonly onAuthResponse;
    private readonly onOpen;
    private readonly onClose;
    private readonly onAuthFailure;
    private connectionTries;
    private readonly connectionTryLimit;
    private readonly secondsBetweenRetries;
    private _isAuthenticated;
    private _isConnected;
    private requests;
    constructor(options?: clientOptions);
    private connect;
    reconnect(): void;
    private opening;
    private closing;
    close(code?: number | undefined, reason?: string | undefined): void;
    private enableMessageReceiver;
    private disableMessageReceiver;
    private authResponse;
    private messageResponse;
    get authentication(): any;
    get isAuthenticated(): boolean;
    get isConnected(): boolean;
    get socket(): WebSocket | null;
    tryAuth(authentication?: any): void;
    sendAction(path: string, data?: Record<string, any>, extraDetails?: Record<string, any>): void;
    sendRequest(path: string, data?: Record<string, any>, timeout?: number): Promise<Record<string, any>>;
}

type FactoryPromise = (...args: any[]) => Promise<void>;
type FactoryFunction = (...args: any[]) => void;
declare const listenerFactory: (ctx: Socket | Client, socket: ClientSocket | null, callback: FactoryPromise) => FactoryFunction;

declare const parseCookies: (cookieString: string) => any;

declare function sleep(miliseconds: number): Promise<unknown>;

declare const _default: {
    default(miliseconds: number): Promise<unknown>;
    ListenerFactory: (ctx: Socket$1 | Client$1, socket: ClientSocket$1 | null, callback: FactoryPromise) => FactoryFunction;
    ParseCookies: (cookieString: string) => any;
    Sleep: typeof sleep;
};

export { type FactoryFunction, type FactoryPromise, listenerFactory as ListenerFactory, parseCookies as ParseCookies, sleep as Sleep, _default as default };