@nmtjs/ws-transport 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/index.js

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

package/dist/injectables.js

@@ -0,0 +1,2 @@
+import { connectionData as connectionDataInjectable } from '@nmtjs/gateway';
+export const connectionData = connectionDataInjectable.$withType();

package/dist/runtimes/bun.js

@@ -0,0 +1,60 @@
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import createAdapter from 'crossws/adapters/bun';
+import * as injectables from "../injectables.js";
+import { createWSTransportWorker } 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(
+        // @ts-expect-error ts bs
+        {
+            ...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: { '/healthy': StatusResponse() },
+            async fetch(request, server) {
+                try {
+                    if (request.headers.get('upgrade') === 'websocket') {
+                        return await adapter.handleUpgrade(request, server);
+                    }
+                }
+                catch (err) {
+                    console.error('Error in WebSocket fetch handler', err);
+                    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 = {
+    proxyable: ProxyableTransportType.WebSocket,
+    injectables,
+    factory(options) {
+        return createWSTransportWorker(adapterFactory, options);
+    },
+};

package/dist/runtimes/deno.js

@@ -0,0 +1,83 @@
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import createAdapter from 'crossws/adapters/deno';
+import * as injectables from "../injectables.js";
+import { createWSTransportWorker } 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 === '/healthy')
+                        return StatusResponse();
+                    try {
+                        if (request.headers.get('upgrade') === 'websocket') {
+                            return await adapter.handleUpgrade(request, info);
+                        }
+                    }
+                    catch (err) {
+                        console.error('Error in WebSocket fetch handler', err);
+                        return InternalServerErrorHttpResponse();
+                    }
+                    return NotFoundHttpResponse();
+                },
+                onListen(addr) {
+                    setTimeout(() => {
+                        resolve({ server, addr });
+                    }, 1);
+                },
+            });
+        });
+    }
+    return {
+        start: async () => {
+            const { server: _server, addr } = await createServer();
+            server = _server;
+            const proto = params.tls ? 'https' : 'http';
+            switch (addr.transport) {
+                case 'unix':
+                    return `${proto}+unix://${addr.path}`;
+                case 'tcp': {
+                    return `${proto}://${addr.hostname}:${addr.port}`;
+                }
+                default:
+                    throw new Error(`Unsupported address transport`);
+            }
+        },
+        stop: async () => {
+            if (server) {
+                await server.shutdown();
+                server = null;
+            }
+        },
+    };
+}
+export const WsTransport = {
+    proxyable: ProxyableTransportType.WebSocket,
+    injectables,
+    factory(options) {
+        return createWSTransportWorker(adapterFactory, options);
+    },
+};

package/dist/runtimes/node.js

@@ -0,0 +1,66 @@
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import createAdapter from 'crossws/adapters/uws';
+import * as injectables from "../injectables.js";
+import { createWSTransportWorker } from "../server.js";
+import { StatusResponse } from "../utils.js";
+import { App, SSLApp, us_socket_local_port } from 'uWebSockets.js';
+const statusResponse = StatusResponse();
+const statusResponseBuffer = await statusResponse.arrayBuffer();
+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.runtime?.ws, ...adapter.websocket })
+        .get('/healthy', (res) => {
+        res.cork(() => {
+            res
+                .writeStatus(`${statusResponse.status} ${statusResponse.statusText}`)
+                .end(statusResponseBuffer);
+        });
+    });
+    return {
+        start: () => new Promise((resolve, reject) => {
+            const proto = params.tls ? 'https' : 'http';
+            if (params.listen.unix) {
+                server.listen_unix((socket) => {
+                    if (socket) {
+                        resolve(`${proto}+unix://` + params.listen.unix);
+                    }
+                    else {
+                        reject(new Error('Failed to start WebSockets server'));
+                    }
+                }, params.listen.unix);
+            }
+            else if (typeof params.listen.port === 'number') {
+                const hostname = params.listen.hostname || '127.0.0.1';
+                server.listen(hostname, params.listen.port, (socket) => {
+                    if (socket) {
+                        resolve(`${proto}://${hostname}:${us_socket_local_port(socket)}`);
+                    }
+                    else {
+                        reject(new Error('Failed to start WebSockets server'));
+                    }
+                });
+            }
+            else {
+                reject(new Error('Invalid listen parameters'));
+            }
+        }),
+        stop: () => {
+            server.close();
+        },
+    };
+}
+export const WsTransport = {
+    proxyable: ProxyableTransportType.WebSocket,
+    injectables,
+    factory(options) {
+        return createWSTransportWorker(adapterFactory, options);
+    },
+};

package/dist/server.js

@@ -0,0 +1,119 @@
+import { ConnectionType, ProtocolVersion } from '@nmtjs/protocol';
+import { defineHooks } from 'crossws';
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, } from "./utils.js";
+export function createWSTransportWorker(adapterFactory, options) {
+    return new WsTransportServer(adapterFactory, options);
+}
+export class WsTransportServer {
+    adapterFactory;
+    options;
+    #server;
+    params;
+    clients = new Map();
+    constructor(adapterFactory, options) {
+        this.adapterFactory = adapterFactory;
+        this.options = options;
+        this.#server = this.createServer();
+    }
+    async start(hooks) {
+        this.params = hooks;
+        return await this.#server.start();
+    }
+    async stop() {
+        for (const peer of this.clients.values()) {
+            try {
+                peer.close(1001, 'Transport stopped');
+            }
+            catch (error) {
+                console.error(`Failed to close WebSocket connection ${peer.context.connectionId}`, error);
+            }
+        }
+        this.clients.clear();
+        await this.#server.stop();
+    }
+    send(connectionId, buffer) {
+        const peer = this.clients.get(connectionId);
+        if (!peer)
+            return false;
+        try {
+            const result = peer.send(buffer);
+            if (typeof result === 'boolean')
+                return result;
+            if (typeof result === 'number')
+                return result > 0;
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to send data over WebSocket connection ${connectionId}`, error);
+            this.clients.delete(connectionId);
+            return false;
+        }
+    }
+    createWsHooks() {
+        return defineHooks({
+            upgrade: async (req) => {
+                const url = new URL(req.url);
+                if (url.pathname !== '/') {
+                    return NotFoundHttpResponse();
+                }
+                const request = {
+                    url,
+                    headers: req.headers,
+                    method: req.method,
+                };
+                const accept = url.searchParams.get('accept') ?? req.headers.get('accept');
+                const contentType = url.searchParams.get('content-type') ??
+                    req.headers.get('content-type');
+                try {
+                    const connection = await this.params.onConnect({
+                        type: ConnectionType.Bidirectional,
+                        protocolVersion: ProtocolVersion.v1,
+                        accept,
+                        contentType,
+                        data: request,
+                    });
+                    return { context: { connectionId: connection.id } };
+                }
+                catch (error) {
+                    console.error('Failed to upgrade WebSocket connection', error);
+                    return InternalServerErrorHttpResponse();
+                }
+            },
+            open: (peer) => {
+                const { connectionId } = peer.context;
+                this.clients.set(connectionId, peer);
+            },
+            message: async (peer, message) => {
+                const data = message.arrayBuffer();
+                try {
+                    await this.params.onMessage({
+                        connectionId: peer.context.connectionId,
+                        data,
+                    });
+                }
+                catch (error) {
+                    console.error(`Error while processing message from ${peer.context.connectionId}`, error);
+                    this.clients.delete(peer.context.connectionId);
+                    peer.close(1011, 'Internal error');
+                }
+            },
+            error: (peer, error) => {
+                console.error(`WebSocket error on connection ${peer.context.connectionId}`, error);
+            },
+            close: async (peer) => {
+                this.clients.delete(peer.context.connectionId);
+                try {
+                    await this.params.onDisconnect(peer.context.connectionId);
+                }
+                catch (error) {
+                    console.error(`Failed to dispose WebSocket connection ${peer.context.connectionId}`, error);
+                }
+            },
+        });
+    }
+    createServer() {
+        const hooks = this.createWsHooks();
+        const opts = { ...this.options, wsHooks: hooks };
+        return this.adapterFactory(opts);
+    }
+}

package/dist/types.js

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

package/dist/utils.js

@@ -0,0 +1,15 @@
+import { ErrorCode } from '@nmtjs/protocol';
+import { ProtocolError } from '@nmtjs/protocol/server';
+export const InternalError = (message = 'Internal Server Error') => new ProtocolError(ErrorCode.InternalServerError, message);
+export const NotFoundError = (message = 'Not Found') => new ProtocolError(ErrorCode.NotFound, message);
+export const ForbiddenError = (message = 'Forbidden') => new ProtocolError(ErrorCode.Forbidden, message);
+export const RequestTimeoutError = (message = 'Request Timeout') => new ProtocolError(ErrorCode.RequestTimeout, message);
+export const NotFoundHttpResponse = () => new Response('Not Found', {
+    status: 404,
+    headers: { 'Content-Type': 'text/plain' },
+});
+export const InternalServerErrorHttpResponse = () => new Response('Internal Server Error', {
+    status: 500,
+    headers: { 'Content-Type': 'text/plain' },
+});
+export const StatusResponse = () => new Response('OK', { status: 200 });

package/package.json

@@ -12,20 +12,20 @@
   },
   "devDependencies": {
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0",
-    "@nmtjs/client": "0.15.0-beta.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/gateway": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/client": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/gateway": "0.15.0-beta.2"
   },
   "peerDependencies": {
     "@types/bun": "^1.3.0",
     "@types/deno": "^2.3.0",
     "@types/node": "^24",
     "uWebSockets.js": "^20.56.0",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/gateway": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/gateway": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/core": "0.15.0-beta.2"
   },
   "peerDependenciesMeta": {
     "@types/bun": {
@@ -51,7 +51,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",