roboto-js 1.7.1 → 1.7.4

package/src/index.js

@@ -3,11 +3,13 @@ import RbtApi from './rbt_api.js';
 import RbtObject from './rbt_object.js';
 import RbtFile from './rbt_file.js';
 import RbtMetricsApi from './rbt_metrics_api.js';
+import CookieStorageAdaptor from './cookie_storage_adaptor.js';
 
 export {
     RbtApi,
     RbtObject,
-    RbtFile
+    RbtFile,
+    CookieStorageAdaptor
     //User,
     //Site
 };
@@ -15,10 +17,10 @@ export {
 export default class Roboto{
 
   getVersion(){
-    return '1.7.0';
+    return '1.7.3';
   }
 
-  constructor({ host, accessKey, localStorageAdaptor, disableWebSocket = false, metricsHost }, proxyReq = null) {
+  constructor({ host, accessKey, localStorageAdaptor, disableWebSocket = false, metricsHost, useCookies = true }, proxyReq = null) {
 
     if (Roboto.instance && !proxyReq) {
       // if on client, there can only be one instance
@@ -28,10 +30,30 @@ export default class Roboto{
 
     const isBrowser = typeof window !== "undefined";
     this.data = {};
+    
+    // Auto-configure storage adaptor
+    let storageAdaptor = localStorageAdaptor;
+    if (!storageAdaptor && isBrowser && useCookies) {
+      // Use cookies by default in browser for better server-side compatibility
+      storageAdaptor = new CookieStorageAdaptor({
+        secure: window.location.protocol === 'https:',
+        sameSite: 'Lax',
+        maxAge: 24 * 60 * 60 // 24 hours
+      });
+      console.log('[Roboto] Using CookieStorageAdaptor for authentication tokens');
+      
+      // Set accessKey for server-side authentication (handled automatically by adapter)
+      if (accessKey) {
+        storageAdaptor.setItem('accessKey', accessKey).catch(e => 
+          console.warn('[Roboto] Failed to set accessKey cookie:', e)
+        );
+      }
+    }
+    
     this.config = {
       accessKey: accessKey, // Use passed accessKey
       baseUrl: `https://${host}`, // Use passed host
-      localStorageAdaptor: localStorageAdaptor
+      localStorageAdaptor: storageAdaptor
     };
 
     // DEVELOPMENT
@@ -58,6 +80,12 @@ export default class Roboto{
     this.api = new RbtApi(this.config);
     if (isBrowser) {
       this.api.initLocalDb();
+      
+      // Add global debug method for cookie storage adapter
+      if (this.config.localStorageAdaptor && this.config.localStorageAdaptor.debugState) {
+        window.debugRobotoCookies = () => this.config.localStorageAdaptor.debugState();
+        console.log('[Roboto] Added global debug method: window.debugRobotoCookies()');
+      }
     }
 
     // METRICS API instance (separate host or same)
@@ -155,7 +183,15 @@ export default class Roboto{
     return this.api.loginWithOauth(params);
   }
   async logout(){
-    return this.api.logout();
+    const result = await this.api.logout();
+    
+    // Clear accessKey and authtoken using standard localStorage interface
+    if (this.config.localStorageAdaptor) {
+      await this.config.localStorageAdaptor.removeItem('accessKey');
+      await this.config.localStorageAdaptor.removeItem('authtoken');
+    }
+    
+    return result;
   }
   async refreshAuthToken(){
     return this.api.refreshAuthToken(this.config.authtoken);

package/src/rbt_api.js

@@ -43,26 +43,9 @@ export default class RbtApi {
       };
     }
 
-    // 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 {}
-    }
+    // Asynchronous browser hydration: set auth header and in-memory user
+    // Use storage adaptor if available, otherwise fallback to localStorage
+    this._initializeFromStorage().catch(e => console.warn('[RbtApi] Storage initialization failed:', e));
     this.localDb = null;
     this.iac_session = null;
     this.appServiceHost = baseUrl;
@@ -77,6 +60,52 @@ export default class RbtApi {
     
   }
 
+  // Initialize authtoken and user from storage (cookies or localStorage)
+  async _initializeFromStorage() {
+    if (!this.localStorageAdaptor) return;
+    
+    try {
+      // Try to get authtoken from storage adaptor (prefixed: rbt_authtoken)
+      let token = await this.localStorageAdaptor.getItem('authtoken');
+      
+      // If not found in prefixed storage, try raw cookie (like accessKey)
+      if (!token && typeof document !== 'undefined') {
+        // Try to get from raw cookie
+        const cookies = document.cookie.split(';');
+        for (let cookie of cookies) {
+          const [name, value] = cookie.trim().split('=');
+          if (name === 'authtoken') {
+            token = decodeURIComponent(value);
+            break;
+          }
+        }
+      }
+      
+      if (token) {
+        this.authtoken = token;
+        this.axios.defaults.headers.common['authtoken'] = token;
+        console.log('[RbtApi] Loaded authtoken from storage adaptor');
+      }
+    } catch (e) {
+      console.warn('[RbtApi] Failed to load authtoken from storage adaptor:', e);
+    }
+    
+    try {
+      // Try to get user from storage adaptor
+      const cachedUser = await this.localStorageAdaptor.getItem('rbtUser');
+      if (cachedUser) {
+        const parsed = typeof cachedUser === 'string' ? JSON.parse(cachedUser) : cachedUser;
+        if (parsed && parsed.id) {
+          this.currentUser = new RbtUser({ id: parsed.id }, this.axios);
+          this.currentUser.setData(parsed);
+          console.log('[RbtApi] Loaded user from storage adaptor');
+        }
+      }
+    } catch (e) {
+      console.warn('[RbtApi] Failed to load user from storage adaptor:', e);
+    }
+  }
+
   getWebSocketClient() {
     // Reuse existing WebSocket if it's OPEN or CONNECTING (to prevent race condition)
     if (this.websocketClient && 
@@ -277,6 +306,8 @@ export default class RbtApi {
         if (this.iac_session?.user) {
           await this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(this.iac_session.user));
         }
+        
+        // authtoken is automatically stored for server-side access by the adapter
       }
 
       return response.data;