@omen.foundation/node-microservice-runtime 0.1.76 → 0.1.78

package/dist/websocket.cjs

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeamableWebSocket = void 0;
+const promises_1 = require("node:timers/promises");
+const node_events_1 = require("node:events");
+const ws_1 = __importDefault(require("ws"));
+class BeamableWebSocket {
+    constructor(options) {
+        var _a, _b;
+        this.emitter = new node_events_1.EventEmitter();
+        this.socket = null;
+        this.isDisposed = false;
+        this.logger = options.logger.child({ component: 'BeamableWebSocket' });
+        this.url = options.url;
+        this.maxRetries = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 20;
+        this.retryDelayMs = (_b = options.retryDelayMs) !== null && _b !== void 0 ? _b : 1000;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    emit(event, ...args) {
+        this.emitter.emit(event, ...args);
+    }
+    async connect() {
+        let attempt = 0;
+        while (!this.isDisposed) {
+            try {
+                attempt += 1;
+                await this.createSocket();
+                return;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.logger.warn({ err, attempt }, 'WebSocket connection attempt failed.');
+                if (attempt >= this.maxRetries) {
+                    throw err;
+                }
+                await (0, promises_1.setTimeout)(this.retryDelayMs * attempt);
+            }
+        }
+        throw new Error('WebSocket disposed before connection could be established.');
+    }
+    async createSocket() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.terminate();
+            this.socket = null;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new ws_1.default(this.url, {
+                perMessageDeflate: true,
+                handshakeTimeout: 30000,
+            });
+            const handleOpen = () => {
+                this.logger.info({ url: this.url }, 'WebSocket connected.');
+                this.socket = ws;
+                ws.off('error', handleError);
+                ws.off('close', handlePrematureClose);
+                this.registerSocketHandlers(ws);
+                this.emit('open');
+                resolve();
+            };
+            const handleError = (error) => {
+                ws.off('open', handleOpen);
+                ws.off('close', handlePrematureClose);
+                reject(error);
+            };
+            const handlePrematureClose = (code, reason) => {
+                ws.off('open', handleOpen);
+                ws.off('error', handleError);
+                const err = new Error(`WebSocket closed before open handshake. code=${code} reason=${reason.toString()}`);
+                reject(err);
+            };
+            ws.on('open', handleOpen);
+            ws.on('error', handleError);
+            ws.on('close', handlePrematureClose);
+        });
+    }
+    registerSocketHandlers(ws) {
+        ws.on('message', (data) => {
+            const payload = typeof data === 'string' ? data : data.toString('utf8');
+            this.logger.debug({ payload }, 'WebSocket received frame.');
+            this.emit('message', payload);
+        });
+        ws.on('close', (code, reason) => {
+            this.logger.warn({ code, reason: reason.toString() }, 'WebSocket closed.');
+            this.emit('close', code === 1000);
+            if (!this.isDisposed) {
+                void this.reconnect();
+            }
+        });
+        ws.on('error', (error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({ err }, 'WebSocket error.');
+            this.emit('error', err);
+        });
+    }
+    async reconnect() {
+        this.logger.info('Attempting to reconnect websocket.');
+        let attempt = 0;
+        while (!this.isDisposed) {
+            try {
+                attempt += 1;
+                await this.createSocket();
+                this.emit('open');
+                return;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.logger.warn({ err, attempt }, 'Retrying websocket connection.');
+                await (0, promises_1.setTimeout)(this.retryDelayMs * Math.min(attempt, 10));
+            }
+        }
+    }
+    async send(text) {
+        if (!this.socket || this.socket.readyState !== ws_1.default.OPEN) {
+            throw new Error('WebSocket is not connected.');
+        }
+        this.logger.debug({ message: text }, 'Sending websocket frame.');
+        this.socket.send(text);
+    }
+    async close() {
+        this.isDisposed = true;
+        if (!this.socket) {
+            return;
+        }
+        const ws = this.socket;
+        if (ws.readyState === ws_1.default.CLOSED || ws.readyState === ws_1.default.CLOSING) {
+            return;
+        }
+        ws.close(1000, 'shutdown');
+    }
+}
+exports.BeamableWebSocket = BeamableWebSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omen.foundation/node-microservice-runtime",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Beamable microservice runtime for Node.js/TypeScript services.",
   "type": "module",
   "main": "dist/index.js",