@insforge/sdk 1.0.1-refresh.8 → 1.0.1-schema.0

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,206 +195,35 @@ 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
-var import_postgrest_js = require("@supabase/postgrest-js");
-function createInsForgePostgrestFetch(httpClient, tokenManager) {
-  return async (input, init) => {
-    const url = typeof input === "string" ? input : input.toString();
-    const urlObj = new URL(url);
-    const tableName = urlObj.pathname.slice(1);
-    const insforgeUrl = `${httpClient.baseUrl}/api/database/records/${tableName}${urlObj.search}`;
-    const token = tokenManager.getAccessToken();
-    const httpHeaders = httpClient.getHeaders();
-    const authToken = token || httpHeaders["Authorization"]?.replace("Bearer ", "");
-    const headers = new Headers(init?.headers);
-    if (authToken && !headers.has("Authorization")) {
-      headers.set("Authorization", `Bearer ${authToken}`);
-    }
-    const response = await fetch(insforgeUrl, {
-      ...init,
-      headers
-    });
-    return response;
-  };
-}
-var Database = class {
-  constructor(httpClient, tokenManager) {
-    this.postgrest = new import_postgrest_js.PostgrestClient("http://dummy", {
-      fetch: createInsForgePostgrestFetch(httpClient, tokenManager),
-      headers: {}
-    });
-  }
-  /**
-   * Create a query builder for a table
-   * 
-   * @example
-   * // Basic query
-   * const { data, error } = await client.database
-   *   .from('posts')
-   *   .select('*')
-   *   .eq('user_id', userId);
-   * 
-   * // With count (Supabase style!)
-   * const { data, error, count } = await client.database
-   *   .from('posts')
-   *   .select('*', { count: 'exact' })
-   *   .range(0, 9);
-   * 
-   * // Just get count, no data
-   * const { count } = await client.database
-   *   .from('posts')
-   *   .select('*', { count: 'exact', head: true });
-   * 
-   * // Complex queries with OR
-   * const { data } = await client.database
-   *   .from('posts')
-   *   .select('*, users!inner(*)')
-   *   .or('status.eq.active,status.eq.pending');
-   * 
-   * // All features work:
-   * - Nested selects
-   * - Foreign key expansion  
-   * - OR/AND/NOT conditions
-   * - Count with head
-   * - Range pagination
-   * - Upserts
-   */
-  from(table) {
-    return this.postgrest.from(table);
-  }
 };
 
 // src/modules/auth.ts
-function convertDbProfileToCamelCase(dbProfile) {
-  const result = {
-    id: dbProfile.id
-  };
-  Object.keys(dbProfile).forEach((key) => {
-    result[key] = dbProfile[key];
-    if (key.includes("_")) {
-      const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-      result[camelKey] = dbProfile[key];
-    }
-  });
-  return result;
-}
-function convertCamelCaseToDbProfile(profile) {
-  const dbProfile = {};
-  Object.keys(profile).forEach((key) => {
-    if (profile[key] === void 0) return;
-    const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-    dbProfile[snakeKey] = profile[key];
-  });
-  return dbProfile;
-}
 function isHostedAuthEnvironment() {
   if (typeof window === "undefined") {
     return false;
@@ -433,74 +241,8 @@ var Auth = class {
   constructor(http, tokenManager) {
     this.http = http;
     this.tokenManager = tokenManager;
-    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 +270,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 +292,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 +326,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 +398,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 {
@@ -717,14 +460,9 @@ var Auth = class {
       }
       this.http.setAuthToken(session.accessToken);
       const authResponse = await this.http.get("/api/auth/sessions/current");
-      const { data: profile, error: profileError } = await this.database.from("users").select("*").eq("id", authResponse.user.id).single();
-      if (profileError && profileError.code !== "PGRST116") {
-        return { data: null, error: profileError };
-      }
       return {
         data: {
-          user: authResponse.user,
-          profile: profile ? convertDbProfileToCamelCase(profile) : null
+          user: authResponse.user
         },
         error: null
       };
@@ -748,17 +486,28 @@ var Auth = class {
   }
   /**
    * Get any user's profile by ID
-   * Returns profile information from the users table (dynamic fields)
+   * Returns profile information from the users table
    */
   async getProfile(userId) {
-    const { data, error } = await this.database.from("users").select("*").eq("id", userId).single();
-    if (error && error.code === "PGRST116") {
-      return { data: null, error: null };
-    }
-    if (data) {
-      return { data: convertDbProfileToCamelCase(data), error: null };
+    try {
+      const response = await this.http.get(`/api/auth/profiles/${userId}`);
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
+      return {
+        data: null,
+        error: new InsForgeError(
+          "An unexpected error occurred while fetching user profile",
+          500,
+          "UNEXPECTED_ERROR"
+        )
+      };
     }
-    return { data: null, error };
   }
   /**
    * Get the current session (only session data, no API call)
@@ -789,42 +538,31 @@ var Auth = class {
   /**
    * Set/Update the current user's profile
    * Updates profile information in the users table (supports any dynamic fields)
+   * Requires authentication
    */
   async setProfile(profile) {
-    const session = this.tokenManager.getSession();
-    if (!session?.accessToken) {
+    try {
+      const response = await this.http.patch(
+        "/api/auth/profiles/current",
+        { profile }
+      );
+      return {
+        data: response,
+        error: null
+      };
+    } catch (error) {
+      if (error instanceof InsForgeError) {
+        return { data: null, error };
+      }
       return {
         data: null,
         error: new InsForgeError(
-          "No authenticated user found",
-          401,
-          "UNAUTHENTICATED"
+          "An unexpected error occurred while updating user profile",
+          500,
+          "UNEXPECTED_ERROR"
         )
       };
     }
-    if (!session.user?.id) {
-      const { data: data2, error: error2 } = await this.getCurrentUser();
-      if (error2) {
-        return { data: null, error: error2 };
-      }
-      if (data2?.user) {
-        session.user = {
-          id: data2.user.id,
-          email: data2.user.email,
-          name: "",
-          emailVerified: false,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        this.tokenManager.saveSession(session);
-      }
-    }
-    const dbProfile = convertCamelCaseToDbProfile(profile);
-    const { data, error } = await this.database.from("users").update(dbProfile).eq("id", session.user.id).select().single();
-    if (data) {
-      return { data: convertDbProfileToCamelCase(data), error: null };
-    }
-    return { data: null, error };
   }
   /**
    * Send email verification (code or link based on config)
@@ -978,14 +716,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,
@@ -1007,6 +744,75 @@ var Auth = class {
   }
 };
 
+// src/modules/database-postgrest.ts
+var import_postgrest_js = require("@supabase/postgrest-js");
+function createInsForgePostgrestFetch(httpClient, tokenManager) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const urlObj = new URL(url);
+    const tableName = urlObj.pathname.slice(1);
+    const insforgeUrl = `${httpClient.baseUrl}/api/database/records/${tableName}${urlObj.search}`;
+    const token = tokenManager.getAccessToken();
+    const httpHeaders = httpClient.getHeaders();
+    const authToken = token || httpHeaders["Authorization"]?.replace("Bearer ", "");
+    const headers = new Headers(init?.headers);
+    if (authToken && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${authToken}`);
+    }
+    const response = await fetch(insforgeUrl, {
+      ...init,
+      headers
+    });
+    return response;
+  };
+}
+var Database = class {
+  constructor(httpClient, tokenManager) {
+    this.postgrest = new import_postgrest_js.PostgrestClient("http://dummy", {
+      fetch: createInsForgePostgrestFetch(httpClient, tokenManager),
+      headers: {}
+    });
+  }
+  /**
+   * Create a query builder for a table
+   * 
+   * @example
+   * // Basic query
+   * const { data, error } = await client.database
+   *   .from('posts')
+   *   .select('*')
+   *   .eq('user_id', userId);
+   * 
+   * // With count (Supabase style!)
+   * const { data, error, count } = await client.database
+   *   .from('posts')
+   *   .select('*', { count: 'exact' })
+   *   .range(0, 9);
+   * 
+   * // Just get count, no data
+   * const { count } = await client.database
+   *   .from('posts')
+   *   .select('*', { count: 'exact', head: true });
+   * 
+   * // Complex queries with OR
+   * const { data } = await client.database
+   *   .from('posts')
+   *   .select('*, users!inner(*)')
+   *   .or('status.eq.active,status.eq.pending');
+   * 
+   * // All features work:
+   * - Nested selects
+   * - Foreign key expansion  
+   * - OR/AND/NOT conditions
+   * - Count with head
+   * - Range pagination
+   * - Upserts
+   */
+  from(table) {
+    return this.postgrest.from(table);
+  }
+};
+
 // src/modules/storage.ts
 var StorageBucket = class {
   constructor(bucketName, http) {
@@ -1528,6 +1334,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 +1584,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 +1630,7 @@ var index_default = InsForgeClient;
   HttpClient,
   InsForgeClient,
   InsForgeError,
+  Realtime,
   Storage,
   StorageBucket,
   TokenManager,