@grest-ts/websocket 0.0.5 → 0.0.7

package/src/schema/GGWebSocketMiddleware.ts

@@ -1,43 +1,43 @@
-/**
- * WebSocket-specific middleware interface.
- * Independent from @grest-ts/http - WebSocket has its own middleware system.
- */
-
-/**
- * Context available during WebSocket handshake.
- */
-export interface GGWebSocketHandshakeContext {
-    /**
-     * Headers from the handshake message (client-sent or server-received).
-     */
-    headers: Record<string, string>;
-    /**
-     * Query parameters from the WebSocket URL.
-     */
-    queryArgs: Record<string, string>;
-}
-
-/**
- * WebSocket middleware interface for both client and server.
- * Unlike HTTP middleware, WebSocket middleware works with handshake data.
- */
-export interface GGWebSocketMiddleware {
-    /**
-     * Client-side: Add headers to the handshake message before sending.
-     * Called by GGSocketPool when establishing a connection.
-     */
-    updateHandshake?(context: GGWebSocketHandshakeContext): void;
-
-    /**
-     * Server-side: Parse headers from the received handshake message.
-     * Called by GGSocketServer when receiving a connection.
-     */
-    parseHandshake?(context: GGWebSocketHandshakeContext): void;
-
-    /**
-     * Server-side: Async processing after parseHandshake.
-     * Can be used for authentication, authorization, etc.
-     * Throwing an error will reject the connection.
-     */
-    process?(): Promise<void>;
-}
+/**
+ * WebSocket-specific middleware interface.
+ * Independent from @grest-ts/http - WebSocket has its own middleware system.
+ */
+
+/**
+ * Context available during WebSocket handshake.
+ */
+export interface GGWebSocketHandshakeContext {
+    /**
+     * Headers from the handshake message (client-sent or server-received).
+     */
+    headers: Record<string, string>;
+    /**
+     * Query parameters from the WebSocket URL.
+     */
+    queryArgs: Record<string, string>;
+}
+
+/**
+ * WebSocket middleware interface for both client and server.
+ * Unlike HTTP middleware, WebSocket middleware works with handshake data.
+ */
+export interface GGWebSocketMiddleware {
+    /**
+     * Client-side: Add headers to the handshake message before sending.
+     * Called by GGSocketPool when establishing a connection.
+     */
+    updateHandshake?(context: GGWebSocketHandshakeContext): void;
+
+    /**
+     * Server-side: Parse headers from the received handshake message.
+     * Called by GGSocketServer when receiving a connection.
+     */
+    parseHandshake?(context: GGWebSocketHandshakeContext): void;
+
+    /**
+     * Server-side: Async processing after parseHandshake.
+     * Can be used for authentication, authorization, etc.
+     * Throwing an error will reject the connection.
+     */
+    process?(): Promise<void>;
+}

package/src/schema/GGWebSocketSchema.ts

@@ -1,57 +1,57 @@
-import {GGWebSocketMiddleware} from "./GGWebSocketMiddleware";
-import {GGContractApiDefinition, GGContractClass} from "@grest-ts/schema";
-
-/**
- * WebSocket API Schema - pure data definition with typed context
- *
- * Type parameters:
- * - TClientToServer: Client-facing type for clientToServer methods (returns GGPromise)
- * - TServerToClient: Client-facing type for serverToClient methods (returns GGPromise)
- * - TContext: Accumulated context type (parseHandshake return types)
- * - TQuery: Query parameters on connect
- * - TClientToServerImpl: Server implementation type for clientToServer handlers (returns Promise)
- */
-export class GGWebSocketSchema<
-    TClientToServer,
-    TServerToClient,
-    TContext = {},
-    TQuery = undefined,
-    TClientToServerImpl = TClientToServer
-> {
-    public readonly name: string
-    public readonly path: string
-    public readonly middlewares: readonly GGWebSocketMiddleware[]
-    private readonly contractFactory: () => GGWebSocketContractRuntime
-    private contractCache: GGWebSocketContractRuntime | null = null
-
-    constructor(
-        name: string,
-        path: string,
-        contractFactory: () => GGWebSocketContractRuntime,
-        middlewares: readonly GGWebSocketMiddleware[] = []
-    ) {
-        this.name = name
-        this.path = path
-        this.middlewares = middlewares
-        this.contractFactory = contractFactory
-        Object.freeze(this.middlewares)
-    }
-
-    get contract(): GGWebSocketContractRuntime {
-        if (!this.contractCache) {
-            this.contractCache = this.contractFactory()
-        }
-        Object.freeze(this)
-        return this.contractCache
-    }
-}
-
-/**
- * Runtime contract structure for WebSocket APIs.
- * Contains GGContractClass instances for proper validation via implement().
- */
-export interface GGWebSocketContractRuntime {
-    apiName: string
-    clientToServer: GGContractClass<GGContractApiDefinition>
-    serverToClient: GGContractClass<GGContractApiDefinition>
-}
+import {GGWebSocketMiddleware} from "./GGWebSocketMiddleware";
+import {GGContractApiDefinition, GGContractClass} from "@grest-ts/schema";
+
+/**
+ * WebSocket API Schema - pure data definition with typed context
+ *
+ * Type parameters:
+ * - TClientToServer: Client-facing type for clientToServer methods (returns GGPromise)
+ * - TServerToClient: Client-facing type for serverToClient methods (returns GGPromise)
+ * - TContext: Accumulated context type (parseHandshake return types)
+ * - TQuery: Query parameters on connect
+ * - TClientToServerImpl: Server implementation type for clientToServer handlers (returns Promise)
+ */
+export class GGWebSocketSchema<
+    TClientToServer,
+    TServerToClient,
+    TContext = {},
+    TQuery = undefined,
+    TClientToServerImpl = TClientToServer
+> {
+    public readonly name: string
+    public readonly path: string
+    public readonly middlewares: readonly GGWebSocketMiddleware[]
+    private readonly contractFactory: () => GGWebSocketContractRuntime
+    private contractCache: GGWebSocketContractRuntime | null = null
+
+    constructor(
+        name: string,
+        path: string,
+        contractFactory: () => GGWebSocketContractRuntime,
+        middlewares: readonly GGWebSocketMiddleware[] = []
+    ) {
+        this.name = name
+        this.path = path
+        this.middlewares = middlewares
+        this.contractFactory = contractFactory
+        Object.freeze(this.middlewares)
+    }
+
+    get contract(): GGWebSocketContractRuntime {
+        if (!this.contractCache) {
+            this.contractCache = this.contractFactory()
+        }
+        Object.freeze(this)
+        return this.contractCache
+    }
+}
+
+/**
+ * Runtime contract structure for WebSocket APIs.
+ * Contains GGContractClass instances for proper validation via implement().
+ */
+export interface GGWebSocketContractRuntime {
+    apiName: string
+    clientToServer: GGContractClass<GGContractApiDefinition>
+    serverToClient: GGContractClass<GGContractApiDefinition>
+}

package/src/schema/webSocketSchema.ts

@@ -1,109 +1,109 @@
-import {GGWebSocketSchema, GGWebSocketContractRuntime} from "./GGWebSocketSchema";
-import {GGWebSocketMiddleware} from "./GGWebSocketMiddleware";
-import {GGContractClass, GGContractClient, GGContractImplementation, GGContractMethod} from "@grest-ts/schema";
-
-/**
- * Bidirectional websocket contract methods
- */
-export interface GGSocketContractMethods {
-    clientToServer: Record<string, GGContractMethod>
-    serverToClient: Record<string, GGContractMethod>
-}
-
-/**
- * WebSocket contract definition
- */
-export interface GGSocketContract<TDef extends GGSocketContractMethods = GGSocketContractMethods> {
-    name: string
-    methods: TDef
-}
-
-/**
- * Create a websocket contract
- */
-export function defineSocketContract<TDef extends GGSocketContractMethods>(
-    name: string,
-    methods: TDef
-): GGSocketContract<TDef> {
-    return {name, methods}
-}
-
-/**
- * Create a WebSocket API schema builder from a contract.
- *
- * @example
- * export const ChatContract = defineSocketContract("Chat", {
- *     clientToServer: {
- *         sendMessage: { input: IsMessage, success: IsVoid, errors: [SERVER_ERROR] }
- *     },
- *     serverToClient: {
- *         onMessage: { input: IsMessage }
- *     }
- * })
- *
- * export const ChatApi = webSocketSchema(ChatContract)
- *     .path("/chat")
- *     .use(AuthMiddleware)
- *     .done()
- */
-export function webSocketSchema<TDef extends GGSocketContractMethods>(
-    contract: GGSocketContract<TDef>
-): GGWebSocketSchemaBuilder<
-    GGContractClient<TDef["clientToServer"]>,
-    GGContractClient<TDef["serverToClient"]>,
-    undefined,
-    undefined,
-    GGContractImplementation<TDef["clientToServer"]>
-> {
-    return new GGWebSocketSchemaBuilder(contract)
-}
-
-class GGWebSocketSchemaBuilder<
-    TClientToServer,
-    TServerToClient,
-    TContext = undefined,
-    TQuery = undefined,
-    TClientToServerImpl = TClientToServer
-> {
-    private _path: string = ""
-    private _middlewares: GGWebSocketMiddleware[] = []
-
-    constructor(
-        private readonly _contract: GGSocketContract
-    ) {
-    }
-
-    path(path: string): this {
-        this._path = path
-        return this
-    }
-
-    use<M extends GGWebSocketMiddleware>(middleware: M): GGWebSocketSchemaBuilder<TClientToServer, TServerToClient, TContext | M, TQuery, TClientToServerImpl> {
-        this._middlewares.push(middleware)
-        return this as any
-    }
-
-    queryOnConnect<TNewQuery>(): GGWebSocketSchemaBuilder<TClientToServer, TServerToClient, TContext, TNewQuery, TClientToServerImpl> {
-        return this as any
-    }
-
-    done(): GGWebSocketSchema<TClientToServer, TServerToClient, TContext, TQuery, TClientToServerImpl> {
-        const contract = this._contract;
-        const contractFactory = (): GGWebSocketContractRuntime => {
-            const methods = contract.methods;
-            const name = contract.name;
-            return {
-                apiName: name,
-                clientToServer: new GGContractClass(name + ".clientToServer", methods.clientToServer),
-                serverToClient: new GGContractClass(name + ".serverToClient", methods.serverToClient)
-            };
-        };
-
-        return new GGWebSocketSchema<TClientToServer, TServerToClient, TContext, TQuery, TClientToServerImpl>(
-            contract.name,
-            this._path,
-            contractFactory,
-            this._middlewares
-        )
-    }
-}
+import {GGWebSocketSchema, GGWebSocketContractRuntime} from "./GGWebSocketSchema";
+import {GGWebSocketMiddleware} from "./GGWebSocketMiddleware";
+import {GGContractClass, GGContractClient, GGContractImplementation, GGContractMethod} from "@grest-ts/schema";
+
+/**
+ * Bidirectional websocket contract methods
+ */
+export interface GGSocketContractMethods {
+    clientToServer: Record<string, GGContractMethod>
+    serverToClient: Record<string, GGContractMethod>
+}
+
+/**
+ * WebSocket contract definition
+ */
+export interface GGSocketContract<TDef extends GGSocketContractMethods = GGSocketContractMethods> {
+    name: string
+    methods: TDef
+}
+
+/**
+ * Create a websocket contract
+ */
+export function defineSocketContract<TDef extends GGSocketContractMethods>(
+    name: string,
+    methods: TDef
+): GGSocketContract<TDef> {
+    return {name, methods}
+}
+
+/**
+ * Create a WebSocket API schema builder from a contract.
+ *
+ * @example
+ * export const ChatContract = defineSocketContract("Chat", {
+ *     clientToServer: {
+ *         sendMessage: { input: IsMessage, success: IsVoid, errors: [SERVER_ERROR] }
+ *     },
+ *     serverToClient: {
+ *         onMessage: { input: IsMessage }
+ *     }
+ * })
+ *
+ * export const ChatApi = webSocketSchema(ChatContract)
+ *     .path("/chat")
+ *     .use(AuthMiddleware)
+ *     .done()
+ */
+export function webSocketSchema<TDef extends GGSocketContractMethods>(
+    contract: GGSocketContract<TDef>
+): GGWebSocketSchemaBuilder<
+    GGContractClient<TDef["clientToServer"]>,
+    GGContractClient<TDef["serverToClient"]>,
+    undefined,
+    undefined,
+    GGContractImplementation<TDef["clientToServer"]>
+> {
+    return new GGWebSocketSchemaBuilder(contract)
+}
+
+class GGWebSocketSchemaBuilder<
+    TClientToServer,
+    TServerToClient,
+    TContext = undefined,
+    TQuery = undefined,
+    TClientToServerImpl = TClientToServer
+> {
+    private _path: string = ""
+    private _middlewares: GGWebSocketMiddleware[] = []
+
+    constructor(
+        private readonly _contract: GGSocketContract
+    ) {
+    }
+
+    path(path: string): this {
+        this._path = path
+        return this
+    }
+
+    use<M extends GGWebSocketMiddleware>(middleware: M): GGWebSocketSchemaBuilder<TClientToServer, TServerToClient, TContext | M, TQuery, TClientToServerImpl> {
+        this._middlewares.push(middleware)
+        return this as any
+    }
+
+    queryOnConnect<TNewQuery>(): GGWebSocketSchemaBuilder<TClientToServer, TServerToClient, TContext, TNewQuery, TClientToServerImpl> {
+        return this as any
+    }
+
+    done(): GGWebSocketSchema<TClientToServer, TServerToClient, TContext, TQuery, TClientToServerImpl> {
+        const contract = this._contract;
+        const contractFactory = (): GGWebSocketContractRuntime => {
+            const methods = contract.methods;
+            const name = contract.name;
+            return {
+                apiName: name,
+                clientToServer: new GGContractClass(name + ".clientToServer", methods.clientToServer),
+                serverToClient: new GGContractClass(name + ".serverToClient", methods.serverToClient)
+            };
+        };
+
+        return new GGWebSocketSchema<TClientToServer, TServerToClient, TContext, TQuery, TClientToServerImpl>(
+            contract.name,
+            this._path,
+            contractFactory,
+            this._middlewares
+        )
+    }
+}