@fluxbase/sdk 2026.1.8 → 2026.1.9-rc.1

package/dist/index.cjs

@@ -1428,8 +1428,9 @@ var RealtimeChannel = class {
     this.presenceCallbacks = /* @__PURE__ */ new Map();
     this.broadcastCallbacks = /* @__PURE__ */ new Map();
     this.executionLogCallbacks = /* @__PURE__ */ new Set();
-    this.subscriptionConfig = null;
-    this.subscriptionId = null;
+    this.subscriptionConfigs = [];
+    this.subscriptionIds = /* @__PURE__ */ new Map();
+    // "schema.table" -> subscription_id
     this.executionLogConfig = null;
     this._presenceState = {};
     this.myPresenceKey = null;
@@ -1458,13 +1459,15 @@ var RealtimeChannel = class {
   on(event, configOrCallback, callback) {
     if (event === "postgres_changes" && typeof configOrCallback !== "function") {
       const config = configOrCallback;
-      this.subscriptionConfig = config;
       const actualCallback = callback;
-      const eventType = config.event;
-      if (!this.callbacks.has(eventType)) {
-        this.callbacks.set(eventType, /* @__PURE__ */ new Set());
+      let entry = this.subscriptionConfigs.find(
+        (e) => e.config.schema === config.schema && e.config.table === config.table && e.config.event === config.event && e.config.filter === config.filter
+      );
+      if (!entry) {
+        entry = { config, callbacks: /* @__PURE__ */ new Set() };
+        this.subscriptionConfigs.push(entry);
       }
-      this.callbacks.get(eventType).add(actualCallback);
+      entry.callbacks.add(actualCallback);
     } else if (event === "broadcast" && typeof configOrCallback !== "function") {
       const config = configOrCallback;
       const actualCallback = callback;
@@ -1535,11 +1538,20 @@ var RealtimeChannel = class {
     this.shouldReconnect = false;
     return new Promise((resolve) => {
       if (this.ws) {
-        this.sendMessage({
-          type: "unsubscribe",
-          channel: this.channelName,
-          subscription_id: this.subscriptionId || void 0
-        });
+        if (this.subscriptionIds.size > 0) {
+          for (const subId of this.subscriptionIds.values()) {
+            this.sendMessage({
+              type: "unsubscribe",
+              channel: this.channelName,
+              subscription_id: subId
+            });
+          }
+        } else {
+          this.sendMessage({
+            type: "unsubscribe",
+            channel: this.channelName
+          });
+        }
         const startTime = Date.now();
         const maxWait = timeout || 5e3;
         const checkDisconnect = () => {
@@ -1774,14 +1786,20 @@ var RealtimeChannel = class {
           }
         };
         this.sendMessage(logSubscribeMessage);
+      } else if (this.subscriptionConfigs.length > 0) {
+        for (const entry of this.subscriptionConfigs) {
+          const subscribeMessage = {
+            type: "subscribe",
+            channel: this.channelName,
+            config: entry.config
+          };
+          this.sendMessage(subscribeMessage);
+        }
       } else {
         const subscribeMessage = {
           type: "subscribe",
           channel: this.channelName
         };
-        if (this.subscriptionConfig) {
-          subscribeMessage.config = this.subscriptionConfig;
-        }
         this.sendMessage(subscribeMessage);
       }
       this.startHeartbeat();
@@ -1861,18 +1879,29 @@ var RealtimeChannel = class {
               this.pendingAcks.delete("access_token");
             }
             console.log("[Fluxbase Realtime] Token updated successfully");
-          } else {
-            if (payload.subscription_id) {
-              this.subscriptionId = payload.subscription_id;
-              console.log("[Fluxbase Realtime] Subscription ID received:", this.subscriptionId);
+          } else if (payload.subscription_id) {
+            const schema = payload.schema || "public";
+            const table = payload.table || "";
+            if (table) {
+              this.subscriptionIds.set(`${schema}.${table}`, payload.subscription_id);
+              console.log("[Fluxbase Realtime] Subscription ID received for", `${schema}.${table}:`, payload.subscription_id);
             } else {
-              console.log("[Fluxbase Realtime] Acknowledged:", message);
+              console.log("[Fluxbase Realtime] Subscription ID received:", payload.subscription_id);
             }
+          } else {
+            console.log("[Fluxbase Realtime] Acknowledged:", message);
           }
         } else {
           if (message.payload && typeof message.payload === "object" && "subscription_id" in message.payload) {
-            this.subscriptionId = message.payload.subscription_id;
-            console.log("[Fluxbase Realtime] Subscription ID received:", this.subscriptionId);
+            const payload = message.payload;
+            const schema = payload.schema || "public";
+            const table = payload.table || "";
+            if (table) {
+              this.subscriptionIds.set(`${schema}.${table}`, payload.subscription_id);
+              console.log("[Fluxbase Realtime] Subscription ID received for", `${schema}.${table}:`, payload.subscription_id);
+            } else {
+              console.log("[Fluxbase Realtime] Subscription ID received:", payload.subscription_id);
+            }
           } else {
             console.log("[Fluxbase Realtime] Acknowledged:", message);
           }
@@ -1966,6 +1995,21 @@ var RealtimeChannel = class {
       old: payload.old_record || payload.old || {},
       errors: payload.errors || null
     };
+    for (const entry of this.subscriptionConfigs) {
+      const c = entry.config;
+      const schemaMatch = !c.schema || c.schema === supabasePayload.schema;
+      const tableMatch = !c.table || c.table === supabasePayload.table;
+      const eventMatch = c.event === "*" || c.event === supabasePayload.eventType;
+      if (schemaMatch && tableMatch && eventMatch) {
+        entry.callbacks.forEach((cb) => {
+          try {
+            cb(supabasePayload);
+          } catch (err) {
+            console.error("[Fluxbase Realtime] Error in postgres_changes callback:", err);
+          }
+        });
+      }
+    }
     const callbacks = this.callbacks.get(supabasePayload.eventType);
     if (callbacks) {
       callbacks.forEach((callback) => callback(supabasePayload));
@@ -8890,6 +8934,168 @@ var FluxbaseAdminStorage = class {
   }
 };
 
+// src/admin-realtime.ts
+var FluxbaseAdminRealtime = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Enable realtime on a table
+   *
+   * Creates the necessary database triggers to broadcast changes to WebSocket subscribers.
+   * Also sets REPLICA IDENTITY FULL to include old values in UPDATE/DELETE events.
+   *
+   * @param table - Table name to enable realtime on
+   * @param options - Optional configuration
+   * @returns Promise resolving to EnableRealtimeResponse
+   *
+   * @example
+   * ```typescript
+   * // Enable realtime on products table (all events)
+   * await client.admin.realtime.enableRealtime('products')
+   *
+   * // Enable on a specific schema
+   * await client.admin.realtime.enableRealtime('orders', {
+   *   schema: 'sales'
+   * })
+   *
+   * // Enable specific events only
+   * await client.admin.realtime.enableRealtime('audit_log', {
+   *   events: ['INSERT'] // Only broadcast inserts
+   * })
+   *
+   * // Exclude large columns from notifications
+   * await client.admin.realtime.enableRealtime('posts', {
+   *   exclude: ['content', 'raw_html'] // Skip these in payload
+   * })
+   * ```
+   */
+  async enableRealtime(table, options) {
+    const request = {
+      schema: options?.schema ?? "public",
+      table,
+      events: options?.events,
+      exclude: options?.exclude
+    };
+    return await this.fetch.post(
+      "/api/v1/admin/realtime/tables",
+      request
+    );
+  }
+  /**
+   * Disable realtime on a table
+   *
+   * Removes the realtime trigger from a table. Existing subscribers will stop
+   * receiving updates for this table.
+   *
+   * @param schema - Schema name
+   * @param table - Table name
+   * @returns Promise resolving to success message
+   *
+   * @example
+   * ```typescript
+   * await client.admin.realtime.disableRealtime('public', 'products')
+   * console.log('Realtime disabled')
+   * ```
+   */
+  async disableRealtime(schema, table) {
+    return await this.fetch.delete(
+      `/api/v1/admin/realtime/tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`
+    );
+  }
+  /**
+   * List all realtime-enabled tables
+   *
+   * Returns a list of all tables that have realtime enabled, along with their
+   * configuration (events, excluded columns, etc.).
+   *
+   * @param options - Optional filter options
+   * @returns Promise resolving to ListRealtimeTablesResponse
+   *
+   * @example
+   * ```typescript
+   * // List all enabled tables
+   * const { tables, count } = await client.admin.realtime.listTables()
+   * console.log(`${count} tables have realtime enabled`)
+   *
+   * tables.forEach(t => {
+   *   console.log(`${t.schema}.${t.table}: ${t.events.join(', ')}`)
+   * })
+   *
+   * // Include disabled tables
+   * const all = await client.admin.realtime.listTables({ includeDisabled: true })
+   * ```
+   */
+  async listTables(options) {
+    const params = options?.includeDisabled ? "?enabled=false" : "";
+    return await this.fetch.get(
+      `/api/v1/admin/realtime/tables${params}`
+    );
+  }
+  /**
+   * Get realtime status for a specific table
+   *
+   * Returns the realtime configuration for a table, including whether it's enabled,
+   * which events are tracked, and which columns are excluded.
+   *
+   * @param schema - Schema name
+   * @param table - Table name
+   * @returns Promise resolving to RealtimeTableStatus
+   *
+   * @example
+   * ```typescript
+   * const status = await client.admin.realtime.getStatus('public', 'products')
+   *
+   * if (status.realtime_enabled) {
+   *   console.log('Events:', status.events.join(', '))
+   *   console.log('Excluded:', status.excluded_columns?.join(', ') || 'none')
+   * } else {
+   *   console.log('Realtime not enabled')
+   * }
+   * ```
+   */
+  async getStatus(schema, table) {
+    return await this.fetch.get(
+      `/api/v1/admin/realtime/tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`
+    );
+  }
+  /**
+   * Update realtime configuration for a table
+   *
+   * Modifies the events or excluded columns for a realtime-enabled table
+   * without recreating the trigger.
+   *
+   * @param schema - Schema name
+   * @param table - Table name
+   * @param config - New configuration
+   * @returns Promise resolving to success message
+   *
+   * @example
+   * ```typescript
+   * // Change which events are tracked
+   * await client.admin.realtime.updateConfig('public', 'products', {
+   *   events: ['INSERT', 'UPDATE'] // Stop tracking deletes
+   * })
+   *
+   * // Update excluded columns
+   * await client.admin.realtime.updateConfig('public', 'posts', {
+   *   exclude: ['raw_content', 'search_vector']
+   * })
+   *
+   * // Clear excluded columns
+   * await client.admin.realtime.updateConfig('public', 'posts', {
+   *   exclude: [] // Include all columns again
+   * })
+   * ```
+   */
+  async updateConfig(schema, table, config) {
+    return await this.fetch.patch(
+      `/api/v1/admin/realtime/tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`,
+      config
+    );
+  }
+};
+
 // src/admin.ts
 var FluxbaseAdmin = class {
   constructor(fetch2) {
@@ -8907,6 +9113,7 @@ var FluxbaseAdmin = class {
     this.ai = new FluxbaseAdminAI(fetch2);
     this.rpc = new FluxbaseAdminRPC(fetch2);
     this.storage = new FluxbaseAdminStorage(fetch2);
+    this.realtime = new FluxbaseAdminRealtime(fetch2);
   }
   /**
    * Set admin authentication token
@@ -11935,6 +12142,7 @@ exports.FluxbaseAdminFunctions = FluxbaseAdminFunctions;
 exports.FluxbaseAdminJobs = FluxbaseAdminJobs;
 exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
 exports.FluxbaseAdminRPC = FluxbaseAdminRPC;
+exports.FluxbaseAdminRealtime = FluxbaseAdminRealtime;
 exports.FluxbaseAdminStorage = FluxbaseAdminStorage;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseBranching = FluxbaseBranching;