@socket-mesh/server 17.3.7 → 18.0.1

package/server.js

@@ -1,80 +1,62 @@
-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 "./auth-engine";
+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";
-import { MiddlewareStream } from "./middleware-stream";
-import { ActionHandshakeWS } from "./action";
+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";
+import { ServerSocket } from "./serversocket.js";
 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);
+        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 {
-                    yield this._processMiddlewareAction(middlewareHandshakeStream, action);
-                }
-                catch (error) {
-                    middlewareHandshakeStream.close();
-                    callback(false, 401, typeof error === 'string' ? error : error.message);
-                    return;
-                }
-                if (ok) {
-                    callback(true);
-                    return;
+                    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));
                 }
-                const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${origin}`);
-                this.emitWarning(error);
+                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, 403, error.message);
-            });
+                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(),
@@ -117,40 +99,22 @@ export class Server extends AsyncStreamEmitter {
         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; }
+        (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;
-            (() => __awaiter(this, void 0, void 0, function* () {
-                yield this.brokerEngine.listen('ready').once();
+            (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) {
@@ -308,10 +272,10 @@ export class Server extends AsyncStreamEmitter {
             type !== MiddlewareType.MIDDLEWARE_INBOUND_RAW &&
             type !== MiddlewareType.MIDDLEWARE_INBOUND &&
             type !== MiddlewareType.MIDDLEWARE_OUTBOUND) {
-            throw new InvalidArgumentsError(`Middleware type "${type}" is not supported`);
+            throw new InvalidArgumentsError(`Middleware ${type} type is not supported`);
         }
         if (this._middleware[type]) {
-            throw new InvalidActionError(`Middleware type "${type}" has already been set`);
+            throw new InvalidActionError(`Middleware ${type} type has already been set`);
         }
         this._middleware[type] = middleware;
     }
@@ -321,47 +285,45 @@ export class Server extends AsyncStreamEmitter {
     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 };
+    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;
             }
-            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;
             }
-            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 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 {
-                    clientError = error;
-                }
-                if (this.middlewareEmitFailures) {
-                    if (socket) {
-                        socket.emitError(error);
-                    }
-                    else {
-                        this.emitWarning(error);
-                    }
+                    this.emitWarning(error);
                 }
-                throw clientError;
             }
-            if (newData === undefined && 'data' in action) {
-                newData = action.data;
-            }
-            return { data: newData, options };
-        });
+            throw clientError;
+        }
+        if (newData === undefined && 'data' in action) {
+            newData = action.data;
+        }
+        return { data: newData, options };
     }
 }

package/serversocket-procedure.d.ts

@@ -1,13 +1,13 @@
 import { DemuxedConsumableStream, StreamDemux, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-import { AuthenticateRequest, HandshakeRequest, InboundRequest, InvokeRequest, PublishRequest, SubscribeRequest, UnsubscribeRequest } from "./request";
+import { AuthenticateRequest, HandshakeRequest, InboundRequest, InvokeRequest, PublishRequest, SubscribeRequest, UnsubscribeRequest } from "./request.js";
 import { Request } from "@socket-mesh/request";
-export declare class ServerSocketProcedure<T> extends StreamDemuxWrapper<InboundRequest<T>> {
-    constructor(stream: StreamDemux<InboundRequest<T>>);
+export declare class ServerSocketProcedure extends StreamDemuxWrapper<InboundRequest> {
+    constructor(stream: StreamDemux<InboundRequest>);
     listen(name: '#handshake'): DemuxedConsumableStream<HandshakeRequest>;
     listen(name: '#authenticate'): DemuxedConsumableStream<AuthenticateRequest>;
     listen(name: '#subscribe'): DemuxedConsumableStream<SubscribeRequest>;
     listen(name: '#unsubscribe'): DemuxedConsumableStream<UnsubscribeRequest>;
-    listen(name: '#publish'): DemuxedConsumableStream<PublishRequest<T>>;
-    listen<U extends T>(name: string): DemuxedConsumableStream<Request<U>>;
-    listen<U extends T, V>(name: string): DemuxedConsumableStream<InvokeRequest<U, V>>;
+    listen(name: '#publish'): DemuxedConsumableStream<PublishRequest>;
+    listen<U>(name: string): DemuxedConsumableStream<Request<U>>;
+    listen<U, V>(name: string): DemuxedConsumableStream<InvokeRequest<U, V>>;
 }

package/serversocket.d.ts

@@ -1,22 +1,21 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { ChannelOptions } from "@socket-mesh/channel";
 import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AuthTokenOptions } from "./auth-engine";
+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";
-import { ActionMessage, ActionPublishOut, AuthInfo, HandshakeAction, InboundAction } from "./action";
-import { AuthStateChanged, AuthTokenSigned, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, RawMessage, ServerSocketEvents, Subscribed, Unsubscribed } from './events';
-import { MiddlewareStream } from './middleware-stream';
-import { ProtocolVersions } from './server-options';
+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";
-import { OutboundPacket, OutboundPacketOptions } from './outbound-packet';
-import { ServerSocketProcedure } from './serversocket-procedure';
+import { Server } from "./server.js";
+import { OutboundPacket, OutboundPacketOptions } from './outbound-packet.js';
+import { ServerSocketProcedure } from './serversocket-procedure.js';
 export type WebSocket = ws.WebSocket & {
     bytesReceived: number;
     upgradeReq: IncomingMessage;
@@ -32,7 +31,7 @@ interface EventObject {
     data?: any;
     cid?: number;
 }
-export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEvents> {
+export declare class ServerSocket extends AsyncStreamEmitter<ServerSocketEvents> {
     authState: AuthState;
     authToken: AuthToken | null;
     batchInterval: number;
@@ -52,12 +51,12 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
         [channel: string]: boolean;
     };
     readonly inboundMessageStream: WritableConsumableStream<string | ArrayBuffer | Buffer[]>;
-    readonly outboundPacketStream: WritableConsumableStream<OutboundPacket<T>>;
-    readonly server: Server<T>;
-    readonly middlewareHandshakeStream: MiddlewareStream<HandshakeAction<T>>;
-    readonly middlewareInboundRawStream: MiddlewareStream<ActionMessage<T>>;
-    readonly middlewareInboundStream: MiddlewareStream<InboundAction<T>>;
-    readonly middlewareOutboundStream: MiddlewareStream<ActionPublishOut<T>>;
+    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;
@@ -65,8 +64,8 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     outboundSentMessageCount: number;
     signedAuthToken: SignedAuthToken | null;
     state: SocketState;
-    readonly receiver: StreamDemuxWrapper<string | void | T | ArrayBuffer | Buffer[] | AuthInfo | ChannelOptions>;
-    readonly procedure: ServerSocketProcedure<T>;
+    readonly receiver: StreamDemuxWrapper<any>;
+    readonly procedure: ServerSocketProcedure;
     private _cid;
     private _handshakeTimeoutRef;
     private _pingIntervalTicker;
@@ -77,9 +76,9 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     private readonly _receiverDemux;
     private readonly _procedureDemux;
     private readonly _sendPing;
-    constructor(id: string, server: Server<T>, socket: WebSocket, protocolVersion: ProtocolVersions);
+    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<T>>;
+    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/simple-broker/packet").Packet<any>>;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
     private _startBatchOnHandshake;