@webiny/api-websockets-standalone 6.6.0-alpha.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-websockets-standalone
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/WebsocketsStandaloneFeature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Per-request real-time transport for the standalone server: registers `ServerWebsocketsTransport`,
+ * overriding the domain's NullWebsocketsTransport. Resolves the shared connection manager + adapter
+ * from the root (registered there as singletons by the handler). Exposed as a Feature so the handler's
+ * `transports` wiring reads uniformly (`WebsocketsStandaloneFeature.register(c)`).
+ */
+export declare const WebsocketsStandaloneFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/WebsocketsStandaloneFeature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ServerWebsocketsTransport } from "./transport/ServerWebsocketsTransport.js";
+const WebsocketsStandaloneFeature = createFeature({
+    name: "WebsocketsServer",
+    register (container) {
+        container.register(ServerWebsocketsTransport);
+    }
+});
+export { WebsocketsStandaloneFeature };
+
+//# sourceMappingURL=WebsocketsStandaloneFeature.js.map

package/WebsocketsStandaloneFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketsStandaloneFeature.js","sources":["../src/WebsocketsStandaloneFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ServerWebsocketsTransport } from \"~/transport/ServerWebsocketsTransport.js\";\n\n/**\n * Per-request real-time transport for the standalone server: registers `ServerWebsocketsTransport`,\n * overriding the domain's NullWebsocketsTransport. Resolves the shared connection manager + adapter\n * from the root (registered there as singletons by the handler). Exposed as a Feature so the handler's\n * `transports` wiring reads uniformly (`WebsocketsStandaloneFeature.register(c)`).\n */\nexport const WebsocketsStandaloneFeature = createFeature({\n    name: \"WebsocketsServer\",\n    register(container) {\n        container.register(ServerWebsocketsTransport);\n    }\n});\n"],"names":["WebsocketsStandaloneFeature","createFeature","container","ServerWebsocketsTransport"],"mappings":";;AASO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/adapter/NodeWsAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { Server as HttpServer } from "node:http";
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+import { WebSocket } from "ws";
+import { WebsocketsServerAdapter } from "./abstractions.js";
+declare class NodeWsAdapterImpl implements WebsocketsServerAdapter.Interface<WebSocket> {
+    private wss;
+    private getWss;
+    start(_server: HttpServer): void;
+    handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void;
+    stop(): Promise<void>;
+    onConnection(cb: (socket: WebSocket, request: import("node:http").IncomingMessage) => void): void;
+    onMessage(socket: WebSocket, cb: (data: Buffer) => void): void;
+    onClose(socket: WebSocket, cb: (code: number, reason: Buffer) => void): void;
+    onError(socket: WebSocket, cb: (error: Error) => void): void;
+    send(socket: WebSocket, data: string): Promise<void>;
+    close(socket: WebSocket, code?: number, reason?: string): void;
+}
+export { NodeWsAdapterImpl };
+export declare const NodeWsAdapter: typeof NodeWsAdapterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWebsocketsServerAdapter<unknown>>;
+};

package/adapter/NodeWsAdapter.js

@@ -0,0 +1,58 @@
+import { WebSocketServer } from "ws";
+import { WebsocketsServerAdapter } from "./abstractions.js";
+class NodeWsAdapterImpl {
+    getWss() {
+        if (!this.wss) throw new Error("WebSocketServer has not been started. Call start() first.");
+        return this.wss;
+    }
+    start(_server) {
+        this.wss = new WebSocketServer({
+            noServer: true
+        });
+    }
+    handleUpgrade(request, socket, head) {
+        this.getWss().handleUpgrade(request, socket, head, (ws)=>{
+            this.getWss().emit("connection", ws, request);
+        });
+    }
+    stop() {
+        const wss = this.getWss();
+        for (const client of wss.clients)client.terminate();
+        return new Promise((resolve, reject)=>{
+            wss.close((err)=>{
+                if (err) return void reject(err);
+                resolve();
+            });
+        });
+    }
+    onConnection(cb) {
+        this.getWss().on("connection", cb);
+    }
+    onMessage(socket, cb) {
+        socket.on("message", cb);
+    }
+    onClose(socket, cb) {
+        socket.on("close", cb);
+    }
+    onError(socket, cb) {
+        socket.on("error", cb);
+    }
+    send(socket, data) {
+        return new Promise((resolve, reject)=>{
+            socket.send(data, (err)=>{
+                if (err) return void reject(err);
+                resolve();
+            });
+        });
+    }
+    close(socket, code, reason) {
+        socket.close(code, reason);
+    }
+}
+const NodeWsAdapter = WebsocketsServerAdapter.createImplementation({
+    implementation: NodeWsAdapterImpl,
+    dependencies: []
+});
+export { NodeWsAdapter, NodeWsAdapterImpl };
+
+//# sourceMappingURL=NodeWsAdapter.js.map

package/adapter/NodeWsAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter/NodeWsAdapter.js","sources":["../../src/adapter/NodeWsAdapter.ts"],"sourcesContent":["import type { Server as HttpServer } from \"node:http\";\nimport type { IncomingMessage } from \"node:http\";\nimport type { Duplex } from \"node:stream\";\nimport { WebSocketServer } from \"ws\";\nimport { WebSocket } from \"ws\";\nimport { WebsocketsServerAdapter } from \"./abstractions.js\";\n\nclass NodeWsAdapterImpl implements WebsocketsServerAdapter.Interface<WebSocket> {\n    private wss: WebSocketServer | undefined;\n\n    private getWss(): WebSocketServer {\n        if (!this.wss) {\n            throw new Error(\"WebSocketServer has not been started. Call start() first.\");\n        }\n        return this.wss;\n    }\n\n    /* The server param is kept for interface compliance but not used —\n       the HTTP upgrade event is handled externally via handleUpgrade(). */\n    public start(_server: HttpServer): void {\n        this.wss = new WebSocketServer({ noServer: true });\n    }\n\n    public handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void {\n        this.getWss().handleUpgrade(request, socket, head, ws => {\n            this.getWss().emit(\"connection\", ws, request);\n        });\n    }\n\n    public stop(): Promise<void> {\n        const wss = this.getWss();\n        /* Terminate all open client connections so wss.close() resolves immediately. */\n        for (const client of wss.clients) {\n            client.terminate();\n        }\n        return new Promise((resolve, reject) => {\n            wss.close(err => {\n                if (err) {\n                    reject(err);\n                    return;\n                }\n                resolve();\n            });\n        });\n    }\n\n    public onConnection(\n        cb: (socket: WebSocket, request: import(\"node:http\").IncomingMessage) => void\n    ): void {\n        this.getWss().on(\"connection\", cb);\n    }\n\n    public onMessage(socket: WebSocket, cb: (data: Buffer) => void): void {\n        socket.on(\"message\", cb);\n    }\n\n    public onClose(socket: WebSocket, cb: (code: number, reason: Buffer) => void): void {\n        socket.on(\"close\", cb);\n    }\n\n    public onError(socket: WebSocket, cb: (error: Error) => void): void {\n        socket.on(\"error\", cb);\n    }\n\n    public send(socket: WebSocket, data: string): Promise<void> {\n        return new Promise((resolve, reject) => {\n            socket.send(data, err => {\n                if (err) {\n                    reject(err);\n                    return;\n                }\n                resolve();\n            });\n        });\n    }\n\n    public close(socket: WebSocket, code?: number, reason?: string): void {\n        socket.close(code, reason);\n    }\n}\n\nexport { NodeWsAdapterImpl };\n\nexport const NodeWsAdapter = WebsocketsServerAdapter.createImplementation({\n    implementation: NodeWsAdapterImpl,\n    dependencies: []\n});\n"],"names":["NodeWsAdapterImpl","Error","_server","WebSocketServer","request","socket","head","ws","wss","client","Promise","resolve","reject","err","cb","data","code","reason","NodeWsAdapter","WebsocketsServerAdapter"],"mappings":";;AAOA,MAAMA;IAGM,SAA0B;QAC9B,IAAI,CAAC,IAAI,CAAC,GAAG,EACT,MAAM,IAAIC,MAAM;QAEpB,OAAO,IAAI,CAAC,GAAG;IACnB;IAIO,MAAMC,OAAmB,EAAQ;QACpC,IAAI,CAAC,GAAG,GAAG,IAAIC,gBAAgB;YAAE,UAAU;QAAK;IACpD;IAEO,cAAcC,OAAwB,EAAEC,MAAc,EAAEC,IAAY,EAAQ;QAC/E,IAAI,CAAC,MAAM,GAAG,aAAa,CAACF,SAASC,QAAQC,MAAMC,CAAAA;YAC/C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,cAAcA,IAAIH;QACzC;IACJ;IAEO,OAAsB;QACzB,MAAMI,MAAM,IAAI,CAAC,MAAM;QAEvB,KAAK,MAAMC,UAAUD,IAAI,OAAO,CAC5BC,OAAO,SAAS;QAEpB,OAAO,IAAIC,QAAQ,CAACC,SAASC;YACzBJ,IAAI,KAAK,CAACK,CAAAA;gBACN,IAAIA,KAAK,YACLD,OAAOC;gBAGXF;YACJ;QACJ;IACJ;IAEO,aACHG,EAA6E,EACzE;QACJ,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,cAAcA;IACnC;IAEO,UAAUT,MAAiB,EAAES,EAA0B,EAAQ;QAClET,OAAO,EAAE,CAAC,WAAWS;IACzB;IAEO,QAAQT,MAAiB,EAAES,EAA0C,EAAQ;QAChFT,OAAO,EAAE,CAAC,SAASS;IACvB;IAEO,QAAQT,MAAiB,EAAES,EAA0B,EAAQ;QAChET,OAAO,EAAE,CAAC,SAASS;IACvB;IAEO,KAAKT,MAAiB,EAAEU,IAAY,EAAiB;QACxD,OAAO,IAAIL,QAAQ,CAACC,SAASC;YACzBP,OAAO,IAAI,CAACU,MAAMF,CAAAA;gBACd,IAAIA,KAAK,YACLD,OAAOC;gBAGXF;YACJ;QACJ;IACJ;IAEO,MAAMN,MAAiB,EAAEW,IAAa,EAAEC,MAAe,EAAQ;QAClEZ,OAAO,KAAK,CAACW,MAAMC;IACvB;AACJ;AAIO,MAAMC,gBAAgBC,wBAAwB,oBAAoB,CAAC;IACtE,gBAAgBnB;IAChB,cAAc,EAAE;AACpB"}

package/adapter/abstractions.d.ts

@@ -0,0 +1,18 @@
+import type { Server as HttpServer } from "node:http";
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+export interface IWebsocketsServerAdapter<TSocket> {
+    start(server: HttpServer): void;
+    stop(): Promise<void>;
+    onConnection(cb: (socket: TSocket, request: IncomingMessage) => void): void;
+    onMessage(socket: TSocket, cb: (data: Buffer) => void): void;
+    onClose(socket: TSocket, cb: (code: number, reason: Buffer) => void): void;
+    onError(socket: TSocket, cb: (error: Error) => void): void;
+    send(socket: TSocket, data: string): Promise<void>;
+    close(socket: TSocket, code?: number, reason?: string): void;
+    handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void;
+}
+export declare const WebsocketsServerAdapter: import("@webiny/di").Abstraction<IWebsocketsServerAdapter<unknown>>;
+export declare namespace WebsocketsServerAdapter {
+    type Interface<TSocket> = IWebsocketsServerAdapter<TSocket>;
+}

package/adapter/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WebsocketsServerAdapter = createAbstraction("WebsocketsServerAdapter");
+export { WebsocketsServerAdapter };
+
+//# sourceMappingURL=abstractions.js.map

package/adapter/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter/abstractions.js","sources":["../../src/adapter/abstractions.ts"],"sourcesContent":["import type { Server as HttpServer } from \"node:http\";\nimport type { IncomingMessage } from \"node:http\";\nimport type { Duplex } from \"node:stream\";\nimport { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IWebsocketsServerAdapter<TSocket> {\n    start(server: HttpServer): void;\n    stop(): Promise<void>;\n    onConnection(cb: (socket: TSocket, request: IncomingMessage) => void): void;\n    onMessage(socket: TSocket, cb: (data: Buffer) => void): void;\n    onClose(socket: TSocket, cb: (code: number, reason: Buffer) => void): void;\n    onError(socket: TSocket, cb: (error: Error) => void): void;\n    send(socket: TSocket, data: string): Promise<void>;\n    close(socket: TSocket, code?: number, reason?: string): void;\n    handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void;\n}\n\nexport const WebsocketsServerAdapter =\n    createAbstraction<IWebsocketsServerAdapter<unknown>>(\"WebsocketsServerAdapter\");\n\nexport namespace WebsocketsServerAdapter {\n    export type Interface<TSocket> = IWebsocketsServerAdapter<TSocket>;\n}\n"],"names":["WebsocketsServerAdapter","createAbstraction"],"mappings":";AAiBO,MAAMA,0BACTC,kBAAqD"}

package/adapter/types.d.ts

@@ -0,0 +1,2 @@
+import type { WebSocket } from "ws";
+export type NodeSocket = WebSocket;

package/connectionManager/ServerConnectionManager.d.ts

@@ -0,0 +1,18 @@
+import { ConnectionRegistry } from "@webiny/api-websockets/exports/api.js";
+import { WebsocketsConnectionManager } from "./abstractions.js";
+export declare class ServerConnectionManagerImpl implements WebsocketsConnectionManager.Interface<unknown> {
+    private readonly registry;
+    private readonly sockets;
+    private readonly metadata;
+    constructor(registry: ConnectionRegistry.Interface);
+    add(params: WebsocketsConnectionManager.AddParams<unknown>): Promise<void>;
+    remove(connectionId: string): Promise<void>;
+    getSocket(connectionId: string): unknown | undefined;
+    getMetadata(connectionId: string): WebsocketsConnectionManager.ConnectionMetadata | undefined;
+    updateLastSeen(connectionId: string): Promise<void>;
+    cleanup(maxAge: number): Promise<string[]>;
+    getActiveConnectionIds(): string[];
+}
+export declare const ServerConnectionManager: typeof ServerConnectionManagerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWebsocketsConnectionManager<unknown>>;
+};

package/connectionManager/ServerConnectionManager.js

@@ -0,0 +1,69 @@
+import { ConnectionRegistry } from "@webiny/api-websockets/exports/api.js";
+import { WebsocketsConnectionManager } from "./abstractions.js";
+class ServerConnectionManagerImpl {
+    constructor(registry){
+        this.registry = registry;
+        this.sockets = new Map();
+        this.metadata = new Map();
+    }
+    async add(params) {
+        this.sockets.set(params.connectionId, params.socket);
+        this.metadata.set(params.connectionId, {
+            connectionId: params.connectionId,
+            endpoint: params.endpoint,
+            connectedAt: params.connectedAt,
+            host: params.host,
+            headers: params.headers
+        });
+        await this.registry.register({
+            connectionId: params.connectionId,
+            identity: params.identity,
+            tenant: params.tenant,
+            endpoint: params.endpoint,
+            connectedOn: new Date(params.connectedAt).toISOString()
+        });
+    }
+    async remove(connectionId) {
+        this.sockets.delete(connectionId);
+        this.metadata.delete(connectionId);
+        try {
+            await this.registry.unregister({
+                connectionId
+            });
+        } catch (err) {
+            if ("CONNECTION_NOT_FOUND" === err.code) return;
+            throw err;
+        }
+    }
+    getSocket(connectionId) {
+        return this.sockets.get(connectionId);
+    }
+    getMetadata(connectionId) {
+        return this.metadata.get(connectionId);
+    }
+    async updateLastSeen(connectionId) {
+        await this.registry.updateLastSeen(connectionId);
+    }
+    async cleanup(maxAge) {
+        const olderThan = new Date(Date.now() - maxAge);
+        const stale = await this.registry.listStale(olderThan);
+        const removed = [];
+        for (const entry of stale){
+            await this.remove(entry.connectionId);
+            removed.push(entry.connectionId);
+        }
+        return removed;
+    }
+    getActiveConnectionIds() {
+        return Array.from(this.sockets.keys());
+    }
+}
+const ServerConnectionManager = WebsocketsConnectionManager.createImplementation({
+    implementation: ServerConnectionManagerImpl,
+    dependencies: [
+        ConnectionRegistry
+    ]
+});
+export { ServerConnectionManager, ServerConnectionManagerImpl };
+
+//# sourceMappingURL=ServerConnectionManager.js.map

package/connectionManager/ServerConnectionManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionManager/ServerConnectionManager.js","sources":["../../src/connectionManager/ServerConnectionManager.ts"],"sourcesContent":["import { ConnectionRegistry } from \"@webiny/api-websockets/exports/api.js\";\nimport { WebsocketsConnectionManager } from \"./abstractions.js\";\n\nexport class ServerConnectionManagerImpl implements WebsocketsConnectionManager.Interface<unknown> {\n    private readonly sockets = new Map<string, unknown>();\n    private readonly metadata = new Map<string, WebsocketsConnectionManager.ConnectionMetadata>();\n\n    public constructor(private readonly registry: ConnectionRegistry.Interface) {}\n\n    public async add(params: WebsocketsConnectionManager.AddParams<unknown>): Promise<void> {\n        this.sockets.set(params.connectionId, params.socket);\n        this.metadata.set(params.connectionId, {\n            connectionId: params.connectionId,\n            endpoint: params.endpoint,\n            connectedAt: params.connectedAt,\n            host: params.host,\n            headers: params.headers\n        });\n\n        // Save the connection to the shared registry. This is what lets the server later push a\n        // message to a specific user — e.g. when a background task finishes and calls\n        // SendToIdentity. That flow looks connections up in the registry by identity id to get their\n        // connection ids, then comes back here to fetch each live socket by connection id and send.\n        // The in-memory map above only answers \"socket for this connection id?\" — it can't be\n        // searched by identity, so without this registry row a targeted send finds nobody. The\n        // registry stores `connectedOn` as an ISO string (it compares connections against a recency\n        // cutoff), so we convert the epoch-ms `connectedAt`.\n        await this.registry.register({\n            connectionId: params.connectionId,\n            identity: params.identity,\n            tenant: params.tenant,\n            endpoint: params.endpoint,\n            connectedOn: new Date(params.connectedAt).toISOString()\n        });\n    }\n\n    public async remove(connectionId: string): Promise<void> {\n        this.sockets.delete(connectionId);\n        this.metadata.delete(connectionId);\n        try {\n            await this.registry.unregister({ connectionId });\n        } catch (err) {\n            if ((err as any).code === \"CONNECTION_NOT_FOUND\") {\n                return;\n            }\n            throw err;\n        }\n    }\n\n    public getSocket(connectionId: string): unknown | undefined {\n        return this.sockets.get(connectionId);\n    }\n\n    public getMetadata(\n        connectionId: string\n    ): WebsocketsConnectionManager.ConnectionMetadata | undefined {\n        return this.metadata.get(connectionId);\n    }\n\n    public async updateLastSeen(connectionId: string): Promise<void> {\n        await this.registry.updateLastSeen(connectionId);\n    }\n\n    public async cleanup(maxAge: number): Promise<string[]> {\n        const olderThan = new Date(Date.now() - maxAge);\n        const stale = await this.registry.listStale(olderThan);\n        const removed: string[] = [];\n        for (const entry of stale) {\n            await this.remove(entry.connectionId);\n            removed.push(entry.connectionId);\n        }\n        return removed;\n    }\n\n    public getActiveConnectionIds(): string[] {\n        return Array.from(this.sockets.keys());\n    }\n}\n\nexport const ServerConnectionManager = WebsocketsConnectionManager.createImplementation({\n    implementation: ServerConnectionManagerImpl,\n    dependencies: [ConnectionRegistry]\n});\n"],"names":["ServerConnectionManagerImpl","registry","Map","params","Date","connectionId","err","maxAge","olderThan","stale","removed","entry","Array","ServerConnectionManager","WebsocketsConnectionManager","ConnectionRegistry"],"mappings":";;AAGO,MAAMA;IAIT,YAAoCC,QAAsC,CAAE;aAAxCA,QAAQ,GAARA;aAHnB,OAAO,GAAG,IAAIC;aACd,QAAQ,GAAG,IAAIA;IAE6C;IAE7E,MAAa,IAAIC,MAAsD,EAAiB;QACpF,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA,OAAO,YAAY,EAAEA,OAAO,MAAM;QACnD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA,OAAO,YAAY,EAAE;YACnC,cAAcA,OAAO,YAAY;YACjC,UAAUA,OAAO,QAAQ;YACzB,aAAaA,OAAO,WAAW;YAC/B,MAAMA,OAAO,IAAI;YACjB,SAASA,OAAO,OAAO;QAC3B;QAUA,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YACzB,cAAcA,OAAO,YAAY;YACjC,UAAUA,OAAO,QAAQ;YACzB,QAAQA,OAAO,MAAM;YACrB,UAAUA,OAAO,QAAQ;YACzB,aAAa,IAAIC,KAAKD,OAAO,WAAW,EAAE,WAAW;QACzD;IACJ;IAEA,MAAa,OAAOE,YAAoB,EAAiB;QACrD,IAAI,CAAC,OAAO,CAAC,MAAM,CAACA;QACpB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACA;QACrB,IAAI;YACA,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAAEA;YAAa;QAClD,EAAE,OAAOC,KAAK;YACV,IAAKA,AAAqB,2BAArBA,IAAY,IAAI,EACjB;YAEJ,MAAMA;QACV;IACJ;IAEO,UAAUD,YAAoB,EAAuB;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA;IAC5B;IAEO,YACHA,YAAoB,EACsC;QAC1D,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA;IAC7B;IAEA,MAAa,eAAeA,YAAoB,EAAiB;QAC7D,MAAM,IAAI,CAAC,QAAQ,CAAC,cAAc,CAACA;IACvC;IAEA,MAAa,QAAQE,MAAc,EAAqB;QACpD,MAAMC,YAAY,IAAIJ,KAAKA,KAAK,GAAG,KAAKG;QACxC,MAAME,QAAQ,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,CAACD;QAC5C,MAAME,UAAoB,EAAE;QAC5B,KAAK,MAAMC,SAASF,MAAO;YACvB,MAAM,IAAI,CAAC,MAAM,CAACE,MAAM,YAAY;YACpCD,QAAQ,IAAI,CAACC,MAAM,YAAY;QACnC;QACA,OAAOD;IACX;IAEO,yBAAmC;QACtC,OAAOE,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI;IACvC;AACJ;AAEO,MAAMC,0BAA0BC,4BAA4B,oBAAoB,CAAC;IACpF,gBAAgBd;IAChB,cAAc;QAACe;KAAmB;AACtC"}

package/connectionManager/abstractions.d.ts

@@ -0,0 +1,33 @@
+import { ConnectionRegistry } from "@webiny/api-websockets/exports/api.js";
+export interface IWebsocketsConnectionManagerAddParams<TSocket> {
+    connectionId: string;
+    socket: TSocket;
+    endpoint: string;
+    identity: ConnectionRegistry.Identity;
+    tenant: string;
+    connectedAt: number;
+    host: string;
+    headers: Record<string, string>;
+}
+export interface IWebsocketsConnectionManagerMetadata {
+    connectionId: string;
+    endpoint: string;
+    connectedAt: number;
+    host: string;
+    headers: Record<string, string>;
+}
+export interface IWebsocketsConnectionManager<TSocket> {
+    add(params: IWebsocketsConnectionManagerAddParams<TSocket>): Promise<void>;
+    remove(connectionId: string): Promise<void>;
+    getSocket(connectionId: string): TSocket | undefined;
+    getMetadata(connectionId: string): IWebsocketsConnectionManagerMetadata | undefined;
+    updateLastSeen(connectionId: string): Promise<void>;
+    cleanup(maxAge: number): Promise<string[]>;
+    getActiveConnectionIds(): string[];
+}
+export declare const WebsocketsConnectionManager: import("@webiny/di").Abstraction<IWebsocketsConnectionManager<unknown>>;
+export declare namespace WebsocketsConnectionManager {
+    type Interface<TSocket> = IWebsocketsConnectionManager<TSocket>;
+    type AddParams<TSocket> = IWebsocketsConnectionManagerAddParams<TSocket>;
+    type ConnectionMetadata = IWebsocketsConnectionManagerMetadata;
+}

package/connectionManager/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WebsocketsConnectionManager = createAbstraction("WebsocketsConnectionManager");
+export { WebsocketsConnectionManager };
+
+//# sourceMappingURL=abstractions.js.map

package/connectionManager/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionManager/abstractions.js","sources":["../../src/connectionManager/abstractions.ts"],"sourcesContent":["import { ConnectionRegistry } from \"@webiny/api-websockets/exports/api.js\";\nimport { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IWebsocketsConnectionManagerAddParams<TSocket> {\n    connectionId: string;\n    socket: TSocket;\n    endpoint: string;\n    identity: ConnectionRegistry.Identity;\n    tenant: string;\n    connectedAt: number;\n    host: string;\n    headers: Record<string, string>;\n}\n\nexport interface IWebsocketsConnectionManagerMetadata {\n    connectionId: string;\n    endpoint: string;\n    connectedAt: number;\n    host: string;\n    headers: Record<string, string>;\n}\n\nexport interface IWebsocketsConnectionManager<TSocket> {\n    add(params: IWebsocketsConnectionManagerAddParams<TSocket>): Promise<void>;\n    remove(connectionId: string): Promise<void>;\n    getSocket(connectionId: string): TSocket | undefined;\n    getMetadata(connectionId: string): IWebsocketsConnectionManagerMetadata | undefined;\n    updateLastSeen(connectionId: string): Promise<void>;\n    cleanup(maxAge: number): Promise<string[]>;\n    getActiveConnectionIds(): string[];\n}\n\nexport const WebsocketsConnectionManager = createAbstraction<IWebsocketsConnectionManager<unknown>>(\n    \"WebsocketsConnectionManager\"\n);\n\nexport namespace WebsocketsConnectionManager {\n    export type Interface<TSocket> = IWebsocketsConnectionManager<TSocket>;\n    export type AddParams<TSocket> = IWebsocketsConnectionManagerAddParams<TSocket>;\n    export type ConnectionMetadata = IWebsocketsConnectionManagerMetadata;\n}\n"],"names":["WebsocketsConnectionManager","createAbstraction"],"mappings":";AAgCO,MAAMA,8BAA8BC,kBACvC"}

package/heartbeat/HeartbeatManager.d.ts

@@ -0,0 +1,9 @@
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+export declare class HeartbeatManager {
+    private readonly connectionManager;
+    private readonly interval;
+    private timer;
+    constructor(connectionManager: WebsocketsConnectionManager.Interface<unknown>, interval: number);
+    start(): void;
+    stop(): void;
+}

package/heartbeat/HeartbeatManager.js

@@ -0,0 +1,20 @@
+class HeartbeatManager {
+    constructor(connectionManager, interval){
+        this.connectionManager = connectionManager;
+        this.interval = interval;
+    }
+    start() {
+        this.timer = setInterval(()=>{
+            this.connectionManager.cleanup(5 * this.interval);
+        }, this.interval);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = void 0;
+        }
+    }
+}
+export { HeartbeatManager };
+
+//# sourceMappingURL=HeartbeatManager.js.map

package/heartbeat/HeartbeatManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat/HeartbeatManager.js","sources":["../../src/heartbeat/HeartbeatManager.ts"],"sourcesContent":["import type { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\n\nexport class HeartbeatManager {\n    private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown>;\n    private readonly interval: number;\n    private timer: ReturnType<typeof setInterval> | undefined;\n\n    public constructor(\n        connectionManager: WebsocketsConnectionManager.Interface<unknown>,\n        interval: number\n    ) {\n        this.connectionManager = connectionManager;\n        this.interval = interval;\n    }\n\n    public start(): void {\n        this.timer = setInterval(() => {\n            this.connectionManager.cleanup(5 * this.interval);\n        }, this.interval);\n    }\n\n    public stop(): void {\n        if (this.timer) {\n            clearInterval(this.timer);\n            this.timer = undefined;\n        }\n    }\n}\n"],"names":["HeartbeatManager","connectionManager","interval","setInterval","clearInterval","undefined"],"mappings":"AAEO,MAAMA;IAKT,YACIC,iBAAiE,EACjEC,QAAgB,CAClB;QACE,IAAI,CAAC,iBAAiB,GAAGD;QACzB,IAAI,CAAC,QAAQ,GAAGC;IACpB;IAEO,QAAc;QACjB,IAAI,CAAC,KAAK,GAAGC,YAAY;YACrB,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,QAAQ;QACpD,GAAG,IAAI,CAAC,QAAQ;IACpB;IAEO,OAAa;QAChB,IAAI,IAAI,CAAC,KAAK,EAAE;YACZC,cAAc,IAAI,CAAC,KAAK;YACxB,IAAI,CAAC,KAAK,GAAGC;QACjB;IACJ;AACJ"}

package/index.d.ts

@@ -0,0 +1,9 @@
+export { createWebsocketsServer, attachWebsocketsServer } from "./server/WebsocketsServer.js";
+export type { IWebsocketsServer, WebsocketsConnectionAuthenticator } from "./server/types.js";
+export * from "./adapter/abstractions.js";
+export * from "./upgradeHandler/abstractions.js";
+export * from "./connectionManager/abstractions.js";
+export { ServerConnectionManager } from "./connectionManager/ServerConnectionManager.js";
+export { NodeWsAdapter } from "./adapter/NodeWsAdapter.js";
+export { ServerWebsocketsTransport } from "./transport/ServerWebsocketsTransport.js";
+export { WebsocketsStandaloneFeature } from "./WebsocketsStandaloneFeature.js";

package/index.js

@@ -0,0 +1,8 @@
+export * from "./adapter/abstractions.js";
+export * from "./upgradeHandler/abstractions.js";
+export * from "./connectionManager/abstractions.js";
+export { attachWebsocketsServer, createWebsocketsServer } from "./server/WebsocketsServer.js";
+export { ServerConnectionManager } from "./connectionManager/ServerConnectionManager.js";
+export { NodeWsAdapter } from "./adapter/NodeWsAdapter.js";
+export { ServerWebsocketsTransport } from "./transport/ServerWebsocketsTransport.js";
+export { WebsocketsStandaloneFeature } from "./WebsocketsStandaloneFeature.js";

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@webiny/api-websockets-standalone",
+	"version": "6.6.0-alpha.4",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "Standalone WebSocket server transport for @webiny/api-websockets",
+	"contributors": [
+		"Bruno Zorić <bruno@webiny.com>"
+	],
+	"exports": {
+		"./*": "./*",
+		".": "./index.js"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api": "6.6.0-alpha.4",
+		"@webiny/api-websockets": "6.6.0-alpha.4",
+		"@webiny/feature": "6.6.0-alpha.4",
+		"@webiny/plugins": "6.6.0-alpha.4",
+		"@webiny/utils": "6.6.0-alpha.4",
+		"ws": "8.21.3",
+		"zod": "4.4.3"
+	},
+	"devDependencies": {
+		"@types/ws": "8.18.1",
+		"@webiny/build-tools": "6.6.0-alpha.4",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/server/WebsocketsServer.d.ts

@@ -0,0 +1,53 @@
+import type { Server as HttpServer } from "node:http";
+import type { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+import type { WebsocketsUpgradeHandler } from "../upgradeHandler/abstractions.js";
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import type { CreateWebsocketsServerParams, AttachWebsocketsServerParams, IWebsocketsServer, WebsocketsConnectionAuthenticator } from "./types.js";
+interface WebsocketsServerParams {
+    httpServer: HttpServer;
+    ownsHttpServer: boolean;
+    adapter: WebsocketsServerAdapter.Interface<unknown>;
+    upgradeHandler: WebsocketsUpgradeHandler.Interface;
+    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;
+    authenticate?: WebsocketsConnectionAuthenticator;
+    heartbeatInterval: number;
+    debug: boolean;
+    port: number;
+    host: string;
+}
+declare class WebsocketsServer implements IWebsocketsServer {
+    private readonly httpServer;
+    private readonly ownsHttpServer;
+    private readonly adapter;
+    private readonly upgradeHandler;
+    private readonly connectionManager;
+    private readonly authenticate;
+    private readonly heartbeat;
+    private readonly debug;
+    private readonly requestedPort;
+    private readonly requestedHost;
+    private shuttingDown;
+    private endpoint;
+    private resolvedPort;
+    constructor(params: WebsocketsServerParams);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    port(): number;
+    private wireUpgradeHandler;
+    private wireConnectionHandler;
+    /**
+     * Authenticates the upgrade using the `?token`/`?tenant` query the app-websockets client sends,
+     * then registers the live socket in the shared connection manager under the resolved identity and
+     * tenant. Getting both right matters for targeted server→client sends: `SendToIdentity` finds
+     * connections by identity id in the registry, so a connection that's anonymous (or never made it
+     * into the registry) can't be reached. Everything here is guarded — if something goes wrong we
+     * don't crash the server or the upgrade, the connection just ends up unaddressable.
+     */
+    private registerConnection;
+    private resolvePortFromExistingServer;
+    private listen;
+    private closeHttpServer;
+}
+export { WebsocketsServer };
+export declare const createWebsocketsServer: (params: CreateWebsocketsServerParams) => IWebsocketsServer;
+export declare const attachWebsocketsServer: (params: AttachWebsocketsServerParams) => IWebsocketsServer;

package/server/WebsocketsServer.js

@@ -0,0 +1,188 @@
+import { createServer } from "node:http";
+import { mdbid } from "@webiny/utils";
+import { NodeWsAdapterImpl } from "../adapter/NodeWsAdapter.js";
+import { DefaultUpgradeHandlerImpl } from "../upgradeHandler/DefaultUpgradeHandler.js";
+import { HeartbeatManager } from "../heartbeat/HeartbeatManager.js";
+const ANONYMOUS_IDENTITY = {
+    id: "",
+    displayName: "",
+    type: ""
+};
+const toHeaders = (raw)=>{
+    const headers = {};
+    for (const [key, value] of Object.entries(raw))if ("string" == typeof value) headers[key] = value;
+    return headers;
+};
+class WebsocketsServer {
+    constructor(params){
+        this.shuttingDown = false;
+        this.endpoint = "";
+        this.resolvedPort = 0;
+        this.httpServer = params.httpServer;
+        this.ownsHttpServer = params.ownsHttpServer;
+        this.adapter = params.adapter;
+        this.upgradeHandler = params.upgradeHandler;
+        this.connectionManager = params.connectionManager;
+        this.authenticate = params.authenticate;
+        this.debug = params.debug;
+        this.requestedPort = params.port;
+        this.requestedHost = params.host;
+        if (params.connectionManager) this.heartbeat = new HeartbeatManager(params.connectionManager, params.heartbeatInterval);
+    }
+    async start() {
+        this.adapter.start(this.httpServer);
+        this.wireUpgradeHandler();
+        this.wireConnectionHandler();
+        if (this.ownsHttpServer) await this.listen();
+        else this.resolvePortFromExistingServer();
+        this.heartbeat?.start();
+        if (this.debug) console.log(`[WebsocketsServer] started on ${this.endpoint}`);
+    }
+    async stop() {
+        this.shuttingDown = true;
+        this.heartbeat?.stop();
+        await this.adapter.stop();
+        if (this.connectionManager) {
+            const activeIds = this.connectionManager.getActiveConnectionIds();
+            for (const connectionId of activeIds)await this.connectionManager.remove(connectionId);
+        }
+        if (this.ownsHttpServer) await this.closeHttpServer();
+        if (this.debug) console.log("[WebsocketsServer] stopped");
+    }
+    port() {
+        return this.resolvedPort;
+    }
+    wireUpgradeHandler() {
+        this.httpServer.on("upgrade", async (request, socket, head)=>{
+            if (this.shuttingDown) return void socket.destroy();
+            const decision = await this.upgradeHandler.shouldUpgrade(request);
+            if (!decision.allowed) {
+                socket.write(`HTTP/1.1 ${decision.statusCode} ${decision.reason}\r\n\r\n`);
+                socket.destroy();
+                return;
+            }
+            this.adapter.handleUpgrade(request, socket, head);
+        });
+    }
+    wireConnectionHandler() {
+        this.adapter.onConnection((socket, request)=>{
+            if (this.shuttingDown) return;
+            const connectionId = mdbid();
+            const connectedAt = Date.now();
+            const host = request.headers.host || "localhost";
+            const headers = toHeaders(request.headers);
+            this.registerConnection({
+                connectionId,
+                socket,
+                request,
+                connectedAt,
+                host,
+                headers
+            });
+            this.adapter.onMessage(socket, (data)=>{
+                if (this.shuttingDown) return;
+                const metadata = this.connectionManager?.getMetadata(connectionId);
+                if (!metadata) return;
+                try {
+                    JSON.parse(data.toString());
+                } catch  {
+                    return;
+                }
+                this.connectionManager?.updateLastSeen(connectionId);
+            });
+            this.adapter.onClose(socket, ()=>{
+                if (this.shuttingDown) return;
+                this.connectionManager?.remove(connectionId);
+            });
+            this.adapter.onError(socket, (error)=>{
+                console.error(`WebSocket error for connection "${connectionId}":`, error.message);
+            });
+        });
+    }
+    async registerConnection(params) {
+        const { connectionId, socket, request, connectedAt, host, headers } = params;
+        let identity = ANONYMOUS_IDENTITY;
+        let tenant = "";
+        try {
+            const url = new URL(request.url ?? "", `http://${host}`);
+            tenant = url.searchParams.get("tenant") ?? "";
+            const token = url.searchParams.get("token") ?? "";
+            if (this.authenticate && token) {
+                const authenticated = await this.authenticate(token);
+                if (authenticated?.id) identity = authenticated;
+            }
+            await this.connectionManager?.add({
+                connectionId,
+                socket,
+                endpoint: this.endpoint,
+                identity,
+                tenant,
+                connectedAt,
+                host,
+                headers
+            });
+        } catch (error) {
+            console.error(`Failed to register WebSocket connection "${connectionId}":`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    resolvePortFromExistingServer() {
+        const address = this.httpServer.address();
+        if (address && "string" != typeof address) {
+            this.resolvedPort = address.port;
+            this.endpoint = `ws://127.0.0.1:${this.resolvedPort}`;
+        }
+    }
+    listen() {
+        return new Promise((resolve, reject)=>{
+            this.httpServer.listen(this.requestedPort, this.requestedHost, ()=>{
+                const address = this.httpServer.address();
+                if (!address || "string" == typeof address) return void reject(new Error("Unexpected server address format."));
+                this.resolvedPort = address.port;
+                this.endpoint = `ws://${this.requestedHost}:${this.resolvedPort}`;
+                resolve();
+            });
+        });
+    }
+    closeHttpServer() {
+        return new Promise((resolve, reject)=>{
+            this.httpServer.close((err)=>{
+                if (err) return void reject(err);
+                resolve();
+            });
+        });
+    }
+}
+const createWebsocketsServer = (params)=>{
+    const httpServer = createServer();
+    const server = new WebsocketsServer({
+        httpServer,
+        ownsHttpServer: true,
+        adapter: new NodeWsAdapterImpl(),
+        upgradeHandler: new DefaultUpgradeHandlerImpl(),
+        connectionManager: params.connectionManager,
+        authenticate: params.authenticate,
+        heartbeatInterval: params.heartbeatInterval ?? 60000,
+        debug: params.debug ?? false,
+        port: params.port ?? 0,
+        host: params.host ?? "127.0.0.1"
+    });
+    return server;
+};
+const attachWebsocketsServer = (params)=>{
+    const server = new WebsocketsServer({
+        httpServer: params.server,
+        ownsHttpServer: false,
+        adapter: new NodeWsAdapterImpl(),
+        upgradeHandler: new DefaultUpgradeHandlerImpl(),
+        connectionManager: params.connectionManager,
+        authenticate: params.authenticate,
+        heartbeatInterval: params.heartbeatInterval ?? 60000,
+        debug: params.debug ?? false,
+        port: 0,
+        host: "127.0.0.1"
+    });
+    return server;
+};
+export { WebsocketsServer, attachWebsocketsServer, createWebsocketsServer };
+
+//# sourceMappingURL=WebsocketsServer.js.map

package/server/WebsocketsServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server/WebsocketsServer.js","sources":["../../src/server/WebsocketsServer.ts"],"sourcesContent":["import { createServer } from \"node:http\";\nimport type { Server as HttpServer, IncomingMessage } from \"node:http\";\nimport type { Duplex } from \"node:stream\";\nimport { mdbid } from \"@webiny/utils\";\nimport type { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\nimport type { WebsocketsUpgradeHandler } from \"~/upgradeHandler/abstractions.js\";\nimport type { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport type { ConnectionRegistry } from \"@webiny/api-websockets/exports/api.js\";\nimport { NodeWsAdapterImpl } from \"~/adapter/NodeWsAdapter.js\";\nimport { DefaultUpgradeHandlerImpl } from \"~/upgradeHandler/DefaultUpgradeHandler.js\";\nimport { HeartbeatManager } from \"~/heartbeat/HeartbeatManager.js\";\nimport type {\n    CreateWebsocketsServerParams,\n    AttachWebsocketsServerParams,\n    IWebsocketsServer,\n    WebsocketsConnectionAuthenticator\n} from \"./types.js\";\n\nconst ANONYMOUS_IDENTITY: ConnectionRegistry.Identity = { id: \"\", displayName: \"\", type: \"\" };\n\nconst toHeaders = (raw: IncomingMessage[\"headers\"]): Record<string, string> => {\n    const headers: Record<string, string> = {};\n    for (const [key, value] of Object.entries(raw)) {\n        if (typeof value === \"string\") {\n            headers[key] = value;\n        }\n    }\n    return headers;\n};\n\ninterface WebsocketsServerParams {\n    httpServer: HttpServer;\n    ownsHttpServer: boolean;\n    adapter: WebsocketsServerAdapter.Interface<unknown>;\n    upgradeHandler: WebsocketsUpgradeHandler.Interface;\n    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;\n    authenticate?: WebsocketsConnectionAuthenticator;\n    heartbeatInterval: number;\n    debug: boolean;\n    port: number;\n    host: string;\n}\n\nclass WebsocketsServer implements IWebsocketsServer {\n    private readonly httpServer: HttpServer;\n    private readonly ownsHttpServer: boolean;\n    private readonly adapter: WebsocketsServerAdapter.Interface<unknown>;\n    private readonly upgradeHandler: WebsocketsUpgradeHandler.Interface;\n    private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown> | undefined;\n    private readonly authenticate: WebsocketsConnectionAuthenticator | undefined;\n    private readonly heartbeat: HeartbeatManager | undefined;\n    private readonly debug: boolean;\n    private readonly requestedPort: number;\n    private readonly requestedHost: string;\n\n    private shuttingDown: boolean = false;\n    private endpoint: string = \"\";\n    private resolvedPort: number = 0;\n\n    public constructor(params: WebsocketsServerParams) {\n        this.httpServer = params.httpServer;\n        this.ownsHttpServer = params.ownsHttpServer;\n        this.adapter = params.adapter;\n        this.upgradeHandler = params.upgradeHandler;\n        this.connectionManager = params.connectionManager;\n        this.authenticate = params.authenticate;\n        this.debug = params.debug;\n        this.requestedPort = params.port;\n        this.requestedHost = params.host;\n\n        if (params.connectionManager) {\n            this.heartbeat = new HeartbeatManager(\n                params.connectionManager,\n                params.heartbeatInterval\n            );\n        }\n    }\n\n    public async start(): Promise<void> {\n        this.adapter.start(this.httpServer);\n        this.wireUpgradeHandler();\n        this.wireConnectionHandler();\n\n        if (this.ownsHttpServer) {\n            await this.listen();\n        } else {\n            this.resolvePortFromExistingServer();\n        }\n\n        this.heartbeat?.start();\n\n        if (this.debug) {\n            console.log(`[WebsocketsServer] started on ${this.endpoint}`);\n        }\n    }\n\n    public async stop(): Promise<void> {\n        this.shuttingDown = true;\n        this.heartbeat?.stop();\n\n        await this.adapter.stop();\n\n        if (this.connectionManager) {\n            const activeIds = this.connectionManager.getActiveConnectionIds();\n            for (const connectionId of activeIds) {\n                await this.connectionManager.remove(connectionId);\n            }\n        }\n\n        if (this.ownsHttpServer) {\n            await this.closeHttpServer();\n        }\n\n        if (this.debug) {\n            console.log(\"[WebsocketsServer] stopped\");\n        }\n    }\n\n    public port(): number {\n        return this.resolvedPort;\n    }\n\n    private wireUpgradeHandler(): void {\n        this.httpServer.on(\n            \"upgrade\",\n            async (request: IncomingMessage, socket: Duplex, head: Buffer) => {\n                if (this.shuttingDown) {\n                    socket.destroy();\n                    return;\n                }\n\n                const decision = await this.upgradeHandler.shouldUpgrade(request);\n                if (!decision.allowed) {\n                    socket.write(`HTTP/1.1 ${decision.statusCode} ${decision.reason}\\r\\n\\r\\n`);\n                    socket.destroy();\n                    return;\n                }\n\n                this.adapter.handleUpgrade(request, socket, head);\n            }\n        );\n    }\n\n    private wireConnectionHandler(): void {\n        this.adapter.onConnection((socket, request) => {\n            if (this.shuttingDown) {\n                return;\n            }\n\n            const connectionId = mdbid();\n            const connectedAt = Date.now();\n            const host = request.headers.host || \"localhost\";\n            const headers = toHeaders(request.headers);\n\n            // Register the connection under its real identity, decoded from the `?token` JWT. Both\n            // the authentication and the registry write are async, so we kick this off without\n            // awaiting it and wire the socket handlers below synchronously — that way we don't miss a\n            // close or message that arrives during the gap. If a message does arrive before\n            // registration finishes, the `getMetadata` guard below just drops it, which is fine since\n            // the client doesn't send anything meaningful right at connect time.\n            void this.registerConnection({\n                connectionId,\n                socket,\n                request,\n                connectedAt,\n                host,\n                headers\n            });\n\n            this.adapter.onMessage(socket, data => {\n                if (this.shuttingDown) {\n                    return;\n                }\n\n                const metadata = this.connectionManager?.getMetadata(connectionId);\n                if (!metadata) {\n                    return;\n                }\n\n                try {\n                    JSON.parse(data.toString());\n                } catch {\n                    return;\n                }\n\n                this.connectionManager?.updateLastSeen(connectionId);\n            });\n\n            this.adapter.onClose(socket, () => {\n                if (this.shuttingDown) {\n                    return;\n                }\n                this.connectionManager?.remove(connectionId);\n            });\n\n            this.adapter.onError(socket, error => {\n                console.error(`WebSocket error for connection \"${connectionId}\":`, error.message);\n            });\n        });\n    }\n\n    /**\n     * Authenticates the upgrade using the `?token`/`?tenant` query the app-websockets client sends,\n     * then registers the live socket in the shared connection manager under the resolved identity and\n     * tenant. Getting both right matters for targeted server→client sends: `SendToIdentity` finds\n     * connections by identity id in the registry, so a connection that's anonymous (or never made it\n     * into the registry) can't be reached. Everything here is guarded — if something goes wrong we\n     * don't crash the server or the upgrade, the connection just ends up unaddressable.\n     */\n    private async registerConnection(params: {\n        connectionId: string;\n        socket: unknown;\n        request: IncomingMessage;\n        connectedAt: number;\n        host: string;\n        headers: Record<string, string>;\n    }): Promise<void> {\n        const { connectionId, socket, request, connectedAt, host, headers } = params;\n\n        let identity: ConnectionRegistry.Identity = ANONYMOUS_IDENTITY;\n        let tenant = \"\";\n\n        try {\n            const url = new URL(request.url ?? \"\", `http://${host}`);\n            tenant = url.searchParams.get(\"tenant\") ?? \"\";\n            const token = url.searchParams.get(\"token\") ?? \"\";\n\n            if (this.authenticate && token) {\n                const authenticated = await this.authenticate(token);\n                if (authenticated?.id) {\n                    identity = authenticated;\n                }\n            }\n\n            await this.connectionManager?.add({\n                connectionId,\n                socket,\n                endpoint: this.endpoint,\n                identity,\n                tenant,\n                connectedAt,\n                host,\n                headers\n            });\n        } catch (error) {\n            console.error(\n                `Failed to register WebSocket connection \"${connectionId}\":`,\n                error instanceof Error ? error.message : String(error)\n            );\n        }\n    }\n\n    private resolvePortFromExistingServer(): void {\n        const address = this.httpServer.address();\n        if (address && typeof address !== \"string\") {\n            this.resolvedPort = address.port;\n            this.endpoint = `ws://127.0.0.1:${this.resolvedPort}`;\n        }\n    }\n\n    private listen(): Promise<void> {\n        return new Promise((resolve, reject) => {\n            this.httpServer.listen(this.requestedPort, this.requestedHost, () => {\n                const address = this.httpServer.address();\n                if (!address || typeof address === \"string\") {\n                    reject(new Error(\"Unexpected server address format.\"));\n                    return;\n                }\n                this.resolvedPort = address.port;\n                this.endpoint = `ws://${this.requestedHost}:${this.resolvedPort}`;\n                resolve();\n            });\n        });\n    }\n\n    private closeHttpServer(): Promise<void> {\n        return new Promise((resolve, reject) => {\n            this.httpServer.close(err => {\n                if (err) {\n                    reject(err);\n                    return;\n                }\n                resolve();\n            });\n        });\n    }\n}\n\nexport { WebsocketsServer };\n\nexport const createWebsocketsServer = (params: CreateWebsocketsServerParams): IWebsocketsServer => {\n    const httpServer = createServer();\n    const server = new WebsocketsServer({\n        httpServer,\n        ownsHttpServer: true,\n        adapter: new NodeWsAdapterImpl(),\n        upgradeHandler: new DefaultUpgradeHandlerImpl(),\n        connectionManager: params.connectionManager,\n        authenticate: params.authenticate,\n        heartbeatInterval: params.heartbeatInterval ?? 60_000,\n        debug: params.debug ?? false,\n        port: params.port ?? 0,\n        host: params.host ?? \"127.0.0.1\"\n    });\n    return server;\n};\n\nexport const attachWebsocketsServer = (params: AttachWebsocketsServerParams): IWebsocketsServer => {\n    const server = new WebsocketsServer({\n        httpServer: params.server,\n        ownsHttpServer: false,\n        adapter: new NodeWsAdapterImpl(),\n        upgradeHandler: new DefaultUpgradeHandlerImpl(),\n        connectionManager: params.connectionManager,\n        authenticate: params.authenticate,\n        heartbeatInterval: params.heartbeatInterval ?? 60_000,\n        debug: params.debug ?? false,\n        port: 0,\n        host: \"127.0.0.1\"\n    });\n    return server;\n};\n"],"names":["ANONYMOUS_IDENTITY","toHeaders","raw","headers","key","value","Object","WebsocketsServer","params","HeartbeatManager","console","activeIds","connectionId","request","socket","head","decision","mdbid","connectedAt","Date","host","data","metadata","JSON","error","identity","tenant","url","URL","token","authenticated","Error","String","address","Promise","resolve","reject","err","createWebsocketsServer","httpServer","createServer","server","NodeWsAdapterImpl","DefaultUpgradeHandlerImpl","attachWebsocketsServer"],"mappings":";;;;;AAkBA,MAAMA,qBAAkD;IAAE,IAAI;IAAI,aAAa;IAAI,MAAM;AAAG;AAE5F,MAAMC,YAAY,CAACC;IACf,MAAMC,UAAkC,CAAC;IACzC,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAO,OAAO,CAACJ,KACtC,IAAI,AAAiB,YAAjB,OAAOG,OACPF,OAAO,CAACC,IAAI,GAAGC;IAGvB,OAAOF;AACX;AAeA,MAAMI;IAgBF,YAAmBC,MAA8B,CAAE;aAJ3C,YAAY,GAAY;aACxB,QAAQ,GAAW;aACnB,YAAY,GAAW;QAG3B,IAAI,CAAC,UAAU,GAAGA,OAAO,UAAU;QACnC,IAAI,CAAC,cAAc,GAAGA,OAAO,cAAc;QAC3C,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,cAAc,GAAGA,OAAO,cAAc;QAC3C,IAAI,CAAC,iBAAiB,GAAGA,OAAO,iBAAiB;QACjD,IAAI,CAAC,YAAY,GAAGA,OAAO,YAAY;QACvC,IAAI,CAAC,KAAK,GAAGA,OAAO,KAAK;QACzB,IAAI,CAAC,aAAa,GAAGA,OAAO,IAAI;QAChC,IAAI,CAAC,aAAa,GAAGA,OAAO,IAAI;QAEhC,IAAIA,OAAO,iBAAiB,EACxB,IAAI,CAAC,SAAS,GAAG,IAAIC,iBACjBD,OAAO,iBAAiB,EACxBA,OAAO,iBAAiB;IAGpC;IAEA,MAAa,QAAuB;QAChC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU;QAClC,IAAI,CAAC,kBAAkB;QACvB,IAAI,CAAC,qBAAqB;QAE1B,IAAI,IAAI,CAAC,cAAc,EACnB,MAAM,IAAI,CAAC,MAAM;aAEjB,IAAI,CAAC,6BAA6B;QAGtC,IAAI,CAAC,SAAS,EAAE;QAEhB,IAAI,IAAI,CAAC,KAAK,EACVE,QAAQ,GAAG,CAAC,CAAC,8BAA8B,EAAE,IAAI,CAAC,QAAQ,EAAE;IAEpE;IAEA,MAAa,OAAsB;QAC/B,IAAI,CAAC,YAAY,GAAG;QACpB,IAAI,CAAC,SAAS,EAAE;QAEhB,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI;QAEvB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YACxB,MAAMC,YAAY,IAAI,CAAC,iBAAiB,CAAC,sBAAsB;YAC/D,KAAK,MAAMC,gBAAgBD,UACvB,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACC;QAE5C;QAEA,IAAI,IAAI,CAAC,cAAc,EACnB,MAAM,IAAI,CAAC,eAAe;QAG9B,IAAI,IAAI,CAAC,KAAK,EACVF,QAAQ,GAAG,CAAC;IAEpB;IAEO,OAAe;QAClB,OAAO,IAAI,CAAC,YAAY;IAC5B;IAEQ,qBAA2B;QAC/B,IAAI,CAAC,UAAU,CAAC,EAAE,CACd,WACA,OAAOG,SAA0BC,QAAgBC;YAC7C,IAAI,IAAI,CAAC,YAAY,EAAE,YACnBD,OAAO,OAAO;YAIlB,MAAME,WAAW,MAAM,IAAI,CAAC,cAAc,CAAC,aAAa,CAACH;YACzD,IAAI,CAACG,SAAS,OAAO,EAAE;gBACnBF,OAAO,KAAK,CAAC,CAAC,SAAS,EAAEE,SAAS,UAAU,CAAC,CAAC,EAAEA,SAAS,MAAM,CAAC,QAAQ,CAAC;gBACzEF,OAAO,OAAO;gBACd;YACJ;YAEA,IAAI,CAAC,OAAO,CAAC,aAAa,CAACD,SAASC,QAAQC;QAChD;IAER;IAEQ,wBAA8B;QAClC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAACD,QAAQD;YAC/B,IAAI,IAAI,CAAC,YAAY,EACjB;YAGJ,MAAMD,eAAeK;YACrB,MAAMC,cAAcC,KAAK,GAAG;YAC5B,MAAMC,OAAOP,QAAQ,OAAO,CAAC,IAAI,IAAI;YACrC,MAAMV,UAAUF,UAAUY,QAAQ,OAAO;YAQpC,IAAI,CAAC,kBAAkB,CAAC;gBACzBD;gBACAE;gBACAD;gBACAK;gBACAE;gBACAjB;YACJ;YAEA,IAAI,CAAC,OAAO,CAAC,SAAS,CAACW,QAAQO,CAAAA;gBAC3B,IAAI,IAAI,CAAC,YAAY,EACjB;gBAGJ,MAAMC,WAAW,IAAI,CAAC,iBAAiB,EAAE,YAAYV;gBACrD,IAAI,CAACU,UACD;gBAGJ,IAAI;oBACAC,KAAK,KAAK,CAACF,KAAK,QAAQ;gBAC5B,EAAE,OAAM;oBACJ;gBACJ;gBAEA,IAAI,CAAC,iBAAiB,EAAE,eAAeT;YAC3C;YAEA,IAAI,CAAC,OAAO,CAAC,OAAO,CAACE,QAAQ;gBACzB,IAAI,IAAI,CAAC,YAAY,EACjB;gBAEJ,IAAI,CAAC,iBAAiB,EAAE,OAAOF;YACnC;YAEA,IAAI,CAAC,OAAO,CAAC,OAAO,CAACE,QAAQU,CAAAA;gBACzBd,QAAQ,KAAK,CAAC,CAAC,gCAAgC,EAAEE,aAAa,EAAE,CAAC,EAAEY,MAAM,OAAO;YACpF;QACJ;IACJ;IAUA,MAAc,mBAAmBhB,MAOhC,EAAiB;QACd,MAAM,EAAEI,YAAY,EAAEE,MAAM,EAAED,OAAO,EAAEK,WAAW,EAAEE,IAAI,EAAEjB,OAAO,EAAE,GAAGK;QAEtE,IAAIiB,WAAwCzB;QAC5C,IAAI0B,SAAS;QAEb,IAAI;YACA,MAAMC,MAAM,IAAIC,IAAIf,QAAQ,GAAG,IAAI,IAAI,CAAC,OAAO,EAAEO,MAAM;YACvDM,SAASC,IAAI,YAAY,CAAC,GAAG,CAAC,aAAa;YAC3C,MAAME,QAAQF,IAAI,YAAY,CAAC,GAAG,CAAC,YAAY;YAE/C,IAAI,IAAI,CAAC,YAAY,IAAIE,OAAO;gBAC5B,MAAMC,gBAAgB,MAAM,IAAI,CAAC,YAAY,CAACD;gBAC9C,IAAIC,eAAe,IACfL,WAAWK;YAEnB;YAEA,MAAM,IAAI,CAAC,iBAAiB,EAAE,IAAI;gBAC9BlB;gBACAE;gBACA,UAAU,IAAI,CAAC,QAAQ;gBACvBW;gBACAC;gBACAR;gBACAE;gBACAjB;YACJ;QACJ,EAAE,OAAOqB,OAAO;YACZd,QAAQ,KAAK,CACT,CAAC,yCAAyC,EAAEE,aAAa,EAAE,CAAC,EAC5DY,iBAAiBO,QAAQP,MAAM,OAAO,GAAGQ,OAAOR;QAExD;IACJ;IAEQ,gCAAsC;QAC1C,MAAMS,UAAU,IAAI,CAAC,UAAU,CAAC,OAAO;QACvC,IAAIA,WAAW,AAAmB,YAAnB,OAAOA,SAAsB;YACxC,IAAI,CAAC,YAAY,GAAGA,QAAQ,IAAI;YAChC,IAAI,CAAC,QAAQ,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,YAAY,EAAE;QACzD;IACJ;IAEQ,SAAwB;QAC5B,OAAO,IAAIC,QAAQ,CAACC,SAASC;YACzB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE;gBAC3D,MAAMH,UAAU,IAAI,CAAC,UAAU,CAAC,OAAO;gBACvC,IAAI,CAACA,WAAW,AAAmB,YAAnB,OAAOA,SAAsB,YACzCG,OAAO,IAAIL,MAAM;gBAGrB,IAAI,CAAC,YAAY,GAAGE,QAAQ,IAAI;gBAChC,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE;gBACjEE;YACJ;QACJ;IACJ;IAEQ,kBAAiC;QACrC,OAAO,IAAID,QAAQ,CAACC,SAASC;YACzB,IAAI,CAAC,UAAU,CAAC,KAAK,CAACC,CAAAA;gBAClB,IAAIA,KAAK,YACLD,OAAOC;gBAGXF;YACJ;QACJ;IACJ;AACJ;AAIO,MAAMG,yBAAyB,CAAC9B;IACnC,MAAM+B,aAAaC;IACnB,MAAMC,SAAS,IAAIlC,iBAAiB;QAChCgC;QACA,gBAAgB;QAChB,SAAS,IAAIG;QACb,gBAAgB,IAAIC;QACpB,mBAAmBnC,OAAO,iBAAiB;QAC3C,cAAcA,OAAO,YAAY;QACjC,mBAAmBA,OAAO,iBAAiB,IAAI;QAC/C,OAAOA,OAAO,KAAK,IAAI;QACvB,MAAMA,OAAO,IAAI,IAAI;QACrB,MAAMA,OAAO,IAAI,IAAI;IACzB;IACA,OAAOiC;AACX;AAEO,MAAMG,yBAAyB,CAACpC;IACnC,MAAMiC,SAAS,IAAIlC,iBAAiB;QAChC,YAAYC,OAAO,MAAM;QACzB,gBAAgB;QAChB,SAAS,IAAIkC;QACb,gBAAgB,IAAIC;QACpB,mBAAmBnC,OAAO,iBAAiB;QAC3C,cAAcA,OAAO,YAAY;QACjC,mBAAmBA,OAAO,iBAAiB,IAAI;QAC/C,OAAOA,OAAO,KAAK,IAAI;QACvB,MAAM;QACN,MAAM;IACV;IACA,OAAOiC;AACX"}

package/server/types.d.ts

@@ -0,0 +1,39 @@
+import type { Server as HttpServer } from "node:http";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { PluginCollection } from "@webiny/plugins/types.js";
+import type { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import type { ConnectionRegistry } from "@webiny/api-websockets/exports/api.js";
+/**
+ * Resolves a connection's identity from the `?token` JWT sent on the WebSocket upgrade — the SAME
+ * token→identity step the HTTP request stack runs (RequestIdentityLoader). Returns `null` for an
+ * absent/invalid/anonymous token, in which case the connection registers anonymously and won't
+ * receive targeted (`SendToIdentity`) messages.
+ *
+ * It's a plain callback rather than a resolved dependency for two reasons: this WebSocket server is a
+ * DI-agnostic class (the handler resolves what it needs and passes plain values in), and the auth it
+ * needs — `AuthenticationContext` — lives in the PER-REQUEST stack, not the root container, so a
+ * boot-time object like this couldn't resolve it directly anyway. The handler builds the callback
+ * (spinning up a request-scoped child container per token). So authenticate has to be a callback the
+ * handler supplies, regardless of DI.
+ */
+export type WebsocketsConnectionAuthenticator = (token: string) => Promise<ConnectionRegistry.Identity | null>;
+interface BaseServerParams {
+    plugins?: PluginsContainer | PluginCollection;
+    heartbeatInterval?: number;
+    debug?: boolean;
+    connectionManager?: WebsocketsConnectionManager.Interface<unknown>;
+    authenticate?: WebsocketsConnectionAuthenticator;
+}
+export interface CreateWebsocketsServerParams extends BaseServerParams {
+    port?: number;
+    host?: string;
+}
+export interface AttachWebsocketsServerParams extends BaseServerParams {
+    server: HttpServer;
+}
+export interface IWebsocketsServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    port(): number;
+}
+export {};

package/transport/ServerWebsocketsTransport.d.ts

@@ -0,0 +1,14 @@
+import { WebsocketsTransport } from "@webiny/api-websockets/exports/api.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+export declare class ServerWebsocketsTransportImpl implements WebsocketsTransport.Interface {
+    private readonly connectionManager;
+    private readonly adapter;
+    constructor(connectionManager: WebsocketsConnectionManager.Interface<unknown>, adapter: WebsocketsServerAdapter.Interface<unknown>);
+    send<T extends GenericRecord = GenericRecord>(connections: WebsocketsTransport.SendConnection[], data: WebsocketsTransport.SendData<T>): Promise<void>;
+    disconnect(connections: WebsocketsTransport.DisconnectConnection[]): Promise<void>;
+}
+export declare const ServerWebsocketsTransport: typeof ServerWebsocketsTransportImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-websockets/transport").IWebsocketsTransport>;
+};

package/transport/ServerWebsocketsTransport.js

@@ -0,0 +1,52 @@
+import { WebsocketsTransport } from "@webiny/api-websockets/exports/api.js";
+import { WebsocketsConnectionManager } from "../connectionManager/abstractions.js";
+import { WebsocketsServerAdapter } from "../adapter/abstractions.js";
+class ServerWebsocketsTransportImpl {
+    constructor(connectionManager, adapter){
+        this.connectionManager = connectionManager;
+        this.adapter = adapter;
+    }
+    async send(connections, data) {
+        for (const connection of connections){
+            const { connectionId } = connection;
+            const socket = this.connectionManager.getSocket(connectionId);
+            if (void 0 === socket) {
+                await this.connectionManager.remove(connectionId);
+                continue;
+            }
+            try {
+                await this.adapter.send(socket, JSON.stringify(data));
+            } catch (ex) {
+                console.error(`Failed to send message to connection "${connectionId}". Check logs for more information.`);
+                console.log(ex);
+            }
+        }
+    }
+    async disconnect(connections) {
+        for (const connection of connections){
+            const { connectionId } = connection;
+            const socket = this.connectionManager.getSocket(connectionId);
+            if (void 0 === socket) {
+                await this.connectionManager.remove(connectionId);
+                continue;
+            }
+            try {
+                this.adapter.close(socket);
+                await this.connectionManager.remove(connectionId);
+            } catch (ex) {
+                console.error(`Failed to disconnect connection "${connectionId}". Check logs for more information.`);
+                console.log(ex);
+            }
+        }
+    }
+}
+const ServerWebsocketsTransport = WebsocketsTransport.createImplementation({
+    implementation: ServerWebsocketsTransportImpl,
+    dependencies: [
+        WebsocketsConnectionManager,
+        WebsocketsServerAdapter
+    ]
+});
+export { ServerWebsocketsTransport, ServerWebsocketsTransportImpl };
+
+//# sourceMappingURL=ServerWebsocketsTransport.js.map

package/transport/ServerWebsocketsTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport/ServerWebsocketsTransport.js","sources":["../../src/transport/ServerWebsocketsTransport.ts"],"sourcesContent":["import { WebsocketsTransport } from \"@webiny/api-websockets/exports/api.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { WebsocketsConnectionManager } from \"~/connectionManager/abstractions.js\";\nimport { WebsocketsServerAdapter } from \"~/adapter/abstractions.js\";\n\nexport class ServerWebsocketsTransportImpl implements WebsocketsTransport.Interface {\n    private readonly connectionManager: WebsocketsConnectionManager.Interface<unknown>;\n    private readonly adapter: WebsocketsServerAdapter.Interface<unknown>;\n\n    public constructor(\n        connectionManager: WebsocketsConnectionManager.Interface<unknown>,\n        adapter: WebsocketsServerAdapter.Interface<unknown>\n    ) {\n        this.connectionManager = connectionManager;\n        this.adapter = adapter;\n    }\n\n    public async send<T extends GenericRecord = GenericRecord>(\n        connections: WebsocketsTransport.SendConnection[],\n        data: WebsocketsTransport.SendData<T>\n    ): Promise<void> {\n        for (const connection of connections) {\n            const { connectionId } = connection;\n            const socket = this.connectionManager.getSocket(connectionId);\n            if (socket === undefined) {\n                await this.connectionManager.remove(connectionId);\n                continue;\n            }\n            try {\n                await this.adapter.send(socket, JSON.stringify(data));\n            } catch (ex) {\n                console.error(\n                    `Failed to send message to connection \"${connectionId}\". Check logs for more information.`\n                );\n                console.log(ex);\n            }\n        }\n    }\n\n    public async disconnect(\n        connections: WebsocketsTransport.DisconnectConnection[]\n    ): Promise<void> {\n        for (const connection of connections) {\n            const { connectionId } = connection;\n            const socket = this.connectionManager.getSocket(connectionId);\n            if (socket === undefined) {\n                await this.connectionManager.remove(connectionId);\n                continue;\n            }\n            try {\n                this.adapter.close(socket);\n                await this.connectionManager.remove(connectionId);\n            } catch (ex) {\n                console.error(\n                    `Failed to disconnect connection \"${connectionId}\". Check logs for more information.`\n                );\n                console.log(ex);\n            }\n        }\n    }\n}\n\nexport const ServerWebsocketsTransport = WebsocketsTransport.createImplementation({\n    implementation: ServerWebsocketsTransportImpl,\n    dependencies: [WebsocketsConnectionManager, WebsocketsServerAdapter]\n});\n"],"names":["ServerWebsocketsTransportImpl","connectionManager","adapter","connections","data","connection","connectionId","socket","undefined","JSON","ex","console","ServerWebsocketsTransport","WebsocketsTransport","WebsocketsConnectionManager","WebsocketsServerAdapter"],"mappings":";;;AAKO,MAAMA;IAIT,YACIC,iBAAiE,EACjEC,OAAmD,CACrD;QACE,IAAI,CAAC,iBAAiB,GAAGD;QACzB,IAAI,CAAC,OAAO,GAAGC;IACnB;IAEA,MAAa,KACTC,WAAiD,EACjDC,IAAqC,EACxB;QACb,KAAK,MAAMC,cAAcF,YAAa;YAClC,MAAM,EAAEG,YAAY,EAAE,GAAGD;YACzB,MAAME,SAAS,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAACD;YAChD,IAAIC,AAAWC,WAAXD,QAAsB;gBACtB,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACD;gBACpC;YACJ;YACA,IAAI;gBACA,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAACC,QAAQE,KAAK,SAAS,CAACL;YACnD,EAAE,OAAOM,IAAI;gBACTC,QAAQ,KAAK,CACT,CAAC,sCAAsC,EAAEL,aAAa,mCAAmC,CAAC;gBAE9FK,QAAQ,GAAG,CAACD;YAChB;QACJ;IACJ;IAEA,MAAa,WACTP,WAAuD,EAC1C;QACb,KAAK,MAAME,cAAcF,YAAa;YAClC,MAAM,EAAEG,YAAY,EAAE,GAAGD;YACzB,MAAME,SAAS,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAACD;YAChD,IAAIC,AAAWC,WAAXD,QAAsB;gBACtB,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACD;gBACpC;YACJ;YACA,IAAI;gBACA,IAAI,CAAC,OAAO,CAAC,KAAK,CAACC;gBACnB,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACD;YACxC,EAAE,OAAOI,IAAI;gBACTC,QAAQ,KAAK,CACT,CAAC,iCAAiC,EAAEL,aAAa,mCAAmC,CAAC;gBAEzFK,QAAQ,GAAG,CAACD;YAChB;QACJ;IACJ;AACJ;AAEO,MAAME,4BAA4BC,oBAAoB,oBAAoB,CAAC;IAC9E,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;KAAwB;AACxE"}

package/upgradeHandler/DefaultUpgradeHandler.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage } from "node:http";
+import { WebsocketsUpgradeHandler } from "./abstractions.js";
+export declare class DefaultUpgradeHandlerImpl implements WebsocketsUpgradeHandler.Interface {
+    shouldUpgrade(_request: IncomingMessage): Promise<WebsocketsUpgradeHandler.Decision>;
+}
+export declare const DefaultUpgradeHandler: typeof DefaultUpgradeHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWebsocketsUpgradeHandler>;
+};

package/upgradeHandler/DefaultUpgradeHandler.js

@@ -0,0 +1,15 @@
+import { WebsocketsUpgradeHandler } from "./abstractions.js";
+class DefaultUpgradeHandlerImpl {
+    async shouldUpgrade(_request) {
+        return {
+            allowed: true
+        };
+    }
+}
+const DefaultUpgradeHandler = WebsocketsUpgradeHandler.createImplementation({
+    implementation: DefaultUpgradeHandlerImpl,
+    dependencies: []
+});
+export { DefaultUpgradeHandler, DefaultUpgradeHandlerImpl };
+
+//# sourceMappingURL=DefaultUpgradeHandler.js.map

package/upgradeHandler/DefaultUpgradeHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeHandler/DefaultUpgradeHandler.js","sources":["../../src/upgradeHandler/DefaultUpgradeHandler.ts"],"sourcesContent":["import type { IncomingMessage } from \"node:http\";\nimport { WebsocketsUpgradeHandler } from \"./abstractions.js\";\n\nexport class DefaultUpgradeHandlerImpl implements WebsocketsUpgradeHandler.Interface {\n    public async shouldUpgrade(\n        _request: IncomingMessage\n    ): Promise<WebsocketsUpgradeHandler.Decision> {\n        return { allowed: true };\n    }\n}\n\nexport const DefaultUpgradeHandler = WebsocketsUpgradeHandler.createImplementation({\n    implementation: DefaultUpgradeHandlerImpl,\n    dependencies: []\n});\n"],"names":["DefaultUpgradeHandlerImpl","_request","DefaultUpgradeHandler","WebsocketsUpgradeHandler"],"mappings":";AAGO,MAAMA;IACT,MAAa,cACTC,QAAyB,EACiB;QAC1C,OAAO;YAAE,SAAS;QAAK;IAC3B;AACJ;AAEO,MAAMC,wBAAwBC,yBAAyB,oBAAoB,CAAC;IAC/E,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/upgradeHandler/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage } from "node:http";
+type UpgradeDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    statusCode: number;
+    reason: string;
+};
+export interface IWebsocketsUpgradeHandler {
+    shouldUpgrade(request: IncomingMessage): Promise<UpgradeDecision>;
+}
+export declare const WebsocketsUpgradeHandler: import("@webiny/di").Abstraction<IWebsocketsUpgradeHandler>;
+export declare namespace WebsocketsUpgradeHandler {
+    type Interface = IWebsocketsUpgradeHandler;
+    type Decision = UpgradeDecision;
+}
+export {};

package/upgradeHandler/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const WebsocketsUpgradeHandler = createAbstraction("WebsocketsUpgradeHandler");
+export { WebsocketsUpgradeHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/upgradeHandler/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeHandler/abstractions.js","sources":["../../src/upgradeHandler/abstractions.ts"],"sourcesContent":["import type { IncomingMessage } from \"node:http\";\nimport { createAbstraction } from \"@webiny/feature/api\";\n\ntype UpgradeDecision = { allowed: true } | { allowed: false; statusCode: number; reason: string };\n\nexport interface IWebsocketsUpgradeHandler {\n    shouldUpgrade(request: IncomingMessage): Promise<UpgradeDecision>;\n}\n\nexport const WebsocketsUpgradeHandler = createAbstraction<IWebsocketsUpgradeHandler>(\n    \"WebsocketsUpgradeHandler\"\n);\n\nexport namespace WebsocketsUpgradeHandler {\n    export type Interface = IWebsocketsUpgradeHandler;\n    export type Decision = UpgradeDecision;\n}\n"],"names":["WebsocketsUpgradeHandler","createAbstraction"],"mappings":";AASO,MAAMA,2BAA2BC,kBACpC"}

package/validator/ServerWebsocketsEventValidator.d.ts

@@ -0,0 +1,4 @@
+import { WebsocketsEventValidator, WebsocketsRunner } from "@webiny/api-websockets/exports/api.js";
+export declare class ServerWebsocketsEventValidator implements WebsocketsEventValidator.Interface {
+    validate<T extends WebsocketsRunner.EventData = WebsocketsRunner.EventData>(input: unknown): Promise<WebsocketsRunner.Event<T>>;
+}

package/validator/ServerWebsocketsEventValidator.js

@@ -0,0 +1,53 @@
+import zod from "zod";
+import { createZodError } from "@webiny/utils";
+const eventTypeEnum = zod["enum"]([
+    "message",
+    "connect",
+    "disconnect"
+]);
+const contextValidation = zod.object({
+    connectionId: zod.string(),
+    connectedAt: zod.number(),
+    host: zod.string(),
+    eventType: eventTypeEnum,
+    route: zod.string(),
+    endpoint: zod.string()
+});
+const bodyValidation = zod.looseObject({
+    token: zod.string().optional(),
+    tenant: zod.string().optional(),
+    messageId: zod.string().nullish(),
+    action: zod.string().optional(),
+    data: zod.looseObject({}).nullish()
+}).optional();
+const validation = zod.object({
+    headers: zod.looseObject({}).optional(),
+    context: contextValidation,
+    body: bodyValidation
+}).superRefine((output, ctx)=>{
+    if ("message" !== output.context.eventType) return;
+    if (!output.body) ctx.addIssue({
+        path: [
+            "body"
+        ],
+        message: "Message event must have a body.",
+        code: zod.ZodIssueCode.custom,
+        fatal: true
+    });
+});
+class ServerWebsocketsEventValidator {
+    async validate(input) {
+        const result = await validation.safeParseAsync(input);
+        if (!result.success) throw createZodError(result.error);
+        const event = {
+            headers: result.data.headers,
+            context: result.data.context,
+            body: result.data.body
+        };
+        if ("message" === event.context.eventType && event.body?.action) event.context.route = event.body.action;
+        return event;
+    }
+}
+export { ServerWebsocketsEventValidator };
+
+//# sourceMappingURL=ServerWebsocketsEventValidator.js.map

package/validator/ServerWebsocketsEventValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator/ServerWebsocketsEventValidator.js","sources":["../../src/validator/ServerWebsocketsEventValidator.ts"],"sourcesContent":["import zod from \"zod\";\nimport { WebsocketsEventValidator, WebsocketsRunner } from \"@webiny/api-websockets/exports/api.js\";\nimport { createZodError } from \"@webiny/utils\";\n\nconst eventTypeEnum = zod.enum([\"message\", \"connect\", \"disconnect\"]);\n\nconst contextValidation = zod.object({\n    connectionId: zod.string(),\n    connectedAt: zod.number(),\n    host: zod.string(),\n    eventType: eventTypeEnum,\n    route: zod.string(),\n    endpoint: zod.string()\n});\n\nconst bodyValidation = zod\n    .looseObject({\n        token: zod.string().optional(),\n        tenant: zod.string().optional(),\n        messageId: zod.string().nullish(),\n        action: zod.string().optional(),\n        data: zod.looseObject({}).nullish()\n    })\n    .optional();\n\nconst validation = zod\n    .object({\n        headers: zod.looseObject({}).optional(),\n        context: contextValidation,\n        body: bodyValidation\n    })\n    .superRefine((output, ctx) => {\n        if (output.context.eventType !== \"message\") {\n            return;\n        }\n        if (!output.body) {\n            ctx.addIssue({\n                path: [\"body\"],\n                message: \"Message event must have a body.\",\n                code: zod.ZodIssueCode.custom,\n                fatal: true\n            });\n        }\n    });\n\nexport class ServerWebsocketsEventValidator implements WebsocketsEventValidator.Interface {\n    public async validate<T extends WebsocketsRunner.EventData = WebsocketsRunner.EventData>(\n        input: unknown\n    ): Promise<WebsocketsRunner.Event<T>> {\n        const result = await validation.safeParseAsync(input);\n        if (!result.success) {\n            throw createZodError(result.error);\n        }\n\n        const event: WebsocketsRunner.Event<T> = {\n            headers: result.data.headers as Record<string, string>,\n            context: result.data.context,\n            body: result.data.body as T\n        };\n\n        /* Use body.action as custom route if provided. */\n        if (event.context.eventType === \"message\" && event.body?.action) {\n            event.context.route = event.body.action;\n        }\n\n        return event;\n    }\n}\n"],"names":["eventTypeEnum","zod","contextValidation","bodyValidation","validation","output","ctx","ServerWebsocketsEventValidator","input","result","createZodError","event"],"mappings":";;AAIA,MAAMA,gBAAgBC,GAAG,CAAHA,OAAQ,CAAC;IAAC;IAAW;IAAW;CAAa;AAEnE,MAAMC,oBAAoBD,IAAI,MAAM,CAAC;IACjC,cAAcA,IAAI,MAAM;IACxB,aAAaA,IAAI,MAAM;IACvB,MAAMA,IAAI,MAAM;IAChB,WAAWD;IACX,OAAOC,IAAI,MAAM;IACjB,UAAUA,IAAI,MAAM;AACxB;AAEA,MAAME,iBAAiBF,IAAAA,WACP,CAAC;IACT,OAAOA,IAAI,MAAM,GAAG,QAAQ;IAC5B,QAAQA,IAAI,MAAM,GAAG,QAAQ;IAC7B,WAAWA,IAAI,MAAM,GAAG,OAAO;IAC/B,QAAQA,IAAI,MAAM,GAAG,QAAQ;IAC7B,MAAMA,IAAI,WAAW,CAAC,CAAC,GAAG,OAAO;AACrC,GACC,QAAQ;AAEb,MAAMG,aAAaH,IAAAA,MACR,CAAC;IACJ,SAASA,IAAI,WAAW,CAAC,CAAC,GAAG,QAAQ;IACrC,SAASC;IACT,MAAMC;AACV,GACC,WAAW,CAAC,CAACE,QAAQC;IAClB,IAAID,AAA6B,cAA7BA,OAAO,OAAO,CAAC,SAAS,EACxB;IAEJ,IAAI,CAACA,OAAO,IAAI,EACZC,IAAI,QAAQ,CAAC;QACT,MAAM;YAAC;SAAO;QACd,SAAS;QACT,MAAML,IAAI,YAAY,CAAC,MAAM;QAC7B,OAAO;IACX;AAER;AAEG,MAAMM;IACT,MAAa,SACTC,KAAc,EACoB;QAClC,MAAMC,SAAS,MAAML,WAAW,cAAc,CAACI;QAC/C,IAAI,CAACC,OAAO,OAAO,EACf,MAAMC,eAAeD,OAAO,KAAK;QAGrC,MAAME,QAAmC;YACrC,SAASF,OAAO,IAAI,CAAC,OAAO;YAC5B,SAASA,OAAO,IAAI,CAAC,OAAO;YAC5B,MAAMA,OAAO,IAAI,CAAC,IAAI;QAC1B;QAGA,IAAIE,AAA4B,cAA5BA,MAAM,OAAO,CAAC,SAAS,IAAkBA,MAAM,IAAI,EAAE,QACrDA,MAAM,OAAO,CAAC,KAAK,GAAGA,MAAM,IAAI,CAAC,MAAM;QAG3C,OAAOA;IACX;AACJ"}