roboto-js 1.7.0 → 1.7.4

package/dist/esm/index.js

@@ -2,20 +2,22 @@ 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';
-export { RbtApi, RbtObject, RbtFile
+import CookieStorageAdaptor from './cookie_storage_adaptor.js';
+export { RbtApi, RbtObject, RbtFile, CookieStorageAdaptor
 //User,
 //Site
 };
 export default class Roboto {
   getVersion() {
-    return '1.6.17';
+    return '1.7.3';
   }
   constructor({
     host,
     accessKey,
     localStorageAdaptor,
     disableWebSocket = false,
-    metricsHost
+    metricsHost,
+    useCookies = true
   }, proxyReq = null) {
     if (Roboto.instance && !proxyReq) {
       // if on client, there can only be one instance
@@ -24,12 +26,29 @@ 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
@@ -54,6 +73,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)
@@ -130,7 +155,14 @@ 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/dist/esm/rbt_api.js

@@ -42,28 +42,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;
@@ -75,6 +56,51 @@ export default class RbtApi {
     this.initAuthToken(authtoken);
     this.initApiKey(apikey);
   }
+
+  // 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 && (this.websocketClient.readyState === WebSocket.OPEN || this.websocketClient.readyState === WebSocket.CONNECTING)) {
@@ -242,6 +268,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;
     } catch (e) {