roboto-js 1.6.17 → 1.7.0

package/src/rbt_object.js

@@ -19,15 +19,27 @@ export default class RbtObject{
       this._data = record.dataJson ? this._deepUnpackJson(record.dataJson) : {};
     }
     
-    if (options.websocketClient && this.id) {
+    if (options.websocketClient && this.id && options.enableRealtime) {
       this._realtime = true;
       this._ws = options.websocketClient;
       this._subscribeToRealtime(this._ws);
+    } else if (options.websocketClient && this.id) {
+      // Store websocket client for potential later use, but don't auto-subscribe
+      this._ws = options.websocketClient;
+    }
+    
+    // If enableRealtime is requested but no websocketClient provided, try to initialize lazily
+    if (options.enableRealtime && this.id && !this._realtime) {
+      this._initRealtime();
     }
     this._eventHandlers = {
       change: [],
       save: []
     };
+    
+    // Debounce properties for WebSocket broadcasting
+    this._broadcastDebounceTimer = null;
+    this._pendingBroadcasts = new Map(); // path -> value
   }
 
   get(path) {
@@ -86,16 +98,22 @@ export default class RbtObject{
         if (!_.isEqual(currentValue, mergedValue)) {
             _.set(this._data, path, mergedValue);  // Set the merged value at the deep path
             this._addChange(path);
+            // Trigger local change events for any registered handlers
+            this._trigger('change', { path, value: mergedValue, options });
         }
     } else {
         // If value is undefined and not merging, delete the key
         if (value === undefined) {
             _.unset(this._data, path);
             this._addChange(path);
+            // Trigger local change events for any registered handlers
+            this._trigger('change', { path, value: undefined, options });
         } else if (!_.isEqual(currentValue, value)) {
             _.set(this._data, path, value);  // Set the value directly at the deep path
             this._addChange(path);
             this._broadcastChange(path, value);
+            // Trigger local change events for any registered handlers
+            this._trigger('change', { path, value, options });
         }
     }
   }
@@ -125,6 +143,8 @@ export default class RbtObject{
               if (!_.isEqual(currentValue, mergedValue)) {
                   _.set(this._data, path, mergedValue);
                   this._addChange(path);
+                  // Trigger change event for this path
+                  this._trigger('change', { path, value: mergedValue, options });
               }
           } else if (!_.isEqual(currentValue, newValue)) {
               _.setWith(this._data, path, newValue, (nsValue, key, nsObject, nsPath) => {
@@ -134,6 +154,8 @@ export default class RbtObject{
                   return nsValue;
               });
               this._addChange(path);
+              // Trigger change event for this path
+              this._trigger('change', { path, value: newValue, options });
           }
       });
   }
@@ -341,11 +363,16 @@ export default class RbtObject{
   _initRealtime() {
     if (this._realtime || !this._axios) return;
 
-    // Lazily pull WebSocket from parent API (injected via axios instance)
-    const api = this._axios?.__rbtApiInstance;
-    if (!api || typeof api.getWebSocketClient !== 'function') return;
-
-    const ws = api.getWebSocketClient();
+    // Use stored websocket client if available
+    let ws = this._ws;
+    
+    // Otherwise, lazily pull WebSocket from parent API (injected via axios instance)
+    if (!ws) {
+      const api = this._axios?.__rbtApiInstance;
+      if (!api || typeof api.getWebSocketClient !== 'function') return;
+      ws = api.getWebSocketClient();
+    }
+    
     if (!ws || this._realtime) return;
 
     this._ws = ws;
@@ -354,6 +381,12 @@ export default class RbtObject{
   }
 
   _subscribeToRealtime(ws) {
+      // Track subscription for reconnection
+      const api = this._axios?.__rbtApiInstance;
+      if (api && typeof api._trackSubscription === 'function') {
+        api._trackSubscription(this.id);
+      }
+
       if (ws.readyState === 1) {
         ws.send(JSON.stringify({ type: 'subscribe', objectId: this.id }));
       } else {
@@ -363,42 +396,107 @@ export default class RbtObject{
       }
 
       ws.addEventListener('message', (event) => {
-        const msg = JSON.parse(event.data);
-        if (msg.objectId !== this.id) return;
-
-        if (msg.type === 'update') {
-          _.set(this._data, msg.delta.path, msg.delta.value);
-          this._trigger('change', msg.delta);
-        } else if (msg.type === 'save') {
-          this._trigger('save', msg.revision || {});
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.objectId !== this.id) return;
+
+          if (msg.type === 'update') {
+            if (msg.delta && msg.delta.path !== undefined) {
+              _.set(this._data, msg.delta.path, msg.delta.value);
+              
+              // Add metadata to indicate if this is state sync vs live update
+              const changeData = {
+                ...msg.delta,
+                isStateSync: msg.isStateSync || false,
+                source: msg.isStateSync ? 'state-sync' : 'realtime',
+                userId: msg.userId || msg.delta.userId || null
+              };
+              
+              this._trigger('change', changeData);
+              
+              if (msg.isStateSync) {
+                console.log('[RbtObject] Applied state sync:', msg.delta.path, '=', msg.delta.value);
+              }
+            } else {
+              console.warn('[RbtObject] Received update message without valid delta:', msg);
+            }
+          } else if (msg.type === 'save') {
+            this._trigger('save', msg.revision || {});
+          }
+        } catch (error) {
+          console.error('[RbtObject] Error processing WebSocket message:', error, event.data);
         }
       });
     }
 
-    onRealtimeChange(cb) {
+    // General change handler for both local and remote changes
+    onChange(cb) {
       this._eventHandlers.change.push(cb);
-      this._initRealtime(); // lazy connect
+      // Auto-initialize realtime if this object has WebSocket capability
+      if (this._ws && !this._realtime) {
+        this._initRealtime();
+      }
     }
 
-    onRealtimeSave(cb) {
+    // General save handler for both local and remote saves
+    onSave(cb) {
       this._eventHandlers.save.push(cb);
-      this._initRealtime(); // lazy connect
+      // Note: Does not initialize realtime connection
     }
 
     _trigger(type, data) {
+      console.log('[AgentProviderSync] _trigger called:', type, 'handlers:', this._eventHandlers[type]?.length, 'data:', data)
       for (const fn of this._eventHandlers[type] || []) {
         fn(data);
       }
     }
 
     _broadcastChange(path, value) {
-      if (this._realtime && this._ws && this._ws.readyState === 1) {
+      if (!this._realtime || !this._ws || this._ws.readyState !== 1) {
+        return;
+      }
+
+      // Store the pending broadcast
+      this._pendingBroadcasts.set(path, value);
+
+      // Clear existing timer if any
+      if (this._broadcastDebounceTimer) {
+        clearTimeout(this._broadcastDebounceTimer);
+      }
+
+      // Set new debounced timer
+      this._broadcastDebounceTimer = setTimeout(() => {
+        this._flushPendingBroadcasts();
+      }, 300);
+    }
+
+    _flushPendingBroadcasts() {
+      if (!this._realtime || !this._ws || this._ws.readyState !== 1) {
+        this._pendingBroadcasts.clear();
+        return;
+      }
+
+      // Send all pending broadcasts
+      for (const [path, value] of this._pendingBroadcasts) {
         this._ws.send(JSON.stringify({
           type: 'update',
           objectId: this.id,
           delta: { path, value }
         }));
       }
+
+      // Clear pending broadcasts and timer
+      this._pendingBroadcasts.clear();
+      this._broadcastDebounceTimer = null;
+    }
+
+    // Cleanup method to clear any pending debounced broadcasts
+    _cleanup() {
+      if (this._broadcastDebounceTimer) {
+        clearTimeout(this._broadcastDebounceTimer);
+        this._broadcastDebounceTimer = null;
+      }
+      this._pendingBroadcasts.clear();
     }