roboto-js 1.6.17 → 1.7.0

package/dist/esm/rbt_object.js

@@ -15,15 +15,27 @@ export default class RbtObject {
     } else {
       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) {
     return _.get(this._data, path);
@@ -80,16 +92,34 @@ 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
+        });
       }
     }
   }
@@ -116,6 +146,12 @@ 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) => {
@@ -125,6 +161,12 @@ export default class RbtObject {
           return nsValue;
         });
         this._addChange(path);
+        // Trigger change event for this path
+        this._trigger('change', {
+          path,
+          value: newValue,
+          options
+        });
       }
     });
   }
@@ -301,16 +343,26 @@ 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;
     this._realtime = true;
     this._subscribeToRealtime(ws);
   }
   _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',
@@ -325,31 +377,82 @@ 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,
@@ -359,5 +462,18 @@ export default class RbtObject {
         }
       }));
     }
+
+    // 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();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roboto-js",
-  "version": "1.6.17",
+  "version": "1.7.0",
   "type": "module",
   "description": "",
   "main": "dist/cjs/index.cjs",
@@ -16,7 +16,8 @@
     "xbuild:esm": "babel src --out-dir dist/esm --presets=@babel/preset-env --no-babelrc --config-file ./babel.esm.config.json",
     "postbuild:cjs": "node postbuild-cjs.js",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "npm run build"
   },
   "author": "",
   "license": "ISC",

package/src/index.js

@@ -211,6 +211,15 @@ export default class Roboto{
     return this.api.query(type, params);
   }
 
+  // WebSocket methods
+  getWebSocketClient(){
+    return this.api.getWebSocketClient();
+  }
+
+  closeWebSocket(){
+    return this.api.closeWebSocket();
+  }
+
   //
   //
   //