@fluxbase/sdk 0.0.1-rc.27 → 0.0.1-rc.28

package/dist/index.js

@@ -663,10 +663,14 @@ var FluxbaseAuth = class {
 
 // src/realtime.ts
 var RealtimeChannel = class {
-  constructor(url, channelName, token = null) {
+  constructor(url, channelName, token = null, config = {}) {
     this.ws = null;
     this.callbacks = /* @__PURE__ */ new Map();
+    this.presenceCallbacks = /* @__PURE__ */ new Map();
+    this.broadcastCallbacks = /* @__PURE__ */ new Map();
     this.subscriptionConfig = null;
+    this._presenceState = {};
+    this.myPresenceKey = null;
     this.reconnectAttempts = 0;
     this.maxReconnectAttempts = 10;
     this.reconnectDelay = 1e3;
@@ -674,6 +678,7 @@ var RealtimeChannel = class {
     this.url = url;
     this.channelName = channelName;
     this.token = token;
+    this.config = config;
   }
   // Implementation
   on(event, configOrCallback, callback) {
@@ -686,6 +691,20 @@ var RealtimeChannel = class {
         this.callbacks.set(eventType, /* @__PURE__ */ new Set());
       }
       this.callbacks.get(eventType).add(actualCallback);
+    } else if (event === "broadcast" && typeof configOrCallback !== "function") {
+      const config = configOrCallback;
+      const actualCallback = callback;
+      if (!this.broadcastCallbacks.has(config.event)) {
+        this.broadcastCallbacks.set(config.event, /* @__PURE__ */ new Set());
+      }
+      this.broadcastCallbacks.get(config.event).add(actualCallback);
+    } else if (event === "presence" && typeof configOrCallback !== "function") {
+      const config = configOrCallback;
+      const actualCallback = callback;
+      if (!this.presenceCallbacks.has(config.event)) {
+        this.presenceCallbacks.set(config.event, /* @__PURE__ */ new Set());
+      }
+      this.presenceCallbacks.get(config.event).add(actualCallback);
     } else {
       const actualEvent = event;
       const actualCallback = configOrCallback;
@@ -735,7 +754,7 @@ var RealtimeChannel = class {
   async unsubscribe(timeout) {
     return new Promise((resolve) => {
       if (this.ws) {
-        this.send({
+        this.sendMessage({
           type: "unsubscribe",
           channel: this.channelName
         });
@@ -758,6 +777,131 @@ var RealtimeChannel = class {
       }
     });
   }
+  /**
+   * Send a broadcast message to all subscribers on this channel
+   *
+   * @param message - Broadcast message with type, event, and payload
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * await channel.send({
+   *   type: 'broadcast',
+   *   event: 'cursor-pos',
+   *   payload: { x: 100, y: 200 }
+   * })
+   * ```
+   */
+  async send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return "error";
+    }
+    try {
+      this.ws.send(
+        JSON.stringify({
+          type: "broadcast",
+          channel: this.channelName,
+          event: message.event,
+          payload: message.payload
+        })
+      );
+      if (this.config.broadcast?.ack) {
+        return "ok";
+      }
+      return "ok";
+    } catch (error) {
+      console.error("[Fluxbase Realtime] Failed to send broadcast:", error);
+      return "error";
+    }
+  }
+  /**
+   * Track user presence on this channel
+   *
+   * @param state - Presence state to track
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * await channel.track({
+   *   user_id: 123,
+   *   status: 'online'
+   * })
+   * ```
+   */
+  async track(state) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return "error";
+    }
+    try {
+      if (!this.myPresenceKey) {
+        this.myPresenceKey = this.config.presence?.key || `presence-${Math.random().toString(36).substr(2, 9)}`;
+      }
+      this.ws.send(
+        JSON.stringify({
+          type: "presence",
+          channel: this.channelName,
+          event: "track",
+          payload: {
+            key: this.myPresenceKey,
+            state
+          }
+        })
+      );
+      return "ok";
+    } catch (error) {
+      console.error("[Fluxbase Realtime] Failed to track presence:", error);
+      return "error";
+    }
+  }
+  /**
+   * Stop tracking presence on this channel
+   *
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * await channel.untrack()
+   * ```
+   */
+  async untrack() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return "error";
+    }
+    if (!this.myPresenceKey) {
+      return "ok";
+    }
+    try {
+      this.ws.send(
+        JSON.stringify({
+          type: "presence",
+          channel: this.channelName,
+          event: "untrack",
+          payload: {
+            key: this.myPresenceKey
+          }
+        })
+      );
+      this.myPresenceKey = null;
+      return "ok";
+    } catch (error) {
+      console.error("[Fluxbase Realtime] Failed to untrack presence:", error);
+      return "error";
+    }
+  }
+  /**
+   * Get current presence state for all users on this channel
+   *
+   * @returns Current presence state
+   *
+   * @example
+   * ```typescript
+   * const state = channel.presenceState()
+   * console.log('Online users:', Object.keys(state).length)
+   * ```
+   */
+  presenceState() {
+    return { ...this._presenceState };
+  }
   /**
    * Internal: Connect to WebSocket
    */
@@ -782,7 +926,7 @@ var RealtimeChannel = class {
       if (this.subscriptionConfig) {
         subscribeMessage.config = this.subscriptionConfig;
       }
-      this.send(subscribeMessage);
+      this.sendMessage(subscribeMessage);
       this.startHeartbeat();
     };
     this.ws.onmessage = (event) => {
@@ -815,7 +959,7 @@ var RealtimeChannel = class {
   /**
    * Internal: Send a message
    */
-  send(message) {
+  sendMessage(message) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(message));
     }
@@ -826,11 +970,18 @@ var RealtimeChannel = class {
   handleMessage(message) {
     switch (message.type) {
       case "heartbeat":
-        this.send({ type: "heartbeat" });
+        this.ws?.send(JSON.stringify({ type: "heartbeat" }));
         break;
       case "broadcast":
-        if (message.payload) {
-          this.handleBroadcast(message.payload);
+        if (message.broadcast) {
+          this.handleBroadcastMessage(message.broadcast);
+        } else if (message.payload) {
+          this.handlePostgresChanges(message.payload);
+        }
+        break;
+      case "presence":
+        if (message.presence) {
+          this.handlePresenceMessage(message.presence);
         }
         break;
       case "ack":
@@ -844,7 +995,48 @@ var RealtimeChannel = class {
   /**
    * Internal: Handle broadcast message
    */
-  handleBroadcast(payload) {
+  handleBroadcastMessage(message) {
+    const event = message.event;
+    const payload = {
+      event,
+      payload: message.payload
+    };
+    if (!this.config.broadcast?.self && message.self) {
+      return;
+    }
+    const callbacks = this.broadcastCallbacks.get(event);
+    if (callbacks) {
+      callbacks.forEach((callback) => callback(payload));
+    }
+    const wildcardCallbacks = this.broadcastCallbacks.get("*");
+    if (wildcardCallbacks) {
+      wildcardCallbacks.forEach((callback) => callback(payload));
+    }
+  }
+  /**
+   * Internal: Handle presence message
+   */
+  handlePresenceMessage(message) {
+    const event = message.event;
+    const payload = {
+      event,
+      key: message.key,
+      newPresences: message.newPresences,
+      leftPresences: message.leftPresences,
+      currentPresences: message.currentPresences || this._presenceState
+    };
+    if (message.currentPresences) {
+      this._presenceState = message.currentPresences;
+    }
+    const callbacks = this.presenceCallbacks.get(event);
+    if (callbacks) {
+      callbacks.forEach((callback) => callback(payload));
+    }
+  }
+  /**
+   * Internal: Handle postgres_changes message
+   */
+  handlePostgresChanges(payload) {
     const supabasePayload = {
       eventType: payload.type || payload.eventType,
       schema: payload.schema,
@@ -868,7 +1060,7 @@ var RealtimeChannel = class {
    */
   startHeartbeat() {
     this.heartbeatInterval = setInterval(() => {
-      this.send({ type: "heartbeat" });
+      this.sendMessage({ type: "heartbeat" });
     }, 3e4);
   }
   /**
@@ -905,17 +1097,57 @@ var FluxbaseRealtime = class {
     this.token = token;
   }
   /**
-   * Create or get a channel
+   * Create or get a channel with optional configuration
+   *
    * @param channelName - Channel name (e.g., 'table:public.products')
+   * @param config - Optional channel configuration
+   * @returns RealtimeChannel instance
+   *
+   * @example
+   * ```typescript
+   * const channel = realtime.channel('room-1', {
+   *   broadcast: { self: true, ack: true },
+   *   presence: { key: 'user-123' }
+   * })
+   * ```
    */
-  channel(channelName) {
-    if (this.channels.has(channelName)) {
-      return this.channels.get(channelName);
+  channel(channelName, config) {
+    const configKey = config ? JSON.stringify(config) : "";
+    const key = `${channelName}:${configKey}`;
+    if (this.channels.has(key)) {
+      return this.channels.get(key);
     }
-    const channel = new RealtimeChannel(this.url, channelName, this.token);
-    this.channels.set(channelName, channel);
+    const channel = new RealtimeChannel(
+      this.url,
+      channelName,
+      this.token,
+      config
+    );
+    this.channels.set(key, channel);
     return channel;
   }
+  /**
+   * Remove a specific channel
+   *
+   * @param channel - The channel to remove
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * const channel = realtime.channel('room-1')
+   * await realtime.removeChannel(channel)
+   * ```
+   */
+  async removeChannel(channel) {
+    await channel.unsubscribe();
+    for (const [key, ch] of this.channels.entries()) {
+      if (ch === channel) {
+        this.channels.delete(key);
+        return "ok";
+      }
+    }
+    return "error";
+  }
   /**
    * Remove all channels
    */
@@ -925,8 +1157,9 @@ var FluxbaseRealtime = class {
   }
   /**
    * Update auth token for all channels
+   * @param token - The new auth token
    */
-  setToken(token) {
+  setAuth(token) {
     this.token = token;
   }
 };
@@ -4363,7 +4596,7 @@ var FluxbaseClient = class {
     const originalSetAuthToken = this.fetch.setAuthToken.bind(this.fetch);
     this.fetch.setAuthToken = (token) => {
       originalSetAuthToken(token);
-      this.realtime.setToken(token);
+      this.realtime.setAuth(token);
     };
   }
   /**
@@ -4387,37 +4620,48 @@ var FluxbaseClient = class {
    */
   setAuthToken(token) {
     this.fetch.setAuthToken(token);
-    this.realtime.setToken(token);
+    this.realtime.setAuth(token);
   }
   /**
-   * Create or get a realtime channel (Supabase-compatible alias)
-   *
-   * This is a convenience method that delegates to client.realtime.channel().
-   * Both patterns work identically:
-   * - client.channel('room-1') - Supabase-style
-   * - client.realtime.channel('room-1') - Fluxbase-style
+   * Create or get a realtime channel (Supabase-compatible)
    *
    * @param name - Channel name
+   * @param config - Optional channel configuration
    * @returns RealtimeChannel instance
    *
    * @example
    * ```typescript
-   * // Supabase-compatible usage
-   * const channel = client.channel('room-1')
-   *   .on('postgres_changes', {
-   *     event: '*',
-   *     schema: 'public',
-   *     table: 'messages'
-   *   }, (payload) => {
-   *     console.log('Change:', payload)
+   * const channel = client.channel('room-1', {
+   *   broadcast: { self: true },
+   *   presence: { key: 'user-123' }
+   * })
+   *   .on('broadcast', { event: 'message' }, (payload) => {
+   *     console.log('Message:', payload)
    *   })
    *   .subscribe()
    * ```
    *
    * @category Realtime
    */
-  channel(name) {
-    return this.realtime.channel(name);
+  channel(name, config) {
+    return this.realtime.channel(name, config);
+  }
+  /**
+   * Remove a realtime channel (Supabase-compatible)
+   *
+   * @param channel - The channel to remove
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * const channel = client.channel('room-1')
+   * await client.removeChannel(channel)
+   * ```
+   *
+   * @category Realtime
+   */
+  removeChannel(channel) {
+    return this.realtime.removeChannel(channel);
   }
   /**
    * Get the internal HTTP client