jsgar 3.0.0 → 3.1.0

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;
@@ -343,6 +343,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 +582,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.0",
   "description": "A Javascript client for the GAR protocol",
   "type": "module",
   "main": "dist/gar.umd.js",