jsgar 3.7.2 → 3.8.0

package/dist/gar.umd.js

@@ -47,7 +47,11 @@
             this.reconnectDelay = 5000; // Milliseconds
             this.user = user;
             this.working_namespace = working_namespace;
-            this.heartbeatTimeoutInterval = heartbeatTimeoutInterval;
+            this.timeoutScale = (typeof process !== 'undefined' && process.env && process.env.TRS_TIMEOUT_SCALE) ? parseFloat(process.env.TRS_TIMEOUT_SCALE) : 1.0;
+            this.scaledHeartbeatTimeoutInterval = heartbeatTimeoutInterval;
+            if (this.timeoutScale !== 1.0) {
+                this.scaledHeartbeatTimeoutInterval *= this.timeoutScale;
+            }
             this.version = 650707;
 
             if (typeof window !== 'undefined' && window.location) {
@@ -70,7 +74,6 @@
             this.heartbeatIntervalId = null;
             this.messageHandlers = new Map();
             this.lastHeartbeatTime = Date.now() / 1000;
-            this.heartbeatTimeout = 3; // Seconds
 
             this.heartbeatTimeoutCallback = null;
             this.stoppedCallback = null;
@@ -145,42 +148,72 @@
 
         /**
          * Establish WebSocket connection with reconnection logic.
+         * @param {number} [openTimeout=20] - Connection timeout in seconds
          */
-        /**
-         * Establish WebSocket connection with reconnection logic.
-         */
-        async connect() {
+        async connect(openTimeout = 20) {
             // Before attempting a new connection, clear any previous state
             this.clearConnectionState();
 
+            let scaledOpenTimeout = openTimeout * this.timeoutScale;
+
             while (this.running && !this.connected) {
                 try {
                     const WS = await this._ensureWebSocketCtor();
                     const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-                    if (this.allowSelfSignedCertificate && isNode) {
-                        // Node.js 'ws' supports options for TLS; browsers do not.
-                        this.websocket = new WS(this.wsEndpoint, ['gar-protocol'], { rejectUnauthorized: false });
-                    } else {
-                        this.websocket = new WS(this.wsEndpoint, ['gar-protocol']);
-                    }
-                    this.websocket.onopen = () => {
-                        this.connected = true;
-                        this.log('INFO', `Connected to WebSocket server at ${this.wsEndpoint} using gar-protocol`);
-                        this._sendMessages();
-                        this._receiveMessages();
-                    };
+
+                    this.log('INFO', `Connecting to WebSocket server at ${this.wsEndpoint}`);
+
+                    const connectionPromise = new Promise((resolve, reject) => {
+                        let websocket;
+                        if (this.allowSelfSignedCertificate && isNode) {
+                            // Node.js 'ws' supports options for TLS; browsers do not.
+                            websocket = new WS(this.wsEndpoint, ['gar-protocol'], { rejectUnauthorized: false });
+                        } else {
+                            websocket = new WS(this.wsEndpoint, ['gar-protocol']);
+                        }
+
+                        const timeoutId = setTimeout(() => {
+                            websocket.onopen = null;
+                            websocket.onclose = null;
+                            websocket.onerror = null;
+                            if (websocket.terminate) websocket.terminate();
+                            else if (websocket.close) websocket.close();
+                            reject(new Error(`Connection timed out after ${scaledOpenTimeout}s`));
+                        }, scaledOpenTimeout * 1000);
+
+                        websocket.onopen = () => {
+                            clearTimeout(timeoutId);
+                            resolve(websocket);
+                        };
+                        websocket.onerror = (error) => {
+                            clearTimeout(timeoutId);
+                            reject(new Error(error.message || 'Unknown WebSocket error'));
+                        };
+                        websocket.onclose = () => {
+                            clearTimeout(timeoutId);
+                            reject(new Error('WebSocket closed during connection attempt'));
+                        };
+                    });
+
+                    this.websocket = await connectionPromise;
+                    this.connected = true;
+                    this.log('INFO', `Connected to WebSocket server at ${this.wsEndpoint} using gar-protocol`);
+
                     this.websocket.onclose = () => {
                         this.log('WARNING', 'WebSocket connection closed.');
                         this.connected = false;
                         this.websocket = null;
+                        this._reconnect();
                     };
                     this.websocket.onerror = (error) => {
                         this.log('ERROR', `WebSocket error: ${error.message || 'Unknown error'}`);
                         this.connected = false;
                         this.websocket = null;
                     };
-                    // Wait indefinitely until connection succeeds or fails
-                    await new Promise(resolve => setTimeout(resolve, 5000));
+
+                    this._sendMessages();
+                    this._receiveMessages();
+
                 } catch (e) {
                     this.log('ERROR', `WebSocket connection failed: ${e.message}. Reconnecting in ${this.reconnectDelay / 1000} seconds...`);
                     this.connected = false;
@@ -329,11 +362,11 @@
 
         /**
          * Register handler for DeleteKey message.
-         * @param {Function} handler - Callback with (keyId)
+         * @param {Function} handler - Callback with (keyId, keyName)
          * @param subscriptionGroup - The subscription group for callback (default 0)
          */
         registerDeleteKeyHandler(handler, subscriptionGroup = 0) {
-            this.registerHandler('DeleteKey', (msg) => handler(msg.value.key_id), subscriptionGroup);
+            this.registerHandler('DeleteKey', (msg) => handler(msg.value.key_id, (msg.value && ('name' in msg.value)) ? msg.value.name : null), subscriptionGroup);
         }
 
         /**
@@ -426,8 +459,8 @@
                 this.log('DEBUG', `New server topic: ${name} (Server ID: ${topicId})`));
             this.registerKeyIntroductionHandler((keyId, name, classList, deletedClass) =>
                 this.log('DEBUG', `Key: ${name} : ${keyId} (Classes: ${JSON.stringify(classList)}/-${deletedClass})`));
-            this.registerDeleteKeyHandler((keyId) =>
-                this.log('DEBUG', `Delete key: ${this.serverKeyIdToName.get(keyId) || 'unknown'} (Server ID: ${keyId})`));
+            this.registerDeleteKeyHandler((keyId, keyName) =>
+                this.log('DEBUG', `Delete key: ${keyName || 'unknown'} (Server ID: ${keyId})`));
             this.registerSubscriptionStatusHandler(this._defaultSubscriptionStatusHandler.bind(this));
             this.registerDeleteRecordHandler((keyId, topicId) =>
                 this.log('DEBUG', `Delete record: ${this.serverKeyIdToName.get(keyId) || 'unknown'} - ${this.serverTopicIdToName.get(topicId) || 'unknown'}`));
@@ -457,13 +490,13 @@
                 message_type: 'Introduction',
                 value: {
                     version: this.version,
-                    heartbeat_timeout_interval: this.heartbeatTimeoutInterval,
+                    heartbeat_timeout_interval: Math.floor(this.scaledHeartbeatTimeoutInterval),
                     user: this.user,
                     working_namespace: this.working_namespace
                 }
             };
             this.sendMessage(introMsg);
-            this.heartbeatIntervalId = setInterval(() => this._heartbeatLoop(), this.heartbeatTimeoutInterval / 2);
+            this.heartbeatIntervalId = setInterval(() => this._heartbeatLoop(), this.scaledHeartbeatTimeoutInterval / 2);
             this.connect();
         }
 
@@ -590,7 +623,7 @@
          */
         checkHeartbeat() {
             const now = Date.now() / 1000;
-            const cutoff = this._initialGracePeriod ? this._initialGraceDeadline : this.lastHeartbeatTime + this.heartbeatTimeout;
+            const cutoff = this._initialGracePeriod ? this._initialGraceDeadline : this.lastHeartbeatTime + (this.scaledHeartbeatTimeoutInterval / 1000.0);
             if (now > cutoff) {
                 this.log('WARNING', `Heartbeat failed; previous heartbeat: ${this.lastHeartbeatTime.toFixed(3)}s`);
                 this.exitCode = 1;
@@ -660,8 +693,16 @@
                 this.serverKeyNameToId.set(message.value.name, message.value.key_id);
             } else if (msgType === 'DeleteKey') {
                 subscriptionGroup = this.activeSubscriptionGroup;
-                this.serverKeyNameToId.delete(this.serverKeyIdToName.get(message.value.key_id) || "");
-                this.serverKeyIdToName.delete(message.value.key_id);
+                const keyId = message.value.key_id;
+                const keyName = this.serverKeyIdToName.get(keyId) || null;
+                message.value.name = keyName;
+                if (keyName) {
+                    this.serverKeyNameToId.delete(keyName);
+                } else {
+                    // Ensure 'name' field exists even if unknown
+                    if (!('name' in message.value)) message.value.name = null;
+                }
+                this.serverKeyIdToName.delete(keyId);
             } else if (msgType === 'Heartbeat') {
                 this.lastHeartbeatTime = Date.now() / 1000;
                 if (this._initialGracePeriod) {
@@ -678,10 +719,14 @@
                 this.serverKeyIdToName.clear();
                 this.serverKeyNameToId.clear();
                 this.recordMap.clear();
-                this.heartbeatTimeout = Math.max(this.heartbeatTimeout, value.heartbeat_timeout_interval / 1000);
+                let newInterval = value.heartbeat_timeout_interval;
+                if (this.timeoutScale !== 1.0) {
+                    newInterval *= this.timeoutScale;
+                }
+                this.scaledHeartbeatTimeoutInterval = Math.max(this.scaledHeartbeatTimeoutInterval, newInterval);
                 this.lastHeartbeatTime = Date.now() / 1000;
                 this._initialGracePeriod = true;
-                this._initialGraceDeadline = this.lastHeartbeatTime + this.heartbeatTimeout * 10;
+                this._initialGraceDeadline = this.lastHeartbeatTime + (this.scaledHeartbeatTimeoutInterval / 1000.0) * 10;
                 // New Introduction: do not reset the first-heartbeat promise to avoid racing
                 // with consumers already awaiting it. The existing promise will resolve on
                 // the first Heartbeat observed during the grace period above.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgar",
-  "version": "3.7.2",
+  "version": "3.8.0",
   "description": "A Javascript client for the GAR protocol",
   "type": "module",
   "main": "dist/gar.umd.js",