@grest-ts/websocket 0.0.6 → 0.0.8

package/src/socket/SocketAdapter.ts

@@ -1,21 +1,21 @@
-export interface SocketAdapter {
-    send(message: string): void;
-
-    close(): void;
-
-    onOpen(handler: () => void): void;
-
-    onMessage(handler: (data: string) => void): void;
-
-    onClose(handler: () => void): void;
-
-    onError(handler: (error: Error) => void): void;
-
-    offOpen(handler: () => void): void;
-
-    offMessage(handler: (data: string) => void): void;
-
-    offClose(handler: () => void): void;
-
-    offError(handler: (error: Error) => void): void;
-}
+export interface SocketAdapter {
+    send(message: string): void;
+
+    close(): void;
+
+    onOpen(handler: () => void): void;
+
+    onMessage(handler: (data: string) => void): void;
+
+    onClose(handler: () => void): void;
+
+    onError(handler: (error: Error) => void): void;
+
+    offOpen(handler: () => void): void;
+
+    offMessage(handler: (data: string) => void): void;
+
+    offClose(handler: () => void): void;
+
+    offError(handler: (error: Error) => void): void;
+}

package/src/socket/SocketMessage.ts

@@ -1,97 +1,97 @@
-import {tPendingMessageId} from "./utils/PendingRequestsMap";
-import {OK_JSON} from "@grest-ts/schema";
-
-export const DELIMITER = ":"
-
-// Message types (single character for fast type checking)
-export enum MessageType {
-    HANDSHAKE = "h",   // Handshake request (client -> server with headers)
-    HANDSHAKE_OK = "k", // Handshake success (server -> client)
-    HANDSHAKE_ERR = "x", // Handshake error (server -> client)
-    MSG = "m",         // Regular message (send-and-forget)
-    REQ = "r",         // Request (expects response)
-    RES = "s",         // Successful response
-}
-
-export interface SocketMessage {
-    type: MessageType;
-    path: string;
-    data?: any;
-}
-
-export interface HandshakeMessage extends SocketMessage {
-    type: MessageType.HANDSHAKE;
-    data: Record<string, string>; // Headers
-}
-
-export interface HandshakeOkMessage extends SocketMessage {
-    type: MessageType.HANDSHAKE_OK;
-}
-
-export interface HandshakeErrMessage extends SocketMessage {
-    type: MessageType.HANDSHAKE_ERR;
-    data: any; // Error details
-}
-
-export interface RegularMessage extends SocketMessage {
-    type: MessageType.MSG;
-    data?: any;
-}
-
-export interface RequestMessage extends SocketMessage {
-    type: MessageType.REQ;
-    id: tPendingMessageId;
-    data?: any;
-}
-
-export interface ResponseMessage extends SocketMessage {
-    type: MessageType.RES;
-    id: tPendingMessageId;
-    data: OK_JSON<any>
-}
-
-export type AnyMessage = HandshakeMessage | HandshakeOkMessage | HandshakeErrMessage | RegularMessage | RequestMessage | ResponseMessage;
-
-export class Message {
-
-    public static create(type: MessageType, path: string, id: tPendingMessageId | "", data: any): string {
-        const dataStr = data !== undefined ? JSON.stringify(data) : "";
-        return type + DELIMITER + String(path) + DELIMITER + (id || "") + DELIMITER + dataStr;
-    }
-
-    public static parse(msg: unknown): AnyMessage | undefined {
-        if (!msg) {
-            return undefined;
-        }
-        const parts = String(msg).split(DELIMITER);
-
-        // Extract the first 4 parts (type, path, id) and everything else is data
-        const type = parts[0];
-        const path = parts[1];
-        const id = parts[2];
-        const data = parts.length > 3 ? parts.slice(3).join(DELIMITER) : undefined;
-
-        // Handshake messages don't require path
-        const isHandshake = type === MessageType.HANDSHAKE ||
-            type === MessageType.HANDSHAKE_OK ||
-            type === MessageType.HANDSHAKE_ERR;
-
-        if (!type || (!isHandshake && !path)) {
-            return undefined;
-        }
-        let dataParsed: any = undefined;
-        if (data) {
-            try {
-                dataParsed = JSON.parse(data);
-            } catch (e) {
-                // If JSON parse fails, keep as undefined
-            }
-        }
-        return {
-            type: type as MessageType,
-            path,
-            id: (id || undefined) as any,
-            data: dataParsed
-        } as AnyMessage;
-    }
-}
+import {tPendingMessageId} from "./utils/PendingRequestsMap";
+import {OK_JSON} from "@grest-ts/schema";
+
+export const DELIMITER = ":"
+
+// Message types (single character for fast type checking)
+export enum MessageType {
+    HANDSHAKE = "h",   // Handshake request (client -> server with headers)
+    HANDSHAKE_OK = "k", // Handshake success (server -> client)
+    HANDSHAKE_ERR = "x", // Handshake error (server -> client)
+    MSG = "m",         // Regular message (send-and-forget)
+    REQ = "r",         // Request (expects response)
+    RES = "s",         // Successful response
+}
+
+export interface SocketMessage {
+    type: MessageType;
+    path: string;
+    data?: any;
+}
+
+export interface HandshakeMessage extends SocketMessage {
+    type: MessageType.HANDSHAKE;
+    data: Record<string, string>; // Headers
+}
+
+export interface HandshakeOkMessage extends SocketMessage {
+    type: MessageType.HANDSHAKE_OK;
+}
+
+export interface HandshakeErrMessage extends SocketMessage {
+    type: MessageType.HANDSHAKE_ERR;
+    data: any; // Error details
+}
+
+export interface RegularMessage extends SocketMessage {
+    type: MessageType.MSG;
+    data?: any;
+}
+
+export interface RequestMessage extends SocketMessage {
+    type: MessageType.REQ;
+    id: tPendingMessageId;
+    data?: any;
+}
+
+export interface ResponseMessage extends SocketMessage {
+    type: MessageType.RES;
+    id: tPendingMessageId;
+    data: OK_JSON<any>
+}
+
+export type AnyMessage = HandshakeMessage | HandshakeOkMessage | HandshakeErrMessage | RegularMessage | RequestMessage | ResponseMessage;
+
+export class Message {
+
+    public static create(type: MessageType, path: string, id: tPendingMessageId | "", data: any): string {
+        const dataStr = data !== undefined ? JSON.stringify(data) : "";
+        return type + DELIMITER + String(path) + DELIMITER + (id || "") + DELIMITER + dataStr;
+    }
+
+    public static parse(msg: unknown): AnyMessage | undefined {
+        if (!msg) {
+            return undefined;
+        }
+        const parts = String(msg).split(DELIMITER);
+
+        // Extract the first 4 parts (type, path, id) and everything else is data
+        const type = parts[0];
+        const path = parts[1];
+        const id = parts[2];
+        const data = parts.length > 3 ? parts.slice(3).join(DELIMITER) : undefined;
+
+        // Handshake messages don't require path
+        const isHandshake = type === MessageType.HANDSHAKE ||
+            type === MessageType.HANDSHAKE_OK ||
+            type === MessageType.HANDSHAKE_ERR;
+
+        if (!type || (!isHandshake && !path)) {
+            return undefined;
+        }
+        let dataParsed: any = undefined;
+        if (data) {
+            try {
+                dataParsed = JSON.parse(data);
+            } catch (e) {
+                // If JSON parse fails, keep as undefined
+            }
+        }
+        return {
+            type: type as MessageType,
+            path,
+            id: (id || undefined) as any,
+            data: dataParsed
+        } as AnyMessage;
+    }
+}

package/src/socket/WebSocketTypes.ts

@@ -1,19 +1,19 @@
-/**
- * Type helpers for WebSocket connection handlers
- */
-
-/**
- * Incoming handler for clientToServer messages.
- * Call .on() with handlers for each method.
- */
-export type WebSocketIncoming<TClientToServer> = {
-    on(handlers: TClientToServer): void
-}
-
-/**
- * Outgoing interface for serverToClient messages.
- * Includes all serverToClient methods plus onClose for lifecycle.
- */
-export type WebSocketOutgoing<TServerToClient> = TServerToClient & {
-    onClose(callback: () => void): void
-}
+/**
+ * Type helpers for WebSocket connection handlers
+ */
+
+/**
+ * Incoming handler for clientToServer messages.
+ * Call .on() with handlers for each method.
+ */
+export type WebSocketIncoming<TClientToServer> = {
+    on(handlers: TClientToServer): void
+}
+
+/**
+ * Outgoing interface for serverToClient messages.
+ * Includes all serverToClient methods plus onClose for lifecycle.
+ */
+export type WebSocketOutgoing<TServerToClient> = TServerToClient & {
+    onClose(callback: () => void): void
+}

package/src/socket/utils/PendingRequestsMap.ts

@@ -1,128 +1,128 @@
-import {ERROR_JSON, OK_JSON, SERVER_ERROR} from "@grest-ts/schema";
-
-interface PendingRequest {
-    resolve: (value: any) => void;
-    reject: (error: any) => void;
-    timeout: any;
-    path: string;
-}
-
-export type tPendingMessageId = string & { tt: never };
-
-export class PendingRequestsMap {
-    private readonly requests: Map<tPendingMessageId, PendingRequest> = new Map();
-    private requestIdCounter: number = 1;
-    // Callbacks waiting for the map to drain (become empty)
-    private drainCallbacks: Array<() => void> = [];
-
-    /**
-     * Get the number of pending requests
-     */
-    public get size(): number {
-        return this.requests.size;
-    }
-
-    /**
-     * Check if there are any pending requests
-     */
-    public hasPending(): boolean {
-        return this.requests.size > 0;
-    }
-
-    /**
-     * Wait for all pending requests to complete (resolve or reject).
-     * Uses event-driven notification instead of polling.
-     * @param timeoutMs - Maximum time to wait for pending requests
-     * @returns Promise that resolves when all pending requests are done or timeout is reached
-     */
-    public waitForPending(timeoutMs: number = 5000): Promise<void> {
-        if (this.requests.size === 0) {
-            return Promise.resolve();
-        }
-
-        return new Promise<void>((resolve) => {
-            const cleanup = () => {
-                clearTimeout(timeout);
-                const idx = this.drainCallbacks.indexOf(onDrain);
-                if (idx !== -1) this.drainCallbacks.splice(idx, 1);
-            };
-
-            const onDrain = () => {
-                cleanup();
-                resolve();
-            };
-
-            const timeout = setTimeout(() => {
-                cleanup();
-                resolve(); // Resolve on timeout (caller checks hasPending)
-            }, timeoutMs);
-
-            this.drainCallbacks.push(onDrain);
-        });
-    }
-
-    /**
-     * Notify drain callbacks if map is empty
-     */
-    private notifyDrainIfEmpty(): void {
-        if (this.requests.size === 0 && this.drainCallbacks.length > 0) {
-            const callbacks = [...this.drainCallbacks];
-            this.drainCallbacks = [];
-            callbacks.forEach(cb => cb());
-        }
-    }
-
-    public create(
-        path: string,
-        timeoutMs: number,
-        callback: (id: tPendingMessageId, waitForResponsePromise: Promise<any>) => Promise<any>
-    ): Promise<any> {
-        const requestId = String(this.requestIdCounter++) as tPendingMessageId;
-        const reqPromise = new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.requests.delete(requestId);
-                this.notifyDrainIfEmpty();
-                reject(new SERVER_ERROR({
-                    displayMessage: 'Request timeout',
-                    debugData: {
-                        timeout: timeoutMs,
-                    }
-                }));
-            }, timeoutMs);
-            this.requests.set(requestId, {resolve, reject, timeout, path});
-        });
-
-        return callback(requestId, reqPromise)
-            .catch((error) => {
-                // If callback throws an error, clean up the pending request
-                const pending = this.requests.get(requestId);
-                if (pending) {
-                    clearTimeout(pending.timeout);
-                    this.requests.delete(requestId);
-                    this.notifyDrainIfEmpty();
-                }
-                throw error;
-            });
-    }
-
-    public resolve(requestId: tPendingMessageId, value: OK_JSON<any> | ERROR_JSON): boolean {
-        const pending = this.requests.get(requestId);
-        if (!pending) {
-            throw new Error('Pending request not found: ' + requestId);
-        }
-        clearTimeout(pending.timeout);
-        this.requests.delete(requestId);
-        pending.resolve(value);
-        this.notifyDrainIfEmpty();
-        return true;
-    }
-
-    public rejectAll(error: typeof SERVER_ERROR.infer): void {
-        this.requests.forEach((pending) => {
-            clearTimeout(pending.timeout);
-            pending.resolve(error.toJSON());
-        });
-        this.requests.clear();
-        this.notifyDrainIfEmpty();
-    }
-}
+import {ERROR_JSON, OK_JSON, SERVER_ERROR} from "@grest-ts/schema";
+
+interface PendingRequest {
+    resolve: (value: any) => void;
+    reject: (error: any) => void;
+    timeout: any;
+    path: string;
+}
+
+export type tPendingMessageId = string & { tt: never };
+
+export class PendingRequestsMap {
+    private readonly requests: Map<tPendingMessageId, PendingRequest> = new Map();
+    private requestIdCounter: number = 1;
+    // Callbacks waiting for the map to drain (become empty)
+    private drainCallbacks: Array<() => void> = [];
+
+    /**
+     * Get the number of pending requests
+     */
+    public get size(): number {
+        return this.requests.size;
+    }
+
+    /**
+     * Check if there are any pending requests
+     */
+    public hasPending(): boolean {
+        return this.requests.size > 0;
+    }
+
+    /**
+     * Wait for all pending requests to complete (resolve or reject).
+     * Uses event-driven notification instead of polling.
+     * @param timeoutMs - Maximum time to wait for pending requests
+     * @returns Promise that resolves when all pending requests are done or timeout is reached
+     */
+    public waitForPending(timeoutMs: number = 5000): Promise<void> {
+        if (this.requests.size === 0) {
+            return Promise.resolve();
+        }
+
+        return new Promise<void>((resolve) => {
+            const cleanup = () => {
+                clearTimeout(timeout);
+                const idx = this.drainCallbacks.indexOf(onDrain);
+                if (idx !== -1) this.drainCallbacks.splice(idx, 1);
+            };
+
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+
+            const timeout = setTimeout(() => {
+                cleanup();
+                resolve(); // Resolve on timeout (caller checks hasPending)
+            }, timeoutMs);
+
+            this.drainCallbacks.push(onDrain);
+        });
+    }
+
+    /**
+     * Notify drain callbacks if map is empty
+     */
+    private notifyDrainIfEmpty(): void {
+        if (this.requests.size === 0 && this.drainCallbacks.length > 0) {
+            const callbacks = [...this.drainCallbacks];
+            this.drainCallbacks = [];
+            callbacks.forEach(cb => cb());
+        }
+    }
+
+    public create(
+        path: string,
+        timeoutMs: number,
+        callback: (id: tPendingMessageId, waitForResponsePromise: Promise<any>) => Promise<any>
+    ): Promise<any> {
+        const requestId = String(this.requestIdCounter++) as tPendingMessageId;
+        const reqPromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.requests.delete(requestId);
+                this.notifyDrainIfEmpty();
+                reject(new SERVER_ERROR({
+                    displayMessage: 'Request timeout',
+                    debugData: {
+                        timeout: timeoutMs,
+                    }
+                }));
+            }, timeoutMs);
+            this.requests.set(requestId, {resolve, reject, timeout, path});
+        });
+
+        return callback(requestId, reqPromise)
+            .catch((error) => {
+                // If callback throws an error, clean up the pending request
+                const pending = this.requests.get(requestId);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.requests.delete(requestId);
+                    this.notifyDrainIfEmpty();
+                }
+                throw error;
+            });
+    }
+
+    public resolve(requestId: tPendingMessageId, value: OK_JSON<any> | ERROR_JSON): boolean {
+        const pending = this.requests.get(requestId);
+        if (!pending) {
+            throw new Error('Pending request not found: ' + requestId);
+        }
+        clearTimeout(pending.timeout);
+        this.requests.delete(requestId);
+        pending.resolve(value);
+        this.notifyDrainIfEmpty();
+        return true;
+    }
+
+    public rejectAll(error: typeof SERVER_ERROR.infer): void {
+        this.requests.forEach((pending) => {
+            clearTimeout(pending.timeout);
+            pending.resolve(error.toJSON());
+        });
+        this.requests.clear();
+        this.notifyDrainIfEmpty();
+    }
+}