roboto-js 1.6.18 → 1.7.1

package/dist/esm/rbt_api.js

@@ -14,6 +14,15 @@ export default class RbtApi {
     localStorageAdaptor = null
   }) {
     this.websocketClient = null;
+
+    // Object cache for sharing instances across multiple load() calls
+    this._objectCache = new Map();
+
+    // Track pending requests to prevent duplicate loads
+    this._pendingLoads = new Map();
+
+    // Track what we've already logged to reduce console spam
+    this._loggedCacheEvents = new Set();
     this.axios = axios.create({
       baseURL: baseUrl,
       headers: {
@@ -32,31 +41,121 @@ export default class RbtApi {
         removeItem: key => Promise.resolve(localStorage.removeItem(key))
       };
     }
+
+    // Synchronous browser hydration: set auth header and in-memory user immediately
+    if (typeof localStorage !== 'undefined') {
+      try {
+        const token = localStorage.getItem('authtoken');
+        if (token) {
+          this.authtoken = token;
+          this.axios.defaults.headers.common['authtoken'] = token;
+        }
+      } catch {}
+      try {
+        const cachedUser = localStorage.getItem('rbtUser');
+        if (cachedUser) {
+          const parsed = JSON.parse(cachedUser);
+          if (parsed && parsed.id) {
+            this.currentUser = new RbtUser({
+              id: parsed.id
+            }, this.axios);
+            this.currentUser.setData(parsed);
+          }
+        }
+      } catch {}
+    }
     this.localDb = null;
     this.iac_session = null;
     this.appServiceHost = baseUrl;
     this.requestCache = {};
+    this._loadCurrentUserPromise = null;
+    this._loadCurrentUserExtendedPromise = null;
 
     // Use the storageAdaptor to get the authToken, if available
     this.initAuthToken(authtoken);
     this.initApiKey(apikey);
   }
   getWebSocketClient() {
-    if (this.websocketClient) return this.websocketClient;
+    // Reuse existing WebSocket if it's OPEN or CONNECTING (to prevent race condition)
+    if (this.websocketClient && (this.websocketClient.readyState === WebSocket.OPEN || this.websocketClient.readyState === WebSocket.CONNECTING)) {
+      return this.websocketClient;
+    }
     const baseUrl = this.axios.defaults.baseURL;
     const wsProtocol = baseUrl.startsWith('https') ? 'wss://' : 'ws://';
     const wsUrl = baseUrl.replace(/^https?:\/\//, wsProtocol);
+    console.log('[RbtApi] Creating new WebSocket connection to:', wsUrl + '/realtime');
     this.websocketClient = new WebSocket(`${wsUrl}/realtime`);
-    this.websocketClient.onopen = () => {
+    this._setupWebSocketHandlers(this.websocketClient);
+    return this.websocketClient;
+  }
+  _setupWebSocketHandlers(ws) {
+    ws.onopen = () => {
       console.log('[RbtApi] WebSocket connected.');
+      this._wsReconnectAttempts = 0;
+      this._wsConnected = true;
+
+      // Re-subscribe to all objects that were previously subscribed
+      if (this._wsSubscriptions) {
+        for (const objectId of this._wsSubscriptions) {
+          ws.send(JSON.stringify({
+            type: 'subscribe',
+            objectId
+          }));
+        }
+      }
     };
-    this.websocketClient.onclose = () => {
-      console.warn('[RbtApi] WebSocket closed.');
+    ws.onclose = event => {
+      console.warn('[RbtApi] WebSocket closed:', event.code, event.reason);
+      this._wsConnected = false;
+
+      // Attempt reconnection with exponential backoff
+      if (!this._wsManualClose && this._wsReconnectAttempts < 5) {
+        const delay = Math.min(1000 * Math.pow(2, this._wsReconnectAttempts), 30000);
+        console.log(`[RbtApi] Attempting reconnection in ${delay}ms (attempt ${this._wsReconnectAttempts + 1}/5)`);
+        setTimeout(() => {
+          this._wsReconnectAttempts++;
+          this.websocketClient = null; // Clear the old connection
+          this.getWebSocketClient(); // Create new connection
+        }, delay);
+      }
     };
-    this.websocketClient.onerror = err => {
-      console.error('[RbtApi] WebSocket error:', err.message || err);
+    ws.onerror = err => {
+      console.error('[RbtApi] WebSocket error:', err);
+      this._wsConnected = false;
     };
-    return this.websocketClient;
+
+    // Handle ping/pong for keep-alive
+    ws.addEventListener('ping', () => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.pong();
+      }
+    });
+
+    // Initialize connection tracking
+    this._wsReconnectAttempts = this._wsReconnectAttempts || 0;
+    this._wsConnected = false;
+    this._wsManualClose = false;
+    this._wsSubscriptions = this._wsSubscriptions || new Set();
+  }
+
+  // Method to track subscriptions for reconnection
+  _trackSubscription(objectId) {
+    if (!this._wsSubscriptions) this._wsSubscriptions = new Set();
+    this._wsSubscriptions.add(objectId);
+  }
+  _untrackSubscription(objectId) {
+    if (this._wsSubscriptions) {
+      this._wsSubscriptions.delete(objectId);
+    }
+  }
+
+  // Method to gracefully close WebSocket
+  closeWebSocket() {
+    if (this.websocketClient) {
+      this._wsManualClose = true;
+      this.websocketClient.close();
+      this.websocketClient = null;
+    }
   }
   async initAuthToken(authtoken) {
     if (!authtoken && this.localStorageAdaptor) {
@@ -140,6 +239,9 @@ export default class RbtApi {
       this.authtoken = response.data.authToken;
       if (this.localStorageAdaptor) {
         await this.localStorageAdaptor.setItem('authtoken', response.data.authToken);
+        if (this.iac_session?.user) {
+          await this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(this.iac_session.user));
+        }
       }
       return response.data;
     } catch (e) {
@@ -200,6 +302,9 @@ export default class RbtApi {
   }
   async loadCurrentUser() {
     try {
+      if (this._loadCurrentUserPromise) {
+        return this._loadCurrentUserPromise;
+      }
       if (this.currentUser) {
         return this.currentUser;
       }
@@ -207,15 +312,23 @@ export default class RbtApi {
         // NOT IMPLEMENTED
         return null;
       } else if (this.authtoken) {
-        let response = await this.refreshAuthToken(this.authtoken);
-        if (!response) return null;
-        if (response?.user) {
-          this.currentUser = new RbtUser({
-            id: response?.user?.id
-          }, this.axios);
-          this.currentUser.setData(response.user);
-        }
-        return this.currentUser;
+        this._loadCurrentUserPromise = (async () => {
+          let response = await this.refreshAuthToken(this.authtoken);
+          if (!response) return null;
+          if (response?.user) {
+            this.currentUser = new RbtUser({
+              id: response?.user?.id
+            }, this.axios);
+            this.currentUser.setData(response.user);
+            if (this.localStorageAdaptor) {
+              await this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(response.user));
+            }
+          }
+          return this.currentUser;
+        })();
+        const result = await this._loadCurrentUserPromise;
+        this._loadCurrentUserPromise = null;
+        return result;
         //this.currentOrg = new RbtObject(response.organization, this.axios);
         //this.currentOrg.type = '<@iac.organization>';
       } else {
@@ -241,25 +354,49 @@ export default class RbtApi {
     }
   }
   async loadCurrentUserExtended() {
-    let currentUser = await this.loadCurrentUser();
-    if (currentUser) {
-      return this.loadUser(currentUser.id);
-    } else {
-      return null;
+    if (this._loadCurrentUserExtendedPromise) {
+      return this._loadCurrentUserExtendedPromise;
+    }
+    this._loadCurrentUserExtendedPromise = (async () => {
+      let currentUser = await this.loadCurrentUser();
+      if (currentUser) {
+        return this.loadUser(currentUser.id);
+      } else {
+        return null;
+      }
+    })();
+    try {
+      return await this._loadCurrentUserExtendedPromise;
+    } finally {
+      this._loadCurrentUserExtendedPromise = null;
     }
   }
   async loadUser(userId) {
     let params = {
       id: userId
     };
+    const cacheKey = `loadUser:${userId}`;
+    const now = Date.now();
+    const existing = this.requestCache[cacheKey];
+    if (existing && now - existing.time < 10000) {
+      // 10s TTL
+      return existing.val;
+    }
     try {
-      const response = await this.axios.post('/user_service/loadUser', [params]);
-      let userData = response?.data?.user;
-      let User = new RbtUser({
-        id: userData.id
-      }, this.axios);
-      User.setData(userData);
-      return User;
+      const p = (async () => {
+        const response = await this.axios.post('/user_service/loadUser', [params]);
+        let userData = response?.data?.user;
+        let User = new RbtUser({
+          id: userData.id
+        }, this.axios);
+        User.setData(userData);
+        return User;
+      })();
+      this.requestCache[cacheKey] = {
+        val: p,
+        time: now
+      };
+      return await p;
     } catch (e) {
       return this._handleError(e);
     }
@@ -388,9 +525,10 @@ export default class RbtApi {
    *
    * @param {string} type - The type of object to create.
    * @param {Object} dataHash - The data for the new object.
+   * @param {Object} options - Additional options including enableRealtime.
    * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
    */
-  async create(type, dataHash = {}) {
+  async create(type, dataHash = {}, options = {}) {
     try {
       const response = await this.axios.post('/object_service/createObject', [type, dataHash]);
       const record = response.data;
@@ -399,7 +537,8 @@ export default class RbtApi {
       }
       return new RbtObject(record, this.axios, {
         isNew: true,
-        websocketClient: this.websocketClient
+        websocketClient: this.websocketClient,
+        enableRealtime: options.enableRealtime || false
       });
     } catch (e) {
       return this._handleError(e);
@@ -476,7 +615,7 @@ export default class RbtApi {
       const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
 
       // Cache the promise of processing data, not just the raw response
-      const processingPromise = responsePromise.then(response => this._processResponseData(response)).catch(e => {
+      const processingPromise = responsePromise.then(response => this._processResponseData(response, params)).catch(e => {
         delete this.requestCache[paramsKey]; // Ensure cache cleanup on failure
         //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
         return this._handleError(e);
@@ -496,15 +635,28 @@ export default class RbtApi {
       return this._handleError(e);
     }
   }
-  _processResponseData(response) {
+  _processResponseData(response, options = {}) {
     if (response.data.ok === false) {
       return this._handleError(response);
     }
     if (Array.isArray(response.data.items)) {
       //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
+
+      // Ensure WebSocket client is available if realtime is requested
+      let websocketClient = this.websocketClient;
+      if (options.enableRealtime && !websocketClient) {
+        console.log('[AgentProviderSync] Creating WebSocket client for realtime objects');
+        websocketClient = this.getWebSocketClient();
+      }
+      console.log('[AgentProviderSync] _processResponseData creating objects with:', {
+        enableRealtime: options.enableRealtime || false,
+        hasWebSocketClient: !!websocketClient,
+        itemCount: response.data.items.length
+      });
       response.data.items = response.data.items.map(record => {
         return new RbtObject(record, this.axios, {
-          websocketClient: this.websocketClient
+          websocketClient: websocketClient,
+          enableRealtime: options.enableRealtime || false
         });
       });
     }
@@ -522,27 +674,249 @@ export default class RbtApi {
    * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
    */
   async load(type, ids, params = {}) {
+    if (type == '<@iac.user>') {
+      debugger;
+    }
     try {
       let mergedParams;
       if (Array.isArray(ids)) {
-        mergedParams = {
-          ...params,
-          where: `id IN ("${ids.join(`","`)}")`
-        };
-        return this.query(type, mergedParams);
+        // For array requests, check cache for each ID and only load missing ones
+        const cachedObjects = [];
+        const missingIds = [];
+        for (const id of ids) {
+          const cacheKey = `${type}:${id}`;
+          const cached = this._objectCache.get(cacheKey);
+          if (cached) {
+            // Only log cache hits once per object to reduce spam
+            const hitLogKey = `hit:${cacheKey}`;
+            if (!this._loggedCacheEvents.has(hitLogKey)) {
+              console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
+                type,
+                id,
+                hasRealtime: !!cached._realtime,
+                requestedRealtime: !!params.enableRealtime
+              });
+              this._loggedCacheEvents.add(hitLogKey);
+            }
+
+            // If realtime is requested but cached object doesn't have it, upgrade it
+            if (params.enableRealtime && !cached._realtime) {
+              console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
+                type,
+                id
+              });
+              cached._initRealtime();
+            }
+            cachedObjects.push(cached);
+          } else {
+            missingIds.push(id);
+          }
+        }
+
+        // Load missing objects
+        let loadedObjects = [];
+        if (missingIds.length > 0) {
+          // Only log bulk cache miss once
+          const bulkMissLogKey = `bulk-miss:${type}:${missingIds.join(',')}`;
+          if (!this._loggedCacheEvents.has(bulkMissLogKey)) {
+            console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
+              type,
+              ids: missingIds
+            });
+            this._loggedCacheEvents.add(bulkMissLogKey);
+          }
+          mergedParams = {
+            ...params,
+            where: `id IN ("${missingIds.join(`","`)}")`
+          };
+          loadedObjects = await this.query(type, mergedParams);
+
+          // Cache the newly loaded objects
+          for (const obj of loadedObjects) {
+            const cacheKey = `${type}:${obj.id}`;
+            this._objectCache.set(cacheKey, obj);
+
+            // Only log cache set once per object to reduce spam
+            const setLogKey = `set:${cacheKey}`;
+            if (!this._loggedCacheEvents.has(setLogKey)) {
+              console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
+                type,
+                id: obj.id
+              });
+              this._loggedCacheEvents.add(setLogKey);
+            }
+          }
+        }
+
+        // Return combined results in original order
+        const result = [];
+        for (const id of ids) {
+          const cacheKey = `${type}:${id}`;
+          const obj = this._objectCache.get(cacheKey);
+          if (obj) {
+            // Ensure realtime is enabled if requested
+            if (params.enableRealtime && !obj._realtime) {
+              obj._initRealtime();
+            }
+            result.push(obj);
+          }
+        }
+        return result;
       } else {
-        mergedParams = {
-          ...params,
-          where: `id="${ids}"`
-        };
-        let res = await this.query(type, mergedParams);
-        return res[0];
+        // For single object requests, check cache first
+        const cacheKey = `${type}:${ids}`;
+        const cached = this._objectCache.get(cacheKey);
+        if (cached) {
+          // Only log cache hits once per object to reduce spam
+          const hitLogKey = `hit:${cacheKey}`;
+          if (!this._loggedCacheEvents.has(hitLogKey) || console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
+            type,
+            id: ids,
+            hasRealtime: !!cached._realtime,
+            requestedRealtime: !!params.enableRealtime
+          })) {
+            this._loggedCacheEvents.add(hitLogKey);
+          }
+
+          // If realtime is requested but cached object doesn't have it, upgrade it
+          if (params.enableRealtime && !cached._realtime) {
+            console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
+              type,
+              id: ids
+            });
+            cached._initRealtime();
+          }
+          return cached;
+        }
+
+        // Check if we're already loading this object
+        const pendingKey = `${type}:${ids}`;
+        if (this._pendingLoads.has(pendingKey)) {
+          // Wait for the existing request to complete
+          return await this._pendingLoads.get(pendingKey);
+        }
+
+        // Only log cache miss once per object to reduce spam
+        const missLogKey = `miss:${cacheKey}`;
+        if (!this._loggedCacheEvents.has(missLogKey)) {
+          console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
+            type,
+            id: ids
+          });
+          this._loggedCacheEvents.add(missLogKey);
+        }
+
+        // Create the loading promise and store it to prevent duplicate requests
+        const loadPromise = (async () => {
+          try {
+            mergedParams = {
+              ...params,
+              where: `id="${ids}"`
+            };
+            let res = await this.query(type, mergedParams);
+            const obj = res[0];
+            if (obj) {
+              // Cache the loaded object
+              this._objectCache.set(cacheKey, obj);
+
+              // Only log cache set once per object to reduce spam
+              const setLogKey = `set:${cacheKey}`;
+              if (!this._loggedCacheEvents.has(setLogKey)) {
+                console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
+                  type,
+                  id: ids
+                });
+                this._loggedCacheEvents.add(setLogKey);
+              }
+            }
+            return obj;
+          } finally {
+            // Remove from pending loads
+            this._pendingLoads.delete(pendingKey);
+          }
+        })();
+
+        // Store the promise so other concurrent requests can await it
+        this._pendingLoads.set(pendingKey, loadPromise);
+        return await loadPromise;
       }
     } catch (e) {
       return this._handleError(e);
     }
   }
 
+  /**
+   * Clears the object cache. Useful for cache invalidation.
+   * @param {string} type - Optional object type to clear. If not provided, clears all.
+   * @param {string} id - Optional object ID to clear. If not provided with type, clears all objects of that type.
+   */
+  clearCache(type = null, id = null) {
+    if (type && id) {
+      // Clear specific object
+      const cacheKey = `${type}:${id}`;
+      const removed = this._objectCache.delete(cacheKey);
+
+      // Clear related log tracking
+      this._loggedCacheEvents.delete(`hit:${cacheKey}`);
+      this._loggedCacheEvents.delete(`miss:${cacheKey}`);
+      this._loggedCacheEvents.delete(`set:${cacheKey}`);
+      console.log('[AgentProviderSync] 🗑️ roboto.clearCache specific object:', {
+        type,
+        id,
+        removed
+      });
+    } else if (type) {
+      // Clear all objects of a specific type
+      let removedCount = 0;
+      for (const [key] of this._objectCache) {
+        if (key.startsWith(`${type}:`)) {
+          this._objectCache.delete(key);
+          removedCount++;
+        }
+      }
+
+      // Clear related log tracking for this type
+      for (const logKey of this._loggedCacheEvents) {
+        if (logKey.includes(`${type}:`)) {
+          this._loggedCacheEvents.delete(logKey);
+        }
+      }
+      console.log('[AgentProviderSync] 🗑️ roboto.clearCache by type:', {
+        type,
+        removedCount
+      });
+    } else {
+      // Clear all cached objects
+      const size = this._objectCache.size;
+      this._objectCache.clear();
+      this._loggedCacheEvents.clear();
+      this._pendingLoads.clear();
+      console.log('[AgentProviderSync] 🗑️ roboto.clearCache all objects:', {
+        clearedCount: size
+      });
+    }
+  }
+
+  /**
+   * Gets cache status for debugging
+   * @returns {Object} Cache status information
+   */
+  getCacheStatus() {
+    const cacheEntries = Array.from(this._objectCache.entries()).map(([key, obj]) => ({
+      key,
+      id: obj.id,
+      type: obj._internalData?.type || 'unknown'
+    }));
+    const pendingLoads = Array.from(this._pendingLoads.keys());
+    return {
+      cacheSize: this._objectCache.size,
+      pendingLoads: pendingLoads.length,
+      loggedEvents: this._loggedCacheEvents.size,
+      entries: cacheEntries,
+      pendingKeys: pendingLoads
+    };
+  }
+
   /**
    * Makes a POST request to a specific endpoint to run a task and handle progress updates.
    *