jsgar 3.0.0 → 3.1.1

package/dist/gar.umd.js

@@ -50,7 +50,7 @@
             this.user = user;
             this.working_namespace = working_namespace;
             this.heartbeatTimeoutInterval = heartbeatTimeoutInterval;
-            this.version = 650705;
+            this.version = 650706;
 
             if (typeof window !== 'undefined' && window.location) {
                 this.application = window.location.href;
@@ -64,25 +64,23 @@
             this.serverTopicNameToId = new Map();
             this.serverKeyIdToName = new Map();
             this.serverKeyNameToId = new Map();
-            this.localTopicCounter = 1;
-            this.localKeyCounter = 1;
             this.localTopicMap = new Map();
             this.localKeyMap = new Map();
+            this.recordMap = new Map();
 
             this.running = false;
             this.heartbeatIntervalId = null;
             this.messageHandlers = new Map();
             this.lastHeartbeatTime = Date.now() / 1000;
             this.heartbeatTimeout = 3; // Seconds
-            this._initialGracePeriod = false;
-            this._initialGraceDeadline = 0;
 
             this.heartbeatTimeoutCallback = null;
             this.stoppedCallback = null;
-            this.recordMap = new Map();
             this.allowSelfSignedCertificate = allowSelfSignedCertificate;
             this.exitCode = 0;
 
+            this.clearConnectionState();
+
             // Initialize log levels and set logLevel
             this.logLevels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
             this.logLevel = logLevel.toUpperCase();
@@ -91,8 +89,6 @@
                 this.logLevel = 'INFO';
             }
 
-            this.activeSubscriptionGroup = 0;
-
             this.registerDefaultHandlers();
         }
 
@@ -114,10 +110,43 @@
             }
         }
 
+        /**
+         * Reset all connection-related state:
+         * server/client topic/key mappings, counters, grace flags, and records.
+         */
+        clearConnectionState() {
+            // Server assigned topic/key <-> name mappings
+            this.serverTopicIdToName.clear();
+            this.serverTopicNameToId.clear();
+            this.serverKeyIdToName.clear();
+            this.serverKeyNameToId.clear();
+
+            // Client assigned topic/key counters and name <-> ID maps
+            this.localTopicCounter = 1;
+            this.localKeyCounter = 1;
+            this.localTopicMap.clear();
+            this.localKeyMap.clear();
+
+            // Heartbeat grace period flags
+            this._initialGracePeriod = false;
+            this._initialGraceDeadline = 0;
+
+            // Cached records
+            this.recordMap.clear();
+
+            this.activeSubscriptionGroup = 0;
+        }
+
+        /**
+         * Establish WebSocket connection with reconnection logic.
+         */
         /**
          * Establish WebSocket connection with reconnection logic.
          */
         async connect() {
+            // Before attempting a new connection, clear any previous state
+            this.clearConnectionState();
+
             while (this.running && !this.connected) {
                 try {
                     if (this.allowSelfSignedCertificate) {
@@ -343,6 +372,19 @@
             }, subscriptionGroup);
         }
 
+        /**
+         * Register handler for BatchUpdate message.
+         * If a batch handler is registered it is expected to process all the updates in the batch.
+         * If no batch handler is registered, individual key introductions and record updates will be fanned out to their respective handlers.
+         * @param {Function} handler - Callback with (batchData, subscriptionGroup)
+         * @param {number} [subscriptionGroup=0] - The subscription group for callback
+         */
+        registerBatchUpdateHandler(handler, subscriptionGroup = 0) {
+            this.registerHandler('BatchUpdate', (msg) => {
+                handler(msg.value, subscriptionGroup);
+            }, subscriptionGroup);
+        }
+
         /**
          * Register a callback to handle heartbeat timeout events.
          * @param {Function} handler - Callback with no arguments
@@ -569,6 +611,84 @@
                 subscriptionGroup = this.activeSubscriptionGroup;
                 const {key_id: keyId, topic_id: topicId} = message.value;
                 this.recordMap.delete(`${keyId}:${topicId}`);
+            } else if (msgType === 'BatchUpdate') {
+                subscriptionGroup = this.activeSubscriptionGroup;
+                const value = message.value;
+                const defaultClass = value.default_class;
+
+                // Check if there's a specific batch update handler
+                const batchHandlerKey = subscriptionGroup ? `BatchUpdate ${subscriptionGroup}` : 'BatchUpdate';
+                const hasBatchHandler = this.messageHandlers.has(batchHandlerKey);
+
+                // Pre-check for individual handlers if no batch handler
+                let keyHandler = null;
+                let recordHandler = null;
+                if (!hasBatchHandler) {
+                    const keyHandlerKey = subscriptionGroup ? `KeyIntroduction ${subscriptionGroup}` : 'KeyIntroduction';
+                    keyHandler = this.messageHandlers.get(keyHandlerKey);
+
+                    const recordHandlerKey = subscriptionGroup ? `JSONRecordUpdate ${subscriptionGroup}` : 'JSONRecordUpdate';
+                    recordHandler = this.messageHandlers.get(recordHandlerKey);
+                }
+
+                for (const keyUpdate of value.keys || []) {
+                    const keyId = keyUpdate.key_id;
+                    const keyName = keyUpdate.name;
+
+                    // Handle key introduction if name is provided and key is new
+                    if (keyName && !this.serverKeyIdToName.has(keyId)) {
+                        this.serverKeyIdToName.set(keyId, keyName);
+                        this.serverKeyNameToId.set(keyName, keyId);
+
+                        // If no batch handler but key handler exists, call KeyIntroduction handler
+                        if (!hasBatchHandler && keyHandler) {
+                            // Determine class_list: use key's classes, or default_class, or null
+                            let keyClasses = keyUpdate.classes;
+                            if (!keyClasses && keyUpdate.class) {
+                                keyClasses = [keyUpdate.class];
+                            } else if (!keyClasses && defaultClass) {
+                                keyClasses = [defaultClass];
+                            }
+
+                            const keyIntroMsg = {
+                                message_type: 'KeyIntroduction',
+                                value: {
+                                    key_id: keyId,
+                                    name: keyName,
+                                    ...(keyClasses ? { class_list: keyClasses } : {})
+                                }
+                            };
+                            keyHandler(keyIntroMsg);
+                        }
+                    }
+
+                    // Process topics for this key - topic IDs are object keys
+                    const topicsDict = keyUpdate.topics || {};
+                    for (const [topicIdStr, recordValue] of Object.entries(topicsDict)) {
+                        const topicId = parseInt(topicIdStr, 10);
+                        this.recordMap.set(`${keyId}:${topicId}`, recordValue);
+
+                        // If no batch handler but record handler exists, call JSONRecordUpdate handler
+                        if (!hasBatchHandler && recordHandler) {
+                            const recordUpdateMsg = {
+                                message_type: 'JSONRecordUpdate',
+                                value: {
+                                    record_id: { key_id: keyId, topic_id: topicId },
+                                    value: recordValue
+                                }
+                            };
+                            recordHandler(recordUpdateMsg);
+                        }
+                    }
+                }
+
+                // If there is a batch handler, call it
+                if (hasBatchHandler) {
+                    const batchHandler = this.messageHandlers.get(batchHandlerKey);
+                    if (batchHandler) {
+                        batchHandler(message);
+                    }
+                }
             } else if (msgType === "ActiveSubscription") {
                 this.activeSubscriptionGroup = message["value"]["subscription_group"];
             } else if (msgType === 'Logoff') {

package/package.json

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