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

package/dist/index.js

@@ -163,16 +163,19 @@ var FluxbaseAuth = class {
     }
   }
   /**
-   * Get the current session
+   * Get the current session (Supabase-compatible)
+   * Returns the session from the client-side cache without making a network request
    */
-  getSession() {
-    return this.session;
+  async getSession() {
+    return { data: { session: this.session }, error: null };
   }
   /**
-   * Get the current user
+   * Get the current user (Supabase-compatible)
+   * Returns the user from the client-side session without making a network request
+   * For server-side validation, use getCurrentUser() instead
    */
-  getUser() {
-    return this.session?.user ?? null;
+  async getUser() {
+    return { data: { user: this.session?.user ?? null }, error: null };
   }
   /**
    * Get the current access token
@@ -181,9 +184,9 @@ var FluxbaseAuth = class {
     return this.session?.access_token ?? null;
   }
   /**
-   * Listen to auth state changes
+   * Listen to auth state changes (Supabase-compatible)
    * @param callback - Function called when auth state changes
-   * @returns Subscription object with unsubscribe method
+   * @returns Object containing subscription data
    *
    * @example
    * ```typescript
@@ -197,11 +200,12 @@ var FluxbaseAuth = class {
    */
   onAuthStateChange(callback) {
     this.stateChangeListeners.add(callback);
-    return {
+    const subscription = {
       unsubscribe: () => {
         this.stateChangeListeners.delete(callback);
       }
     };
+    return { data: { subscription } };
   }
   /**
    * Sign in with email and password
@@ -218,7 +222,7 @@ var FluxbaseAuth = class {
         ...authResponse,
         expires_at: Date.now() + authResponse.expires_in * 1e3
       };
-      this.setSession(session);
+      this.setSessionInternal(session);
       return session;
     });
   }
@@ -243,7 +247,7 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session);
+      this.setSessionInternal(session);
       return { user: session.user, session };
     });
   }
@@ -260,9 +264,10 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Refresh the access token
+   * Refresh the session (Supabase-compatible)
+   * Returns a new session with refreshed tokens
    */
-  async refreshToken() {
+  async refreshSession() {
     return wrapAsync(async () => {
       if (!this.session?.refresh_token) {
         throw new Error("No refresh token available");
@@ -277,8 +282,8 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session, "TOKEN_REFRESHED");
-      return { session };
+      this.setSessionInternal(session, "TOKEN_REFRESHED");
+      return { session, user: session.user };
     });
   }
   /**
@@ -311,10 +316,28 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Set the auth token manually
+   * Set the session manually (Supabase-compatible)
+   * Useful for restoring a session from storage or SSR scenarios
+   * @param session - Object containing access_token and refresh_token
+   * @returns Promise with session data
    */
-  setToken(token) {
-    this.fetch.setAuthToken(token);
+  async setSession(session) {
+    return wrapAsync(async () => {
+      const authSession = {
+        access_token: session.access_token,
+        refresh_token: session.refresh_token,
+        user: null,
+        // Will be populated by getCurrentUser
+        expires_in: 3600,
+        // Default, will be updated on refresh
+        expires_at: Date.now() + 3600 * 1e3
+      };
+      this.fetch.setAuthToken(session.access_token);
+      const user = await this.fetch.get("/api/v1/auth/user");
+      authSession.user = user;
+      this.setSessionInternal(authSession, "SIGNED_IN");
+      return { user, session: authSession };
+    });
   }
   /**
    * Setup 2FA for the current user
@@ -387,7 +410,7 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session, "MFA_CHALLENGE_VERIFIED");
+      this.setSessionInternal(session, "MFA_CHALLENGE_VERIFIED");
       return { user: session.user, session };
     });
   }
@@ -476,7 +499,7 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session);
+      this.setSessionInternal(session);
       return { user: session.user, session };
     });
   }
@@ -493,7 +516,7 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session);
+      this.setSessionInternal(session);
       return { user: session.user, session };
     });
   }
@@ -542,7 +565,7 @@ var FluxbaseAuth = class {
         ...response,
         expires_at: Date.now() + response.expires_in * 1e3
       };
-      this.setSession(session);
+      this.setSessionInternal(session);
       return { user: session.user, session };
     });
   }
@@ -572,7 +595,7 @@ var FluxbaseAuth = class {
   /**
    * Internal: Set the session and persist it
    */
-  setSession(session, event = "SIGNED_IN") {
+  setSessionInternal(session, event = "SIGNED_IN") {
     this.session = session;
     this.fetch.setAuthToken(session.access_token);
     this.saveSession();
@@ -616,7 +639,7 @@ var FluxbaseAuth = class {
     const delay = refreshAt - Date.now();
     if (delay > 0) {
       this.refreshTimer = setTimeout(async () => {
-        const result = await this.refreshToken();
+        const result = await this.refreshSession();
         if (result.error) {
           console.error("Failed to refresh token:", result.error);
           this.clearSession();
@@ -640,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;
@@ -651,6 +678,7 @@ var RealtimeChannel = class {
     this.url = url;
     this.channelName = channelName;
     this.token = token;
+    this.config = config;
   }
   // Implementation
   on(event, configOrCallback, callback) {
@@ -663,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;
@@ -712,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
         });
@@ -735,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
    */
@@ -759,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) => {
@@ -792,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));
     }
@@ -803,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":
@@ -821,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,
@@ -845,7 +1060,7 @@ var RealtimeChannel = class {
    */
   startHeartbeat() {
     this.heartbeatInterval = setInterval(() => {
-      this.send({ type: "heartbeat" });
+      this.sendMessage({ type: "heartbeat" });
     }, 3e4);
   }
   /**
@@ -882,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
    */
@@ -902,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;
   }
 };
@@ -937,15 +1193,20 @@ var StorageBucket = class {
       if (options?.upsert !== void 0) {
         formData.append("upsert", String(options.upsert));
       }
-      const response = await this.fetch.request(
-        `/api/v1/storage/${this.bucketName}/${path}`,
-        {
-          method: "POST",
-          body: formData,
-          headers: {}
-          // Let browser set Content-Type for FormData
-        }
-      );
+      let response;
+      if (options?.onUploadProgress) {
+        response = await this.uploadWithProgress(path, formData, options.onUploadProgress);
+      } else {
+        response = await this.fetch.request(
+          `/api/v1/storage/${this.bucketName}/${path}`,
+          {
+            method: "POST",
+            body: formData,
+            headers: {}
+            // Let browser set Content-Type for FormData
+          }
+        );
+      }
       return {
         data: {
           id: response.id || response.key || path,
@@ -958,6 +1219,57 @@ var StorageBucket = class {
       return { data: null, error };
     }
   }
+  /**
+   * Upload with progress tracking using XMLHttpRequest
+   * @private
+   */
+  uploadWithProgress(path, formData, onProgress) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      const url = `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`;
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          const percentage = Math.round(event.loaded / event.total * 100);
+          onProgress({
+            loaded: event.loaded,
+            total: event.total,
+            percentage
+          });
+        }
+      });
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const response = JSON.parse(xhr.responseText);
+            resolve(response);
+          } catch (e) {
+            resolve(xhr.responseText);
+          }
+        } else {
+          try {
+            const errorData = JSON.parse(xhr.responseText);
+            reject(new Error(errorData.error || xhr.statusText));
+          } catch (e) {
+            reject(new Error(xhr.statusText));
+          }
+        }
+      });
+      xhr.addEventListener("error", () => {
+        reject(new Error("Upload failed"));
+      });
+      xhr.addEventListener("abort", () => {
+        reject(new Error("Upload aborted"));
+      });
+      xhr.open("POST", url);
+      const headers = this.fetch["defaultHeaders"];
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== "content-type") {
+          xhr.setRequestHeader(key, value);
+        }
+      }
+      xhr.send(formData);
+    });
+  }
   /**
    * Download a file from the bucket
    * @param path - The path/key of the file
@@ -4284,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);
     };
   }
   /**
@@ -4308,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