@nmtjs/ws-transport 0.12.9 → 0.13.1

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from './injectables.ts';
 export * from './server.ts';
-export * from './transport.ts';
 export * from './types.ts';
 export * from './utils.ts';

package/dist/index.js

@@ -1,5 +1,4 @@
 export * from "./injectables.js";
 export * from "./server.js";
-export * from "./transport.js";
 export * from "./types.js";
 export * from "./utils.js";

package/dist/injectables.d.ts

@@ -1,14 +1,6 @@
 import { type LazyInjectable, Scope } from '@nmtjs/core';
+import type { WsTransportServerRequest } from './types.ts';
 export declare const WsTransportInjectables: {
-    readonly connectionData: LazyInjectable<Readonly<{
-        url: string;
-        origin: URL | null;
-        method: string;
-        headers: Headers;
-        querystring: string;
-        query: URLSearchParams;
-        remoteAddress: string;
-        proxiedRemoteAddress: string;
-    }>, Scope.Connection>;
+    readonly connectionData: LazyInjectable<WsTransportServerRequest, Scope.Connection>;
     readonly httpResponseHeaders: LazyInjectable<Headers, Scope.Call>;
 };

package/dist/runtimes/bun.d.ts

@@ -0,0 +1,2 @@
+import type { WsConnectionData, WsTransportOptions } from '../types.ts';
+export declare const WsTransport: import("@nmtjs/protocol/server").TransportPlugin<WsConnectionData, WsTransportOptions<"bun">>;

package/dist/runtimes/bun.js

@@ -0,0 +1,68 @@
+import { createTransport } from '@nmtjs/protocol/server';
+import createAdapter from 'crossws/adapters/bun';
+import { WsTransportServer } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+function adapterFactory(params) {
+    const adapter = createAdapter({ hooks: params.wsHooks });
+    let server = null;
+    function createServer() {
+        return globalThis.Bun.serve({
+            ...params.runtime?.server,
+            unix: params.listen.unix,
+            port: params.listen.port,
+            hostname: params.listen.hostname,
+            reusePort: params.listen.reusePort,
+            tls: params.tls
+                ? {
+                    cert: params.tls.cert,
+                    key: params.tls.key,
+                    passphrase: params.tls.passphrase,
+                }
+                : undefined,
+            websocket: {
+                ...params.runtime?.ws,
+                ...adapter.websocket,
+            },
+            routes: {
+                ...params.runtime?.server?.routes,
+                '/healthy': StatusResponse(),
+            },
+            async fetch(request, server) {
+                const url = new URL(request.url);
+                if (url.pathname.startsWith(params.apiPath)) {
+                    try {
+                        if (request.headers.get('upgrade') === 'websocket') {
+                            return await adapter.handleUpgrade(request, server);
+                        }
+                        const { body, headers, method } = request;
+                        return await params.fetchHandler({
+                            url,
+                            method,
+                            headers,
+                        }, body, request.signal);
+                    }
+                    catch (err) {
+                        params.logger.error({ err }, 'Error in fetch handler');
+                        return InternalServerErrorHttpResponse();
+                    }
+                }
+                return NotFoundHttpResponse();
+            },
+        });
+    }
+    return {
+        start: async () => {
+            server = createServer();
+            return server.url.href;
+        },
+        stop: async () => {
+            if (server) {
+                await server.stop();
+                server = null;
+            }
+        },
+    };
+}
+export const WsTransport = createTransport('WsTransport', (context, options) => {
+    return new WsTransportServer(adapterFactory, context, options);
+});

package/dist/runtimes/deno.d.ts

@@ -0,0 +1,2 @@
+import type { WsConnectionData, WsTransportOptions } from '../types.ts';
+export declare const WsTransport: import("@nmtjs/protocol/server").TransportPlugin<WsConnectionData, WsTransportOptions<"deno">>;

package/dist/runtimes/deno.js

@@ -0,0 +1,91 @@
+import { createTransport } from '@nmtjs/protocol/server';
+import createAdapter from 'crossws/adapters/deno';
+import { WsTransportServer } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+function adapterFactory(params) {
+    const adapter = createAdapter({ hooks: params.wsHooks });
+    let server = null;
+    function createServer() {
+        const listenOptions = params.listen.unix
+            ? { path: params.listen.unix }
+            : {
+                port: params.listen.port,
+                hostname: params.listen.hostname,
+                reusePort: params.listen.reusePort,
+            };
+        const options = {
+            ...listenOptions,
+            tls: params.tls
+                ? {
+                    cert: params.tls.cert,
+                    key: params.tls.key,
+                    passphrase: params.tls.passphrase,
+                }
+                : undefined,
+        };
+        return new Promise((resolve) => {
+            const server = globalThis.Deno.serve({
+                ...params.runtime?.server,
+                ...options,
+                handler: async (request, info) => {
+                    const url = new URL(request.url);
+                    if (url.pathname.startsWith(params.apiPath)) {
+                        try {
+                            if (request.headers.get('upgrade') === 'websocket') {
+                                return await adapter.handleUpgrade(request, info);
+                            }
+                            const { headers, method, body } = request;
+                            return await params.fetchHandler({
+                                url,
+                                method,
+                                headers,
+                            }, body, request.signal);
+                        }
+                        catch (err) {
+                            params.logger.error({ err }, 'Error in fetch handler');
+                            return InternalServerErrorHttpResponse();
+                        }
+                    }
+                    else if (url.pathname === '/healthy') {
+                        return StatusResponse();
+                    }
+                    return NotFoundHttpResponse();
+                },
+                onListen(addr) {
+                    setTimeout(() => {
+                        resolve({ server, addr });
+                    }, 1);
+                },
+            });
+        });
+    }
+    return {
+        start: async () => {
+            const { server: _server, addr } = await createServer();
+            server = _server;
+            switch (addr.transport) {
+                case 'unix':
+                case 'unixpacket':
+                    return `unix://${addr.path}`;
+                case 'tcp':
+                case 'udp': {
+                    const proto = params.tls ? 'https' : 'http';
+                    return `${proto}://${addr.hostname}:${addr.port}`;
+                }
+                case 'vsock':
+                    return `vsock://${addr.cid}:${addr.port}`;
+                default:
+                    throw new Error(`Unsupported address transport`);
+            }
+        },
+        stop: async () => {
+            if (server) {
+                await server.shutdown();
+                server = null;
+            }
+        },
+    };
+}
+export const WsTransport = createTransport('WsTransport', (context, options) => {
+    return new WsTransportServer(adapterFactory, context, options);
+});

package/dist/runtimes/node.d.ts

@@ -0,0 +1,2 @@
+import type { WsConnectionData, WsTransportOptions } from '../types.ts';
+export declare const WsTransport: import("@nmtjs/protocol/server").TransportPlugin<WsConnectionData, WsTransportOptions<"node">>;

package/dist/runtimes/node.js

@@ -0,0 +1,127 @@
+import { App, SSLApp } from 'uWebSockets.js';
+import { createTransport } from '@nmtjs/protocol/server';
+import createAdapter from 'crossws/adapters/uws';
+import { WsTransportServer } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+function adapterFactory(params) {
+    const adapter = createAdapter({ hooks: params.wsHooks });
+    const server = params.tls
+        ? SSLApp({
+            passphrase: params.tls.passphrase,
+            key_file_name: params.tls.key,
+            cert_file_name: params.tls.cert,
+        })
+        : App();
+    server
+        .ws(params.apiPath, {
+        ...params.runtime?.ws,
+        ...adapter.websocket,
+    })
+        .get('/healthy', async (res) => {
+        res.onAborted(() => { });
+        const response = StatusResponse();
+        res.cork(async () => {
+            res
+                .writeStatus(`${response.status} ${response.statusText}`)
+                .end(await response.arrayBuffer());
+        });
+    })
+        .any('/*', async (res, req) => {
+        const controller = new AbortController();
+        res.onAborted(() => controller.abort());
+        let response = NotFoundHttpResponse();
+        const headers = new Headers();
+        const method = req.getMethod();
+        req.forEach((k, v) => headers.append(k, v));
+        const host = headers.get('host') || 'localhost';
+        const proto = headers.get('x-forwarded-proto') || params.tls ? 'https' : 'http';
+        const url = new URL(req.getUrl(), `${proto}://${host}`);
+        if (url.pathname.startsWith(params.apiPath)) {
+            try {
+                const body = new ReadableStream({
+                    start(controller) {
+                        res.onData((chunk, isLast) => {
+                            if (chunk)
+                                controller.enqueue(Buffer.from(chunk.slice(0)));
+                            if (isLast)
+                                controller.close();
+                        });
+                        res.onAborted(() => controller.error());
+                    },
+                });
+                response = await params.fetchHandler({
+                    url,
+                    method,
+                    headers,
+                }, body, controller.signal);
+            }
+            catch (err) {
+                params.logger.error({ err }, 'Error in fetch handler');
+                response = InternalServerErrorHttpResponse();
+            }
+        }
+        if (controller.signal.aborted)
+            return undefined;
+        else {
+            res.cork(() => {
+                res.writeStatus(`${response.status.toString()} ${response.statusText}`);
+                response.headers.forEach((v, k) => res.writeHeader(k, v));
+            });
+            if (response.body) {
+                try {
+                    const reader = response.body.getReader();
+                    let chunk = await reader.read();
+                    do {
+                        if (controller.signal.aborted)
+                            break;
+                        if (chunk.value)
+                            res.write(chunk.value);
+                        chunk = await reader.read();
+                    } while (!chunk.done);
+                    res.end();
+                }
+                catch {
+                    res.close();
+                }
+            }
+            else {
+                res.end();
+            }
+        }
+    });
+    return {
+        start: () => new Promise((resolve, reject) => {
+            if (params.listen.unix) {
+                server.listen_unix((socket) => {
+                    if (socket) {
+                        resolve('unix://' + params.listen.unix);
+                    }
+                    else {
+                        reject(new Error('Failed to start WebSockets server'));
+                    }
+                }, params.listen.unix);
+            }
+            else if (typeof params.listen.port === 'number') {
+                const proto = params.tls ? 'https' : 'http';
+                const hostname = params.listen.hostname || '127.0.0.1';
+                server.listen(hostname, params.listen.port, (socket) => {
+                    if (socket) {
+                        resolve(`${proto}://${hostname}:${params.listen.port}`);
+                    }
+                    else {
+                        reject(new Error('Failed to start WebSockets server'));
+                    }
+                });
+            }
+            else {
+                reject(new Error('Invalid listen parameters'));
+            }
+        }),
+        stop: () => {
+            server.close();
+        },
+    };
+}
+export const WsTransport = createTransport('WsTransport', (context, options) => {
+    return new WsTransportServer(adapterFactory, context, options);
+});

package/dist/server.d.ts

@@ -1,27 +1,30 @@
-import { type HttpRequest, type HttpResponse, type TemplatedApp } from 'uWebSockets.js';
 import { ClientMessageType, type ServerMessageType } from '@nmtjs/protocol';
 import { Connection, type Transport, type TransportPluginContext } from '@nmtjs/protocol/server';
-import type { WsConnectionData, WsTransportOptions, WsTransportSocket } from './types.ts';
+import { type Peer } from 'crossws';
+import type { WsAdapterServerFactory, WsConnectionData, WsTransportOptions, WsTransportServerRequest } from './types.ts';
 export declare class WsTransportServer implements Transport<WsConnectionData> {
+    #private;
+    protected readonly adapterFactory: WsAdapterServerFactory<any>;
     protected readonly context: TransportPluginContext;
     protected readonly options: WsTransportOptions;
-    protected server: TemplatedApp;
-    protected clients: Map<string, WsTransportSocket>;
-    constructor(context: TransportPluginContext, options: WsTransportOptions);
-    send(connection: Connection<WsConnectionData>, messageType: ServerMessageType, buffer: ArrayBuffer): void;
+    clients: Map<string, Peer<import("crossws").AdapterInternal>>;
+    constructor(adapterFactory: WsAdapterServerFactory<any>, context: TransportPluginContext, options: WsTransportOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
-    protected httpHandler(res: HttpResponse, req: HttpRequest): Promise<undefined>;
+    send(connection: Connection<WsConnectionData>, messageType: ServerMessageType, buffer: ArrayBuffer): void;
+    httpHandler(request: WsTransportServerRequest, body: ReadableStream | null, requestSignal: AbortSignal): Promise<Response>;
+    private applyCors;
     protected get protocol(): import("@nmtjs/protocol/server").Protocol;
     protected get logger(): import("@nmtjs/core").Logger;
     protected logError(cause: any, message?: string): Promise<void>;
-    protected applyCors(res: HttpResponse, req: HttpRequest): void;
-    protected [ClientMessageType.Rpc](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.RpcAbort](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.RpcStreamAbort](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.ClientStreamPush](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.ClientStreamEnd](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.ClientStreamAbort](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.ServerStreamPull](ws: WsTransportSocket, buffer: ArrayBuffer): void;
-    protected [ClientMessageType.ServerStreamAbort](ws: WsTransportSocket, buffer: ArrayBuffer): void;
+    protected [ClientMessageType.Rpc](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.RpcAbort](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.RpcStreamAbort](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.ClientStreamPush](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.ClientStreamEnd](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.ClientStreamAbort](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.ServerStreamPull](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    protected [ClientMessageType.ServerStreamAbort](peer: Peer, buffer: ArrayBuffer, connectionId: string): void;
+    private createWsHooks;
+    private createServer;
 }