@spacelr/sdk 0.1.5 → 0.1.7

package/dist/index.mjs

@@ -70,6 +70,9 @@ var HttpClient = class {
     this.tokenManager = tokenManager;
   }
   async request(options) {
+    return this.requestWithRetry(options, false);
+  }
+  async requestWithRetry(options, isRetry) {
     const url = this.buildUrl(options.path, options.query);
     const headers = await this.buildHeaders(options);
     const timeout = this.config.timeout ?? 3e4;
@@ -86,6 +89,11 @@ var HttpClient = class {
       });
       const responseBody = await this.parseResponse(response);
       if (!response.ok) {
+        if (options.authenticated && response.status === 401) {
+          if (await this.recoverFromAuthFailure(isRetry)) {
+            return this.requestWithRetry(options, true);
+          }
+        }
         this.throwHttpError(response.status, responseBody);
       }
       return this.extractData(responseBody);
@@ -102,12 +110,45 @@ var HttpClient = class {
     }
   }
   async uploadForm(path, formData, onProgress) {
+    return this.uploadFormWithRetry(path, formData, onProgress, false);
+  }
+  async uploadFormWithRetry(path, formData, onProgress, isRetry) {
     const url = this.buildUrl(path);
     const headers = await this.buildFormHeaders();
     const timeoutMs = this.config.timeout ?? 3e4;
-    if (onProgress) {
-      return this.uploadFormWithProgress(url, headers, formData, onProgress, timeoutMs);
+    try {
+      if (onProgress) {
+        return await this.uploadFormWithProgress(url, headers, formData, onProgress, timeoutMs);
+      }
+      return await this.uploadFormOnce(url, headers, formData, timeoutMs);
+    } catch (error) {
+      if (error instanceof SpacelrAuthError && error.statusCode === 401) {
+        if (await this.recoverFromAuthFailure(isRetry)) {
+          return this.uploadFormWithRetry(path, formData, onProgress, true);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Shared handler for a 401 on an authenticated request. Returns true if the
+   * caller should retry with a refreshed token. 403 is never routed here —
+   * it means "forbidden for this action" and must not trigger logout.
+   *
+   * `emitAuthLost('unauthorized')` is deduped inside TokenManager, so it's a
+   * no-op if `executeRefresh` already emitted 'refresh-failed'.
+   */
+  async recoverFromAuthFailure(isRetry) {
+    if (isRetry) {
+      this.tokenManager.emitAuthLost("unauthorized");
+      return false;
     }
+    const refreshed = await this.tokenManager.forceRefresh();
+    if (refreshed) return true;
+    this.tokenManager.emitAuthLost("unauthorized");
+    return false;
+  }
+  async uploadFormOnce(url, headers, formData, timeoutMs) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
@@ -153,6 +194,8 @@ var HttpClient = class {
           if (!contentType.includes("application/json")) {
             if (xhr.status >= 200 && xhr.status < 300) {
               resolve({ success: true, data: xhr.responseText });
+            } else if (xhr.status === 401 || xhr.status === 403) {
+              reject(new SpacelrAuthError(`HTTP ${xhr.status}`, xhr.status));
             } else {
               reject(new SpacelrNetworkError(`HTTP ${xhr.status}: ${xhr.responseText.slice(0, 200)}`));
             }
@@ -309,6 +352,12 @@ var TokenManager = class {
   constructor(storage, refreshBufferSeconds = 60) {
     this.refreshCallback = null;
     this.refreshPromise = null;
+    this.tokenRefreshedListeners = /* @__PURE__ */ new Set();
+    this.authLostListeners = /* @__PURE__ */ new Set();
+    // Guard so callbacks that run during auth-loss handling (e.g. a logout()
+    // that hits `/auth/logout` with a dead token) don't re-emit and loop.
+    // Cleared by setTokens() / clearTokens() to re-arm for the next session.
+    this.authLostEmitted = false;
     this.storage = storage ?? new MemoryTokenStorage();
     this.refreshBufferSeconds = refreshBufferSeconds;
   }
@@ -330,14 +379,53 @@ var TokenManager = class {
   }
   async setTokens(tokens) {
     await this.storage.setTokens(tokens);
+    this.authLostEmitted = false;
   }
   async clearTokens() {
     await this.storage.clearTokens();
     this.refreshPromise = null;
+    this.authLostEmitted = false;
   }
   async getStoredTokens() {
     return this.storage.getTokens();
   }
+  /**
+   * Force a refresh using the current stored refresh token.
+   * Returns the new access token, or null if refresh is not possible or fails.
+   * A rejecting custom `TokenStorage.getTokens()` is treated as "no tokens"
+   * so callers (notably `HttpClient`'s 401 retry path) see a clean `null`
+   * rather than an exception that would get wrapped as a network error.
+   */
+  async forceRefresh() {
+    if (this.authLostEmitted) return null;
+    let tokens;
+    try {
+      tokens = await this.storage.getTokens();
+    } catch {
+      return null;
+    }
+    if (!tokens) return null;
+    const refreshed = await this.tryRefresh(tokens);
+    return refreshed?.accessToken ?? null;
+  }
+  onTokenRefreshed(listener) {
+    this.tokenRefreshedListeners.add(listener);
+    return () => this.tokenRefreshedListeners.delete(listener);
+  }
+  onAuthLost(listener) {
+    this.authLostListeners.add(listener);
+    return () => this.authLostListeners.delete(listener);
+  }
+  emitAuthLost(reason) {
+    if (this.authLostEmitted) return;
+    this.authLostEmitted = true;
+    for (const listener of this.authLostListeners) {
+      try {
+        listener(reason);
+      } catch {
+      }
+    }
+  }
   isTokenExpired(tokens) {
     if (!tokens.expiresAt) return false;
     return Date.now() >= tokens.expiresAt * 1e3;
@@ -350,21 +438,40 @@ var TokenManager = class {
   async tryRefresh(tokens) {
     if (!tokens.refreshToken || !this.refreshCallback) return null;
     if (this.refreshPromise) {
-      return this.refreshPromise;
+      try {
+        return await this.refreshPromise;
+      } catch {
+        return null;
+      }
     }
     this.refreshPromise = this.executeRefresh(tokens.refreshToken);
     try {
-      const result = await this.refreshPromise;
-      return result;
+      return await this.refreshPromise;
+    } catch {
+      return null;
     } finally {
       this.refreshPromise = null;
     }
   }
   async executeRefresh(refreshToken) {
     const callback = this.refreshCallback;
-    const newTokens = await callback(refreshToken);
-    await this.storage.setTokens(newTokens);
-    return newTokens;
+    try {
+      const newTokens = await callback(refreshToken);
+      await this.storage.setTokens(newTokens);
+      this.emitTokenRefreshed(newTokens);
+      return newTokens;
+    } catch (error) {
+      this.emitAuthLost("refresh-failed");
+      throw error;
+    }
+  }
+  emitTokenRefreshed(tokens) {
+    for (const listener of this.tokenRefreshedListeners) {
+      try {
+        listener(tokens);
+      } catch {
+      }
+    }
   }
 };
 
@@ -435,6 +542,7 @@ async function generatePKCEChallenge() {
 
 // libs/sdk/src/core/realtime.ts
 import { io } from "socket.io-client";
+var REBUILD_RETRY_DELAY_MS = 5e3;
 var RealtimeClient = class {
   constructor(config) {
     this.socket = null;
@@ -442,9 +550,26 @@ var RealtimeClient = class {
     this.connecting = null;
     // Store original where objects per room for reconnect resubscription
     this.roomWhereMap = /* @__PURE__ */ new Map();
+    this.unsubscribeFromTokenRefreshed = null;
+    // Wake-up listeners (browser only) — recover from long OS suspends where
+    // socket.io's internal reconnect loop may have already given up.
+    this.onVisibilityChange = null;
+    this.onOnline = null;
+    // Set by `disconnect()`; checked by async paths (rebuildSocket, deferred
+    // retries) to avoid reviving a client the consumer has torn down.
+    this.disposed = false;
+    // Scheduled retry after a failed `rebuildSocket()`; cleared when it fires
+    // or when `disconnect()` tears down.
+    this.rebuildRetryTimer = null;
+    this.connectionState = "disconnected";
+    this.connectionStateListeners = /* @__PURE__ */ new Set();
     this.config = config;
   }
   async subscribe(projectId, collectionName, callback, onError, where) {
+    this.ensureWakeListeners();
+    if (this.connectionState === "disconnected") {
+      this.setConnectionState("reconnecting");
+    }
     await this.ensureConnected();
     const room = this.buildRoomKey(projectId, collectionName, where);
     if (!this.subscriptions.has(room)) {
@@ -486,7 +611,24 @@ var RealtimeClient = class {
       }
     };
   }
+  /**
+   * Tear down the realtime client permanently. After this call the instance
+   * is disposed — subsequent `subscribe()` calls will not re-establish a
+   * connection. Create a new `RealtimeClient` (via `createClient`) if you
+   * need to reconnect after a logout.
+   */
   disconnect() {
+    this.setConnectionState("disconnected");
+    this.disposed = true;
+    if (this.rebuildRetryTimer) {
+      clearTimeout(this.rebuildRetryTimer);
+      this.rebuildRetryTimer = null;
+    }
+    if (this.unsubscribeFromTokenRefreshed) {
+      this.unsubscribeFromTokenRefreshed();
+      this.unsubscribeFromTokenRefreshed = null;
+    }
+    this.detachWakeListeners();
     if (this.socket) {
       this.socket.disconnect();
       this.socket = null;
@@ -495,6 +637,23 @@ var RealtimeClient = class {
     this.roomWhereMap.clear();
     this.connecting = null;
   }
+  getConnectionState() {
+    return this.connectionState;
+  }
+  onConnectionStateChanged(listener) {
+    this.connectionStateListeners.add(listener);
+    return () => this.connectionStateListeners.delete(listener);
+  }
+  setConnectionState(next) {
+    if (this.connectionState === next) return;
+    this.connectionState = next;
+    for (const listener of this.connectionStateListeners) {
+      try {
+        listener(next);
+      } catch {
+      }
+    }
+  }
   buildRoomKey(projectId, collectionName, where) {
     const base = `db:${projectId}:${collectionName}`;
     if (!where || Object.keys(where).length === 0) {
@@ -537,6 +696,8 @@ var RealtimeClient = class {
         // Disabled until first successful connect
       });
       this.socket.on("authenticated", () => {
+        if (this.disposed) return;
+        this.setConnectionState("connected");
         if (initialConnect) {
           initialConnect = false;
           if (this.socket) {
@@ -545,11 +706,15 @@ var RealtimeClient = class {
             this.socket.io.opts.reconnectionDelayMax = 5e3;
             this.socket.io.opts.reconnectionAttempts = 50;
           }
+          if (this.config.onTokenRefreshed && !this.unsubscribeFromTokenRefreshed) {
+            this.unsubscribeFromTokenRefreshed = this.config.onTokenRefreshed(
+              (accessToken) => {
+                this.socket?.emit("reauthenticate", { token: accessToken });
+              }
+            );
+          }
           resolve();
-        }
-      });
-      this.socket.on("connect", () => {
-        if (!initialConnect) {
+        } else {
           this.resubscribeAll();
         }
       });
@@ -558,6 +723,9 @@ var RealtimeClient = class {
           reject(new Error(`WebSocket connection failed: ${err.message}`));
         }
       });
+      this.socket.io.on("reconnect_failed", () => {
+        void this.rebuildSocket();
+      });
       this.socket.on("db:event", (event) => {
         const base = `db:${event.projectId}:${event.collectionName}`;
         const baseCallbacks = this.subscriptions.get(base);
@@ -581,6 +749,9 @@ var RealtimeClient = class {
         }
       });
       this.socket.on("disconnect", () => {
+        if (!this.disposed) {
+          this.setConnectionState("reconnecting");
+        }
       });
     });
   }
@@ -603,6 +774,70 @@ var RealtimeClient = class {
     }
     return true;
   }
+  /**
+   * Tear down the current socket and create a fresh one. Used by both
+   * `reconnect_failed` (socket.io gave up) and the visibility/online wake-up
+   * listeners. Preserves the `subscriptions` map so existing rooms can be
+   * replayed to the server on the new connection. If the rebuild itself
+   * fails it schedules one retry after 5 s — beyond that we rely on the
+   * next wake-up event (visibility/online) to try again.
+   */
+  async rebuildSocket() {
+    if (this.disposed || this.connecting) return;
+    const previous = this.socket;
+    this.socket = null;
+    if (previous) previous.disconnect();
+    this.setConnectionState("reconnecting");
+    try {
+      await this.ensureConnected();
+      this.handlePostRebuild();
+    } catch {
+      this.scheduleRebuildRetry();
+    }
+  }
+  handlePostRebuild() {
+    const newSocket = this.socket;
+    if (this.disposed) {
+      this.socket = null;
+      newSocket?.disconnect();
+      return;
+    }
+    if (this.subscriptions.size > 0) {
+      this.resubscribeAll();
+    }
+  }
+  scheduleRebuildRetry() {
+    if (this.disposed || this.rebuildRetryTimer) return;
+    this.rebuildRetryTimer = setTimeout(() => {
+      this.rebuildRetryTimer = null;
+      void this.rebuildSocket();
+    }, REBUILD_RETRY_DELAY_MS);
+    this.rebuildRetryTimer.unref?.();
+  }
+  ensureWakeListeners() {
+    if (typeof document === "undefined" || typeof window === "undefined") return;
+    if (this.onVisibilityChange !== null) return;
+    const wakeIfUnhealthy = () => {
+      if (typeof document !== "undefined" && document.visibilityState !== "visible") return;
+      if (this.socket?.connected) return;
+      if (this.connecting) return;
+      void this.rebuildSocket();
+    };
+    this.onVisibilityChange = wakeIfUnhealthy;
+    this.onOnline = wakeIfUnhealthy;
+    document.addEventListener("visibilitychange", this.onVisibilityChange);
+    window.addEventListener("online", this.onOnline);
+  }
+  detachWakeListeners() {
+    if (typeof document !== "undefined" && this.onVisibilityChange) {
+      document.removeEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    if (typeof window !== "undefined" && this.onOnline) {
+      window.removeEventListener("online", this.onOnline);
+    }
+    this.onVisibilityChange = null;
+    this.onOnline = null;
+  }
   resubscribeAll() {
     for (const [room] of this.subscriptions) {
       const queryIdx = room.indexOf("?");
@@ -682,11 +917,14 @@ var AuthModule = class {
     });
   }
   async logout() {
-    await this.http.request({
-      method: "POST",
-      path: "/auth/logout",
-      authenticated: true
-    });
+    try {
+      await this.http.request({
+        method: "POST",
+        path: "/auth/logout",
+        authenticated: true
+      });
+    } catch {
+    }
     await this.tokenManager.clearTokens();
   }
   async verifyEmail(token) {
@@ -1124,11 +1362,11 @@ var CollectionRef = class {
     this.collectionName = collectionName;
     this.basePath = `/db/${collectionName}`;
   }
-  async insert(document) {
+  async insert(document2) {
     return this.http.request({
       method: "POST",
       path: this.basePath,
-      body: { documents: [document] },
+      body: { documents: [document2] },
       authenticated: true
     });
   }
@@ -1426,7 +1664,8 @@ function createClient(config) {
   const httpClient = new HttpClient(config, tokenManager);
   const realtime = new RealtimeClient({
     baseUrl: config.apiUrl,
-    getToken: () => tokenManager.getAccessToken()
+    getToken: () => tokenManager.getAccessToken(),
+    onTokenRefreshed: (listener) => tokenManager.onTokenRefreshed((tokens) => listener(tokens.accessToken))
   });
   const auth = new AuthModule(httpClient, tokenManager, config);
   const storage = new StorageModule(httpClient, tokenManager, config);
@@ -1439,8 +1678,26 @@ function createClient(config) {
     db,
     notifications,
     functions,
+    setTokens(tokens) {
+      return tokenManager.setTokens(tokens);
+    },
+    clearTokens() {
+      return tokenManager.clearTokens();
+    },
     disconnect() {
       realtime.disconnect();
+    },
+    onAuthLost(listener) {
+      return tokenManager.onAuthLost(listener);
+    },
+    onTokenRefreshed(listener) {
+      return tokenManager.onTokenRefreshed(listener);
+    },
+    onConnectionStateChanged(listener) {
+      return realtime.onConnectionStateChanged(listener);
+    },
+    getConnectionState() {
+      return realtime.getConnectionState();
     }
   };
 }