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

Websocket implementation to simplify communication and queueing of user actions.

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

type DataType = Record<string, any>;
type ClientSocket = ws & {
    userData: DataType;
};
type MessageObject = {
    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) => Promise<void> | void;
type onClose = (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;
    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;
    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 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;
}

declare const _default: {
    default: typeof Socket;
    Action: typeof Action;
    Socket: typeof Socket;
};

export { Action, type ActionParameters, type ClientSocket, type DataType, type MessageObject, type OnRunParameters, Socket, type SocketOptions, _default as default, type onAuth, type onAuthFailure, type onAuthSuccess, type onClose, type onConnection, type onError, type onMessage };