@insforge/sdk 1.0.1-refresh.8 → 1.0.1

package/dist/index.js

@@ -27,6 +27,7 @@ __export(index_exports, {
   HttpClient: () => HttpClient,
   InsForgeClient: () => InsForgeClient,
   InsForgeError: () => InsForgeError,
+  Realtime: () => Realtime,
   Storage: () => Storage,
   StorageBucket: () => StorageBucket,
   TokenManager: () => TokenManager,
@@ -111,7 +112,6 @@ var HttpClient = class {
       method,
       headers: requestHeaders,
       body: processedBody,
-      credentials: "include",
       ...fetchOptions
     });
     if (response.status === 204) {
@@ -176,29 +176,8 @@ var HttpClient = class {
 // src/lib/token-manager.ts
 var TOKEN_KEY = "insforge-auth-token";
 var USER_KEY = "insforge-auth-user";
-var AUTH_FLAG_COOKIE = "isAuthenticated";
-function hasAuthCookie() {
-  if (typeof document === "undefined") return false;
-  return document.cookie.split(";").some(
-    (c) => c.trim().startsWith(`${AUTH_FLAG_COOKIE}=`)
-  );
-}
-function setAuthCookie() {
-  if (typeof document === "undefined") return;
-  const maxAge = 7 * 24 * 60 * 60;
-  document.cookie = `${AUTH_FLAG_COOKIE}=true; path=/; max-age=${maxAge}; SameSite=Lax`;
-}
-function clearAuthCookie() {
-  if (typeof document === "undefined") return;
-  document.cookie = `${AUTH_FLAG_COOKIE}=; path=/; max-age=0; SameSite=Lax`;
-}
 var TokenManager = class {
   constructor(storage) {
-    // In-memory storage
-    this.accessToken = null;
-    this.user = null;
-    // Mode: 'memory' (new backend) or 'storage' (legacy backend, default)
-    this._mode = "storage";
     if (storage) {
       this.storage = storage;
     } else if (typeof window !== "undefined" && window.localStorage) {
@@ -216,112 +195,32 @@ var TokenManager = class {
       };
     }
   }
-  /**
-   * Get current mode
-   */
-  get mode() {
-    return this._mode;
-  }
-  /**
-   * Set mode to memory (new backend with cookies + memory)
-   */
-  setMemoryMode() {
-    if (this._mode === "storage") {
-      this.storage.removeItem(TOKEN_KEY);
-      this.storage.removeItem(USER_KEY);
-    }
-    this._mode = "memory";
-  }
-  /**
-   * Set mode to storage (legacy backend with localStorage)
-   * Also loads existing session from localStorage
-   */
-  setStorageMode() {
-    this._mode = "storage";
-    this.loadFromStorage();
+  saveSession(session) {
+    this.storage.setItem(TOKEN_KEY, session.accessToken);
+    this.storage.setItem(USER_KEY, JSON.stringify(session.user));
   }
-  /**
-   * Load session from localStorage
-   */
-  loadFromStorage() {
+  getSession() {
     const token = this.storage.getItem(TOKEN_KEY);
     const userStr = this.storage.getItem(USER_KEY);
-    if (token && userStr) {
-      try {
-        this.accessToken = token;
-        this.user = JSON.parse(userStr);
-      } catch {
-        this.clearSession();
-      }
+    if (!token || !userStr) {
+      return null;
     }
-  }
-  /**
-   * Save session (memory always, localStorage only in storage mode)
-   */
-  saveSession(session) {
-    this.accessToken = session.accessToken;
-    this.user = session.user;
-    if (this._mode === "storage") {
-      this.storage.setItem(TOKEN_KEY, session.accessToken);
-      this.storage.setItem(USER_KEY, JSON.stringify(session.user));
+    try {
+      const user = JSON.parse(userStr);
+      return { accessToken: token, user };
+    } catch {
+      this.clearSession();
+      return null;
     }
   }
-  /**
-   * Get current session
-   */
-  getSession() {
-    if (!this.accessToken || !this.user) return null;
-    return {
-      accessToken: this.accessToken,
-      user: this.user
-    };
-  }
-  /**
-   * Get access token
-   */
   getAccessToken() {
-    return this.accessToken;
-  }
-  /**
-   * Set access token
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-    if (this._mode === "storage") {
-      this.storage.setItem(TOKEN_KEY, token);
-    }
-  }
-  /**
-   * Get user
-   */
-  getUser() {
-    return this.user;
-  }
-  /**
-   * Set user
-   */
-  setUser(user) {
-    this.user = user;
-    if (this._mode === "storage") {
-      this.storage.setItem(USER_KEY, JSON.stringify(user));
-    }
+    const token = this.storage.getItem(TOKEN_KEY);
+    return typeof token === "string" ? token : null;
   }
-  /**
-   * Clear session (both memory and localStorage)
-   */
   clearSession() {
-    this.accessToken = null;
-    this.user = null;
     this.storage.removeItem(TOKEN_KEY);
     this.storage.removeItem(USER_KEY);
   }
-  /**
-   * Check if there's a session in localStorage (for legacy detection)
-   */
-  hasStoredSession() {
-    const token = this.storage.getItem(TOKEN_KEY);
-    return !!token;
-  }
 };
 
 // src/modules/database-postgrest.ts
@@ -436,71 +335,6 @@ var Auth = class {
     this.database = new Database(http, tokenManager);
     this.detectAuthCallback();
   }
-  /**
-  * Restore session on app initialization
-  * 
-  * @returns Object with isLoggedIn status
-  * 
-  * @example
-  * ```typescript
-  * const client = new InsForgeClient({ baseUrl: '...' });
-  * const { isLoggedIn } = await client.auth.restoreSession();
-  * 
-  * if (isLoggedIn) {
-  *   const { data } = await client.auth.getCurrentUser();
-  * }
-  * ```
-  */
-  async restoreSession() {
-    if (typeof window === "undefined") {
-      return { isLoggedIn: false };
-    }
-    if (this.tokenManager.getAccessToken()) {
-      return { isLoggedIn: true };
-    }
-    if (hasAuthCookie()) {
-      try {
-        const response = await this.http.post(
-          "/api/auth/refresh"
-        );
-        if (response.accessToken) {
-          this.tokenManager.setMemoryMode();
-          this.tokenManager.setAccessToken(response.accessToken);
-          this.http.setAuthToken(response.accessToken);
-          if (response.user) {
-            this.tokenManager.setUser(response.user);
-          }
-          return { isLoggedIn: true };
-        }
-      } catch (error) {
-        if (error instanceof InsForgeError) {
-          if (error.statusCode === 404) {
-            this.tokenManager.setStorageMode();
-            const token = this.tokenManager.getAccessToken();
-            if (token) {
-              this.http.setAuthToken(token);
-              return { isLoggedIn: true };
-            }
-            return { isLoggedIn: false };
-          }
-          if (error.statusCode === 401 || error.statusCode === 403) {
-            clearAuthCookie();
-            return { isLoggedIn: false };
-          }
-        }
-        return { isLoggedIn: false };
-      }
-    }
-    if (this.tokenManager.hasStoredSession()) {
-      this.tokenManager.setStorageMode();
-      const token = this.tokenManager.getAccessToken();
-      if (token) {
-        this.http.setAuthToken(token);
-        return { isLoggedIn: true };
-      }
-    }
-    return { isLoggedIn: false };
-  }
   /**
    * Automatically detect and handle OAuth callback parameters in the URL
    * This runs on initialization to seamlessly complete the OAuth flow
@@ -528,9 +362,8 @@ var Auth = class {
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           }
         };
-        this.http.setAuthToken(accessToken);
         this.tokenManager.saveSession(session);
-        setAuthCookie();
+        this.http.setAuthToken(accessToken);
         const url = new URL(window.location.href);
         url.searchParams.delete("access_token");
         url.searchParams.delete("user_id");
@@ -551,13 +384,14 @@ var Auth = class {
   async signUp(request) {
     try {
       const response = await this.http.post("/api/auth/users", request);
-      if (response.accessToken && response.user && !isHostedAuthEnvironment()) {
+      if (response.accessToken && response.user) {
         const session = {
           accessToken: response.accessToken,
           user: response.user
         };
-        this.tokenManager.saveSession(session);
-        setAuthCookie();
+        if (!isHostedAuthEnvironment()) {
+          this.tokenManager.saveSession(session);
+        }
         this.http.setAuthToken(response.accessToken);
       }
       return {
@@ -584,15 +418,21 @@ var Auth = class {
   async signInWithPassword(request) {
     try {
       const response = await this.http.post("/api/auth/sessions", request);
-      if (response.accessToken && response.user && !isHostedAuthEnvironment()) {
-        const session = {
-          accessToken: response.accessToken,
-          user: response.user
-        };
+      const session = {
+        accessToken: response.accessToken || "",
+        user: response.user || {
+          id: "",
+          email: "",
+          name: "",
+          emailVerified: false,
+          createdAt: "",
+          updatedAt: ""
+        }
+      };
+      if (!isHostedAuthEnvironment()) {
         this.tokenManager.saveSession(session);
-        setAuthCookie();
-        this.http.setAuthToken(response.accessToken);
       }
+      this.http.setAuthToken(response.accessToken || "");
       return {
         data: response,
         error: null
@@ -650,13 +490,8 @@ var Auth = class {
    */
   async signOut() {
     try {
-      try {
-        await this.http.post("/api/auth/logout");
-      } catch {
-      }
       this.tokenManager.clearSession();
       this.http.setAuthToken(null);
-      clearAuthCookie();
       return { error: null };
     } catch (error) {
       return {
@@ -978,14 +813,13 @@ var Auth = class {
         "/api/auth/email/verify",
         request
       );
-      if (response.accessToken && !isHostedAuthEnvironment()) {
+      if (response.accessToken) {
         const session = {
           accessToken: response.accessToken,
           user: response.user || {}
         };
         this.tokenManager.saveSession(session);
         this.http.setAuthToken(response.accessToken);
-        setAuthCookie();
       }
       return {
         data: response,
@@ -1528,6 +1362,239 @@ var Functions = class {
   }
 };
 
+// src/modules/realtime.ts
+var import_socket = require("socket.io-client");
+var CONNECT_TIMEOUT = 1e4;
+var Realtime = class {
+  constructor(baseUrl, tokenManager) {
+    this.socket = null;
+    this.connectPromise = null;
+    this.subscribedChannels = /* @__PURE__ */ new Set();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.baseUrl = baseUrl;
+    this.tokenManager = tokenManager;
+  }
+  notifyListeners(event, payload) {
+    const listeners = this.eventListeners.get(event);
+    if (!listeners) return;
+    for (const cb of listeners) {
+      try {
+        cb(payload);
+      } catch (err) {
+        console.error(`Error in ${event} callback:`, err);
+      }
+    }
+  }
+  /**
+   * Connect to the realtime server
+   * @returns Promise that resolves when connected
+   */
+  connect() {
+    if (this.socket?.connected) {
+      return Promise.resolve();
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve, reject) => {
+      const session = this.tokenManager.getSession();
+      const token = session?.accessToken;
+      this.socket = (0, import_socket.io)(this.baseUrl, {
+        transports: ["websocket"],
+        auth: token ? { token } : void 0
+      });
+      let initialConnection = true;
+      let timeoutId = null;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+      timeoutId = setTimeout(() => {
+        if (initialConnection) {
+          initialConnection = false;
+          this.connectPromise = null;
+          this.socket?.disconnect();
+          this.socket = null;
+          reject(new Error(`Connection timeout after ${CONNECT_TIMEOUT}ms`));
+        }
+      }, CONNECT_TIMEOUT);
+      this.socket.on("connect", () => {
+        cleanup();
+        for (const channel of this.subscribedChannels) {
+          this.socket.emit("realtime:subscribe", { channel });
+        }
+        this.notifyListeners("connect");
+        if (initialConnection) {
+          initialConnection = false;
+          this.connectPromise = null;
+          resolve();
+        }
+      });
+      this.socket.on("connect_error", (error) => {
+        cleanup();
+        this.notifyListeners("connect_error", error);
+        if (initialConnection) {
+          initialConnection = false;
+          this.connectPromise = null;
+          reject(error);
+        }
+      });
+      this.socket.on("disconnect", (reason) => {
+        this.notifyListeners("disconnect", reason);
+      });
+      this.socket.on("realtime:error", (error) => {
+        this.notifyListeners("error", error);
+      });
+      this.socket.onAny((event, message) => {
+        if (event === "realtime:error") return;
+        this.notifyListeners(event, message);
+      });
+    });
+    return this.connectPromise;
+  }
+  /**
+   * Disconnect from the realtime server
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.subscribedChannels.clear();
+  }
+  /**
+   * Check if connected to the realtime server
+   */
+  get isConnected() {
+    return this.socket?.connected ?? false;
+  }
+  /**
+   * Get the current connection state
+   */
+  get connectionState() {
+    if (!this.socket) return "disconnected";
+    if (this.socket.connected) return "connected";
+    return "connecting";
+  }
+  /**
+   * Get the socket ID (if connected)
+   */
+  get socketId() {
+    return this.socket?.id;
+  }
+  /**
+   * Subscribe to a channel
+   *
+   * Automatically connects if not already connected.
+   *
+   * @param channel - Channel name (e.g., 'orders:123', 'broadcast')
+   * @returns Promise with the subscription response
+   */
+  async subscribe(channel) {
+    if (this.subscribedChannels.has(channel)) {
+      return { ok: true, channel };
+    }
+    if (!this.socket?.connected) {
+      try {
+        await this.connect();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Connection failed";
+        return { ok: false, channel, error: { code: "CONNECTION_FAILED", message } };
+      }
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("realtime:subscribe", { channel }, (response) => {
+        if (response.ok) {
+          this.subscribedChannels.add(channel);
+        }
+        resolve(response);
+      });
+    });
+  }
+  /**
+   * Unsubscribe from a channel (fire-and-forget)
+   *
+   * @param channel - Channel name to unsubscribe from
+   */
+  unsubscribe(channel) {
+    this.subscribedChannels.delete(channel);
+    if (this.socket?.connected) {
+      this.socket.emit("realtime:unsubscribe", { channel });
+    }
+  }
+  /**
+   * Publish a message to a channel
+   *
+   * @param channel - Channel name
+   * @param event - Event name
+   * @param payload - Message payload
+   */
+  async publish(channel, event, payload) {
+    if (!this.socket?.connected) {
+      throw new Error("Not connected to realtime server. Call connect() first.");
+    }
+    this.socket.emit("realtime:publish", { channel, event, payload });
+  }
+  /**
+   * Listen for events
+   *
+   * Reserved event names:
+   * - 'connect' - Fired when connected to the server
+   * - 'connect_error' - Fired when connection fails (payload: Error)
+   * - 'disconnect' - Fired when disconnected (payload: reason string)
+   * - 'error' - Fired when a realtime error occurs (payload: RealtimeErrorPayload)
+   *
+   * All other events receive a `SocketMessage` payload with metadata.
+   *
+   * @param event - Event name to listen for
+   * @param callback - Callback function when event is received
+   */
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  /**
+   * Remove a listener for a specific event
+   *
+   * @param event - Event name
+   * @param callback - The callback function to remove
+   */
+  off(event, callback) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(callback);
+      if (listeners.size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Listen for an event only once, then automatically remove the listener
+   *
+   * @param event - Event name to listen for
+   * @param callback - Callback function when event is received
+   */
+  once(event, callback) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      callback(payload);
+    };
+    this.on(event, wrapper);
+  }
+  /**
+   * Get all currently subscribed channels
+   *
+   * @returns Array of channel names
+   */
+  getSubscribedChannels() {
+    return Array.from(this.subscribedChannels);
+  }
+};
+
 // src/client.ts
 var InsForgeClient = class {
   constructor(config = {}) {
@@ -1545,11 +1612,15 @@ var InsForgeClient = class {
     if (existingSession?.accessToken) {
       this.http.setAuthToken(existingSession.accessToken);
     }
-    this.auth = new Auth(this.http, this.tokenManager);
+    this.auth = new Auth(
+      this.http,
+      this.tokenManager
+    );
     this.database = new Database(this.http, this.tokenManager);
     this.storage = new Storage(this.http);
     this.ai = new AI(this.http);
     this.functions = new Functions(this.http);
+    this.realtime = new Realtime(this.http.baseUrl, this.tokenManager);
   }
   /**
    * Get the underlying HTTP client for custom requests
@@ -1587,6 +1658,7 @@ var index_default = InsForgeClient;
   HttpClient,
   InsForgeClient,
   InsForgeError,
+  Realtime,
   Storage,
   StorageBucket,
   TokenManager,