jsgar 2.2.2 → 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') {
@@ -589,58 +680,62 @@
         }
 
         /**
-         * Send a subscription request using local IDs.
+         * Send an already-formatted subscription message
+         * @param {object} subscriptionMessageValue - json representation of the gar `subscribe` struct
+         */
+        subscribeFormatted(subscriptionMessageValue) {
+            const subMsg = {
+                message_type: 'Subscribe',
+                value: subscriptionMessageValue,
+            };
+            this.sendMessage(subMsg);
+        }
+
+        /**
+         * Send a subscription request
          * @param {string} name - Subscription name
          * @param {string} [subscriptionMode='Streaming'] - Subscription mode
-         * @param {string} [mode] - Deprecated: use subscriptionMode instead
-         * @param {string} [subscriptionSet] - Subscription set identifier
-         * @param {string} [maxHistory] - Maximum history to include
-         * @param {number} [snapshotSizeLimit=0] - Limit snapshot size
-         * @param {number} [nagleInterval=0] - Nagle interval in milliseconds
-         * @param {number} [subscriptionGroup=0] - Subscription group ID for isolating callbacks
-         * @param {string} [density] - For performance tuning
-         * @param {boolean} [includeReferencedKeys=false] - Add keys from key references in matched records
-         * @param {boolean} [includeReferencingKeys=false] - Add keys that have one or more records referencing any matched keys
-         * @param {boolean} [includeAllNamespace=false] - Include keys and topics from all namespaces
-         * @param {number} [limit=0] - Limits records in initial snapshot (0 = all)
          * @param {string|Array<string>|null} [keyName=null] - Key name(s)
          * @param {string|Array<string>|null} [topicName=null] - Topic name(s)
          * @param {string|Array<string>|null} [className=null] - Class name(s)
          * @param {string|null} [keyFilter=null] - Key filter regex (cannot use with keyName)
-         * @param {string|null} [excludeKeyFilter=null] - Exclude key filter regex (cannot use with keyName)
          * @param {string|null} [topicFilter=null] - Topic filter regex (cannot use with topicName)
+         * @param {string|null} [excludeKeyFilter=null] - Exclude key filter regex (cannot use with keyName)
          * @param {string|null} [excludeTopicFilter=null] - Exclude topic filter regex (cannot use with topicName)
-         * @param {string} [workingNamespace] - Namespace for matching relative paths
+         * @param {string|null} [maxHistory] - Maximum history to include
+         * @param {boolean} [includeReferencedKeys=false] - Add keys from key references in matched records
+         * @param {boolean} [includeReferencingKeys=false] - Add keys that have one or more records referencing any matched keys
+         * @param {boolean} [includeAllNamespace=false] - Include keys and topics from all namespaces
+         * @param {string|null} [workingNamespace] - Namespace for matching relative paths
+         * @param {string|null} [density] - For performance tuning
+         * @param {number} [subscriptionGroup=0] - Subscription group ID for isolating callbacks
+         * @param {string|null} [subscriptionSet] - Subscription set identifier
+         * @param {number} [snapshotSizeLimit=0] - Limit snapshot size
+         * @param {number} [nagleInterval=0] - Nagle interval in milliseconds
+         * @param {number} [limit=0] - Limits records in initial snapshot (0 = all)
          */
         subscribe(
             name,
             subscriptionMode = 'Streaming',
-            mode = null,
-            subscriptionSet = null,
-            maxHistory = null,
-            snapshotSizeLimit = 0,
-            nagleInterval = 0,
-            subscriptionGroup = 0,
-            density = null,
-            includeReferencedKeys = false,
-            includeReferencingKeys = false,
-            includeAllNamespace = false,
-            limit = 0,
             keyName = null,
             topicName = null,
             className = null,
             keyFilter = null,
-            excludeKeyFilter = null,
             topicFilter = null,
+            excludeKeyFilter = null,
             excludeTopicFilter = null,
-            workingNamespace = null
+            maxHistory = null,
+            includeReferencedKeys = false,
+            includeReferencingKeys = false,
+            includeAllNamespace = false,
+            workingNamespace = null,
+            density = null,
+            subscriptionGroup = 0,
+            subscriptionSet = null,
+            snapshotSizeLimit = 0,
+            nagleInterval = 0,
+            limit = 0
         ) {
-            // Handle deprecated mode parameter
-            if (mode !== null) {
-                console.warn('The "mode" parameter is deprecated. Use "subscriptionMode" instead.');
-                subscriptionMode = mode;
-            }
-
             // Validate mutually exclusive parameters
             if (keyName && (keyFilter || excludeKeyFilter)) {
                 throw new Error('keyName cannot be used with keyFilter or excludeKeyFilter');
@@ -690,10 +785,10 @@
             };
             
             // Add optional fields only if they have values
-            if (subscriptionSet !== null) {
+            if (subscriptionSet) {
                 valueDict.subscription_set = subscriptionSet;
             }
-            if (maxHistory !== null) {
+            if (maxHistory) {
                 valueDict.max_history = maxHistory;
             }
             if (snapshotSizeLimit > 0) {
@@ -705,7 +800,7 @@
             if (subscriptionGroup > 0) {
                 valueDict.subscription_group = subscriptionGroup;
             }
-            if (density !== null) {
+            if (density) {
                 valueDict.density = density;
             }
             if (includeReferencedKeys) {
@@ -745,11 +840,56 @@
                 valueDict.working_namespace = workingNamespace;
             }
 
-            const subMsg = {
-                message_type: 'Subscribe',
-                value: valueDict,
-            };
-            this.sendMessage(subMsg);
+            this.subscribeFormatted(valueDict);
+        }
+
+        /**
+         * Wrapper to `subscribe` with a smaller set of arguments.
+         * @param {string} name - Subscription name
+         * @param {string} [subscriptionMode='Streaming'] - Subscription mode
+         * @param {number} [subscriptionGroup=0] - Subscription group ID for isolating callbacks
+         * @param {number} [snapshotSizeLimit=0] - Limit snapshot size
+         * @param {string|Array<string>|null} [keyName=null] - Key name(s)
+         * @param {string|Array<string>|null} [topicName=null] - Topic name(s)
+         * @param {string|Array<string>|null} [className=null] - Class name(s)
+         * @param {string|null} [keyFilter=null] - Key filter regex (cannot use with keyName)
+         * @param {string|null} [topicFilter=null] - Topic filter regex (cannot use with topicName)
+         * @param {string|null} [excludeKeyFilter=null] - Exclude key filter regex (cannot use with keyName)
+         * @param {string|null} [excludeTopicFilter=null] - Exclude topic filter regex (cannot use with topicName)
+         */
+        subscribeCommon(
+            name,
+            subscriptionMode = 'Streaming',
+            subscriptionGroup = 0,
+            snapshotSizeLimit = 0,
+            keyName = null,
+            topicName = null,
+            className = null,
+            keyFilter = null,
+            topicFilter = null,
+            excludeKeyFilter = null,
+            excludeTopicFilter = null,
+        ) {
+            this.subscribe(
+                name,
+                subscriptionMode,
+                keyName,
+                topicName,
+                className,
+                keyFilter,
+                topicFilter,
+                excludeKeyFilter,
+                excludeTopicFilter,
+                null,
+                false,
+                false,
+                false,
+                null,
+                null,
+                subscriptionGroup,
+                null,
+                snapshotSizeLimit
+            );
         }
 
         /**

package/package.json

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