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

package/dist/index.js

@@ -208,8 +208,8 @@ var FluxbaseAuth = class {
     return { data: { subscription } };
   }
   /**
-   * Sign in with email and password
-   * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+   * Sign in with email and password (Supabase-compatible)
+   * Returns { user, session } if successful, or SignInWith2FAResponse if 2FA is required
    */
   async signIn(credentials) {
     return wrapAsync(async () => {
@@ -223,19 +223,21 @@ var FluxbaseAuth = class {
         expires_at: Date.now() + authResponse.expires_in * 1e3
       };
       this.setSessionInternal(session);
-      return session;
+      return { user: session.user, session };
     });
   }
   /**
-   * Sign in with email and password
+   * Sign in with email and password (Supabase-compatible)
    * Alias for signIn() to maintain compatibility with common authentication patterns
-   * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+   * Returns { user, session } if successful, or SignInWith2FAResponse if 2FA is required
    */
   async signInWithPassword(credentials) {
     return this.signIn(credentials);
   }
   /**
-   * Sign up with email and password
+   * Sign up with email and password (Supabase-compatible)
+   * Returns session when email confirmation is disabled
+   * Returns null session when email confirmation is required
    */
   async signUp(credentials) {
     return wrapAsync(async () => {
@@ -243,12 +245,15 @@ var FluxbaseAuth = class {
         "/api/v1/auth/signup",
         credentials
       );
-      const session = {
-        ...response,
-        expires_at: Date.now() + response.expires_in * 1e3
-      };
-      this.setSessionInternal(session);
-      return { user: session.user, session };
+      if (response.access_token && response.refresh_token) {
+        const session = {
+          ...response,
+          expires_at: Date.now() + response.expires_in * 1e3
+        };
+        this.setSessionInternal(session);
+        return { user: response.user, session };
+      }
+      return { user: response.user, session: null };
     });
   }
   /**
@@ -283,7 +288,7 @@ var FluxbaseAuth = class {
         expires_at: Date.now() + response.expires_in * 1e3
       };
       this.setSessionInternal(session, "TOKEN_REFRESHED");
-      return { session, user: session.user };
+      return { user: session.user, session };
     });
   }
   /**
@@ -340,8 +345,9 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Setup 2FA for the current user
-   * Returns TOTP secret and QR code URL
+   * Setup 2FA for the current user (Supabase-compatible)
+   * Enrolls a new MFA factor and returns TOTP details
+   * @returns Promise with factor id, type, and TOTP setup details
    */
   async setup2FA() {
     return wrapAsync(async () => {
@@ -354,8 +360,10 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Enable 2FA after verifying the TOTP code
-   * Returns backup codes that should be saved by the user
+   * Enable 2FA after verifying the TOTP code (Supabase-compatible)
+   * Verifies the TOTP code and returns new tokens with MFA session
+   * @param code - TOTP code from authenticator app
+   * @returns Promise with access_token, refresh_token, and user
    */
   async enable2FA(code) {
     return wrapAsync(async () => {
@@ -369,8 +377,10 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Disable 2FA for the current user
-   * Requires password confirmation
+   * Disable 2FA for the current user (Supabase-compatible)
+   * Unenrolls the MFA factor
+   * @param password - User password for confirmation
+   * @returns Promise with unenrolled factor id
    */
   async disable2FA(password) {
     return wrapAsync(async () => {
@@ -384,7 +394,9 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Check 2FA status for the current user
+   * Check 2FA status for the current user (Supabase-compatible)
+   * Lists all enrolled MFA factors
+   * @returns Promise with all factors and TOTP factors
    */
   async get2FAStatus() {
     return wrapAsync(async () => {
@@ -397,8 +409,10 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Verify 2FA code during login
+   * Verify 2FA code during login (Supabase-compatible)
    * Call this after signIn returns requires_2fa: true
+   * @param request - User ID and TOTP code
+   * @returns Promise with access_token, refresh_token, and user
    */
   async verify2FA(request) {
     return wrapAsync(async () => {
@@ -406,31 +420,36 @@ var FluxbaseAuth = class {
         "/api/v1/auth/2fa/verify",
         request
       );
-      const session = {
-        ...response,
-        expires_at: Date.now() + response.expires_in * 1e3
-      };
-      this.setSessionInternal(session, "MFA_CHALLENGE_VERIFIED");
-      return { user: session.user, session };
+      if (response.access_token && response.refresh_token) {
+        const session = {
+          user: response.user,
+          access_token: response.access_token,
+          refresh_token: response.refresh_token,
+          expires_in: response.expires_in || 3600,
+          expires_at: Date.now() + (response.expires_in || 3600) * 1e3
+        };
+        this.setSessionInternal(session, "MFA_CHALLENGE_VERIFIED");
+      }
+      return response;
     });
   }
   /**
-   * Send password reset email
+   * Send password reset email (Supabase-compatible)
    * Sends a password reset link to the provided email address
    * @param email - Email address to send reset link to
+   * @returns Promise with OTP-style response
    */
   async sendPasswordReset(email) {
     return wrapAsync(async () => {
-      return await this.fetch.post(
-        "/api/v1/auth/password/reset",
-        { email }
-      );
+      await this.fetch.post("/api/v1/auth/password/reset", { email });
+      return { user: null, session: null };
     });
   }
   /**
    * Supabase-compatible alias for sendPasswordReset()
    * @param email - Email address to send reset link to
    * @param _options - Optional redirect configuration (currently not used)
+   * @returns Promise with OTP-style response
    */
   async resetPasswordForEmail(email, _options) {
     return this.sendPasswordReset(email);
@@ -451,36 +470,42 @@ var FluxbaseAuth = class {
     });
   }
   /**
-   * Reset password with token
+   * Reset password with token (Supabase-compatible)
    * Complete the password reset process with a valid token
    * @param token - Password reset token
    * @param newPassword - New password to set
+   * @returns Promise with user and new session
    */
   async resetPassword(token, newPassword) {
     return wrapAsync(async () => {
-      return await this.fetch.post(
+      const response = await this.fetch.post(
         "/api/v1/auth/password/reset/confirm",
         {
           token,
           new_password: newPassword
         }
       );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSessionInternal(session, "PASSWORD_RECOVERY");
+      return { user: session.user, session };
     });
   }
   /**
-   * Send magic link for passwordless authentication
+   * Send magic link for passwordless authentication (Supabase-compatible)
    * @param email - Email address to send magic link to
    * @param options - Optional configuration for magic link
+   * @returns Promise with OTP-style response
    */
   async sendMagicLink(email, options) {
     return wrapAsync(async () => {
-      return await this.fetch.post(
-        "/api/v1/auth/magiclink",
-        {
-          email,
-          redirect_to: options?.redirect_to
-        }
-      );
+      await this.fetch.post("/api/v1/auth/magiclink", {
+        email,
+        redirect_to: options?.redirect_to
+      });
+      return { user: null, session: null };
     });
   }
   /**
@@ -663,10 +688,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 +703,7 @@ var RealtimeChannel = class {
     this.url = url;
     this.channelName = channelName;
     this.token = token;
+    this.config = config;
   }
   // Implementation
   on(event, configOrCallback, callback) {
@@ -686,6 +716,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 +779,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 +802,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 +951,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 +984,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 +995,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 +1020,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 +1085,7 @@ var RealtimeChannel = class {
    */
   startHeartbeat() {
     this.heartbeatInterval = setInterval(() => {
-      this.send({ type: "heartbeat" });
+      this.sendMessage({ type: "heartbeat" });
     }, 3e4);
   }
   /**
@@ -905,17 +1122,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 +1182,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 +4621,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 +4645,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