roboto-js 1.6.18 → 1.7.0

package/src/rbt_api.js

@@ -12,6 +12,15 @@ export default class RbtApi {
     
     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: {
@@ -33,10 +42,33 @@ 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);
@@ -46,26 +78,93 @@ export default class RbtApi {
   }
 
   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._setupWebSocketHandlers(this.websocketClient);
+
+    return this.websocketClient;
+  }
 
-    this.websocketClient.onopen = () => {
+  _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) {
@@ -175,6 +274,9 @@ export default class RbtApi {
 
       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;
@@ -256,6 +358,9 @@ export default class RbtApi {
   async loadCurrentUser(){
 
     try {
+      if (this._loadCurrentUserPromise) {
+        return this._loadCurrentUserPromise;
+      }
         
       if(this.currentUser){
         return this.currentUser;
@@ -269,17 +374,24 @@ export default class RbtApi {
       }
       else if(this.authtoken){
 
-        let response = await this.refreshAuthToken(this.authtoken);
-        if(!response) return null;
+        this._loadCurrentUserPromise = (async () => {
+          let response = await this.refreshAuthToken(this.authtoken);
+          if(!response) return null;
 
-        if(response?.user){
+          if(response?.user){
 
-          this.currentUser = new RbtUser({ id: response?.user?.id }, this.axios);
-          this.currentUser.setData(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>';
 
@@ -319,12 +431,24 @@ export default class RbtApi {
 
   async loadCurrentUserExtended(){
 
-    let currentUser = await this.loadCurrentUser();
-    if(currentUser){
-      return this.loadUser(currentUser.id);
+    if (this._loadCurrentUserExtendedPromise) {
+      return this._loadCurrentUserExtendedPromise;
     }
-    else{
-      return null;
+
+    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;
     }
 
   }
@@ -334,15 +458,23 @@ export default class RbtApi {
 
     let params = { id: userId };
 
-    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 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 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);
     }
@@ -494,9 +626,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;
@@ -504,7 +637,11 @@ export default class RbtApi {
       if(dataHash){
         record.data = dataHash;
       }
-      return new RbtObject(record, this.axios, { isNew: true, websocketClient: this.websocketClient });
+      return new RbtObject(record, this.axios, { 
+        isNew: true, 
+        websocketClient: this.websocketClient,
+        enableRealtime: options.enableRealtime || false
+      });
     } catch (e) {
       return this._handleError(e);
     }
@@ -566,7 +703,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);
@@ -585,15 +722,32 @@ export default class RbtApi {
     }
   }
 
-  _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 });
+        return new RbtObject(record, this.axios, { 
+          websocketClient: websocketClient,
+          enableRealtime: options.enableRealtime || false
+        });
       });
     }
 
@@ -612,17 +766,149 @@ export default class RbtApi {
    */
   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) {
@@ -631,6 +917,73 @@ export default class RbtApi {
 
   }
 
+  /**
+   * 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.
    *