@socket-mesh/server 18.0.5 → 18.1.0

package/dist/server.js

@@ -0,0 +1,266 @@
+import ws from "ws";
+import { ServerProtocolError } from "@socket-mesh/errors";
+import { ServerSocket } from "./server-socket.js";
+import defaultCodec from "@socket-mesh/formatter";
+import { removeAuthTokenHandler } from "@socket-mesh/client";
+import { defaultAuthEngine, isAuthEngine } from "@socket-mesh/auth-engine";
+import { handshakeHandler } from "./handlers/handshake.js";
+import { authenticateHandler } from "./handlers/authenticate.js";
+import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+import { subscribeHandler } from "./handlers/subscribe.js";
+import { unsubscribeHandler } from "./handlers/unsubscribe.js";
+import { SimpleBroker } from "./broker/simple-broker.js";
+import { publishHandler } from "./handlers/publish.js";
+export class Server extends AsyncStreamEmitter {
+    constructor(options) {
+        super();
+        let cid = 1;
+        if (!options) {
+            options = {};
+        }
+        options.clientTracking = true;
+        this.ackTimeoutMs = options.ackTimeoutMs || 10000;
+        this.allowClientPublish = options.allowClientPublish ?? true;
+        this.auth = isAuthEngine(options.authEngine) ? options.authEngine : defaultAuthEngine(options.authEngine);
+        this.brokerEngine = options.brokerEngine || new SimpleBroker();
+        this._callIdGenerator = options.callIdGenerator || (() => {
+            return cid++;
+        });
+        this.clients = {};
+        this.clientCount = 0;
+        this.codecEngine = options.codecEngine || defaultCodec;
+        this._handlers = Object.assign({
+            "#authenticate": authenticateHandler,
+            "#handshake": handshakeHandler,
+            "#publish": publishHandler,
+            "#removeAuthToken": removeAuthTokenHandler,
+            "#subscribe": subscribeHandler,
+            "#unsubscribe": unsubscribeHandler
+        }, options.handlers);
+        this.httpServer = options.server;
+        this.plugins = options.plugins || [];
+        this.origins = options.origins || '*:*';
+        this.pendingClients = {};
+        this.pendingClientCount = 0;
+        this.isPingTimeoutDisabled = (options.isPingTimeoutDisabled === true);
+        this.pingIntervalMs = options.pingIntervalMs || 8000;
+        this.pingTimeoutMs = options.pingTimeoutMs || 20000;
+        this.socketChannelLimit = options.socketChannelLimit;
+        this.socketStreamCleanupMode = options.socketStreamCleanupMode || 'kill';
+        this.strictHandshake = options.strictHandshake ?? true;
+        options.verifyClient = this.verifyClient.bind(this);
+        this._wss = new ws.WebSocketServer(options);
+        this._wss.on('close', this.onClose.bind(this));
+        this._wss.on('connection', this.onConnection.bind(this));
+        this._wss.on('error', this.onError.bind(this));
+        this._wss.on('headers', this.onHeaders.bind(this));
+        this._wss.on('listening', this.onListening.bind(this));
+        (async () => {
+            for await (let { error } of this.brokerEngine.listen('error')) {
+                this.emit('warning', { warning: error });
+            }
+        })();
+        if (this.brokerEngine.isReady) {
+            setTimeout(() => {
+                this._isReady = true;
+                this.emit('ready', {});
+            }, 0);
+        }
+        else {
+            this._isReady = false;
+            (async () => {
+                await this.brokerEngine.listen('ready').once();
+                this._isReady = true;
+                this.emit('ready', {});
+            })();
+        }
+    }
+    addPlugin(...plugin) {
+        this.plugins.push(...plugin);
+    }
+    bind(socket) {
+        if (socket.type === 'client') {
+            (async () => {
+                for await (let event of socket.listen()) {
+                    this.emit(`socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}`, Object.assign({ socket }, event.value));
+                }
+            })();
+            (async () => {
+                for await (let event of socket.channels.listen()) {
+                    this.emit(`socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}`, Object.assign({ socket }, event.value));
+                }
+            })();
+        }
+        (async () => {
+            for await (let {} of socket.listen('connect')) {
+                if (this.pendingClients[socket.id]) {
+                    delete this.pendingClients[socket.id];
+                    this.pendingClientCount--;
+                }
+                this.clients[socket.id] = socket;
+                this.clientCount++;
+                this.startPinging();
+            }
+        })();
+        (async () => {
+            for await (let {} of socket.listen('connectAbort')) {
+                this.socketDisconnected(socket);
+            }
+        })();
+        (async () => {
+            for await (let {} of socket.listen('disconnect')) {
+                this.socketDisconnected(socket);
+            }
+        })();
+    }
+    close(keepSocketsOpen) {
+        this._isListening = false;
+        return new Promise((resolve, reject) => {
+            this._wss.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+            if (!keepSocketsOpen) {
+                for (let socket of Object.values(this.clients)) {
+                    socket.disconnect();
+                }
+            }
+        });
+    }
+    get exchange() {
+        return this.brokerEngine.exchange;
+    }
+    get isListening() {
+        return this._isListening;
+    }
+    get isReady() {
+        return this._isReady;
+    }
+    onClose(code, reason) {
+        this.emit('close', {});
+    }
+    onConnection(wsSocket, upgradeReq) {
+        /*
+                if (!wsSocket.upgradeReq) {
+                    // Normalize ws modules to match.
+                    wsSocket.upgradeReq = upgradeReq;
+                }
+        */
+        const socket = new ServerSocket({
+            ackTimeoutMs: this.ackTimeoutMs,
+            callIdGenerator: this._callIdGenerator,
+            codecEngine: this.codecEngine,
+            handlers: this._handlers,
+            plugins: this.plugins,
+            onUnhandledRequest: this.onUnhandledRequest.bind(this),
+            request: upgradeReq,
+            socket: wsSocket,
+            server: this,
+            state: {},
+            streamCleanupMode: this.socketStreamCleanupMode
+        });
+        this.pendingClientCount++;
+        this.bind(this.pendingClients[socket.id] = socket);
+        //		ws.on('error', console.error);
+        this.emit('connection', { socket, upgradeReq });
+        // Emit event to signal that a socket handshake has been initiated.
+        this.emit('handshake', { socket });
+    }
+    onError(error) {
+        if (typeof error === 'string') {
+            error = new ServerProtocolError(error);
+        }
+        this.emit('error', { error });
+    }
+    onHeaders(headers, request) {
+        this.emit('headers', { headers, request });
+    }
+    onListening() {
+        this._isListening = true;
+        this.emit('listening', {});
+    }
+    onUnhandledRequest(socket, packet) {
+    }
+    socketDisconnected(socket) {
+        if (!!this.pendingClients[socket.id]) {
+            delete this.pendingClients[socket.id];
+            this.pendingClientCount--;
+        }
+        if (!!this.clients[socket.id]) {
+            delete this.clients[socket.id];
+            this.clientCount--;
+        }
+        if (this.clientCount <= 0) {
+            this.stopPinging();
+        }
+    }
+    startPinging() {
+        if (!this._pingIntervalRef && !this.isPingTimeoutDisabled) {
+            this._pingIntervalRef = setInterval(() => {
+                for (const id in this.clients) {
+                    this.clients[id]
+                        .ping()
+                        .catch(err => {
+                        this.onError(err);
+                    });
+                }
+            }, this.pingIntervalMs);
+        }
+    }
+    stopPinging() {
+        if (this._pingIntervalRef) {
+            clearInterval(this._pingIntervalRef);
+            this._pingIntervalRef = null;
+        }
+    }
+    async verifyClient(info, callback) {
+        try {
+            if (typeof info.origin !== 'string' || info.origin === 'null') {
+                info.origin = '*';
+            }
+            if (this.origins.indexOf('*:*') === -1) {
+                let ok = false;
+                try {
+                    const url = new URL(info.origin);
+                    url.port = url.port || (url.protocol === 'https:' ? '443' : '80');
+                    ok = !!(~this.origins.indexOf(url.hostname + ':' + url.port) ||
+                        ~this.origins.indexOf(url.hostname + ':*') ||
+                        ~this.origins.indexOf('*:' + url.port));
+                }
+                catch (e) { }
+                if (!ok) {
+                    const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${info.origin}`);
+                    this.emit('warning', { warning: error });
+                    callback(false, 403, error.message);
+                    return;
+                }
+            }
+            try {
+                for (const plugin of this.plugins) {
+                    if (plugin.onConnection) {
+                        await plugin.onConnection(info.req);
+                    }
+                }
+            }
+            catch (err) {
+                callback(false, 401, typeof err === 'string' ? err : err.message);
+                return;
+            }
+            callback(true);
+        }
+        catch (err) {
+            this.onError(err);
+            this.emit('warning', { warning: err });
+            callback(false, 403, typeof err === 'string' ? err : err.message);
+        }
+    }
+    emit(event, data) {
+        super.emit(event, data);
+    }
+    listen(event) {
+        return super.listen(event);
+    }
+}

package/package.json

@@ -1,59 +1,45 @@
 {
 	"name": "@socket-mesh/server",
-	"version": "18.0.5",
-	"description": "Server module for SocketMesh",
-	"main": "index.js",
-	"type": "module",
-	"repository": {
-		"type": "git",
-		"url": "git://github.com/socket-mesh/server.git"
+	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
+	"version": "18.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": ["./dist"],
+	"author": {
+		"name": "Greg Kimmy"
 	},
-	"dependencies": {
-		"@socket-mesh/async-stream-emitter": "^7.0.6",
-		"@socket-mesh/consumable-stream": "3.2.1",
-		"@socket-mesh/auth": "^2.1.6",
-		"@socket-mesh/errors": "^3.0.8",
-		"@socket-mesh/formatter": "^4.0.5",
-		"@socket-mesh/request": "^2.0.9",
-		"@socket-mesh/broker": "^1.0.5",
-		"@socket-mesh/simple-broker": "^6.0.6",
-		"@socket-mesh/stream-demux": "^10.0.4",
-		"@socket-mesh/writable-consumable-stream": "^4.2.9",
-		"@socket-mesh/channel": "6.0.29",
-		"base64id": "^2.0.0",
-		"clone-deep": "^4.0.1",
-		"jsonwebtoken": "^9.0.2",
-		"ws": "^8.14.2"
+	"scripts": {
+    "build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
+    "deploy": "npm run build && node ../../scripts/publish.mjs",
+		"test": "cross-env node --test --import=./run-test.js test/server-test.ts"
 	},
 	"devDependencies": {
-		"@socket-mesh/client": "^18.0.7",
 		"@socket-mesh/local-storage": "^1.0.2",
 		"@types/base64id": "^2.0.2",
-		"@types/clone-deep": "^4.0.4",
-		"@types/jsonwebtoken": "^9.0.5",
-		"@types/ws": "^8.5.10",
-		"cross-env": "^7.0.3",
-		"ts-node": "^10.9.1",
-		"typescript": "^5.3.2"
+		"@types/jsonwebtoken": "^9.0.6",
+		"@types/ws": "^8.5.10"
 	},
-	"scripts": {
-		"build": "node ./scripts/build.mjs && tsc",
-		"deploy": "cd dist && npm publish --access public",
-		"test": "cross-env node --test --loader ts-node/esm test/test.ts"
+	"dependencies": {
+		"@socket-mesh/async-stream-emitter": "^7.1.2",
+		"@socket-mesh/auth": "^2.2.0",
+		"@socket-mesh/auth-engine": "^1.0.0",
+		"@socket-mesh/client": "^18.1.0",
+		"@socket-mesh/errors": "^3.2.0",
+		"@socket-mesh/formatter": "^4.1.0",
+		"base64id": "^2.0.0",
+		"events": "^3.3.0",
+		"jsonwebtoken": "^9.0.2",
+		"ws": "^8.18.0"
 	},
 	"keywords": [
-		"websocket",
-		"realtime",
-		"socketcluster",
-		"socketmesh"
-	],
-	"author": "Jonathan Gros-Dubois <grosjona@yahoo.com.au>",
-	"contributors": [
-		"Greg Kimmy",
-		{
-			"name": "Jonathan Gros-Dubois",
-			"email": "grosjona@yahoo.com.au"
-		}
+		"ncom",
+		"tcp",
+		"simple",
+		"socket",
+		"messages"
 	],
-	"license": "MIT"
+	"engines": {
+		"node": ">= 0.8.0"
+	}
 }

package/action.d.ts

@@ -1,106 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { AuthTokenError, AuthTokenExpiredError } from "@socket-mesh/errors";
-import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { IncomingMessage } from 'http';
-import { DataPacket } from "@socket-mesh/broker";
-import { ChannelOptions } from "@socket-mesh/channel";
-import { ServerSocket } from "./serversocket.js";
-import { HandshakeRequest } from "./request.js";
-export declare enum ActionType {
-    HANDSHAKE_WS = "handshakeWS",
-    HANDSHAKE_SC = "handshakeSC",
-    MESSAGE = "message",
-    TRANSMIT = "transmit",
-    INVOKE = "invoke",
-    SUBSCRIBE = "subscribe",
-    PUBLISH_IN = "publishIn",
-    PUBLISH_OUT = "publishOut",
-    AUTHENTICATE = "authenticate"
-}
-export interface ActionResult<T> {
-    data: T;
-    options?: ActionOptions;
-}
-export interface ActionOptions {
-    useCache: boolean;
-}
-export declare abstract class Action<T, U extends ActionType = ActionType> {
-    readonly type: U;
-    readonly promise: Promise<ActionResult<T> | undefined>;
-    outcome: 'allowed' | 'blocked' | null;
-    private _resolve;
-    private _reject;
-    constructor(type: U);
-    allow: (packet?: ActionResult<T>) => void;
-    block: (error: Error) => void;
-}
-export type MiddlewareAction = ActionTransmit | ActionInvoke | ActionPublishIn | ActionPublishOut | ActionSubscribe | ActionHandshakeSC | ActionHandshakeWS | ActionAuthenticate | ActionMessage;
-export type InboundAction = ActionAuthenticate | ActionTransmit | ActionInvoke | ActionPublishIn | ActionSubscribe;
-export type HandshakeAction = ActionHandshakeSC | ActionHandshakeWS;
-export declare class ActionHandshakeWS extends Action<undefined, ActionType.HANDSHAKE_WS> {
-    constructor(request: IncomingMessage);
-    request: IncomingMessage;
-}
-export type AuthInfo = {
-    signedAuthToken: SignedAuthToken;
-    authTokenError: AuthTokenError;
-    authToken: null;
-    authState: AuthState;
-} | {
-    signedAuthToken: SignedAuthToken;
-    authTokenError: null;
-    authToken: AuthToken;
-    authState: AuthState;
-};
-export declare class ActionHandshakeSC extends Action<AuthInfo, ActionType.HANDSHAKE_SC> {
-    constructor(socket: ServerSocket, request: HandshakeRequest, data: AuthInfo);
-    request: HandshakeRequest;
-    socket: ServerSocket;
-    data: AuthInfo;
-}
-export declare class ActionMessage extends Action<string | ArrayBuffer | Buffer[], ActionType.MESSAGE> {
-    constructor(socket: ServerSocket, data: string | ArrayBuffer | Buffer[]);
-    socket: ServerSocket;
-    data: string | ArrayBuffer | Buffer[];
-}
-export declare class ActionTransmit extends Action<any, ActionType.TRANSMIT> {
-    constructor(socket: ServerSocket, receiver: string, packet: DataPacket<any>);
-    socket: ServerSocket;
-    authTokenExpiredError?: AuthTokenExpiredError;
-    receiver: string;
-    data?: DataPacket<any>;
-}
-export declare class ActionInvoke extends Action<any, ActionType.INVOKE> {
-    constructor(socket: ServerSocket, procedure: string, packet?: DataPacket<any>);
-    socket: ServerSocket;
-    authTokenExpiredError?: AuthTokenExpiredError;
-    procedure: string;
-    data?: DataPacket<any>;
-}
-export declare class ActionSubscribe extends Action<ChannelOptions, ActionType.SUBSCRIBE> {
-    constructor(socket: ServerSocket, packet?: DataPacket<ChannelOptions>);
-    socket: ServerSocket;
-    authTokenExpiredError?: AuthTokenExpiredError;
-    channel: string;
-    data?: ChannelOptions;
-}
-export declare class ActionPublishIn extends Action<any, ActionType.PUBLISH_IN> {
-    constructor(socket: ServerSocket, packet: Partial<DataPacket<any>>);
-    socket: ServerSocket;
-    authTokenExpiredError?: AuthTokenExpiredError;
-    channel: string;
-    data?: any;
-}
-export declare class ActionPublishOut extends Action<any, ActionType.PUBLISH_OUT> {
-    constructor(socket: ServerSocket);
-    socket: ServerSocket;
-    channel?: string;
-    data?: any;
-}
-export declare class ActionAuthenticate extends Action<undefined, ActionType.AUTHENTICATE> {
-    constructor(socket: ServerSocket, authToken: AuthToken, signedAuthToken: SignedAuthToken);
-    socket: ServerSocket;
-    authToken: AuthToken;
-    signedAuthToken: string;
-}

package/action.js

@@ -1,141 +0,0 @@
-import { InvalidActionError } from "@socket-mesh/errors";
-export var ActionType;
-(function (ActionType) {
-    ActionType["HANDSHAKE_WS"] = "handshakeWS";
-    ActionType["HANDSHAKE_SC"] = "handshakeSC";
-    ActionType["MESSAGE"] = "message";
-    ActionType["TRANSMIT"] = "transmit";
-    ActionType["INVOKE"] = "invoke";
-    ActionType["SUBSCRIBE"] = "subscribe";
-    ActionType["PUBLISH_IN"] = "publishIn";
-    ActionType["PUBLISH_OUT"] = "publishOut";
-    ActionType["AUTHENTICATE"] = "authenticate";
-})(ActionType || (ActionType = {}));
-export class Action {
-    type;
-    promise;
-    outcome;
-    _resolve;
-    _reject;
-    constructor(type) {
-        this.type = type;
-        this.outcome = null;
-        this.promise = new Promise((resolve, reject) => {
-            this._resolve = resolve;
-            this._reject = reject;
-        });
-    }
-    allow = (packet) => {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
-        }
-        this.outcome = 'allowed';
-        this._resolve(packet);
-    };
-    block = (error) => {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
-        }
-        this.outcome = 'blocked';
-        this._reject(error);
-    };
-}
-export class ActionHandshakeWS extends Action {
-    constructor(request) {
-        super(ActionType.HANDSHAKE_WS);
-        this.request = request;
-    }
-    request;
-}
-export class ActionHandshakeSC extends Action {
-    constructor(socket, request, data) {
-        super(ActionType.HANDSHAKE_SC);
-        this.socket = socket;
-        this.request = request;
-        this.data = data;
-    }
-    request;
-    socket;
-    data;
-}
-export class ActionMessage extends Action {
-    constructor(socket, data) {
-        super(ActionType.MESSAGE);
-        this.socket = socket;
-        this.data = data;
-    }
-    socket;
-    data;
-}
-export class ActionTransmit extends Action {
-    constructor(socket, receiver, packet) {
-        super(ActionType.TRANSMIT);
-        this.socket = socket;
-        this.receiver = receiver;
-        if (packet !== undefined) {
-            this.data = packet;
-        }
-    }
-    socket;
-    authTokenExpiredError;
-    receiver;
-    data;
-}
-export class ActionInvoke extends Action {
-    constructor(socket, procedure, packet) {
-        super(ActionType.INVOKE);
-        this.socket = socket;
-        this.procedure = procedure;
-        if (packet !== undefined) {
-            this.data = packet;
-        }
-    }
-    socket;
-    authTokenExpiredError;
-    procedure;
-    data;
-}
-export class ActionSubscribe extends Action {
-    constructor(socket, packet) {
-        super(ActionType.SUBSCRIBE);
-        this.socket = socket;
-        this.channel = packet.channel;
-        this.data = packet.data;
-    }
-    socket;
-    authTokenExpiredError;
-    channel;
-    data;
-}
-export class ActionPublishIn extends Action {
-    constructor(socket, packet) {
-        super(ActionType.PUBLISH_IN);
-        this.socket = socket;
-        this.channel = packet.channel;
-        this.data = packet.data;
-    }
-    socket;
-    authTokenExpiredError;
-    channel;
-    data;
-}
-export class ActionPublishOut extends Action {
-    constructor(socket) {
-        super(ActionType.PUBLISH_OUT);
-        this.socket = socket;
-    }
-    socket;
-    channel;
-    data;
-}
-export class ActionAuthenticate extends Action {
-    constructor(socket, authToken, signedAuthToken) {
-        super(ActionType.AUTHENTICATE);
-        this.socket = socket;
-        this.authToken = authToken;
-        this.signedAuthToken = signedAuthToken;
-    }
-    socket;
-    authToken;
-    signedAuthToken;
-}

package/auth-engine.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import jwt from 'jsonwebtoken';
-import { ServerSocket } from './serversocket.js';
-export interface AuthTokenOptions extends jwt.SignOptions {
-    rejectOnFailedDelivery?: boolean;
-}
-export interface VerifyOptions extends jwt.VerifyOptions {
-    socket: ServerSocket;
-}
-export declare class AuthEngine {
-    verifyToken(signedToken: string, key: jwt.Secret | jwt.GetPublicKeyOrSecret, options: VerifyOptions): Promise<jwt.JwtPayload>;
-    signToken(token: string | object | Buffer, key: jwt.Secret, options: jwt.SignOptions): Promise<string>;
-}

package/auth-engine.js

@@ -1,32 +0,0 @@
-import jwt from 'jsonwebtoken';
-import { InvalidArgumentsError } from '@socket-mesh/errors';
-export class AuthEngine {
-    verifyToken(signedToken, key, options) {
-        const jwtOptions = Object.assign({}, options || {});
-        if (typeof signedToken === 'string' || signedToken == null) {
-            return new Promise((resolve, reject) => {
-                const cb = (err, token) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(token);
-                };
-                jwt.verify(signedToken || '', key, jwtOptions, cb);
-            });
-        }
-        return Promise.reject(new InvalidArgumentsError('Invalid token format - Token must be a string'));
-    }
-    signToken(token, key, options) {
-        const jwtOptions = Object.assign({}, options || {});
-        return new Promise((resolve, reject) => {
-            jwt.sign(token, key, jwtOptions, (err, signedToken) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(signedToken);
-            });
-        });
-    }
-}