jsgar 3.7.1 → 3.7.8

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;
@@ -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;
@@ -678,10 +711,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.
@@ -1075,6 +1112,17 @@
             this.sendMessage(msg);
         }
 
+        /**
+         * Delete a key by name if it exists in the localKeyMap. Safe to call multiple times.
+         * @param {string} keyName - Key name
+         */
+        deleteKey(keyName) {
+            const keyId = this.localKeyMap.get(keyName);
+            if (keyId) {
+                this.publishDeleteKey(keyId);
+            }
+        }
+
         /**
          * Publish a DeleteRecord message using local key and topic IDs.
          * @param {number} keyId - Key ID
@@ -1199,10 +1247,7 @@
             const resultContainer = { };
 
             const cleanup = () => {
-                const keyId = this.localKeyMap.get(queryKey);
-                if (keyId) {
-                    this.publishDeleteKey(keyId);
-                }
+                this.deleteKey(queryKey);
             };
 
             return new Promise((resolve) => {

package/package.json

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