@socket-mesh/server 18.0.1 → 18.0.2

package/action.d.ts

@@ -3,7 +3,7 @@
 import { AuthTokenError, AuthTokenExpiredError } from "@socket-mesh/errors";
 import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { IncomingMessage } from 'http';
-import { DataPacket } from "@socket-mesh/simple-broker";
+import { DataPacket } from "@socket-mesh/broker";
 import { ChannelOptions } from "@socket-mesh/channel";
 import { ServerSocket } from "./serversocket.js";
 import { HandshakeRequest } from "./request.js";

package/action.js

@@ -12,21 +12,12 @@ export var ActionType;
     ActionType["AUTHENTICATE"] = "authenticate";
 })(ActionType || (ActionType = {}));
 export class Action {
+    type;
+    promise;
+    outcome;
+    _resolve;
+    _reject;
     constructor(type) {
-        this.allow = (packet) => {
-            if (this.outcome) {
-                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
-            }
-            this.outcome = 'allowed';
-            this._resolve(packet);
-        };
-        this.block = (error) => {
-            if (this.outcome) {
-                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
-            }
-            this.outcome = 'blocked';
-            this._reject(error);
-        };
         this.type = type;
         this.outcome = null;
         this.promise = new Promise((resolve, reject) => {
@@ -34,12 +25,27 @@ export class Action {
             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) {
@@ -48,6 +54,9 @@ export class ActionHandshakeSC extends Action {
         this.request = request;
         this.data = data;
     }
+    request;
+    socket;
+    data;
 }
 export class ActionMessage extends Action {
     constructor(socket, data) {
@@ -55,6 +64,8 @@ export class ActionMessage extends Action {
         this.socket = socket;
         this.data = data;
     }
+    socket;
+    data;
 }
 export class ActionTransmit extends Action {
     constructor(socket, receiver, packet) {
@@ -65,6 +76,10 @@ export class ActionTransmit extends Action {
             this.data = packet;
         }
     }
+    socket;
+    authTokenExpiredError;
+    receiver;
+    data;
 }
 export class ActionInvoke extends Action {
     constructor(socket, procedure, packet) {
@@ -75,6 +90,10 @@ export class ActionInvoke extends Action {
             this.data = packet;
         }
     }
+    socket;
+    authTokenExpiredError;
+    procedure;
+    data;
 }
 export class ActionSubscribe extends Action {
     constructor(socket, packet) {
@@ -83,6 +102,10 @@ export class ActionSubscribe extends Action {
         this.channel = packet.channel;
         this.data = packet.data;
     }
+    socket;
+    authTokenExpiredError;
+    channel;
+    data;
 }
 export class ActionPublishIn extends Action {
     constructor(socket, packet) {
@@ -91,12 +114,19 @@ export class ActionPublishIn extends Action {
         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) {
@@ -105,4 +135,7 @@ export class ActionAuthenticate extends Action {
         this.authToken = authToken;
         this.signedAuthToken = signedAuthToken;
     }
+    socket;
+    authToken;
+    signedAuthToken;
 }

package/inbound-packet.d.ts

@@ -1,6 +1,6 @@
 import { SignedAuthToken } from "@socket-mesh/auth";
 import { ChannelOptions } from "@socket-mesh/channel";
-import { DataPacket } from "@socket-mesh/simple-broker";
+import { DataPacket } from "@socket-mesh/broker";
 export type InboundPacket = InboundHandshakePacket | InboundDataPacket | InboundPublishPacket | InboundSubscribePacket | InboundUnsubscribePacket | InboundAuthenticatePacket | InboundRemoveAuthTokenPacket;
 export interface InboundHandshakePacket {
     event: '#handshake';

package/index.d.ts

@@ -4,6 +4,7 @@ import { Server } from "./server.js";
 import { ServerOptions } from "./server-options.js";
 export { Server } from "./server.js";
 export { ServerSocket } from "./serversocket.js";
+export { SocketState } from "./socket-state.js";
 export { ServerOptions } from "./server-options.js";
 export { MiddlewareType } from "./middleware-type.js";
 export * from "./action.js";

package/index.js

@@ -2,6 +2,7 @@ import http from "http";
 import { Server } from "./server.js";
 export { Server } from "./server.js";
 export { ServerSocket } from "./serversocket.js";
+export { SocketState } from "./socket-state.js";
 export { MiddlewareType } from "./middleware-type.js";
 export * from "./action.js";
 export function listen(port, options, fn) {

package/middleware-stream.js

@@ -1,5 +1,6 @@
 import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
 export class MiddlewareStream extends WritableConsumableStream {
+    type;
     constructor(type) {
         super();
         this.type = type;

package/outbound-packet.d.ts

@@ -1,4 +1,4 @@
-import { DataPacket } from "@socket-mesh/simple-broker";
+import { DataPacket } from "@socket-mesh/broker";
 export type OutboundPacket = OutboundPublishPacket | OutboundTransmitPacket | OutboundInvokePacket;
 export interface OutboundPublishPacket {
     event: '#publish';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@socket-mesh/server",
-	"version": "18.0.1",
+	"version": "18.0.2",
 	"description": "Server module for SocketMesh",
 	"main": "index.js",
 	"type": "module",
@@ -15,7 +15,8 @@
 		"@socket-mesh/errors": "^3.0.8",
 		"@socket-mesh/formatter": "^4.0.5",
 		"@socket-mesh/request": "^2.0.9",
-		"@socket-mesh/simple-broker": "^6.0.0",
+		"@socket-mesh/broker": "^1.0.0",
+		"@socket-mesh/simple-broker": "^6.0.1",
 		"@socket-mesh/stream-demux": "^10.0.1",
 		"@socket-mesh/writable-consumable-stream": "^4.2.9",
 		"@socket-mesh/channel": "6.0.25",
@@ -25,7 +26,7 @@
 		"ws": "^8.14.2"
 	},
 	"devDependencies": {
-		"@socket-mesh/client": "^18.0.3",
+		"@socket-mesh/client": "^18.0.5",
 		"@socket-mesh/local-storage": "^1.0.2",
 		"@types/base64id": "^2.0.1",
 		"@types/clone-deep": "^4.0.3",

package/request.d.ts

@@ -1,6 +1,6 @@
 import { Request, RequestSocket, RequestWithResponse } from "@socket-mesh/request";
 import { Connected } from "./events.js";
-import { DataPacket } from "@socket-mesh/simple-broker";
+import { DataPacket } from "@socket-mesh/broker";
 import { ChannelOptions } from "@socket-mesh/channel";
 export type InboundRequest = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest | InvokeRequest<any, any>;
 export interface HandshakeData {

package/server.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { AuthEngine } from "./auth-engine.js";
 import { CodecEngine } from "@socket-mesh/formatter";
-import { Broker, Packet } from "@socket-mesh/simple-broker";
+import { Broker, Packet } from "@socket-mesh/broker";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { MiddlewareType } from "./middleware-type.js";
 import { MiddlewareStream } from "./middleware-stream.js";

package/server.js

@@ -12,52 +12,40 @@ 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();
-        this._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);
-        };
         let opts = {
             brokerEngine: new SimpleBroker(),
             wsEngine: 'ws',
@@ -326,4 +314,48 @@ export class Server extends AsyncStreamEmitter {
         }
         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

@@ -78,7 +78,7 @@ export declare class ServerSocket extends AsyncStreamEmitter<ServerSocketEvents>
     private readonly _sendPing;
     constructor(id: string, server: Server, socket: WebSocket, protocolVersion: ProtocolVersions);
     getBackpressure(): number;
-    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/simple-broker/packet").Packet<any>>;
+    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/broker/packet").Packet<any>>;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
     private _startBatchOnHandshake;

package/serversocket.js

@@ -15,6 +15,48 @@ import { AuthenticateRequest, HandshakeRequest, UnsubscribeRequest } from './req
 import { ServerSocketProcedure } from './serversocket-procedure.js';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 export class ServerSocket extends AsyncStreamEmitter {
+    authState;
+    authToken;
+    batchInterval;
+    batchOnHandshake;
+    batchOnHandshakeDuration;
+    cloneData;
+    channelSubscriptionsCount;
+    inboundReceivedMessageCount;
+    inboundProcessedMessageCount;
+    isBatching;
+    isBufferingBatch;
+    request;
+    id;
+    socket;
+    protocolVersion;
+    channelSubscriptions;
+    inboundMessageStream;
+    outboundPacketStream;
+    server;
+    middlewareHandshakeStream;
+    middlewareInboundRawStream;
+    middlewareInboundStream;
+    middlewareOutboundStream;
+    remoteAddress;
+    remoteFamily;
+    remotePort;
+    outboundPreparedMessageCount;
+    outboundSentMessageCount;
+    signedAuthToken;
+    state;
+    receiver;
+    procedure;
+    _cid;
+    _handshakeTimeoutRef;
+    _pingIntervalTicker;
+    _pingTimeoutTicker;
+    _batchBuffer;
+    _batchingIntervalId;
+    _callbackMap;
+    _receiverDemux;
+    _procedureDemux;
+    _sendPing;
     constructor(id, server, socket, protocolVersion) {
         super();
         this.id = id;