@socket-mesh/server 18.0.6 → 18.1.0

package/server.js

@@ -1,361 +0,0 @@
-import { AuthEngine } from "./auth-engine.js";
-import formatter from "@socket-mesh/formatter";
-import { SimpleBroker } from "@socket-mesh/simple-broker";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { InvalidArgumentsError, InvalidOptionsError, InvalidActionError, ServerProtocolError, SilentMiddlewareBlockedError } from "@socket-mesh/errors";
-import { MiddlewareType } from "./middleware-type.js";
-import { MiddlewareStream } from "./middleware-stream.js";
-import { ActionHandshakeWS } from "./action.js";
-import { WebSocketServer } from 'ws';
-import base64id from 'base64id';
-import { ServerSocket } from "./serversocket.js";
-import url from "url";
-import crypto from "crypto";
-export class Server extends AsyncStreamEmitter {
-    allowClientPublish;
-    auth;
-    clientsCount;
-    codec;
-    defaultVerificationOptions;
-    defaultSignatureOptions;
-    isReady;
-    httpServer;
-    middlewareEmitFailures;
-    pendingClientsCount;
-    ackTimeout;
-    handshakeTimeout;
-    options;
-    path;
-    perMessageDeflate;
-    pingInterval;
-    pingTimeout;
-    pingTimeoutDisabled;
-    protocolVersion;
-    origins;
-    signatureKey;
-    strictHandshake;
-    socketChannelLimit;
-    verificationKey;
-    clients;
-    pendingClients;
-    brokerEngine;
-    exchange;
-    wsServer;
-    _allowAllOrigins;
-    _path;
-    _middleware;
-    constructor(options) {
-        super();
-        let opts = {
-            brokerEngine: new SimpleBroker(),
-            wsEngine: 'ws',
-            wsEngineServerOptions: {},
-            maxPayload: null,
-            allowClientPublish: true,
-            ackTimeout: 10000,
-            handshakeTimeout: 10000,
-            strictHandshake: true,
-            pingTimeout: 20000,
-            pingTimeoutDisabled: false,
-            pingInterval: 8000,
-            origins: '*:*',
-            path: '/socketcluster/',
-            protocolVersion: 2,
-            authDefaultExpiry: 86400,
-            batchOnHandshake: false,
-            batchOnHandshakeDuration: 400,
-            batchInterval: 50,
-            middlewareEmitFailures: true,
-            socketStreamCleanupMode: 'kill',
-            cloneData: false
-        };
-        this.options = Object.assign(opts, options);
-        this._middleware = {};
-        this.origins = opts.origins;
-        this._allowAllOrigins = this.origins.indexOf('*:*') !== -1;
-        this.ackTimeout = opts.ackTimeout;
-        this.handshakeTimeout = opts.handshakeTimeout;
-        this.pingInterval = opts.pingInterval;
-        this.pingTimeout = opts.pingTimeout;
-        this.pingTimeoutDisabled = opts.pingTimeoutDisabled;
-        this.allowClientPublish = opts.allowClientPublish;
-        this.perMessageDeflate = opts.perMessageDeflate;
-        this.httpServer = opts.httpServer;
-        this.socketChannelLimit = opts.socketChannelLimit;
-        this.protocolVersion = opts.protocolVersion;
-        this.strictHandshake = opts.strictHandshake;
-        this.brokerEngine = opts.brokerEngine;
-        this.middlewareEmitFailures = opts.middlewareEmitFailures;
-        this._path = opts.path;
-        (async () => {
-            for await (let { error } of this.brokerEngine.listen('error')) {
-                this.emitWarning(error);
-            }
-        })();
-        if (this.brokerEngine.isReady) {
-            this.isReady = true;
-            this.emit('ready', {});
-        }
-        else {
-            this.isReady = false;
-            (async () => {
-                await this.brokerEngine.listen('ready').once();
-                this.isReady = true;
-                this.emit('ready', {});
-            })();
-        }
-        //		let wsEngine = typeof opts.wsEngine === 'string' ? require(opts.wsEngine) : opts.wsEngine;
-        //		if (!wsEngine || !wsEngine.Server) {
-        //			throw new InvalidOptionsError(
-        //				'The wsEngine option must be a path or module name which points ' +
-        //				'to a valid WebSocket engine module with a compatible interface'
-        //			);
-        //		}
-        //		let WSServer = wsEngine.Server;
-        if (opts.authPrivateKey != null || opts.authPublicKey != null) {
-            if (opts.authPrivateKey == null) {
-                throw new InvalidOptionsError('The authPrivateKey option must be specified if authPublicKey is specified');
-            }
-            else if (opts.authPublicKey == null) {
-                throw new InvalidOptionsError('The authPublicKey option must be specified if authPrivateKey is specified');
-            }
-            this.signatureKey = opts.authPrivateKey;
-            this.verificationKey = opts.authPublicKey;
-        }
-        else {
-            if (opts.authKey == null) {
-                opts.authKey = crypto.randomBytes(32).toString('hex');
-            }
-            this.signatureKey = opts.authKey;
-            this.verificationKey = opts.authKey;
-        }
-        this.defaultVerificationOptions = {};
-        if (opts.authVerifyAlgorithms != null) {
-            this.defaultVerificationOptions.algorithms = opts.authVerifyAlgorithms;
-        }
-        else if (opts.authAlgorithm != null) {
-            this.defaultVerificationOptions.algorithms = [opts.authAlgorithm];
-        }
-        this.defaultSignatureOptions = {
-            expiresIn: opts.authDefaultExpiry
-        };
-        if (opts.authAlgorithm != null) {
-            this.defaultSignatureOptions.algorithm = opts.authAlgorithm;
-        }
-        if (opts.authEngine) {
-            this.auth = opts.authEngine;
-        }
-        else {
-            // Default authentication engine
-            this.auth = new AuthEngine();
-        }
-        if (opts.codecEngine) {
-            this.codec = opts.codecEngine;
-        }
-        else {
-            // Default codec engine
-            this.codec = formatter;
-        }
-        this.brokerEngine.setCodecEngine(this.codec);
-        this.exchange = this.brokerEngine.exchange();
-        this.clients = {};
-        this.clientsCount = 0;
-        this.pendingClients = {};
-        this.pendingClientsCount = 0;
-        const wsServerOptions = opts.wsEngineServerOptions || {};
-        wsServerOptions.server = this.httpServer;
-        wsServerOptions.verifyClient = this._verifyHandshake.bind(this);
-        if (wsServerOptions.path == null && this._path != null) {
-            wsServerOptions.path = this._path;
-        }
-        if (wsServerOptions.perMessageDeflate == null && this.perMessageDeflate != null) {
-            wsServerOptions.perMessageDeflate = this.perMessageDeflate;
-        }
-        if (wsServerOptions.handleProtocols == null && opts.handleProtocols != null) {
-            wsServerOptions.handleProtocols = opts.handleProtocols;
-        }
-        if (wsServerOptions.maxPayload == null && opts.maxPayload != null) {
-            wsServerOptions.maxPayload = opts.maxPayload;
-        }
-        if (wsServerOptions.clientTracking == null) {
-            wsServerOptions.clientTracking = false;
-        }
-        this.wsServer = new WebSocketServer(wsServerOptions);
-        this.wsServer.on('error', this._handleServerError.bind(this));
-        this.wsServer.on('connection', this._handleSocketConnection.bind(this));
-    }
-    setAuthEngine(authEngine) {
-        this.auth = authEngine;
-    }
-    setCodecEngine(codecEngine) {
-        this.codec = codecEngine;
-        this.brokerEngine.setCodecEngine(codecEngine);
-    }
-    emitError(error) {
-        this.emit('error', { error });
-    }
-    emitWarning(warning) {
-        this.emit('warning', { warning });
-    }
-    _handleServerError(error) {
-        if (typeof error === 'string') {
-            error = new ServerProtocolError(error);
-        }
-        this.emitError(error);
-    }
-    _handleSocketConnection(wsSocket, upgradeReq) {
-        if (!wsSocket.upgradeReq) {
-            // Normalize ws modules to match.
-            wsSocket.upgradeReq = upgradeReq;
-        }
-        let socketId = this.generateId();
-        let agSocket = new ServerSocket(socketId, this, wsSocket, this.protocolVersion);
-        //agSocket.exchange = this.exchange;
-        const inboundRawMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_INBOUND_RAW];
-        if (inboundRawMiddleware) {
-            inboundRawMiddleware(agSocket.middlewareInboundRawStream);
-        }
-        const inboundMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_INBOUND];
-        if (inboundMiddleware) {
-            inboundMiddleware(agSocket.middlewareInboundStream);
-        }
-        const outboundMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_OUTBOUND];
-        if (outboundMiddleware) {
-            outboundMiddleware(agSocket.middlewareOutboundStream);
-        }
-        // Emit event to signal that a socket handshake has been initiated.
-        this.emit('handshake', { socket: agSocket });
-    }
-    emit(eventName, data) {
-        super.emit(eventName, data);
-    }
-    listen(eventName) {
-        return super.listen(eventName);
-    }
-    close(keepSocketsOpen) {
-        this.isReady = false;
-        return new Promise((resolve, reject) => {
-            this.wsServer.close((err) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve();
-            });
-            if (!keepSocketsOpen) {
-                for (let socket of Object.values(this.clients)) {
-                    socket.terminate();
-                }
-            }
-        });
-    }
-    getPath() {
-        return this._path;
-    }
-    generateId() {
-        return base64id.generateId();
-    }
-    setMiddleware(type, middleware) {
-        if (type !== MiddlewareType.MIDDLEWARE_HANDSHAKE &&
-            type !== MiddlewareType.MIDDLEWARE_INBOUND_RAW &&
-            type !== MiddlewareType.MIDDLEWARE_INBOUND &&
-            type !== MiddlewareType.MIDDLEWARE_OUTBOUND) {
-            throw new InvalidArgumentsError(`Middleware ${type} type is not supported`);
-        }
-        if (this._middleware[type]) {
-            throw new InvalidActionError(`Middleware ${type} type has already been set`);
-        }
-        this._middleware[type] = middleware;
-    }
-    removeMiddleware(type) {
-        delete this._middleware[type];
-    }
-    hasMiddleware(type) {
-        return !!this._middleware[type];
-    }
-    async _processMiddlewareAction(middlewareStream, action, socket) {
-        if (!this.hasMiddleware(middlewareStream.type)) {
-            return { data: 'data' in action ? action.data : undefined };
-        }
-        middlewareStream.write(action);
-        let newData;
-        let options;
-        try {
-            const result = await action.promise;
-            if (result) {
-                newData = result.data;
-                options = result.options;
-            }
-        }
-        catch (error) {
-            let clientError;
-            if (!error) {
-                error = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
-                clientError = error;
-            }
-            else if (error.silent) {
-                clientError = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
-            }
-            else {
-                clientError = error;
-            }
-            if (this.middlewareEmitFailures) {
-                if (socket) {
-                    socket.emitError(error);
-                }
-                else {
-                    this.emitWarning(error);
-                }
-            }
-            throw clientError;
-        }
-        if (newData === undefined && 'data' in action) {
-            newData = action.data;
-        }
-        return { data: newData, options };
-    }
-    _verifyHandshake = async function (info, callback) {
-        let req = info.req;
-        let origin = info.origin;
-        if (typeof origin !== 'string' || origin === 'null') {
-            origin = '*';
-        }
-        let ok = false;
-        if (this._allowAllOrigins) {
-            ok = true;
-        }
-        else {
-            try {
-                let parts = url.parse(origin);
-                parts.port = parts.port || (parts.protocol === 'https:' ? '443' : '80');
-                ok = !!(~this.origins.indexOf(parts.hostname + ':' + parts.port) ||
-                    ~this.origins.indexOf(parts.hostname + ':*') ||
-                    ~this.origins.indexOf('*:' + parts.port));
-            }
-            catch (e) { }
-        }
-        const middlewareHandshakeStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_HANDSHAKE);
-        req['handshakeStream'] = middlewareHandshakeStream;
-        const handshakeMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_HANDSHAKE];
-        if (handshakeMiddleware) {
-            handshakeMiddleware(middlewareHandshakeStream);
-        }
-        const action = new ActionHandshakeWS(req);
-        try {
-            await this._processMiddlewareAction(middlewareHandshakeStream, action);
-        }
-        catch (error) {
-            middlewareHandshakeStream.close();
-            callback(false, 401, typeof error === 'string' ? error : error.message);
-            return;
-        }
-        if (ok) {
-            callback(true);
-            return;
-        }
-        const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${origin}`);
-        this.emitWarning(error);
-        middlewareHandshakeStream.close();
-        callback(false, 403, error.message);
-    };
-}

package/serversocket.d.ts

@@ -1,182 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AuthTokenOptions } from "./auth-engine.js";
-import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { DemuxedConsumableStream, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-import { ResponsePacketError } from "@socket-mesh/request";
-import { IncomingMessage } from 'http';
-import { SocketState } from "./socket-state.js";
-import { ActionMessage, ActionPublishOut, HandshakeAction, InboundAction } from "./action.js";
-import { AuthStateChanged, AuthTokenSigned, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, RawMessage, ServerSocketEvents, Subscribed, Unsubscribed } from './events.js';
-import { MiddlewareStream } from './middleware-stream.js';
-import { ProtocolVersions } from './server-options.js';
-import ws from "ws";
-import { Server } from "./server.js";
-import { OutboundPacket, OutboundPacketOptions } from './outbound-packet.js';
-import { RemoteProcedure } from './remote-procedure.js';
-export type WebSocket = ws.WebSocket & {
-    bytesReceived: number;
-    upgradeReq: IncomingMessage;
-};
-interface SendOptions {
-    mask?: boolean;
-    binary?: boolean;
-    compress?: boolean;
-    fin?: boolean;
-}
-interface EventObject {
-    event: string;
-    data?: any;
-    cid?: number;
-}
-export declare class ServerSocket extends AsyncStreamEmitter<ServerSocketEvents> {
-    authState: AuthState;
-    authToken: AuthToken | null;
-    batchInterval: number;
-    batchOnHandshake: boolean;
-    batchOnHandshakeDuration: number;
-    cloneData: boolean;
-    channelSubscriptionsCount: number;
-    inboundReceivedMessageCount: number;
-    inboundProcessedMessageCount: number;
-    isBatching: boolean;
-    isBufferingBatch: boolean;
-    request: IncomingMessage;
-    readonly id: string;
-    readonly socket: WebSocket;
-    readonly protocolVersion: ProtocolVersions;
-    readonly channelSubscriptions: {
-        [channel: string]: boolean;
-    };
-    readonly inboundMessageStream: WritableConsumableStream<string | ArrayBuffer | Buffer[]>;
-    readonly outboundPacketStream: WritableConsumableStream<OutboundPacket>;
-    readonly server: Server;
-    readonly middlewareHandshakeStream: MiddlewareStream<HandshakeAction>;
-    readonly middlewareInboundRawStream: MiddlewareStream<ActionMessage>;
-    readonly middlewareInboundStream: MiddlewareStream<InboundAction>;
-    readonly middlewareOutboundStream: MiddlewareStream<ActionPublishOut>;
-    readonly remoteAddress?: string;
-    readonly remoteFamily?: string;
-    readonly remotePort?: number;
-    outboundPreparedMessageCount: number;
-    outboundSentMessageCount: number;
-    signedAuthToken: SignedAuthToken | null;
-    state: SocketState;
-    readonly receiver: StreamDemuxWrapper<any>;
-    readonly procedure: RemoteProcedure;
-    private _cid;
-    private _handshakeTimeoutRef;
-    private _pingIntervalTicker;
-    private _pingTimeoutTicker;
-    private _batchBuffer;
-    private _batchingIntervalId;
-    private _callbackMap;
-    private readonly _receiverDemux;
-    private readonly _procedureDemux;
-    private readonly _sendPing;
-    constructor(id: string, server: Server, socket: WebSocket, protocolVersion: ProtocolVersions);
-    getBackpressure(): number;
-    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/broker/packet").Packet<any>>;
-    getInboundBackpressure(): number;
-    getOutboundBackpressure(): number;
-    private _startBatchOnHandshake;
-    private _handleInboundMessageStream;
-    private _handleHandshakeTimeout;
-    private _processHandshakeRequest;
-    private _processAuthenticateRequest;
-    private _subscribeSocket;
-    private _processSubscribeRequest;
-    private _unsubscribeFromAllChannels;
-    private _unsubscribe;
-    private _processUnsubscribePacket;
-    private _processUnsubscribeRequest;
-    private _processInboundPublishPacket;
-    private _processInboundPublishRequest;
-    private _processInboundPacket;
-    private _resetPongTimeout;
-    private _nextCallId;
-    getState(): SocketState;
-    getBytesReceived(): number;
-    emitError(error: Error): void;
-    private _abortAllPendingEventsDueToBadConnection;
-    closeAllMiddlewares(): void;
-    closeInput(): void;
-    closeOutput(): void;
-    closeIO(): void;
-    closeAllStreams(): void;
-    killAllMiddlewares(): void;
-    killInput(): void;
-    killOutput(): void;
-    killIO(): void;
-    killAllStreams(): void;
-    private _destroy;
-    disconnect(code?: number, reason?: string): void;
-    terminate(): void;
-    send(data: string, options?: SendOptions): void;
-    decode(message: string): any;
-    encode(object: any): string;
-    startBatch(): void;
-    flushBatch(): void;
-    cancelBatch(): void;
-    private _startBatching;
-    startBatching(): void;
-    private _stopBatching;
-    stopBatching(): void;
-    private _cancelBatching;
-    cancelBatching(): void;
-    serializeObject(object: any): string | null;
-    sendObject(object: EventObject | ResponsePacketError): void;
-    private _handleOutboundPacketStream;
-    private _transmit;
-    transmit(event: string, data: any, options?: OutboundPacketOptions): void;
-    invoke(event: string, data?: any, options?: OutboundPacketOptions): Promise<unknown>;
-    emit(eventName: 'message' | 'raw', data: RawMessage): void;
-    emit(eventName: 'error', data: ErrorOccurred): void;
-    emit(eventName: 'authStateChange', data: AuthStateChanged): void;
-    emit(eventName: 'authenticate', data: Authenticated): void;
-    emit(eventName: 'authTokenSigned', data: AuthTokenSigned): void;
-    emit(eventName: 'deauthenticate', data: Deauthenticated): void;
-    emit(eventName: 'badAuthToken', data: BadAuthToken): void;
-    emit(eventName: 'connect', data: Connected): void;
-    emit(eventName: 'subscribe', data: Subscribed): void;
-    emit(eventName: 'unsubscribe', data: Unsubscribed): void;
-    emit(eventName: 'connectAbort', data: ConnectAborted): void;
-    emit(eventName: 'disconnect', data: Disconnected): void;
-    emit(eventName: 'close', data: Closed): void;
-    emit(eventName: 'end'): void;
-    listen(eventName: 'message' | 'raw'): DemuxedConsumableStream<RawMessage>;
-    listen(eventName: 'error'): DemuxedConsumableStream<ErrorOccurred>;
-    listen(eventName: 'authStateChange'): DemuxedConsumableStream<AuthStateChanged>;
-    listen(eventName: 'authenticate'): DemuxedConsumableStream<Authenticated>;
-    listen(eventName: 'authTokenSigned'): DemuxedConsumableStream<AuthTokenSigned>;
-    listen(eventName: 'deauthenticate'): DemuxedConsumableStream<Deauthenticated>;
-    listen(eventName: 'badAuthToken'): DemuxedConsumableStream<BadAuthToken>;
-    listen(eventName: 'connect'): DemuxedConsumableStream<Connected>;
-    listen(eventName: 'subscribe'): DemuxedConsumableStream<Subscribed>;
-    listen(eventName: 'unsubscribe'): DemuxedConsumableStream<Unsubscribed>;
-    listen(eventName: 'connectAbort'): DemuxedConsumableStream<ConnectAborted>;
-    listen(eventName: 'disconnect'): DemuxedConsumableStream<Disconnected>;
-    listen(eventName: 'close'): DemuxedConsumableStream<Closed>;
-    listen(event: 'end'): DemuxedConsumableStream<void>;
-    private _processTransmit;
-    private _invoke;
-    triggerAuthenticationEvents(oldAuthState: AuthState): void;
-    setAuthToken(data: AuthToken, options?: AuthTokenOptions): Promise<void>;
-    getAuthToken(): AuthToken | null;
-    deauthenticateSelf(): void;
-    deauthenticate(options?: {
-        rejectOnFailedDelivery: boolean;
-    }): Promise<void>;
-    kickOut(channel: string, message: string): Promise<void[]>;
-    subscriptions(): string[];
-    isSubscribed(channel: string): boolean;
-    private _processAuthTokenExpiry;
-    isAuthTokenExpired(token: AuthToken | null): boolean;
-    private _processTokenError;
-    private _emitBadAuthTokenError;
-    private _validateAuthToken;
-    private _processAuthentication;
-}
-export {};