@socket-mesh/client 18.0.9 → 18.1.2

package/dist/client-transport.js

@@ -0,0 +1,262 @@
+import { SocketTransport } from "@socket-mesh/core";
+import ws from "isomorphic-ws";
+import { LocalStorageAuthEngine, isAuthEngine } from "./client-auth-engine.js";
+import { hydrateError, socketProtocolErrorStatuses } from "@socket-mesh/errors";
+export class ClientTransport extends SocketTransport {
+    constructor(options) {
+        super(options);
+        this.type = 'client';
+        this._uri = typeof options.address === 'string' ? new URL(options.address) : options.address;
+        this.authEngine =
+            isAuthEngine(options.authEngine) ?
+                options.authEngine :
+                new LocalStorageAuthEngine(Object.assign({ authTokenName: `socketmesh.authToken${this._uri.protocol}${this._uri.hostname}` }, options.authEngine));
+        this.connectTimeoutMs = options.connectTimeoutMs ?? 20000;
+        this._pingTimeoutMs = this.connectTimeoutMs;
+        if (options.wsOptions) {
+            this._wsOptions = options.wsOptions;
+        }
+        this._connectAttempts = 0;
+        this._pendingReconnectTimeout = null;
+        this.autoReconnect = options.autoReconnect;
+        this.isPingTimeoutDisabled = (options.isPingTimeoutDisabled === true);
+    }
+    get autoReconnect() {
+        return this._autoReconnect;
+    }
+    set autoReconnect(value) {
+        if (value) {
+            this._autoReconnect = Object.assign({
+                initialDelay: 10000,
+                randomness: 10000,
+                multiplier: 1.5,
+                maxDelayMs: 60000
+            }, value === true ? {} : value);
+        }
+        else {
+            this._autoReconnect = false;
+        }
+    }
+    connect(options) {
+        let timeoutMs = this.connectTimeoutMs;
+        if (options) {
+            let changeOptions = false;
+            if (options.connectTimeoutMs) {
+                timeoutMs = options.connectTimeoutMs;
+            }
+            if (options.address) {
+                changeOptions = true;
+                this._uri = typeof options.address === 'string' ? new URL(options.address) : options.address;
+            }
+            if (options.wsOptions) {
+                changeOptions = true;
+                this._wsOptions = options.wsOptions;
+            }
+            if (changeOptions && this.status !== 'closed') {
+                this.disconnect(1000, 'Socket was disconnected by the client to initiate a new connection');
+            }
+        }
+        if (this.status === 'closed') {
+            this.webSocket = new ws(this._uri, this._wsOptions);
+            this.socket.emit('connecting', {});
+            this._connectTimeoutRef = setTimeout(() => {
+                this.disconnect(4007);
+            }, timeoutMs);
+        }
+    }
+    get connectAttempts() {
+        return this._connectAttempts;
+    }
+    disconnect(code = 1000, reason) {
+        if (code !== 4007) {
+            this.resetReconnect();
+        }
+        super.disconnect(code, reason);
+    }
+    async handshake() {
+        const token = await this.authEngine.loadToken();
+        // Don't wait for this.state to be 'ready'.
+        // The underlying WebSocket (this.socket) is already open.
+        // The casting to HandshakeStatus has to be here or typescript freaks out
+        const status = await this.invoke('#handshake', { authToken: token })[0];
+        if ('authError' in status) {
+            status.authError = hydrateError(status.authError);
+        }
+        return status;
+    }
+    onClose(code, reason) {
+        const status = this.status;
+        let reconnecting = false;
+        super.onClose(code, reason);
+        // Try to reconnect
+        // on server ping timeout (4000)
+        // or on client pong timeout (4001)
+        // or on close without status (1005)
+        // or on handshake failure (4003)
+        // or on handshake rejection (4008)
+        // or on socket hung up (1006)
+        if (this.autoReconnect) {
+            if (code === 4000 || code === 4001 || code === 1005) {
+                // If there is a ping or pong timeout or socket closes without
+                // status, don't wait before trying to reconnect - These could happen
+                // if the client wakes up after a period of inactivity and in this case we
+                // want to re-establish the connection as soon as possible.
+                reconnecting = !!this.autoReconnect;
+                this.tryReconnect(0);
+                // Codes 4500 and above will be treated as permanent disconnects.
+                // Socket will not try to auto-reconnect.
+            }
+            else if (code !== 1000 && code < 4500) {
+                reconnecting = !!this.autoReconnect;
+                this.tryReconnect();
+            }
+        }
+        if (!reconnecting) {
+            const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+            this.onDisconnect(status, code, strReason);
+        }
+    }
+    onOpen() {
+        super.onOpen();
+        clearTimeout(this._connectTimeoutRef);
+        this._connectTimeoutRef = null;
+        this.resetReconnect();
+        this.resetPingTimeout(this.isPingTimeoutDisabled ? false : this.pingTimeoutMs, 4000);
+        let authError;
+        this.handshake()
+            .then(status => {
+            this.id = status.id;
+            this.pingTimeoutMs = status.pingTimeoutMs;
+            if ('authToken' in status && status.authToken) {
+                return this.setAuthorization(status.authToken);
+            }
+            if ('authError' in status) {
+                authError = status.authError;
+            }
+            return this.changeToUnauthenticatedState();
+        })
+            .then(() => {
+            this.setReadyStatus(this.pingTimeoutMs, authError);
+        })
+            .catch(err => {
+            if (err.statusCode == null) {
+                err.statusCode = 4003;
+            }
+            this.onError(err);
+            this.disconnect(err.statusCode, err.toString());
+        });
+    }
+    onPingPong() {
+        this.send('');
+        this.resetPingTimeout(this.isPingTimeoutDisabled ? false : this.pingTimeoutMs, 4000);
+        this.socket.emit('ping', {});
+    }
+    get pendingReconnect() {
+        return (this._pendingReconnectTimeout !== null);
+    }
+    get pingTimeoutMs() {
+        return this._pingTimeoutMs;
+    }
+    set pingTimeoutMs(value) {
+        this._pingTimeoutMs = value;
+        this.resetPingTimeout(this.isPingTimeoutDisabled ? false : this.pingTimeoutMs, 4000);
+    }
+    resetReconnect() {
+        this._pendingReconnectTimeout = null;
+        this._connectAttempts = 0;
+    }
+    async send(data) {
+        this.webSocket.send(data);
+    }
+    async setAuthorization(signedAuthToken, authToken) {
+        const wasAuthenticated = !!this.signedAuthToken;
+        const changed = await super.setAuthorization(signedAuthToken, authToken);
+        if (changed) {
+            this.triggerAuthenticationEvents(false, wasAuthenticated);
+            // Even if saving the auth token failes we do NOT want to throw an exception.
+            this.authEngine.saveToken(this.signedAuthToken)
+                .catch(err => {
+                this.onError(err);
+            });
+        }
+        return changed;
+    }
+    get status() {
+        if (this.pendingReconnect) {
+            return 'connecting';
+        }
+        return super.status;
+    }
+    tryReconnect(initialDelay) {
+        if (!this.autoReconnect) {
+            return;
+        }
+        const exponent = this._connectAttempts++;
+        const reconnectOptions = this.autoReconnect;
+        let timeoutMs;
+        if (initialDelay == null || exponent > 0) {
+            const initialTimeout = Math.round(reconnectOptions.initialDelay + (reconnectOptions.randomness || 0) * Math.random());
+            timeoutMs = Math.round(initialTimeout * Math.pow(reconnectOptions.multiplier, exponent));
+        }
+        else {
+            timeoutMs = initialDelay;
+        }
+        if (timeoutMs > reconnectOptions.maxDelayMs) {
+            timeoutMs = reconnectOptions.maxDelayMs;
+        }
+        this._pendingReconnectTimeout = timeoutMs;
+        this.connect({ connectTimeoutMs: timeoutMs });
+    }
+    get uri() {
+        return this._uri;
+    }
+    get webSocket() {
+        return super.webSocket;
+    }
+    set webSocket(value) {
+        if (this.webSocket) {
+            if (this._connectTimeoutRef) {
+                clearTimeout(this._connectTimeoutRef);
+                this._connectTimeoutRef = null;
+            }
+        }
+        super.webSocket = value;
+        if (this.webSocket && this.webSocket.on) {
+            // WebSockets will throw an error if they are closed before they are completely open.
+            // We hook into these events to supress those errors and clean them up after a connection is established.
+            function onOpenCloseError() {
+                this.off('open', onOpenCloseError);
+                this.off('close', onOpenCloseError);
+                this.off('error', onOpenCloseError);
+            }
+            this.webSocket.on('open', onOpenCloseError);
+            this.webSocket.on('close', onOpenCloseError);
+            this.webSocket.on('error', onOpenCloseError);
+        }
+    }
+    async transmit(serviceAndMethod, arg) {
+        if (this.status === 'closed') {
+            this.connect();
+            await this.socket.listen('connect').once();
+        }
+        await super.transmit(serviceAndMethod, arg);
+    }
+    invoke(methodOptions, arg) {
+        let abort;
+        return [
+            Promise.resolve()
+                .then(() => {
+                if (this.status === 'closed') {
+                    this.connect();
+                    return this.socket.listen('connect').once();
+                }
+            })
+                .then(() => {
+                const result = super.invoke(methodOptions, arg);
+                abort = result[1];
+                return result[0];
+            }),
+            abort
+        ];
+    }
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./kickout.js";
+export * from "./publish.js";
+export * from "./remove-auth-token.js";
+export * from "./set-auth-token.js";

package/dist/handlers/index.js

@@ -0,0 +1,4 @@
+export * from "./kickout.js";
+export * from "./publish.js";
+export * from "./remove-auth-token.js";
+export * from "./set-auth-token.js";

package/dist/handlers/kickout.d.ts

@@ -0,0 +1,6 @@
+import { RequestHandlerArgs } from "@socket-mesh/core";
+import { ClientSocket } from "../client-socket.js";
+import { ClientTransport } from "../client-transport.js";
+import { ClientMap, KickOutOptions } from "../maps/client-map.js";
+import { BasicSocketMapClient } from "../maps/socket-map.js";
+export declare function kickOutHandler({ socket, options }: RequestHandlerArgs<KickOutOptions, BasicSocketMapClient, ClientSocket<ClientMap>, ClientTransport<ClientMap>>): Promise<void>;

package/dist/handlers/kickout.js

@@ -0,0 +1,5 @@
+export async function kickOutHandler({ socket, options }) {
+    if (typeof options.channel !== 'string')
+        return;
+    socket.channels.kickOut(options.channel, options.message);
+}

package/dist/handlers/publish.d.ts

@@ -0,0 +1,7 @@
+import { PublishOptions } from "@socket-mesh/channels";
+import { RequestHandlerArgs } from "@socket-mesh/core";
+import { ClientSocket } from "../client-socket.js";
+import { ClientTransport } from "../client-transport.js";
+import { ClientMap } from "../maps/client-map.js";
+import { BasicSocketMapClient } from "../maps/socket-map.js";
+export declare function publishHandler({ socket, options }: RequestHandlerArgs<PublishOptions, BasicSocketMapClient, ClientSocket<ClientMap>, ClientTransport<ClientMap>>): Promise<void>;

package/dist/handlers/publish.js

@@ -0,0 +1,3 @@
+export async function publishHandler({ socket, options }) {
+    socket.channels.write(options.channel, options.data);
+}

package/dist/handlers/remove-auth-token.d.ts

@@ -0,0 +1,2 @@
+import { RequestHandlerArgs } from "@socket-mesh/core";
+export declare function removeAuthTokenHandler({ transport }: RequestHandlerArgs<void>): Promise<void>;

package/dist/handlers/remove-auth-token.js

@@ -0,0 +1,3 @@
+export async function removeAuthTokenHandler({ transport }) {
+    await transport.changeToUnauthenticatedState();
+}

package/dist/handlers/set-auth-token.d.ts

@@ -0,0 +1,3 @@
+import { SignedAuthToken } from "@socket-mesh/auth";
+import { RequestHandlerArgs } from "@socket-mesh/core";
+export declare function setAuthTokenHandler({ transport, options }: RequestHandlerArgs<SignedAuthToken>): Promise<void>;

package/dist/handlers/set-auth-token.js

@@ -0,0 +1,3 @@
+export async function setAuthTokenHandler({ transport, options }) {
+    await transport.setAuthorization(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./handlers/index.js";
+export * from "./maps/index.js";
+export * from "./plugins/index.js";
+export * from "./client-auth-engine.js";
+export * from "./client-channels.js";
+export * from "./client-socket.js";
+export * from "./client-socket-options.js";
+export * from "./client-transport.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./handlers/index.js";
+export * from "./maps/index.js";
+export * from "./plugins/index.js";
+export * from "./client-auth-engine.js";
+export * from "./client-channels.js";
+export * from "./client-socket.js";
+export * from "./client-socket-options.js";
+export * from "./client-transport.js";

package/dist/maps/client-map.d.ts

@@ -0,0 +1,21 @@
+import { SignedAuthToken } from "@socket-mesh/auth";
+import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
+export interface ClientMap {
+    Channel: ChannelMap;
+    Incoming: MethodMap;
+    Service: ServiceMap;
+    Outgoing: PublicMethodMap;
+    PrivateOutgoing: PrivateMethodMap;
+    State: object;
+}
+export interface KickOutOptions {
+    channel: string;
+    message: string;
+}
+export type ClientPrivateMap = {
+    '#kickOut': (options: KickOutOptions) => void;
+    '#setAuthToken': (token: SignedAuthToken) => void;
+    '#removeAuthToken': () => void;
+    '#publish': (options: PublishOptions) => void;
+};

package/dist/maps/client-map.js

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

package/dist/maps/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client-map.js";
+export * from "./server-map.js";
+export * from "./socket-map.js";

package/dist/maps/index.js

@@ -0,0 +1,3 @@
+export * from "./client-map.js";
+export * from "./server-map.js";
+export * from "./socket-map.js";

package/dist/maps/server-map.d.ts

@@ -0,0 +1,27 @@
+import { SignedAuthToken } from "@socket-mesh/auth";
+import { ChannelOptions, PublishOptions } from "@socket-mesh/channels";
+export interface HandshakeOptions {
+    authToken: SignedAuthToken;
+}
+export type HandshakeStatus = HandshakeErrorStatus | HandshakeAuthenticatedStatus;
+export interface HandshakeErrorStatus {
+    id: string;
+    pingTimeoutMs: number;
+    authError: Error;
+}
+export interface HandshakeAuthenticatedStatus {
+    id: string;
+    pingTimeoutMs: number;
+    authToken: SignedAuthToken;
+}
+export interface SubscribeOptions extends ChannelOptions {
+    channel: string;
+}
+export type ServerPrivateMap = {
+    '#authenticate': (authToken: string) => void;
+    '#handshake': (options: HandshakeOptions) => HandshakeStatus;
+    '#publish': (options: PublishOptions) => void;
+    '#removeAuthToken': () => void;
+    '#subscribe': (options: SubscribeOptions) => void;
+    '#unsubscribe': (channelName: string) => void;
+};

package/dist/maps/server-map.js

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

package/dist/maps/socket-map.d.ts

@@ -0,0 +1,17 @@
+import { ClientMap, ClientPrivateMap } from "./client-map.js";
+import { PublicMethodMap } from "@socket-mesh/core";
+import { ServerPrivateMap } from "./server-map.js";
+export interface SocketMapFromClient<T extends ClientMap> {
+    Incoming: T['Incoming'] & ClientPrivateMap;
+    Service: T['Service'];
+    Outgoing: T['Outgoing'];
+    PrivateOutgoing: T['PrivateOutgoing'] & ServerPrivateMap;
+    State: T['State'];
+}
+export interface BasicSocketMapClient<TOutgoing extends PublicMethodMap = {}, TState extends object = {}> {
+    Incoming: ClientPrivateMap;
+    Service: {};
+    Outgoing: TOutgoing;
+    PrivateOutgoing: ServerPrivateMap;
+    State: TState;
+}

package/dist/maps/socket-map.js

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

package/dist/plugins/batching-plugin.d.ts

@@ -0,0 +1,41 @@
+import { EmptySocketMap, SocketMap } from "@socket-mesh/core";
+import { Plugin, SendRequestPluginArgs, SendResponsePluginArgs } from "@socket-mesh/core";
+export interface BatchingPluginOptions {
+    batchOnHandshakeDuration?: number | false;
+    batchInterval?: number;
+}
+export declare abstract class BatchingPlugin<T extends SocketMap = EmptySocketMap> implements Plugin<T> {
+    batchOnHandshakeDuration: number | boolean;
+    batchInterval: number;
+    private _batchingIntervalId;
+    private _handshakeTimeoutId;
+    private _isBatching;
+    constructor(options?: BatchingPluginOptions);
+    type: string;
+    cancelBatching(): void;
+    protected abstract flush(): void;
+    get isBatching(): boolean;
+    onReady(): void;
+    onDisconnected(): void;
+    startBatching(): void;
+    private start;
+    stopBatching(): void;
+    private stop;
+}
+export declare class RequestBatchingPlugin<T extends SocketMap = EmptySocketMap> extends BatchingPlugin<T> {
+    private _requests;
+    private _continue;
+    constructor(options?: BatchingPluginOptions);
+    cancelBatching(): void;
+    protected flush(): void;
+    sendRequest({ requests, cont }: SendRequestPluginArgs<T>): void;
+    type: 'requestBatching';
+}
+export declare class ResponseBatchingPlugin<T extends SocketMap = EmptySocketMap> extends BatchingPlugin<T> {
+    private _responses;
+    private _continue;
+    constructor(options?: BatchingPluginOptions);
+    protected flush(): void;
+    sendResponse({ responses, cont }: SendResponsePluginArgs<T>): void;
+    type: 'responseBatching';
+}

package/dist/plugins/batching-plugin.js

@@ -0,0 +1,111 @@
+export class BatchingPlugin {
+    constructor(options) {
+        this._isBatching = false;
+        this.batchInterval = options?.batchInterval || 50;
+        this.batchOnHandshakeDuration = options?.batchOnHandshakeDuration ?? false;
+        this._batchingIntervalId = null;
+        this._handshakeTimeoutId = null;
+    }
+    cancelBatching() {
+        if (this._batchingIntervalId !== null) {
+            clearInterval(this._batchingIntervalId);
+        }
+        this._isBatching = false;
+        this._batchingIntervalId = null;
+    }
+    get isBatching() {
+        return this._isBatching || this._batchingIntervalId !== null;
+    }
+    onReady() {
+        if (this._isBatching) {
+            this.start();
+        }
+        else if (typeof this.batchOnHandshakeDuration === 'number' && this.batchOnHandshakeDuration > 0) {
+            this.start();
+            this._handshakeTimeoutId = setTimeout(() => {
+                this.stop();
+            }, this.batchOnHandshakeDuration);
+        }
+    }
+    onDisconnected() {
+        this.cancelBatching();
+    }
+    startBatching() {
+        this._isBatching = true;
+        this.start();
+    }
+    start() {
+        if (this._batchingIntervalId !== null) {
+            return;
+        }
+        this._batchingIntervalId = setInterval(() => {
+            this.flush();
+        }, this.batchInterval);
+    }
+    stopBatching() {
+        this._isBatching = false;
+        this.stop();
+    }
+    stop() {
+        if (this._batchingIntervalId !== null) {
+            clearInterval(this._batchingIntervalId);
+        }
+        this._batchingIntervalId = null;
+        if (this._handshakeTimeoutId !== null) {
+            clearTimeout(this._handshakeTimeoutId);
+            this._handshakeTimeoutId = null;
+        }
+        this.flush();
+    }
+}
+export class RequestBatchingPlugin extends BatchingPlugin {
+    constructor(options) {
+        super(options);
+        this.type = 'requestBatching';
+        this._requests = [];
+        this._continue = null;
+    }
+    cancelBatching() {
+        super.cancelBatching();
+        this._requests = [];
+        this._continue = null;
+    }
+    flush() {
+        if (this._requests.length) {
+            this._continue(this._requests);
+            this._requests = [];
+            this._continue = null;
+        }
+    }
+    sendRequest({ requests, cont }) {
+        if (!this.isBatching) {
+            cont(requests);
+            return;
+        }
+        this._continue = cont;
+        this._requests.push(...requests);
+    }
+}
+export class ResponseBatchingPlugin extends BatchingPlugin {
+    constructor(options) {
+        super(options);
+        this.type = 'responseBatching';
+        this._responses = [];
+        this._continue = null;
+    }
+    flush() {
+        if (this._responses.length) {
+            this._continue(this._responses);
+            this._responses = [];
+            this._continue = null;
+        }
+    }
+    sendResponse({ responses, cont }) {
+        if (!this.isBatching) {
+            cont(responses);
+            return;
+        }
+        this._continue = cont;
+        this._responses.push(...responses);
+    }
+}

package/dist/plugins/in-order-plugin.d.ts

@@ -0,0 +1,10 @@
+import { RawData } from "ws";
+import { EmptySocketMap, MessageRawPluginArgs, Plugin, PluginArgs, SocketMap } from "@socket-mesh/core";
+export declare class InOrderPlugin<T extends SocketMap = EmptySocketMap> implements Plugin<T> {
+    type: 'inOrder';
+    private readonly _inboundMessageStream;
+    constructor();
+    handleInboundMessageStream(): void;
+    onEnd({ transport }: PluginArgs<T>): void;
+    onMessageRaw(options: MessageRawPluginArgs<T>): Promise<string | RawData>;
+}

package/dist/plugins/in-order-plugin.js

@@ -0,0 +1,70 @@
+import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
+export class InOrderPlugin {
+    //private readonly _outboundMessageStream: WritableConsumableStream<SendRequestPluginArgs<T>>;
+    constructor() {
+        this._inboundMessageStream = new WritableConsumableStream();
+        //this._outboundMessageStream = new WritableConsumableStream<SendRequestPluginArgs<T>>;
+        this.handleInboundMessageStream();
+        //this.handleOutboundMessageStream();
+    }
+    handleInboundMessageStream() {
+        (async () => {
+            for await (let { message, callback, promise } of this._inboundMessageStream) {
+                callback(null, message);
+                try {
+                    await promise;
+                }
+                catch (err) {
+                    // Dont throw it is handled in the socket transport
+                }
+            }
+        })();
+    }
+    /*
+        handleOutboundMessageStream(): void {
+            (async () => {
+                for await (let { requests, cont } of this._outboundMessageStream) {
+                    await new Promise<void>((resolve) => {
+                        const reqCol = new RequestCollection(requests);
+    
+                        if (reqCol.isDone()) {
+                            resolve();
+                            cont(requests);
+                            return;
+                        }
+    
+                        reqCol.listen(() => {
+                            resolve();
+                        });
+    
+                        cont(requests);
+                    });
+                }
+            })();
+        }
+    */
+    onEnd({ transport }) {
+        if (transport.streamCleanupMode === 'close') {
+            this._inboundMessageStream.close();
+            //this._outboundMessageStream.close();
+        }
+        else if (transport.streamCleanupMode === 'kill') {
+            this._inboundMessageStream.kill();
+            //this._outboundMessageStream.kill();
+        }
+    }
+    onMessageRaw(options) {
+        let callback;
+        const promise = new Promise((resolve, reject) => {
+            callback = (err, data) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(data);
+            };
+        });
+        this._inboundMessageStream.write({ callback, ...options });
+        return promise;
+    }
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./batching-plugin.js";
+export * from "./in-order-plugin.js";
+export * from "./offline-plugin.js";

package/dist/plugins/index.js

@@ -0,0 +1,3 @@
+export * from "./batching-plugin.js";
+export * from "./in-order-plugin.js";
+export * from "./offline-plugin.js";