@socket-mesh/server 17.3.1

package/request.js

@@ -0,0 +1,22 @@
+import { Request } from "@socket-mesh/request";
+export class HandshakeRequest extends Request {
+    constructor(socket, id, procedureName, data) {
+        super(socket, id, procedureName, data);
+    }
+}
+export class UnsubscribeRequest extends Request {
+    constructor(socket, id, procedureName, data) {
+        super(socket, id, procedureName, data);
+    }
+}
+export class AuthenticateRequest extends Request {
+    constructor(socket, id, procedureName, data) {
+        super(socket, id, procedureName, data);
+    }
+}
+export function isSubscribeRequest(request) {
+    return request.procedure === '#subscribe';
+}
+export function isPublishRequest(request) {
+    return request.procedure === '#publish';
+}

package/server-options.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { CodecEngine } from "@socket-mesh/formatter";
+import ws from "ws";
+import jwt from "jsonwebtoken";
+import { Server as HttpServer } from 'http';
+import { AuthEngine } from "@socket-mesh/server-auth";
+export type ProtocolVersions = 1 | 2;
+export interface ServerOptions {
+    httpServer?: HttpServer;
+    wsEngine?: string | {
+        Server: ws.Server;
+    };
+    wsEngineServerOptions?: ws.ServerOptions;
+    authKey?: jwt.Secret;
+    perMessageDeflate?: boolean | ws.PerMessageDeflateOptions;
+    authPrivateKey?: jwt.Secret;
+    authPublicKey?: jwt.Secret;
+    authDefaultExpiry?: number;
+    authAlgorithm?: jwt.Algorithm;
+    protocolVersion?: ProtocolVersions;
+    handshakeTimeout?: number;
+    ackTimeout?: number;
+    origins?: string;
+    socketChannelLimit?: number;
+    pingInterval?: number;
+    pingTimeout?: number;
+    pingTimeoutDisabled?: boolean;
+    middlewareEmitFailures?: boolean;
+    path?: string;
+    allowClientPublish?: boolean;
+    batchOnHandshake?: boolean;
+    batchOnHandshakeDuration?: number;
+    batchInterval?: number;
+    socketStreamCleanupMode?: 'kill' | 'close';
+    authVerifyAlgorithms?: jwt.Algorithm[];
+    authEngine?: AuthEngine;
+    codecEngine?: CodecEngine;
+    cloneData?: boolean;
+    strictHandshake?: boolean;
+    [additionalOptions: string]: any;
+}

package/server-options.js

@@ -0,0 +1 @@
+export {};

package/server.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { AuthEngine } from "@socket-mesh/server-auth";
+import { CodecEngine } from "@socket-mesh/formatter";
+import { Broker, Packet } from "@socket-mesh/simple-broker";
+import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+import { MiddlewareType } from "./middleware-type";
+import { MiddlewareStream } from "./middleware-stream";
+import { ActionAuthenticate, ActionHandshakeSC, ActionHandshakeWS, ActionInvoke, ActionMessage, ActionPublishIn, ActionPublishOut, ActionResult, ActionSubscribe, ActionTransmit, AuthInfo, MiddlewareAction } from "./action";
+import { ProtocolVersions, ServerOptions } from "./server-options";
+import ws from "ws";
+import jwt from "jsonwebtoken";
+import { Server as HttpServer } from 'http';
+import { ServerSocket } from "./serversocket";
+import { ChannelOptions, Client } from "@socket-mesh/channel";
+import { AuthStateChanged, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, ServerSocketEvents, Subscribed, Unsubscribed, WarningOccurred } from "./events";
+export type ServerEvent<T, U extends ServerSocketEvents | {}> = {
+    socket: ServerSocket<T>;
+} & U;
+type ServerEvents<T> = ServerEvent<T, Connected> | ServerEvent<T, ConnectAborted> | ServerEvent<T, Disconnected> | ServerEvent<T, Closed> | {} | ServerEvent<T, BadAuthToken> | ServerEvent<T, Authenticated> | ServerEvent<T, AuthStateChanged> | ServerEvent<T, Deauthenticated> | ServerEvent<T, {}> | ErrorOccurred | WarningOccurred | ServerEvent<T, Subscribed> | ServerEvent<T, Unsubscribed>;
+export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
+    allowClientPublish: boolean;
+    auth: AuthEngine;
+    clientsCount: number;
+    codec: CodecEngine;
+    defaultVerificationOptions: jwt.VerifyOptions;
+    defaultSignatureOptions: jwt.SignOptions;
+    isReady: boolean;
+    httpServer?: HttpServer;
+    middlewareEmitFailures: boolean;
+    pendingClientsCount: number;
+    ackTimeout: number;
+    handshakeTimeout: number;
+    options: ServerOptions;
+    path: string;
+    perMessageDeflate?: boolean | ws.PerMessageDeflateOptions;
+    pingInterval: number;
+    pingTimeout: number;
+    pingTimeoutDisabled: boolean;
+    protocolVersion: ProtocolVersions;
+    origins: string;
+    signatureKey: jwt.Secret;
+    strictHandshake: boolean;
+    socketChannelLimit?: number;
+    verificationKey: jwt.Secret;
+    readonly clients: {
+        [id: string]: ServerSocket<T>;
+    };
+    readonly pendingClients: {
+        [id: string]: ServerSocket<T>;
+    };
+    readonly brokerEngine: Broker<T>;
+    readonly exchange: Client<Packet<T>>;
+    readonly wsServer: ws.Server;
+    private readonly _allowAllOrigins;
+    private readonly _path;
+    private readonly _middleware;
+    constructor(options: ServerOptions);
+    setAuthEngine(authEngine: AuthEngine): void;
+    setCodecEngine(codecEngine: CodecEngine): void;
+    emitError(error: Error): void;
+    emitWarning(warning: Error): void;
+    private _handleServerError;
+    private _handleSocketConnection;
+    emit(eventName: 'connection', data: ServerEvent<T, Connected>): void;
+    emit(eventName: 'connectionAbort', data: ServerEvent<T, ConnectAborted>): void;
+    emit(eventName: 'disconnection', data: ServerEvent<T, Disconnected>): void;
+    emit(eventName: 'closure', data: ServerEvent<T, Closed>): void;
+    emit(eventName: 'ready', data: {}): void;
+    emit(eventName: 'authentication', data: ServerEvent<T, Authenticated>): void;
+    emit(eventName: 'badSocketAuthToken', data: ServerEvent<T, BadAuthToken>): void;
+    emit(eventName: 'error', data: ErrorOccurred): void;
+    emit(eventName: 'handshake', data: ServerEvent<T, {}>): void;
+    emit(eventName: 'warning', data: WarningOccurred): void;
+    emit(eventName: 'subscription', data: ServerEvent<T, Subscribed>): void;
+    emit(eventName: 'unsubscription', data: ServerEvent<T, Unsubscribed>): void;
+    emit(eventName: 'authenticationStateChange', data: ServerEvent<T, AuthStateChanged>): void;
+    emit(eventName: 'deauthentication', data: ServerEvent<T, Deauthenticated>): void;
+    close(keepSocketsOpen: boolean): Promise<void>;
+    getPath(): string;
+    generateId(): string;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_HANDSHAKE, middleware: (stream: MiddlewareStream<void>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND_RAW, middleware: (stream: MiddlewareStream<string | ArrayBuffer | Buffer[]>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND, middleware: (stream: MiddlewareStream<ChannelOptions | T | void>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_OUTBOUND, middleware: (stream: MiddlewareStream<T>) => void): void;
+    removeMiddleware(type: MiddlewareType): void;
+    hasMiddleware(type: MiddlewareType): boolean;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<void | T | ChannelOptions>, action: ActionSubscribe<T> | ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<void | T | ChannelOptions>, action: ActionAuthenticate<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<T>, action: ActionPublishOut<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ChannelOptions>, action: ActionSubscribe<T>, socket?: ServerSocket<T>): Promise<ActionResult<ChannelOptions>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<void>, action: ActionHandshakeWS, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<void>, action: ActionHandshakeSC<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<string | ArrayBuffer | Buffer[]>, action: ActionMessage<T>, socket?: ServerSocket<T>): Promise<ActionResult<string | ArrayBuffer | Buffer[]>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<T | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>, action: MiddlewareAction<T>, socket?: ServerSocket<T>): Promise<ActionResult<T | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>>;
+    private _verifyHandshake;
+}
+export {};

package/server.js

@@ -0,0 +1,361 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { AuthEngine } from "@socket-mesh/server-auth";
+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";
+import { MiddlewareStream } from "./middleware-stream";
+import { ActionHandshakeWS } from "./action";
+import base64id from 'base64id';
+import { ServerSocket } from "./serversocket";
+import url from "url";
+import crypto from "crypto";
+export class Server extends AsyncStreamEmitter {
+    constructor(options) {
+        super();
+        this._verifyHandshake = function (info, callback) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let req = info.req;
+                let origin = info.origin;
+                if (origin === 'null' || 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 {
+                    yield 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);
+            });
+        };
+        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;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(this.brokerEngine.listen('error')), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        let { error } = _c;
+                        this.emitWarning(error);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }))();
+        if (this.brokerEngine.isReady) {
+            this.isReady = true;
+            this.emit('ready', {});
+        }
+        else {
+            this.isReady = false;
+            (() => __awaiter(this, void 0, void 0, function* () {
+                yield 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;
+        let 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 WSServer(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);
+    }
+    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];
+    }
+    _processMiddlewareAction(middlewareStream, action, socket) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasMiddleware(middlewareStream.type)) {
+                return { data: 'data' in action ? action.data : undefined };
+            }
+            middlewareStream.write(action);
+            let newData;
+            let options;
+            try {
+                const result = yield 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 };
+        });
+    }
+}