@fluxbase/sdk 0.0.1-rc.43 → 0.0.1-rc.44

package/dist/index.cjs

@@ -3,6 +3,10 @@
 // src/fetch.ts
 var FluxbaseFetch = class {
   constructor(baseUrl, options = {}) {
+    this.refreshTokenCallback = null;
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.anonKey = null;
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.defaultHeaders = {
       "Content-Type": "application/json",
@@ -11,12 +15,30 @@ var FluxbaseFetch = class {
     this.timeout = options.timeout ?? 3e4;
     this.debug = options.debug ?? false;
   }
+  /**
+   * Register a callback to refresh the token when a 401 error occurs
+   * The callback should return true if refresh was successful, false otherwise
+   */
+  setRefreshTokenCallback(callback) {
+    this.refreshTokenCallback = callback;
+  }
+  /**
+   * Set the anon key for fallback authentication
+   * When setAuthToken(null) is called, the Authorization header will be
+   * restored to use this anon key instead of being deleted
+   */
+  setAnonKey(key) {
+    this.anonKey = key;
+  }
   /**
    * Update the authorization header
+   * When token is null, restores to anon key if available
    */
   setAuthToken(token) {
     if (token) {
       this.defaultHeaders["Authorization"] = `Bearer ${token}`;
+    } else if (this.anonKey) {
+      this.defaultHeaders["Authorization"] = `Bearer ${this.anonKey}`;
     } else {
       delete this.defaultHeaders["Authorization"];
     }
@@ -25,6 +47,12 @@ var FluxbaseFetch = class {
    * Make an HTTP request
    */
   async request(path, options) {
+    return this.requestInternal(path, options, false);
+  }
+  /**
+   * Internal request implementation with retry capability
+   */
+  async requestInternal(path, options, isRetry) {
     const url = `${this.baseUrl}${path}`;
     const headers = { ...this.defaultHeaders, ...options.headers };
     const controller = new AbortController();
@@ -33,10 +61,14 @@ var FluxbaseFetch = class {
       console.log(`[Fluxbase SDK] ${options.method} ${url}`, options.body);
     }
     try {
+      const isFormData = options.body && (options.body.constructor?.name === "FormData" || options.body instanceof FormData);
+      const requestHeaders = isFormData ? Object.fromEntries(
+        Object.entries(headers).filter(([key]) => key.toLowerCase() !== "content-type")
+      ) : headers;
       const response = await fetch(url, {
         method: options.method,
-        headers,
-        body: options.body ? JSON.stringify(options.body) : void 0,
+        headers: requestHeaders,
+        body: isFormData ? options.body : options.body ? JSON.stringify(options.body) : void 0,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -50,6 +82,12 @@ var FluxbaseFetch = class {
       if (this.debug) {
         console.log(`[Fluxbase SDK] Response:`, response.status, data);
       }
+      if (response.status === 401 && !isRetry && !options.skipAutoRefresh && this.refreshTokenCallback) {
+        const refreshSuccess = await this.handleTokenRefresh();
+        if (refreshSuccess) {
+          return this.requestInternal(path, options, true);
+        }
+      }
       if (!response.ok) {
         const error = new Error(
           typeof data === "object" && data && "error" in data ? String(data.error) : response.statusText
@@ -72,12 +110,122 @@ var FluxbaseFetch = class {
       throw new Error("Unknown error occurred");
     }
   }
+  /**
+   * Handle token refresh with deduplication
+   * Multiple concurrent requests that fail with 401 will share the same refresh operation
+   */
+  async handleTokenRefresh() {
+    if (this.isRefreshing && this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = this.executeRefresh();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.isRefreshing = false;
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Execute the actual token refresh
+   */
+  async executeRefresh() {
+    if (!this.refreshTokenCallback) {
+      return false;
+    }
+    try {
+      return await this.refreshTokenCallback();
+    } catch (error) {
+      if (this.debug) {
+        console.error("[Fluxbase SDK] Token refresh failed:", error);
+      }
+      return false;
+    }
+  }
   /**
    * GET request
    */
   async get(path, options = {}) {
     return this.request(path, { ...options, method: "GET" });
   }
+  /**
+   * GET request that returns response with headers (for count queries)
+   */
+  async getWithHeaders(path, options = {}) {
+    return this.requestWithHeaders(path, { ...options, method: "GET" });
+  }
+  /**
+   * Make an HTTP request and return response with headers
+   */
+  async requestWithHeaders(path, options) {
+    return this.requestWithHeadersInternal(path, options, false);
+  }
+  /**
+   * Internal request implementation that returns response with headers
+   */
+  async requestWithHeadersInternal(path, options, isRetry) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { ...this.defaultHeaders, ...options.headers };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? this.timeout);
+    if (this.debug) {
+      console.log(`[Fluxbase SDK] ${options.method} ${url}`, options.body);
+    }
+    try {
+      const isFormData = options.body && (options.body.constructor?.name === "FormData" || options.body instanceof FormData);
+      const requestHeaders = isFormData ? Object.fromEntries(
+        Object.entries(headers).filter(([key]) => key.toLowerCase() !== "content-type")
+      ) : headers;
+      const response = await fetch(url, {
+        method: options.method,
+        headers: requestHeaders,
+        body: isFormData ? options.body : options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("content-type");
+      let data;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      if (this.debug) {
+        console.log(`[Fluxbase SDK] Response:`, response.status, data);
+      }
+      if (response.status === 401 && !isRetry && !options.skipAutoRefresh && this.refreshTokenCallback) {
+        const refreshSuccess = await this.handleTokenRefresh();
+        if (refreshSuccess) {
+          return this.requestWithHeadersInternal(path, options, true);
+        }
+      }
+      if (!response.ok) {
+        const error = new Error(
+          typeof data === "object" && data && "error" in data ? String(data.error) : response.statusText
+        );
+        error.status = response.status;
+        error.details = data;
+        throw error;
+      }
+      return {
+        data,
+        headers: response.headers,
+        status: response.status
+      };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.status = 408;
+          throw timeoutError;
+        }
+        throw err;
+      }
+      throw new Error("Unknown error occurred");
+    }
+  }
   /**
    * POST request
    */
@@ -141,6 +289,9 @@ async function wrapAsyncVoid(operation) {
 
 // src/auth.ts
 var AUTH_STORAGE_KEY = "fluxbase.auth.session";
+var AUTO_REFRESH_TICK_THRESHOLD = 10;
+var AUTO_REFRESH_TICK_MINIMUM = 1e3;
+var MAX_REFRESH_RETRIES = 3;
 var MemoryStorage = class {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
@@ -186,6 +337,10 @@ var FluxbaseAuth = class {
     this.fetch = fetch2;
     this.persist = persist;
     this.autoRefresh = autoRefresh;
+    this.fetch.setRefreshTokenCallback(async () => {
+      const result = await this.refreshSession();
+      return !result.error;
+    });
     if (this.persist) {
       if (isLocalStorageAvailable()) {
         this.storage = localStorage;
@@ -253,6 +408,24 @@ var FluxbaseAuth = class {
     };
     return { data: { subscription } };
   }
+  /**
+   * Start the automatic token refresh timer
+   * This is called automatically when autoRefresh is enabled and a session exists
+   * Only works in browser environments
+   */
+  startAutoRefresh() {
+    this.scheduleTokenRefresh();
+  }
+  /**
+   * Stop the automatic token refresh timer
+   * Call this when you want to disable auto-refresh without signing out
+   */
+  stopAutoRefresh() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
   /**
    * Sign in with email and password (Supabase-compatible)
    * Returns { user, session } if successful, or SignInWith2FAResponse if 2FA is required
@@ -334,10 +507,13 @@ var FluxbaseAuth = class {
         "/api/v1/auth/refresh",
         {
           refresh_token: this.session.refresh_token
-        }
+        },
+        { skipAutoRefresh: true }
+        // Prevent infinite loop on 401
       );
       const session = {
         ...response,
+        user: response.user ?? this.session.user,
         expires_at: Date.now() + response.expires_in * 1e3
       };
       this.setSessionInternal(session, "TOKEN_REFRESHED");
@@ -386,7 +562,10 @@ var FluxbaseAuth = class {
       if (attributes.nonce) {
         requestBody.nonce = attributes.nonce;
       }
-      const user = await this.fetch.patch("/api/v1/auth/user", requestBody);
+      const user = await this.fetch.patch(
+        "/api/v1/auth/user",
+        requestBody
+      );
       if (this.session) {
         this.session.user = user;
         this.saveSession();
@@ -859,24 +1038,57 @@ var FluxbaseAuth = class {
   }
   /**
    * Internal: Schedule automatic token refresh
+   * Only runs in browser environments when autoRefresh is enabled
    */
   scheduleTokenRefresh() {
-    if (!this.autoRefresh || !this.session?.expires_at) {
+    if (!this.autoRefresh || typeof window === "undefined") {
+      return;
+    }
+    if (!this.session?.expires_at) {
       return;
     }
     if (this.refreshTimer) {
       clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
     }
-    const refreshAt = this.session.expires_at - 60 * 1e3;
-    const delay = refreshAt - Date.now();
-    if (delay > 0) {
-      this.refreshTimer = setTimeout(async () => {
-        const result = await this.refreshSession();
-        if (result.error) {
-          console.error("Failed to refresh token:", result.error);
-          this.clearSession();
-        }
-      }, delay);
+    const expiresAt = this.session.expires_at;
+    const now = Date.now();
+    const timeUntilExpiry = expiresAt - now;
+    const refreshIn = Math.max(
+      timeUntilExpiry - AUTO_REFRESH_TICK_THRESHOLD * 1e3,
+      AUTO_REFRESH_TICK_MINIMUM
+    );
+    this.refreshTimer = setTimeout(() => {
+      this.attemptRefresh();
+    }, refreshIn);
+  }
+  /**
+   * Internal: Attempt to refresh the token with retry logic
+   * Uses exponential backoff: 1s, 2s, 4s delays between retries
+   */
+  async attemptRefresh(retries = MAX_REFRESH_RETRIES) {
+    try {
+      const result = await this.refreshSession();
+      if (result.error) {
+        throw result.error;
+      }
+    } catch (error) {
+      if (retries > 0) {
+        const delay = Math.pow(2, MAX_REFRESH_RETRIES - retries) * 1e3;
+        console.warn(
+          `Token refresh failed, retrying in ${delay / 1e3}s (${retries} attempts remaining)`,
+          error
+        );
+        this.refreshTimer = setTimeout(() => {
+          this.attemptRefresh(retries - 1);
+        }, delay);
+      } else {
+        console.error(
+          "Token refresh failed after all retries, signing out",
+          error
+        );
+        this.clearSession();
+      }
     }
   }
   /**
@@ -907,14 +1119,24 @@ var RealtimeChannel = class {
     this.reconnectAttempts = 0;
     this.maxReconnectAttempts = 10;
     this.reconnectDelay = 1e3;
+    this.shouldReconnect = true;
     this.heartbeatInterval = null;
     this.pendingAcks = /* @__PURE__ */ new Map();
     this.messageIdCounter = 0;
+    this.onTokenRefreshNeeded = null;
+    this.isRefreshingToken = false;
     this.url = url;
     this.channelName = channelName;
     this.token = token;
     this.config = config;
   }
+  /**
+   * Set callback to request a token refresh when connection fails due to auth
+   * @internal
+   */
+  setTokenRefreshCallback(callback) {
+    this.onTokenRefreshNeeded = callback;
+  }
   // Implementation
   on(event, configOrCallback, callback) {
     if (event === "postgres_changes" && typeof configOrCallback !== "function") {
@@ -966,6 +1188,7 @@ var RealtimeChannel = class {
    * @param _timeout - Optional timeout in milliseconds (currently unused)
    */
   subscribe(callback, _timeout) {
+    this.shouldReconnect = true;
     this.connect();
     if (callback) {
       const checkConnection = () => {
@@ -987,6 +1210,7 @@ var RealtimeChannel = class {
    * @returns Promise resolving to status string (Supabase-compatible)
    */
   async unsubscribe(timeout) {
+    this.shouldReconnect = false;
     return new Promise((resolve) => {
       if (this.ws) {
         this.sendMessage({
@@ -1162,6 +1386,22 @@ var RealtimeChannel = class {
   presenceState() {
     return { ...this._presenceState };
   }
+  /**
+   * Check if the current token is expired or about to expire
+   */
+  isTokenExpired() {
+    if (!this.token) return false;
+    try {
+      const parts = this.token.split(".");
+      if (parts.length !== 3 || !parts[1]) return false;
+      const payload = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+      if (!payload.exp) return false;
+      const now = Math.floor(Date.now() / 1e3);
+      return payload.exp <= now + 10;
+    } catch {
+      return true;
+    }
+  }
   /**
    * Internal: Connect to WebSocket
    */
@@ -1169,6 +1409,29 @@ var RealtimeChannel = class {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       return;
     }
+    if (this.isTokenExpired() && this.onTokenRefreshNeeded && !this.isRefreshingToken) {
+      this.isRefreshingToken = true;
+      console.log("[Fluxbase Realtime] Token expired, requesting refresh before connecting");
+      this.onTokenRefreshNeeded().then((newToken) => {
+        this.isRefreshingToken = false;
+        if (newToken) {
+          this.token = newToken;
+          console.log("[Fluxbase Realtime] Token refreshed, connecting with new token");
+        }
+        this.connectWithToken();
+      }).catch((err) => {
+        this.isRefreshingToken = false;
+        console.error("[Fluxbase Realtime] Token refresh failed:", err);
+        this.connectWithToken();
+      });
+      return;
+    }
+    this.connectWithToken();
+  }
+  /**
+   * Internal: Actually establish the WebSocket connection
+   */
+  connectWithToken() {
     const wsUrl = new URL(this.url);
     wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
     wsUrl.pathname = "/realtime";
@@ -1190,11 +1453,17 @@ var RealtimeChannel = class {
       this.startHeartbeat();
     };
     this.ws.onmessage = (event) => {
+      let message;
       try {
-        const message = JSON.parse(event.data);
-        this.handleMessage(message);
+        message = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
       } catch (err) {
         console.error("[Fluxbase Realtime] Failed to parse message:", err);
+        return;
+      }
+      try {
+        this.handleMessage(message);
+      } catch (err) {
+        console.error("[Fluxbase Realtime] Error handling message:", err, message);
       }
     };
     this.ws.onerror = (error) => {
@@ -1230,7 +1499,6 @@ var RealtimeChannel = class {
   handleMessage(message) {
     switch (message.type) {
       case "heartbeat":
-        this.ws?.send(JSON.stringify({ type: "heartbeat" }));
         break;
       case "broadcast":
         if (message.broadcast) {
@@ -1250,6 +1518,23 @@ var RealtimeChannel = class {
           if (ackHandler) {
             ackHandler.resolve(message.status || "ok");
           }
+        } else if (message.payload && typeof message.payload === "object" && "type" in message.payload) {
+          const payload = message.payload;
+          if (payload.type === "access_token" && this.pendingAcks.has("access_token")) {
+            const ackHandler = this.pendingAcks.get("access_token");
+            if (ackHandler) {
+              ackHandler.resolve("ok");
+              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 {
+              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;
@@ -1261,6 +1546,18 @@ var RealtimeChannel = class {
         break;
       case "error":
         console.error("[Fluxbase Realtime] Error:", message.error);
+        if (this.pendingAcks.has("access_token")) {
+          const ackHandler = this.pendingAcks.get("access_token");
+          if (ackHandler) {
+            ackHandler.reject(new Error(message.error || "Token update failed"));
+            this.pendingAcks.delete("access_token");
+          }
+        }
+        break;
+      case "postgres_changes":
+        if (message.payload) {
+          this.handlePostgresChanges(message.payload);
+        }
         break;
     }
   }
@@ -1314,7 +1611,7 @@ var RealtimeChannel = class {
       schema: payload.schema,
       table: payload.table,
       commit_timestamp: payload.timestamp || payload.commit_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      new: payload.new_record || payload.new || {},
+      new: payload.new_record || payload.new || payload.record || {},
       old: payload.old_record || payload.old || {},
       errors: payload.errors || null
     };
@@ -1331,6 +1628,7 @@ var RealtimeChannel = class {
    * Internal: Start heartbeat interval
    */
   startHeartbeat() {
+    this.stopHeartbeat();
     this.heartbeatInterval = setInterval(() => {
       this.sendMessage({ type: "heartbeat" });
     }, 3e4);
@@ -1344,10 +1642,61 @@ var RealtimeChannel = class {
       this.heartbeatInterval = null;
     }
   }
+  /**
+   * Update the authentication token on an existing connection
+   * Sends an access_token message to the server to update auth context
+   * On failure, silently triggers a reconnect
+   *
+   * @param token - The new JWT access token
+   * @internal
+   */
+  updateToken(token) {
+    this.token = token;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    if (!token) {
+      this.disconnect();
+      this.connect();
+      return;
+    }
+    const message = {
+      type: "access_token",
+      token
+    };
+    try {
+      this.ws.send(JSON.stringify(message));
+      const timeout = setTimeout(() => {
+        console.warn(
+          "[Fluxbase Realtime] Token update acknowledgment timeout, reconnecting"
+        );
+        this.disconnect();
+        this.connect();
+      }, 5e3);
+      this.pendingAcks.set("access_token", {
+        resolve: () => {
+          clearTimeout(timeout);
+        },
+        reject: () => {
+          clearTimeout(timeout);
+          this.disconnect();
+          this.connect();
+        },
+        timeout
+      });
+    } catch (error) {
+      console.error("[Fluxbase Realtime] Failed to send token update:", error);
+      this.disconnect();
+      this.connect();
+    }
+  }
   /**
    * Internal: Attempt to reconnect
    */
   attemptReconnect() {
+    if (!this.shouldReconnect) {
+      return;
+    }
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error("[Fluxbase Realtime] Max reconnect attempts reached");
       return;
@@ -1365,9 +1714,21 @@ var RealtimeChannel = class {
 var FluxbaseRealtime = class {
   constructor(url, token = null) {
     this.channels = /* @__PURE__ */ new Map();
+    this.tokenRefreshCallback = null;
     this.url = url;
     this.token = token;
   }
+  /**
+   * Set callback to request a token refresh when connections fail due to auth
+   * This callback should refresh the auth token and return the new access token
+   * @internal
+   */
+  setTokenRefreshCallback(callback) {
+    this.tokenRefreshCallback = callback;
+    this.channels.forEach((channel) => {
+      channel.setTokenRefreshCallback(callback);
+    });
+  }
   /**
    * Create or get a channel with optional configuration
    *
@@ -1395,6 +1756,9 @@ var FluxbaseRealtime = class {
       this.token,
       config
     );
+    if (this.tokenRefreshCallback) {
+      channel.setTokenRefreshCallback(this.tokenRefreshCallback);
+    }
     this.channels.set(key, channel);
     return channel;
   }
@@ -1429,10 +1793,16 @@ var FluxbaseRealtime = class {
   }
   /**
    * Update auth token for all channels
+   * Updates both the stored token for new channels and propagates
+   * the token to all existing connected channels.
+   *
    * @param token - The new auth token
    */
   setAuth(token) {
     this.token = token;
+    this.channels.forEach((channel) => {
+      channel.updateToken(token);
+    });
   }
 };
 
@@ -1542,23 +1912,228 @@ var StorageBucket = class {
       xhr.send(formData);
     });
   }
+  async download(path, options) {
+    try {
+      const controller = new AbortController();
+      let timeoutId;
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          return { data: null, error: new Error("Download aborted") };
+        }
+        options.signal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+      }
+      const timeout = options?.timeout ?? (options?.stream ? 0 : 3e4);
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => controller.abort(), timeout);
+      }
+      try {
+        const response = await fetch(
+          `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`,
+          {
+            headers: this.fetch["defaultHeaders"],
+            signal: controller.signal
+          }
+        );
+        if (timeoutId) clearTimeout(timeoutId);
+        if (!response.ok) {
+          throw new Error(`Failed to download file: ${response.statusText}`);
+        }
+        if (options?.stream) {
+          if (!response.body) {
+            throw new Error("Response body is not available for streaming");
+          }
+          const contentLength = response.headers.get("content-length");
+          const size = contentLength ? parseInt(contentLength, 10) : null;
+          return {
+            data: { stream: response.body, size },
+            error: null
+          };
+        }
+        const blob = await response.blob();
+        return { data: blob, error: null };
+      } catch (err) {
+        if (timeoutId) clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === "AbortError") {
+          if (options?.signal?.aborted) {
+            return { data: null, error: new Error("Download aborted") };
+          }
+          return { data: null, error: new Error("Download timeout") };
+        }
+        throw err;
+      }
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
   /**
-   * Download a file from the bucket
-   * @param path - The path/key of the file
+   * Download a file with resumable chunked downloads for large files.
+   * Returns a ReadableStream that abstracts the chunking internally.
+   *
+   * Features:
+   * - Downloads file in chunks using HTTP Range headers
+   * - Automatically retries failed chunks with exponential backoff
+   * - Reports progress via callback
+   * - Falls back to regular streaming if Range not supported
+   *
+   * @param path - The file path within the bucket
+   * @param options - Download options including chunk size, retries, and progress callback
+   * @returns A ReadableStream and file size (consumer doesn't need to know about chunking)
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await storage.from('bucket').downloadResumable('large.json', {
+   *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+   *   maxRetries: 3,
+   *   onProgress: (progress) => console.log(`${progress.percentage}% complete`)
+   * });
+   * if (data) {
+   *   console.log(`File size: ${data.size} bytes`);
+   *   // Process data.stream...
+   * }
+   * ```
    */
-  async download(path) {
+  async downloadResumable(path, options) {
     try {
-      const response = await fetch(
-        `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`,
-        {
-          headers: this.fetch["defaultHeaders"]
-        }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to download file: ${response.statusText}`);
+      const chunkSize = options?.chunkSize ?? 5 * 1024 * 1024;
+      const maxRetries = options?.maxRetries ?? 3;
+      const retryDelayMs = options?.retryDelayMs ?? 1e3;
+      const chunkTimeout = options?.chunkTimeout ?? 3e4;
+      const url = `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`;
+      const headers = this.fetch["defaultHeaders"];
+      if (options?.signal?.aborted) {
+        return { data: null, error: new Error("Download aborted") };
+      }
+      const headResponse = await fetch(url, {
+        method: "HEAD",
+        headers,
+        signal: options?.signal
+      });
+      if (!headResponse.ok) {
+        throw new Error(`Failed to get file info: ${headResponse.statusText}`);
+      }
+      const contentLength = headResponse.headers.get("content-length");
+      const acceptRanges = headResponse.headers.get("accept-ranges");
+      const totalSize = contentLength ? parseInt(contentLength, 10) : null;
+      if (acceptRanges !== "bytes") {
+        const { data, error } = await this.download(path, {
+          stream: true,
+          timeout: 0,
+          signal: options?.signal
+        });
+        if (error) return { data: null, error };
+        return {
+          data,
+          error: null
+        };
       }
-      const blob = await response.blob();
-      return { data: blob, error: null };
+      let downloadedBytes = 0;
+      let currentChunk = 0;
+      const totalChunks = totalSize ? Math.ceil(totalSize / chunkSize) : null;
+      let lastProgressTime = Date.now();
+      let lastProgressBytes = 0;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          if (options?.signal?.aborted) {
+            controller.error(new Error("Download aborted"));
+            return;
+          }
+          if (totalSize !== null && downloadedBytes >= totalSize) {
+            controller.close();
+            return;
+          }
+          const rangeStart = downloadedBytes;
+          const rangeEnd = totalSize !== null ? Math.min(downloadedBytes + chunkSize - 1, totalSize - 1) : downloadedBytes + chunkSize - 1;
+          let retryCount = 0;
+          let chunk = null;
+          while (retryCount <= maxRetries && chunk === null) {
+            try {
+              if (options?.signal?.aborted) {
+                controller.error(new Error("Download aborted"));
+                return;
+              }
+              const chunkController = new AbortController();
+              const timeoutId = setTimeout(
+                () => chunkController.abort(),
+                chunkTimeout
+              );
+              if (options?.signal) {
+                options.signal.addEventListener(
+                  "abort",
+                  () => chunkController.abort(),
+                  { once: true }
+                );
+              }
+              const chunkResponse = await fetch(url, {
+                headers: {
+                  ...headers,
+                  Range: `bytes=${rangeStart}-${rangeEnd}`
+                },
+                signal: chunkController.signal
+              });
+              clearTimeout(timeoutId);
+              if (!chunkResponse.ok && chunkResponse.status !== 206) {
+                throw new Error(
+                  `Chunk download failed: ${chunkResponse.statusText}`
+                );
+              }
+              const arrayBuffer = await chunkResponse.arrayBuffer();
+              chunk = new Uint8Array(arrayBuffer);
+              if (totalSize === null && chunk.byteLength < chunkSize) {
+                downloadedBytes += chunk.byteLength;
+                currentChunk++;
+                controller.enqueue(chunk);
+                controller.close();
+                return;
+              }
+            } catch (err) {
+              if (options?.signal?.aborted) {
+                controller.error(new Error("Download aborted"));
+                return;
+              }
+              retryCount++;
+              if (retryCount > maxRetries) {
+                controller.error(
+                  new Error(
+                    `Failed to download chunk after ${maxRetries} retries`
+                  )
+                );
+                return;
+              }
+              const delay = retryDelayMs * Math.pow(2, retryCount - 1);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+          }
+          if (chunk) {
+            downloadedBytes += chunk.byteLength;
+            currentChunk++;
+            if (options?.onProgress) {
+              const now = Date.now();
+              const elapsed = (now - lastProgressTime) / 1e3;
+              const bytesPerSecond = elapsed > 0 ? (downloadedBytes - lastProgressBytes) / elapsed : 0;
+              lastProgressTime = now;
+              lastProgressBytes = downloadedBytes;
+              options.onProgress({
+                loaded: downloadedBytes,
+                total: totalSize,
+                percentage: totalSize ? Math.round(downloadedBytes / totalSize * 100) : null,
+                currentChunk,
+                totalChunks,
+                bytesPerSecond
+              });
+            }
+            controller.enqueue(chunk);
+            if (totalSize !== null && downloadedBytes >= totalSize) {
+              controller.close();
+            }
+          }
+        }
+      });
+      return {
+        data: { stream, size: totalSize },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -4846,7 +5421,9 @@ var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
    */
   async getJob(jobId) {
     try {
-      const data = await this.fetch.get(`/api/v1/admin/jobs/queue/${jobId}`);
+      const data = await this.fetch.get(
+        `/api/v1/admin/jobs/queue/${jobId}`
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -5061,8 +5638,14 @@ var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
             return fn;
           }
           const bundled = await _FluxbaseAdminJobs.bundleCode({
+            // Apply global bundle options first
+            ...bundleOptions,
+            // Then override with per-function values (these take priority)
             code: fn.code,
-            ...bundleOptions
+            // Use function's sourceDir for resolving relative imports
+            baseDir: fn.sourceDir || bundleOptions?.baseDir,
+            // Use function's nodePaths for additional module resolution
+            nodePaths: fn.nodePaths || bundleOptions?.nodePaths
           });
           return {
             ...fn,
@@ -5122,23 +5705,74 @@ var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
         "esbuild is required for bundling. Install it with: npm install esbuild"
       );
     }
-    const result = await esbuild.build({
+    const externals = [...options.external ?? []];
+    const alias = {};
+    if (options.importMap) {
+      for (const [key, value] of Object.entries(options.importMap)) {
+        if (value.startsWith("npm:")) {
+          externals.push(key);
+        } else if (value.startsWith("https://") || value.startsWith("http://")) {
+          externals.push(key);
+        } else if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) {
+          alias[key] = value;
+        } else {
+          externals.push(key);
+        }
+      }
+    }
+    const denoExternalPlugin = {
+      name: "deno-external",
+      setup(build) {
+        build.onResolve({ filter: /^npm:/ }, (args) => ({
+          path: args.path,
+          external: true
+        }));
+        build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+          path: args.path,
+          external: true
+        }));
+        build.onResolve({ filter: /^jsr:/ }, (args) => ({
+          path: args.path,
+          external: true
+        }));
+      }
+    };
+    const resolveDir = options.baseDir || process.cwd?.() || "/";
+    const buildOptions = {
       stdin: {
         contents: options.code,
         loader: "ts",
-        resolveDir: process.cwd?.() || "/"
+        resolveDir
       },
+      // Set absWorkingDir for consistent path resolution
+      absWorkingDir: resolveDir,
       bundle: true,
       write: false,
       format: "esm",
-      platform: "neutral",
+      // Use 'node' platform for better node_modules resolution (Deno supports Node APIs)
+      platform: "node",
       target: "esnext",
       minify: options.minify ?? false,
       sourcemap: options.sourcemap ? "inline" : false,
-      external: options.external ?? [],
+      external: externals,
+      plugins: [denoExternalPlugin],
       // Preserve handler export
-      treeShaking: true
-    });
+      treeShaking: true,
+      // Resolve .ts, .js, .mjs extensions
+      resolveExtensions: [".ts", ".tsx", ".js", ".mjs", ".json"],
+      // ESM conditions for better module resolution
+      conditions: ["import", "module"]
+    };
+    if (Object.keys(alias).length > 0) {
+      buildOptions.alias = alias;
+    }
+    if (options.nodePaths && options.nodePaths.length > 0) {
+      buildOptions.nodePaths = options.nodePaths;
+    }
+    if (options.define) {
+      buildOptions.define = options.define;
+    }
+    const result = await esbuild.build(buildOptions);
     const output = result.outputFiles?.[0];
     if (!output) {
       throw new Error("Bundling failed: no output generated");
@@ -5495,7 +6129,7 @@ var FluxbaseAdmin = class {
 
 // src/query-builder.ts
 var QueryBuilder = class {
-  constructor(fetch2, table) {
+  constructor(fetch2, table, schema) {
     this.selectQuery = "*";
     this.filters = [];
     this.orFilters = [];
@@ -5504,17 +6138,33 @@ var QueryBuilder = class {
     this.singleRow = false;
     this.maybeSingleRow = false;
     this.operationType = "select";
+    this.headOnly = false;
     this.fetch = fetch2;
     this.table = table;
+    this.schema = schema;
+  }
+  /**
+   * Build the API path for this table, including schema if specified
+   */
+  buildTablePath() {
+    return this.schema ? `/api/v1/tables/${this.schema}/${this.table}` : `/api/v1/tables/${this.table}`;
   }
   /**
    * Select columns to return
    * @example select('*')
    * @example select('id, name, email')
    * @example select('id, name, posts(title, content)')
+   * @example select('*', { count: 'exact' }) // Get exact count
+   * @example select('*', { count: 'exact', head: true }) // Get count only (no data)
    */
-  select(columns = "*") {
+  select(columns = "*", options) {
     this.selectQuery = columns;
+    if (options?.count) {
+      this.countType = options.count;
+    }
+    if (options?.head) {
+      this.headOnly = true;
+    }
     return this;
   }
   /**
@@ -5544,7 +6194,7 @@ var QueryBuilder = class {
     const headers = {
       Prefer: preferValues.join(",")
     };
-    let path = `/api/v1/tables/${this.table}`;
+    let path = this.buildTablePath();
     if (options?.onConflict) {
       path += `?on_conflict=${encodeURIComponent(options.onConflict)}`;
     }
@@ -6109,10 +6759,7 @@ var QueryBuilder = class {
           throw new Error("Insert data is required for insert operation");
         }
         const body = Array.isArray(this.insertData) ? this.insertData : this.insertData;
-        const response = await this.fetch.post(
-          `/api/v1/tables/${this.table}`,
-          body
-        );
+        const response = await this.fetch.post(this.buildTablePath(), body);
         return {
           data: response,
           error: null,
@@ -6126,7 +6773,7 @@ var QueryBuilder = class {
           throw new Error("Update data is required for update operation");
         }
         const queryString2 = this.buildQueryString();
-        const path2 = `/api/v1/tables/${this.table}${queryString2}`;
+        const path2 = `${this.buildTablePath()}${queryString2}`;
         const response = await this.fetch.patch(path2, this.updateData);
         return {
           data: response,
@@ -6138,7 +6785,7 @@ var QueryBuilder = class {
       }
       if (this.operationType === "delete") {
         const queryString2 = this.buildQueryString();
-        const path2 = `/api/v1/tables/${this.table}${queryString2}`;
+        const path2 = `${this.buildTablePath()}${queryString2}`;
         await this.fetch.delete(path2);
         return {
           data: null,
@@ -6149,7 +6796,66 @@ var QueryBuilder = class {
         };
       }
       const queryString = this.buildQueryString();
-      const path = `/api/v1/tables/${this.table}${queryString}`;
+      const path = `${this.buildTablePath()}${queryString}`;
+      if (this.countType) {
+        const response = await this.fetch.getWithHeaders(path);
+        const serverCount = this.parseContentRangeCount(response.headers);
+        const data2 = response.data;
+        if (this.headOnly) {
+          return {
+            data: null,
+            error: null,
+            count: serverCount,
+            status: response.status,
+            statusText: "OK"
+          };
+        }
+        if (this.singleRow) {
+          if (Array.isArray(data2) && data2.length === 0) {
+            return {
+              data: null,
+              error: { message: "No rows found", code: "PGRST116" },
+              count: serverCount ?? 0,
+              status: 404,
+              statusText: "Not Found"
+            };
+          }
+          const singleData = Array.isArray(data2) ? data2[0] : data2;
+          return {
+            data: singleData,
+            error: null,
+            count: serverCount ?? 1,
+            status: 200,
+            statusText: "OK"
+          };
+        }
+        if (this.maybeSingleRow) {
+          if (Array.isArray(data2) && data2.length === 0) {
+            return {
+              data: null,
+              error: null,
+              count: serverCount ?? 0,
+              status: 200,
+              statusText: "OK"
+            };
+          }
+          const singleData = Array.isArray(data2) ? data2[0] : data2;
+          return {
+            data: singleData,
+            error: null,
+            count: serverCount ?? 1,
+            status: 200,
+            statusText: "OK"
+          };
+        }
+        return {
+          data: data2,
+          error: null,
+          count: serverCount ?? (Array.isArray(data2) ? data2.length : null),
+          status: 200,
+          statusText: "OK"
+        };
+      }
       const data = await this.fetch.get(path);
       if (this.singleRow) {
         if (Array.isArray(data) && data.length === 0) {
@@ -6292,6 +6998,9 @@ var QueryBuilder = class {
     if (this.offsetValue !== void 0) {
       params.append("offset", String(this.offsetValue));
     }
+    if (this.countType) {
+      params.append("count", this.countType);
+    }
     const queryString = params.toString();
     return queryString ? `?${queryString}` : "";
   }
@@ -6313,6 +7022,38 @@ var QueryBuilder = class {
     }
     return String(value);
   }
+  /**
+   * Parse the Content-Range header to extract the total count
+   * Header format: "0-999/50000" or "* /50000" (when no rows returned)
+   */
+  parseContentRangeCount(headers) {
+    const contentRange = headers.get("Content-Range");
+    if (!contentRange) {
+      return null;
+    }
+    const match = contentRange.match(/\/(\d+)$/);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+    return null;
+  }
+};
+
+// src/schema-query-builder.ts
+var SchemaQueryBuilder = class {
+  constructor(fetch2, schemaName) {
+    this.fetch = fetch2;
+    this.schemaName = schemaName;
+  }
+  /**
+   * Create a query builder for a table in this schema
+   *
+   * @param table - The table name (without schema prefix)
+   * @returns A query builder instance for constructing and executing queries
+   */
+  from(table) {
+    return new QueryBuilder(this.fetch, table, this.schemaName);
+  }
 };
 
 // src/client.ts
@@ -6346,6 +7087,7 @@ var FluxbaseClient = class {
       timeout: options?.timeout,
       debug: options?.debug
     });
+    this.fetch.setAnonKey(fluxbaseKey);
     this.auth = new FluxbaseAuth(
       this.fetch,
       options?.auth?.autoRefresh ?? true,
@@ -6393,6 +7135,37 @@ var FluxbaseClient = class {
   from(table) {
     return new QueryBuilder(this.fetch, table);
   }
+  /**
+   * Access a specific database schema
+   *
+   * Use this to query tables in non-public schemas.
+   *
+   * @param schemaName - The schema name (e.g., 'jobs', 'analytics')
+   * @returns A schema query builder for constructing queries on that schema
+   *
+   * @example
+   * ```typescript
+   * // Query the jobs.execution_logs table
+   * const { data } = await client
+   *   .schema('jobs')
+   *   .from('execution_logs')
+   *   .select('*')
+   *   .eq('job_id', jobId)
+   *   .execute()
+   *
+   * // Insert into a custom schema table
+   * await client
+   *   .schema('analytics')
+   *   .from('events')
+   *   .insert({ event_type: 'click', data: {} })
+   *   .execute()
+   * ```
+   *
+   * @category Database
+   */
+  schema(schemaName) {
+    return new SchemaQueryBuilder(this.fetch, schemaName);
+  }
   /**
    * Call a PostgreSQL function (Remote Procedure Call)
    *
@@ -6435,6 +7208,14 @@ var FluxbaseClient = class {
       originalSetAuthToken(token);
       this.realtime.setAuth(token);
     };
+    this.realtime.setTokenRefreshCallback(async () => {
+      const result = await this.auth.refreshSession();
+      if (result.error || !result.data?.session) {
+        console.error("[Fluxbase] Failed to refresh token for realtime:", result.error);
+        return null;
+      }
+      return result.data.session.access_token;
+    });
   }
   /**
    * Get the current authentication token
@@ -6519,12 +7300,29 @@ var FluxbaseClient = class {
     return this.fetch;
   }
 };
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  if (typeof Deno !== "undefined" && Deno?.env) {
+    return Deno.env.get(name);
+  }
+  return void 0;
+}
 function createClient(fluxbaseUrl, fluxbaseKey, options) {
-  return new FluxbaseClient(
-    fluxbaseUrl,
-    fluxbaseKey,
-    options
-  );
+  const url = fluxbaseUrl || getEnvVar("FLUXBASE_URL") || getEnvVar("NEXT_PUBLIC_FLUXBASE_URL") || getEnvVar("VITE_FLUXBASE_URL");
+  const key = fluxbaseKey || getEnvVar("FLUXBASE_ANON_KEY") || getEnvVar("FLUXBASE_SERVICE_TOKEN") || getEnvVar("FLUXBASE_JOB_TOKEN") || getEnvVar("NEXT_PUBLIC_FLUXBASE_ANON_KEY") || getEnvVar("VITE_FLUXBASE_ANON_KEY");
+  if (!url) {
+    throw new Error(
+      "Fluxbase URL is required. Pass it as the first argument or set FLUXBASE_URL environment variable."
+    );
+  }
+  if (!key) {
+    throw new Error(
+      "Fluxbase key is required. Pass it as the second argument or set FLUXBASE_ANON_KEY environment variable."
+    );
+  }
+  return new FluxbaseClient(url, key, options);
 }
 
 exports.APIKeysManager = APIKeysManager;
@@ -6551,6 +7349,7 @@ exports.InvitationsManager = InvitationsManager;
 exports.OAuthProviderManager = OAuthProviderManager;
 exports.QueryBuilder = QueryBuilder;
 exports.RealtimeChannel = RealtimeChannel;
+exports.SchemaQueryBuilder = SchemaQueryBuilder;
 exports.SettingsClient = SettingsClient;
 exports.StorageBucket = StorageBucket;
 exports.SystemSettingsManager = SystemSettingsManager;