@fluxbase/sdk 0.0.1-rc.2 → 0.0.1-rc.21

package/dist/index.cjs

@@ -116,6 +116,29 @@ var FluxbaseFetch = class {
   }
 };
 
+// src/utils/error-handling.ts
+async function wrapAsync(operation) {
+  try {
+    const data = await operation();
+    return { data, error: null };
+  } catch (error) {
+    return {
+      data: null,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+async function wrapAsyncVoid(operation) {
+  try {
+    await operation();
+    return { error: null };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
 // src/auth.ts
 var AUTH_STORAGE_KEY = "fluxbase.auth.session";
 var FluxbaseAuth = class {
@@ -187,83 +210,107 @@ var FluxbaseAuth = class {
    * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
    */
   async signIn(credentials) {
-    const response = await this.fetch.post(
-      "/api/v1/auth/signin",
-      credentials
-    );
-    if ("requires_2fa" in response && response.requires_2fa) {
-      return response;
-    }
-    const authResponse = response;
-    const session = {
-      ...authResponse,
-      expires_at: Date.now() + authResponse.expires_in * 1e3
-    };
-    this.setSession(session);
-    return session;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post("/api/v1/auth/signin", credentials);
+      if ("requires_2fa" in response && response.requires_2fa) {
+        return response;
+      }
+      const authResponse = response;
+      const session = {
+        ...authResponse,
+        expires_at: Date.now() + authResponse.expires_in * 1e3
+      };
+      this.setSession(session);
+      return session;
+    });
+  }
+  /**
+   * Sign in with email and password
+   * Alias for signIn() to maintain compatibility with common authentication patterns
+   * Returns AuthSession if successful, or SignInWith2FAResponse if 2FA is required
+   */
+  async signInWithPassword(credentials) {
+    return this.signIn(credentials);
   }
   /**
    * Sign up with email and password
    */
   async signUp(credentials) {
-    const response = await this.fetch.post("/api/v1/auth/signup", credentials);
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session);
-    return session;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/signup",
+        credentials
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session);
+      return { user: session.user, session };
+    });
   }
   /**
    * Sign out the current user
    */
   async signOut() {
-    try {
-      await this.fetch.post("/api/v1/auth/signout");
-    } finally {
-      this.clearSession();
-    }
+    return wrapAsyncVoid(async () => {
+      try {
+        await this.fetch.post("/api/v1/auth/signout");
+      } finally {
+        this.clearSession();
+      }
+    });
   }
   /**
    * Refresh the access token
    */
   async refreshToken() {
-    if (!this.session?.refresh_token) {
-      throw new Error("No refresh token available");
-    }
-    const response = await this.fetch.post("/api/v1/auth/refresh", {
-      refresh_token: this.session.refresh_token
+    return wrapAsync(async () => {
+      if (!this.session?.refresh_token) {
+        throw new Error("No refresh token available");
+      }
+      const response = await this.fetch.post(
+        "/api/v1/auth/refresh",
+        {
+          refresh_token: this.session.refresh_token
+        }
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session, "TOKEN_REFRESHED");
+      return { session };
     });
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session, "TOKEN_REFRESHED");
-    return session;
   }
   /**
    * Get the current user from the server
    */
   async getCurrentUser() {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    return await this.fetch.get("/api/v1/auth/user");
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      const user = await this.fetch.get("/api/v1/auth/user");
+      return { user };
+    });
   }
   /**
    * Update the current user
    */
   async updateUser(data) {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    const user = await this.fetch.patch("/api/v1/auth/user", data);
-    if (this.session) {
-      this.session.user = user;
-      this.saveSession();
-      this.emitAuthChange("USER_UPDATED", this.session);
-    }
-    return user;
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      const user = await this.fetch.patch("/api/v1/auth/user", data);
+      if (this.session) {
+        this.session.user = user;
+        this.saveSession();
+        this.emitAuthChange("USER_UPDATED", this.session);
+      }
+      return { user };
+    });
   }
   /**
    * Set the auth token manually
@@ -276,55 +323,75 @@ var FluxbaseAuth = class {
    * Returns TOTP secret and QR code URL
    */
   async setup2FA() {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    return await this.fetch.post("/api/v1/auth/2fa/setup");
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      return await this.fetch.post(
+        "/api/v1/auth/2fa/setup"
+      );
+    });
   }
   /**
    * Enable 2FA after verifying the TOTP code
    * Returns backup codes that should be saved by the user
    */
   async enable2FA(code) {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    return await this.fetch.post("/api/v1/auth/2fa/enable", { code });
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      return await this.fetch.post(
+        "/api/v1/auth/2fa/enable",
+        { code }
+      );
+    });
   }
   /**
    * Disable 2FA for the current user
    * Requires password confirmation
    */
   async disable2FA(password) {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    return await this.fetch.post(
-      "/api/v1/auth/2fa/disable",
-      { password }
-    );
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      return await this.fetch.post(
+        "/api/v1/auth/2fa/disable",
+        { password }
+      );
+    });
   }
   /**
    * Check 2FA status for the current user
    */
   async get2FAStatus() {
-    if (!this.session) {
-      throw new Error("Not authenticated");
-    }
-    return await this.fetch.get("/api/v1/auth/2fa/status");
+    return wrapAsync(async () => {
+      if (!this.session) {
+        throw new Error("Not authenticated");
+      }
+      return await this.fetch.get(
+        "/api/v1/auth/2fa/status"
+      );
+    });
   }
   /**
    * Verify 2FA code during login
    * Call this after signIn returns requires_2fa: true
    */
   async verify2FA(request) {
-    const response = await this.fetch.post("/api/v1/auth/2fa/verify", request);
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session, "MFA_CHALLENGE_VERIFIED");
-    return session;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/2fa/verify",
+        request
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session, "MFA_CHALLENGE_VERIFIED");
+      return { user: session.user, session };
+    });
   }
   /**
    * Send password reset email
@@ -332,7 +399,20 @@ var FluxbaseAuth = class {
    * @param email - Email address to send reset link to
    */
   async sendPasswordReset(email) {
-    return await this.fetch.post("/api/v1/auth/password/reset", { email });
+    return wrapAsync(async () => {
+      return await this.fetch.post(
+        "/api/v1/auth/password/reset",
+        { email }
+      );
+    });
+  }
+  /**
+   * Supabase-compatible alias for sendPasswordReset()
+   * @param email - Email address to send reset link to
+   * @param _options - Optional redirect configuration (currently not used)
+   */
+  async resetPasswordForEmail(email, _options) {
+    return this.sendPasswordReset(email);
   }
   /**
    * Verify password reset token
@@ -340,8 +420,13 @@ var FluxbaseAuth = class {
    * @param token - Password reset token to verify
    */
   async verifyResetToken(token) {
-    return await this.fetch.post("/api/v1/auth/password/reset/verify", {
-      token
+    return wrapAsync(async () => {
+      return await this.fetch.post(
+        "/api/v1/auth/password/reset/verify",
+        {
+          token
+        }
+      );
     });
   }
   /**
@@ -351,9 +436,14 @@ var FluxbaseAuth = class {
    * @param newPassword - New password to set
    */
   async resetPassword(token, newPassword) {
-    return await this.fetch.post("/api/v1/auth/password/reset/confirm", {
-      token,
-      new_password: newPassword
+    return wrapAsync(async () => {
+      return await this.fetch.post(
+        "/api/v1/auth/password/reset/confirm",
+        {
+          token,
+          new_password: newPassword
+        }
+      );
     });
   }
   /**
@@ -362,9 +452,14 @@ var FluxbaseAuth = class {
    * @param options - Optional configuration for magic link
    */
   async sendMagicLink(email, options) {
-    return await this.fetch.post("/api/v1/auth/magiclink", {
-      email,
-      redirect_to: options?.redirect_to
+    return wrapAsync(async () => {
+      return await this.fetch.post(
+        "/api/v1/auth/magiclink",
+        {
+          email,
+          redirect_to: options?.redirect_to
+        }
+      );
     });
   }
   /**
@@ -372,34 +467,47 @@ var FluxbaseAuth = class {
    * @param token - Magic link token from email
    */
   async verifyMagicLink(token) {
-    const response = await this.fetch.post("/api/v1/auth/magiclink/verify", {
-      token
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/magiclink/verify",
+        {
+          token
+        }
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session);
+      return { user: session.user, session };
     });
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session);
-    return session;
   }
   /**
    * Sign in anonymously
    * Creates a temporary anonymous user session
    */
   async signInAnonymously() {
-    const response = await this.fetch.post("/api/v1/auth/signin/anonymous");
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session);
-    return session;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/signin/anonymous"
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session);
+      return { user: session.user, session };
+    });
   }
   /**
    * Get list of enabled OAuth providers
    */
   async getOAuthProviders() {
-    return await this.fetch.get("/api/v1/auth/oauth/providers");
+    return wrapAsync(async () => {
+      return await this.fetch.get(
+        "/api/v1/auth/oauth/providers"
+      );
+    });
   }
   /**
    * Get OAuth authorization URL for a provider
@@ -407,17 +515,19 @@ var FluxbaseAuth = class {
    * @param options - Optional OAuth configuration
    */
   async getOAuthUrl(provider, options) {
-    const params = new URLSearchParams();
-    if (options?.redirect_to) {
-      params.append("redirect_to", options.redirect_to);
-    }
-    if (options?.scopes && options.scopes.length > 0) {
-      params.append("scopes", options.scopes.join(","));
-    }
-    const queryString = params.toString();
-    const url = queryString ? `/api/v1/auth/oauth/${provider}/authorize?${queryString}` : `/api/v1/auth/oauth/${provider}/authorize`;
-    const response = await this.fetch.get(url);
-    return response;
+    return wrapAsync(async () => {
+      const params = new URLSearchParams();
+      if (options?.redirect_to) {
+        params.append("redirect_to", options.redirect_to);
+      }
+      if (options?.scopes && options.scopes.length > 0) {
+        params.append("scopes", options.scopes.join(","));
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/api/v1/auth/oauth/${provider}/authorize?${queryString}` : `/api/v1/auth/oauth/${provider}/authorize`;
+      const response = await this.fetch.get(url);
+      return response;
+    });
   }
   /**
    * Exchange OAuth authorization code for session
@@ -425,13 +535,18 @@ var FluxbaseAuth = class {
    * @param code - Authorization code from OAuth callback
    */
   async exchangeCodeForSession(code) {
-    const response = await this.fetch.post("/api/v1/auth/oauth/callback", { code });
-    const session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session);
-    return session;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/oauth/callback",
+        { code }
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session);
+      return { user: session.user, session };
+    });
   }
   /**
    * Convenience method to initiate OAuth sign-in
@@ -440,12 +555,21 @@ var FluxbaseAuth = class {
    * @param options - Optional OAuth configuration
    */
   async signInWithOAuth(provider, options) {
-    const { url } = await this.getOAuthUrl(provider, options);
-    if (typeof window !== "undefined") {
-      window.location.href = url;
-    } else {
-      throw new Error("signInWithOAuth can only be called in a browser environment");
-    }
+    return wrapAsync(async () => {
+      const result = await this.getOAuthUrl(provider, options);
+      if (result.error) {
+        throw result.error;
+      }
+      const url = result.data.url;
+      if (typeof window !== "undefined") {
+        window.location.href = url;
+      } else {
+        throw new Error(
+          "signInWithOAuth can only be called in a browser environment"
+        );
+      }
+      return { provider, url };
+    });
   }
   /**
    * Internal: Set the session and persist it
@@ -493,11 +617,12 @@ var FluxbaseAuth = class {
     const refreshAt = this.session.expires_at - 60 * 1e3;
     const delay = refreshAt - Date.now();
     if (delay > 0) {
-      this.refreshTimer = setTimeout(() => {
-        this.refreshToken().catch((err) => {
-          console.error("Failed to refresh token:", err);
+      this.refreshTimer = setTimeout(async () => {
+        const result = await this.refreshToken();
+        if (result.error) {
+          console.error("Failed to refresh token:", result.error);
           this.clearSession();
-        });
+        }
       }, delay);
     }
   }
@@ -562,22 +687,55 @@ var RealtimeChannel = class {
   }
   /**
    * Subscribe to the channel
+   * @param callback - Optional status callback (Supabase-compatible)
+   * @param _timeout - Optional timeout in milliseconds (currently unused)
    */
-  subscribe() {
+  subscribe(callback, _timeout) {
     this.connect();
+    if (callback) {
+      const checkConnection = () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          callback("SUBSCRIBED");
+        } else if (this.ws && this.ws.readyState === WebSocket.CLOSED) {
+          callback("CHANNEL_ERROR", new Error("Failed to connect"));
+        } else {
+          setTimeout(checkConnection, 100);
+        }
+      };
+      setTimeout(checkConnection, 100);
+    }
     return this;
   }
   /**
    * Unsubscribe from the channel
-   */
-  unsubscribe() {
-    if (this.ws) {
-      this.send({
-        type: "unsubscribe",
-        channel: this.channelName
-      });
-      this.disconnect();
-    }
+   * @param timeout - Optional timeout in milliseconds
+   * @returns Promise resolving to status string (Supabase-compatible)
+   */
+  async unsubscribe(timeout) {
+    return new Promise((resolve) => {
+      if (this.ws) {
+        this.send({
+          type: "unsubscribe",
+          channel: this.channelName
+        });
+        const startTime = Date.now();
+        const maxWait = timeout || 5e3;
+        const checkDisconnect = () => {
+          if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            this.disconnect();
+            resolve("ok");
+          } else if (Date.now() - startTime > maxWait) {
+            this.disconnect();
+            resolve("timed out");
+          } else {
+            setTimeout(checkDisconnect, 100);
+          }
+        };
+        setTimeout(checkDisconnect, 100);
+      } else {
+        resolve("ok");
+      }
+    });
   }
   /**
    * Internal: Connect to WebSocket
@@ -666,13 +824,22 @@ var RealtimeChannel = class {
    * Internal: Handle broadcast message
    */
   handleBroadcast(payload) {
-    const callbacks = this.callbacks.get(payload.type);
+    const supabasePayload = {
+      eventType: payload.type || payload.eventType,
+      schema: payload.schema,
+      table: payload.table,
+      commit_timestamp: payload.timestamp || payload.commit_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      new: payload.new_record || payload.new || {},
+      old: payload.old_record || payload.old || {},
+      errors: payload.errors || null
+    };
+    const callbacks = this.callbacks.get(supabasePayload.eventType);
     if (callbacks) {
-      callbacks.forEach((callback) => callback(payload));
+      callbacks.forEach((callback) => callback(supabasePayload));
     }
     const wildcardCallbacks = this.callbacks.get("*");
     if (wildcardCallbacks) {
-      wildcardCallbacks.forEach((callback) => callback(payload));
+      wildcardCallbacks.forEach((callback) => callback(supabasePayload));
     }
   }
   /**
@@ -702,7 +869,9 @@ var RealtimeChannel = class {
     }
     this.reconnectAttempts++;
     const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-    console.log(`[Fluxbase Realtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    console.log(
+      `[Fluxbase Realtime] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`
+    );
     setTimeout(() => {
       this.connect();
     }, delay);
@@ -770,7 +939,7 @@ var StorageBucket = class {
       if (options?.upsert !== void 0) {
         formData.append("upsert", String(options.upsert));
       }
-      const data = await this.fetch.request(
+      const response = await this.fetch.request(
         `/api/v1/storage/${this.bucketName}/${path}`,
         {
           method: "POST",
@@ -779,7 +948,14 @@ var StorageBucket = class {
           // Let browser set Content-Type for FormData
         }
       );
-      return { data, error: null };
+      return {
+        data: {
+          id: response.id || response.key || path,
+          path,
+          fullPath: `${this.bucketName}/${path}`
+        },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -807,13 +983,24 @@ var StorageBucket = class {
   }
   /**
    * List files in the bucket
-   * @param options - List options (prefix, limit, offset)
+   * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
+   * @param pathOrOptions - The folder path or list options
+   * @param maybeOptions - List options when first param is a path
    */
-  async list(options) {
+  async list(pathOrOptions, maybeOptions) {
     try {
       const params = new URLSearchParams();
-      if (options?.prefix) {
-        params.set("prefix", options.prefix);
+      let prefix;
+      let options;
+      if (typeof pathOrOptions === "string") {
+        prefix = pathOrOptions;
+        options = maybeOptions;
+      } else {
+        options = pathOrOptions;
+        prefix = options?.prefix;
+      }
+      if (prefix) {
+        params.set("prefix", prefix);
       }
       if (options?.limit) {
         params.set("limit", String(options.limit));
@@ -823,8 +1010,17 @@ var StorageBucket = class {
       }
       const queryString = params.toString();
       const path = `/api/v1/storage/${this.bucketName}${queryString ? `?${queryString}` : ""}`;
-      const data = await this.fetch.get(path);
-      return { data: data.objects || [], error: null };
+      const response = await this.fetch.get(path);
+      const files = (response.files || []).map((file) => ({
+        name: file.key || file.name,
+        id: file.id,
+        bucket_id: file.bucket || this.bucketName,
+        created_at: file.last_modified || file.created_at,
+        updated_at: file.updated_at,
+        last_accessed_at: file.last_accessed_at,
+        metadata: file.metadata
+      }));
+      return { data: files, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -835,10 +1031,15 @@ var StorageBucket = class {
    */
   async remove(paths) {
     try {
+      const removedFiles = [];
       for (const path of paths) {
         await this.fetch.delete(`/api/v1/storage/${this.bucketName}/${path}`);
+        removedFiles.push({
+          name: path,
+          bucket_id: this.bucketName
+        });
       }
-      return { data: null, error: null };
+      return { data: removedFiles, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -875,14 +1076,17 @@ var StorageBucket = class {
    */
   async move(fromPath, toPath) {
     try {
-      const data = await this.fetch.post(
+      await this.fetch.post(
         `/api/v1/storage/${this.bucketName}/move`,
         {
           from_path: fromPath,
           to_path: toPath
         }
       );
-      return { data, error: null };
+      return {
+        data: { message: "Successfully moved" },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
@@ -894,14 +1098,65 @@ var StorageBucket = class {
    */
   async copy(fromPath, toPath) {
     try {
-      const data = await this.fetch.post(
+      await this.fetch.post(
         `/api/v1/storage/${this.bucketName}/copy`,
         {
           from_path: fromPath,
           to_path: toPath
         }
       );
-      return { data, error: null };
+      return {
+        data: { path: toPath },
+        error: null
+      };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Share a file with another user (RLS)
+   * @param path - The file path
+   * @param options - Share options (userId and permission)
+   */
+  async share(path, options) {
+    try {
+      await this.fetch.post(
+        `/api/v1/storage/${this.bucketName}/${path}/share`,
+        {
+          user_id: options.userId,
+          permission: options.permission
+        }
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Revoke file access from a user (RLS)
+   * @param path - The file path
+   * @param userId - The user ID to revoke access from
+   */
+  async revokeShare(path, userId) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/storage/${this.bucketName}/${path}/share/${userId}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List users a file is shared with (RLS)
+   * @param path - The file path
+   */
+  async listShares(path) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/storage/${this.bucketName}/${path}/shares`
+      );
+      return { data: data.shares || [], error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -923,9 +1178,7 @@ var FluxbaseStorage = class {
    */
   async listBuckets() {
     try {
-      const data = await this.fetch.get(
-        "/api/v1/storage/buckets"
-      );
+      const data = await this.fetch.get("/api/v1/storage/buckets");
       return { data: data.buckets || [], error: null };
     } catch (error) {
       return { data: null, error };
@@ -938,7 +1191,7 @@ var FluxbaseStorage = class {
   async createBucket(bucketName) {
     try {
       await this.fetch.post(`/api/v1/storage/buckets/${bucketName}`);
-      return { data: null, error: null };
+      return { data: { name: bucketName }, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -950,7 +1203,7 @@ var FluxbaseStorage = class {
   async deleteBucket(bucketName) {
     try {
       await this.fetch.delete(`/api/v1/storage/buckets/${bucketName}`);
-      return { data: null, error: null };
+      return { data: { message: "Successfully deleted" }, error: null };
     } catch (error) {
       return { data: null, error };
     }
@@ -967,250 +1220,931 @@ var FluxbaseStorage = class {
         return { data: null, error: listError };
       }
       if (objects && objects.length > 0) {
-        const paths = objects.map((obj) => obj.key);
+        const paths = objects.map((obj) => obj.name);
         const { error: removeError } = await bucket.remove(paths);
         if (removeError) {
           return { data: null, error: removeError };
         }
       }
+      return { data: { message: "Successfully emptied" }, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update bucket settings (RLS - requires admin or service key)
+   * @param bucketName - The name of the bucket
+   * @param settings - Bucket settings to update
+   */
+  async updateBucketSettings(bucketName, settings) {
+    try {
+      await this.fetch.put(`/api/v1/storage/buckets/${bucketName}`, settings);
       return { data: null, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
+  /**
+   * Get bucket details
+   * @param bucketName - The name of the bucket
+   */
+  async getBucket(bucketName) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/storage/buckets/${bucketName}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
 };
 
-// src/settings.ts
-var SystemSettingsManager = class {
+// src/functions.ts
+var FluxbaseFunctions = class {
   constructor(fetch2) {
     this.fetch = fetch2;
   }
   /**
-   * List all system settings
+   * Invoke an edge function
+   *
+   * This method is fully compatible with Supabase's functions.invoke() API.
+   *
+   * @param functionName - The name of the function to invoke
+   * @param options - Invocation options including body, headers, and HTTP method
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * // Simple invocation
+   * const { data, error } = await client.functions.invoke('hello', {
+   *   body: { name: 'World' }
+   * })
+   *
+   * // With GET method
+   * const { data, error } = await client.functions.invoke('get-data', {
+   *   method: 'GET'
+   * })
+   *
+   * // With custom headers
+   * const { data, error } = await client.functions.invoke('api-proxy', {
+   *   body: { query: 'search' },
+   *   headers: { 'Authorization': 'Bearer token' },
+   *   method: 'POST'
+   * })
+   * ```
+   */
+  async invoke(functionName, options) {
+    try {
+      const method = options?.method || "POST";
+      const headers = options?.headers || {};
+      const body = options?.body;
+      const endpoint = `/api/v1/functions/${functionName}/invoke`;
+      let response;
+      switch (method) {
+        case "GET":
+          response = await this.fetch.get(endpoint, { headers });
+          break;
+        case "DELETE":
+          response = await this.fetch.delete(endpoint, { headers });
+          break;
+        case "PUT":
+          response = await this.fetch.put(endpoint, body, { headers });
+          break;
+        case "PATCH":
+          response = await this.fetch.patch(endpoint, body, { headers });
+          break;
+        case "POST":
+        default:
+          response = await this.fetch.post(endpoint, body, { headers });
+          break;
+      }
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new edge function
+   *
+   * @param request - Function configuration and code
+   * @returns Promise resolving to { data, error } tuple with created function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.create({
+   *   name: 'my-function',
+   *   code: 'export default async function handler(req) { return { hello: "world" } }',
+   *   enabled: true
+   * })
+   * ```
+   */
+  async create(request) {
+    try {
+      const data = await this.fetch.post("/api/v1/functions", request);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all edge functions
+   *
+   * @returns Promise resolving to { data, error } tuple with array of functions
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.list()
+   * if (data) {
+   *   console.log('Functions:', data.map(f => f.name))
+   * }
+   * ```
+   */
+  async list() {
+    try {
+      const data = await this.fetch.get("/api/v1/functions");
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific edge function
+   *
+   * @param name - Function name
+   * @returns Promise resolving to { data, error } tuple with function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.get('my-function')
+   * if (data) {
+   *   console.log('Function version:', data.version)
+   * }
+   * ```
+   */
+  async get(name) {
+    try {
+      const data = await this.fetch.get(`/api/v1/functions/${name}`);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an existing edge function
+   *
+   * @param name - Function name
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.update('my-function', {
+   *   enabled: false,
+   *   description: 'Updated description'
+   * })
+   * ```
+   */
+  async update(name, updates) {
+    try {
+      const data = await this.fetch.put(`/api/v1/functions/${name}`, updates);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete an edge function
+   *
+   * @param name - Function name
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.delete('my-function')
+   * ```
+   */
+  async delete(name) {
+    try {
+      await this.fetch.delete(`/api/v1/functions/${name}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution history for an edge function
+   *
+   * @param name - Function name
+   * @param limit - Maximum number of executions to return (optional)
+   * @returns Promise resolving to { data, error } tuple with execution records
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.functions.getExecutions('my-function', 10)
+   * if (data) {
+   *   data.forEach(exec => {
+   *     console.log(`${exec.executed_at}: ${exec.status} (${exec.duration_ms}ms)`)
+   *   })
+   * }
+   * ```
+   */
+  async getExecutions(name, limit) {
+    try {
+      const params = limit ? `?limit=${limit}` : "";
+      const data = await this.fetch.get(
+        `/api/v1/functions/${name}/executions${params}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/settings.ts
+var SystemSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List all system settings
+   *
+   * @returns Promise resolving to ListSystemSettingsResponse
+   *
+   * @example
+   * ```typescript
+   * const response = await client.admin.settings.system.list()
+   * console.log(response.settings)
+   * ```
+   */
+  async list() {
+    const settings = await this.fetch.get(
+      "/api/v1/admin/system/settings"
+    );
+    return { settings: Array.isArray(settings) ? settings : [] };
+  }
+  /**
+   * Get a specific system setting by key
+   *
+   * @param key - Setting key (e.g., 'app.auth.enable_signup')
+   * @returns Promise resolving to SystemSetting
+   *
+   * @example
+   * ```typescript
+   * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
+   * console.log(setting.value)
+   * ```
+   */
+  async get(key) {
+    return await this.fetch.get(
+      `/api/v1/admin/system/settings/${key}`
+    );
+  }
+  /**
+   * Update or create a system setting
+   *
+   * @param key - Setting key
+   * @param request - Update request with value and optional description
+   * @returns Promise resolving to SystemSetting
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.admin.settings.system.update('app.auth.enable_signup', {
+   *   value: { value: true },
+   *   description: 'Enable user signup'
+   * })
+   * ```
+   */
+  async update(key, request) {
+    return await this.fetch.put(
+      `/api/v1/admin/system/settings/${key}`,
+      request
+    );
+  }
+  /**
+   * Delete a system setting
+   *
+   * @param key - Setting key to delete
+   * @returns Promise<void>
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.system.delete('app.auth.enable_signup')
+   * ```
+   */
+  async delete(key) {
+    await this.fetch.delete(`/api/v1/admin/system/settings/${key}`);
+  }
+};
+var AppSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Get all application settings
+   *
+   * Returns structured settings for authentication, features, email, and security.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * const settings = await client.admin.settings.app.get()
+   *
+   * console.log('Signup enabled:', settings.authentication.enable_signup)
+   * console.log('Realtime enabled:', settings.features.enable_realtime)
+   * console.log('Email provider:', settings.email.provider)
+   * ```
+   */
+  async get() {
+    return await this.fetch.get("/api/v1/admin/app/settings");
+  }
+  /**
+   * Update application settings
+   *
+   * Supports partial updates - only provide the fields you want to change.
+   *
+   * @param request - Settings to update (partial update supported)
+   * @returns Promise resolving to AppSettings - Updated settings
+   *
+   * @example
+   * ```typescript
+   * // Update authentication settings
+   * const updated = await client.admin.settings.app.update({
+   *   authentication: {
+   *     enable_signup: true,
+   *     password_min_length: 12
+   *   }
+   * })
+   *
+   * // Update multiple categories
+   * await client.admin.settings.app.update({
+   *   authentication: { enable_signup: false },
+   *   features: { enable_realtime: true },
+   *   security: { enable_global_rate_limit: true }
+   * })
+   * ```
+   */
+  async update(request) {
+    return await this.fetch.put(
+      "/api/v1/admin/app/settings",
+      request
+    );
+  }
+  /**
+   * Reset all application settings to defaults
+   *
+   * This will delete all custom settings and return to default values.
+   *
+   * @returns Promise resolving to AppSettings - Default settings
+   *
+   * @example
+   * ```typescript
+   * const defaults = await client.admin.settings.app.reset()
+   * console.log('Settings reset to defaults:', defaults)
+   * ```
+   */
+  async reset() {
+    return await this.fetch.post(
+      "/api/v1/admin/app/settings/reset",
+      {}
+    );
+  }
+  /**
+   * Enable user signup
+   *
+   * Convenience method to enable user registration.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.enableSignup()
+   * ```
+   */
+  async enableSignup() {
+    return await this.update({
+      authentication: { enable_signup: true }
+    });
+  }
+  /**
+   * Disable user signup
+   *
+   * Convenience method to disable user registration.
+   *
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.disableSignup()
+   * ```
+   */
+  async disableSignup() {
+    return await this.update({
+      authentication: { enable_signup: false }
+    });
+  }
+  /**
+   * Update password minimum length
+   *
+   * Convenience method to set password requirements.
+   *
+   * @param length - Minimum password length (8-128 characters)
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.setPasswordMinLength(12)
+   * ```
+   */
+  async setPasswordMinLength(length) {
+    if (length < 8 || length > 128) {
+      throw new Error(
+        "Password minimum length must be between 8 and 128 characters"
+      );
+    }
+    return await this.update({
+      authentication: { password_min_length: length }
+    });
+  }
+  /**
+   * Enable or disable a feature
+   *
+   * Convenience method to toggle feature flags.
+   *
+   * @param feature - Feature name ('realtime' | 'storage' | 'functions')
+   * @param enabled - Whether to enable or disable the feature
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * // Enable realtime
+   * await client.admin.settings.app.setFeature('realtime', true)
+   *
+   * // Disable storage
+   * await client.admin.settings.app.setFeature('storage', false)
+   * ```
+   */
+  async setFeature(feature, enabled) {
+    const featureKey = feature === "realtime" ? "enable_realtime" : feature === "storage" ? "enable_storage" : "enable_functions";
+    return await this.update({
+      features: { [featureKey]: enabled }
+    });
+  }
+  /**
+   * Enable or disable global rate limiting
+   *
+   * Convenience method to toggle global rate limiting.
+   *
+   * @param enabled - Whether to enable rate limiting
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.setRateLimiting(true)
+   * ```
+   */
+  async setRateLimiting(enabled) {
+    return await this.update({
+      security: { enable_global_rate_limit: enabled }
+    });
+  }
+  /**
+   * Configure SMTP email provider
+   *
+   * Convenience method to set up SMTP email delivery.
+   *
+   * @param config - SMTP configuration
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.configureSMTP({
+   *   host: 'smtp.gmail.com',
+   *   port: 587,
+   *   username: 'your-email@gmail.com',
+   *   password: 'your-app-password',
+   *   use_tls: true,
+   *   from_address: 'noreply@yourapp.com',
+   *   from_name: 'Your App'
+   * })
+   * ```
+   */
+  async configureSMTP(config) {
+    return await this.update({
+      email: {
+        enabled: true,
+        provider: "smtp",
+        from_address: config.from_address,
+        from_name: config.from_name,
+        reply_to_address: config.reply_to_address,
+        smtp: {
+          host: config.host,
+          port: config.port,
+          username: config.username,
+          password: config.password,
+          use_tls: config.use_tls
+        }
+      }
+    });
+  }
+  /**
+   * Configure SendGrid email provider
+   *
+   * Convenience method to set up SendGrid email delivery.
+   *
+   * @param apiKey - SendGrid API key
+   * @param options - Optional from address, name, and reply-to
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.configureSendGrid('SG.xxx', {
+   *   from_address: 'noreply@yourapp.com',
+   *   from_name: 'Your App'
+   * })
+   * ```
+   */
+  async configureSendGrid(apiKey, options) {
+    return await this.update({
+      email: {
+        enabled: true,
+        provider: "sendgrid",
+        from_address: options?.from_address,
+        from_name: options?.from_name,
+        reply_to_address: options?.reply_to_address,
+        sendgrid: {
+          api_key: apiKey
+        }
+      }
+    });
+  }
+  /**
+   * Configure Mailgun email provider
+   *
+   * Convenience method to set up Mailgun email delivery.
+   *
+   * @param apiKey - Mailgun API key
+   * @param domain - Mailgun domain
+   * @param options - Optional EU region flag and email addresses
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.configureMailgun('key-xxx', 'mg.yourapp.com', {
+   *   eu_region: false,
+   *   from_address: 'noreply@yourapp.com',
+   *   from_name: 'Your App'
+   * })
+   * ```
+   */
+  async configureMailgun(apiKey, domain, options) {
+    return await this.update({
+      email: {
+        enabled: true,
+        provider: "mailgun",
+        from_address: options?.from_address,
+        from_name: options?.from_name,
+        reply_to_address: options?.reply_to_address,
+        mailgun: {
+          api_key: apiKey,
+          domain,
+          eu_region: options?.eu_region ?? false
+        }
+      }
+    });
+  }
+  /**
+   * Configure AWS SES email provider
+   *
+   * Convenience method to set up AWS SES email delivery.
+   *
+   * @param accessKeyId - AWS access key ID
+   * @param secretAccessKey - AWS secret access key
+   * @param region - AWS region (e.g., 'us-east-1')
+   * @param options - Optional email addresses
+   * @returns Promise resolving to AppSettings
+   *
+   * @example
+   * ```typescript
+   * await client.admin.settings.app.configureSES(
+   *   'AKIAIOSFODNN7EXAMPLE',
+   *   'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+   *   'us-east-1',
+   *   {
+   *     from_address: 'noreply@yourapp.com',
+   *     from_name: 'Your App'
+   *   }
+   * )
+   * ```
+   */
+  async configureSES(accessKeyId, secretAccessKey, region, options) {
+    return await this.update({
+      email: {
+        enabled: true,
+        provider: "ses",
+        from_address: options?.from_address,
+        from_name: options?.from_name,
+        reply_to_address: options?.reply_to_address,
+        ses: {
+          access_key_id: accessKeyId,
+          secret_access_key: secretAccessKey,
+          region
+        }
+      }
+    });
+  }
+  /**
+   * Enable or disable email functionality
    *
-   * @returns Promise resolving to ListSystemSettingsResponse
+   * Convenience method to toggle email system on/off.
+   *
+   * @param enabled - Whether to enable email
+   * @returns Promise resolving to AppSettings
    *
    * @example
    * ```typescript
-   * const response = await client.admin.settings.system.list()
-   * console.log(response.settings)
+   * await client.admin.settings.app.setEmailEnabled(true)
    * ```
    */
-  async list() {
-    const settings = await this.fetch.get("/api/v1/admin/system/settings");
-    return { settings: Array.isArray(settings) ? settings : [] };
+  async setEmailEnabled(enabled) {
+    return await this.update({
+      email: { enabled }
+    });
   }
   /**
-   * Get a specific system setting by key
+   * Configure password complexity requirements
    *
-   * @param key - Setting key (e.g., 'app.auth.enable_signup')
-   * @returns Promise resolving to SystemSetting
+   * Convenience method to set password validation rules.
+   *
+   * @param requirements - Password complexity requirements
+   * @returns Promise resolving to AppSettings
    *
    * @example
    * ```typescript
-   * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
-   * console.log(setting.value)
+   * await client.admin.settings.app.setPasswordComplexity({
+   *   min_length: 12,
+   *   require_uppercase: true,
+   *   require_lowercase: true,
+   *   require_number: true,
+   *   require_special: true
+   * })
    * ```
    */
-  async get(key) {
-    return await this.fetch.get(`/api/v1/admin/system/settings/${key}`);
+  async setPasswordComplexity(requirements) {
+    return await this.update({
+      authentication: {
+        password_min_length: requirements.min_length,
+        password_require_uppercase: requirements.require_uppercase,
+        password_require_lowercase: requirements.require_lowercase,
+        password_require_number: requirements.require_number,
+        password_require_special: requirements.require_special
+      }
+    });
   }
   /**
-   * Update or create a system setting
+   * Configure session settings
    *
-   * @param key - Setting key
-   * @param request - Update request with value and optional description
-   * @returns Promise resolving to SystemSetting
+   * Convenience method to set session timeout and limits.
+   *
+   * @param timeoutMinutes - Session timeout in minutes (0 for no timeout)
+   * @param maxSessionsPerUser - Maximum concurrent sessions per user (0 for unlimited)
+   * @returns Promise resolving to AppSettings
    *
    * @example
    * ```typescript
-   * const updated = await client.admin.settings.system.update('app.auth.enable_signup', {
-   *   value: { value: true },
-   *   description: 'Enable user signup'
-   * })
+   * // 30 minute sessions, max 3 devices per user
+   * await client.admin.settings.app.setSessionSettings(30, 3)
    * ```
    */
-  async update(key, request) {
-    return await this.fetch.put(`/api/v1/admin/system/settings/${key}`, request);
+  async setSessionSettings(timeoutMinutes, maxSessionsPerUser) {
+    return await this.update({
+      authentication: {
+        session_timeout_minutes: timeoutMinutes,
+        max_sessions_per_user: maxSessionsPerUser
+      }
+    });
   }
   /**
-   * Delete a system setting
+   * Enable or disable email verification requirement
    *
-   * @param key - Setting key to delete
-   * @returns Promise<void>
+   * Convenience method to require email verification for new signups.
+   *
+   * @param required - Whether to require email verification
+   * @returns Promise resolving to AppSettings
    *
    * @example
    * ```typescript
-   * await client.admin.settings.system.delete('app.auth.enable_signup')
+   * await client.admin.settings.app.setEmailVerificationRequired(true)
    * ```
    */
-  async delete(key) {
-    await this.fetch.delete(`/api/v1/admin/system/settings/${key}`);
+  async setEmailVerificationRequired(required) {
+    return await this.update({
+      authentication: { require_email_verification: required }
+    });
   }
 };
-var AppSettingsManager = class {
+var CustomSettingsManager = class {
   constructor(fetch2) {
     this.fetch = fetch2;
   }
   /**
-   * Get all application settings
-   *
-   * Returns structured settings for authentication, features, email, and security.
+   * Create a new custom setting
    *
-   * @returns Promise resolving to AppSettings
+   * @param request - Custom setting creation request
+   * @returns Promise resolving to CustomSetting
    *
    * @example
    * ```typescript
-   * const settings = await client.admin.settings.app.get()
-   *
-   * console.log('Signup enabled:', settings.authentication.enable_signup)
-   * console.log('Realtime enabled:', settings.features.enable_realtime)
-   * console.log('Email provider:', settings.email.provider)
+   * const setting = await client.admin.settings.custom.create({
+   *   key: 'api.quotas',
+   *   value: { free: 1000, pro: 10000, enterprise: 100000 },
+   *   value_type: 'json',
+   *   description: 'API request quotas by tier',
+   *   metadata: { category: 'billing' }
+   * })
    * ```
    */
-  async get() {
-    return await this.fetch.get("/api/v1/admin/app/settings");
+  async create(request) {
+    return await this.fetch.post(
+      "/api/v1/admin/settings/custom",
+      request
+    );
   }
   /**
-   * Update application settings
+   * List all custom settings
    *
-   * Supports partial updates - only provide the fields you want to change.
+   * @returns Promise resolving to ListCustomSettingsResponse
    *
-   * @param request - Settings to update (partial update supported)
-   * @returns Promise resolving to AppSettings - Updated settings
+   * @example
+   * ```typescript
+   * const response = await client.admin.settings.custom.list()
+   * console.log(response.settings)
+   * ```
+   */
+  async list() {
+    const settings = await this.fetch.get(
+      "/api/v1/admin/settings/custom"
+    );
+    return { settings: Array.isArray(settings) ? settings : [] };
+  }
+  /**
+   * Get a specific custom setting by key
+   *
+   * @param key - Setting key (e.g., 'feature.dark_mode')
+   * @returns Promise resolving to CustomSetting
    *
    * @example
    * ```typescript
-   * // Update authentication settings
-   * const updated = await client.admin.settings.app.update({
-   *   authentication: {
-   *     enable_signup: true,
-   *     password_min_length: 12
-   *   }
-   * })
+   * const setting = await client.admin.settings.custom.get('feature.dark_mode')
+   * console.log(setting.value)
+   * ```
+   */
+  async get(key) {
+    return await this.fetch.get(
+      `/api/v1/admin/settings/custom/${key}`
+    );
+  }
+  /**
+   * Update an existing custom setting
    *
-   * // Update multiple categories
-   * await client.admin.settings.app.update({
-   *   authentication: { enable_signup: false },
-   *   features: { enable_realtime: true },
-   *   security: { enable_global_rate_limit: true }
+   * @param key - Setting key
+   * @param request - Update request with new values
+   * @returns Promise resolving to CustomSetting
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.admin.settings.custom.update('feature.dark_mode', {
+   *   value: { enabled: false },
+   *   description: 'Updated description'
    * })
    * ```
    */
-  async update(request) {
-    return await this.fetch.put("/api/v1/admin/app/settings", request);
+  async update(key, request) {
+    return await this.fetch.put(
+      `/api/v1/admin/settings/custom/${key}`,
+      request
+    );
   }
   /**
-   * Reset all application settings to defaults
-   *
-   * This will delete all custom settings and return to default values.
+   * Delete a custom setting
    *
-   * @returns Promise resolving to AppSettings - Default settings
+   * @param key - Setting key to delete
+   * @returns Promise<void>
    *
    * @example
    * ```typescript
-   * const defaults = await client.admin.settings.app.reset()
-   * console.log('Settings reset to defaults:', defaults)
+   * await client.admin.settings.custom.delete('feature.dark_mode')
    * ```
    */
-  async reset() {
-    return await this.fetch.post("/api/v1/admin/app/settings/reset", {});
+  async delete(key) {
+    await this.fetch.delete(`/api/v1/admin/settings/custom/${key}`);
+  }
+};
+var EmailTemplateManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
   }
   /**
-   * Enable user signup
-   *
-   * Convenience method to enable user registration.
+   * List all email templates
    *
-   * @returns Promise resolving to AppSettings
+   * @returns Promise resolving to ListEmailTemplatesResponse
    *
    * @example
    * ```typescript
-   * await client.admin.settings.app.enableSignup()
+   * const response = await client.admin.emailTemplates.list()
+   * console.log(response.templates)
    * ```
    */
-  async enableSignup() {
-    return await this.update({
-      authentication: { enable_signup: true }
-    });
+  async list() {
+    const templates = await this.fetch.get(
+      "/api/v1/admin/email/templates"
+    );
+    return { templates: Array.isArray(templates) ? templates : [] };
   }
   /**
-   * Disable user signup
-   *
-   * Convenience method to disable user registration.
+   * Get a specific email template by type
    *
-   * @returns Promise resolving to AppSettings
+   * @param type - Template type (magic_link | verify_email | reset_password | invite_user)
+   * @returns Promise resolving to EmailTemplate
    *
    * @example
    * ```typescript
-   * await client.admin.settings.app.disableSignup()
+   * const template = await client.admin.emailTemplates.get('magic_link')
+   * console.log(template.subject)
+   * console.log(template.html_body)
    * ```
    */
-  async disableSignup() {
-    return await this.update({
-      authentication: { enable_signup: false }
-    });
+  async get(type) {
+    return await this.fetch.get(
+      `/api/v1/admin/email/templates/${type}`
+    );
   }
   /**
-   * Update password minimum length
+   * Update an email template
    *
-   * Convenience method to set password requirements.
+   * Available template variables:
+   * - magic_link: `{{.MagicLink}}`, `{{.AppName}}`, `{{.ExpiryMinutes}}`
+   * - verify_email: `{{.VerificationLink}}`, `{{.AppName}}`
+   * - reset_password: `{{.ResetLink}}`, `{{.AppName}}`, `{{.ExpiryMinutes}}`
+   * - invite_user: `{{.InviteLink}}`, `{{.AppName}}`, `{{.InviterName}}`
    *
-   * @param length - Minimum password length (8-128 characters)
-   * @returns Promise resolving to AppSettings
+   * @param type - Template type to update
+   * @param request - Update request with subject, html_body, and optional text_body
+   * @returns Promise resolving to EmailTemplate
    *
    * @example
    * ```typescript
-   * await client.admin.settings.app.setPasswordMinLength(12)
+   * const updated = await client.admin.emailTemplates.update('magic_link', {
+   *   subject: 'Your Magic Link - Sign in to ' + '{{.AppName}}',
+   *   html_body: '<html><body><h1>Welcome!</h1><a href="' + '{{.MagicLink}}' + '">Sign In</a></body></html>',
+   *   text_body: 'Click here to sign in: ' + '{{.MagicLink}}'
+   * })
    * ```
    */
-  async setPasswordMinLength(length) {
-    if (length < 8 || length > 128) {
-      throw new Error("Password minimum length must be between 8 and 128 characters");
-    }
-    return await this.update({
-      authentication: { password_min_length: length }
-    });
+  async update(type, request) {
+    return await this.fetch.put(
+      `/api/v1/admin/email/templates/${type}`,
+      request
+    );
   }
   /**
-   * Enable or disable a feature
+   * Reset an email template to default
    *
-   * Convenience method to toggle feature flags.
+   * Removes any customizations and restores the template to its original state.
    *
-   * @param feature - Feature name ('realtime' | 'storage' | 'functions')
-   * @param enabled - Whether to enable or disable the feature
-   * @returns Promise resolving to AppSettings
+   * @param type - Template type to reset
+   * @returns Promise resolving to EmailTemplate - The default template
    *
    * @example
    * ```typescript
-   * // Enable realtime
-   * await client.admin.settings.app.setFeature('realtime', true)
-   *
-   * // Disable storage
-   * await client.admin.settings.app.setFeature('storage', false)
+   * const defaultTemplate = await client.admin.emailTemplates.reset('magic_link')
    * ```
    */
-  async setFeature(feature, enabled) {
-    const featureKey = feature === "realtime" ? "enable_realtime" : feature === "storage" ? "enable_storage" : "enable_functions";
-    return await this.update({
-      features: { [featureKey]: enabled }
-    });
+  async reset(type) {
+    return await this.fetch.post(
+      `/api/v1/admin/email/templates/${type}/reset`,
+      {}
+    );
   }
   /**
-   * Enable or disable global rate limiting
+   * Send a test email using the template
    *
-   * Convenience method to toggle global rate limiting.
+   * Useful for previewing template changes before deploying to production.
    *
-   * @param enabled - Whether to enable rate limiting
-   * @returns Promise resolving to AppSettings
+   * @param type - Template type to test
+   * @param recipientEmail - Email address to send test to
+   * @returns Promise<void>
    *
    * @example
    * ```typescript
-   * await client.admin.settings.app.setRateLimiting(true)
+   * await client.admin.emailTemplates.test('magic_link', 'test@example.com')
    * ```
    */
-  async setRateLimiting(enabled) {
-    return await this.update({
-      security: { enable_global_rate_limit: enabled }
+  async test(type, recipientEmail) {
+    await this.fetch.post(`/api/v1/admin/email/templates/${type}/test`, {
+      recipient_email: recipientEmail
     });
   }
 };
@@ -1218,6 +2152,7 @@ var FluxbaseSettings = class {
   constructor(fetch2) {
     this.system = new SystemSettingsManager(fetch2);
     this.app = new AppSettingsManager(fetch2);
+    this.custom = new CustomSettingsManager(fetch2);
   }
 };
 
@@ -2240,6 +3175,7 @@ var FluxbaseAdmin = class {
     this.oauth = new FluxbaseOAuth(fetch2);
     this.impersonation = new ImpersonationManager(fetch2);
     this.management = new FluxbaseManagement(fetch2);
+    this.emailTemplates = new EmailTemplateManager(fetch2);
   }
   /**
    * Set admin authentication token
@@ -2278,9 +3214,11 @@ var FluxbaseAdmin = class {
    * ```
    */
   async getSetupStatus() {
-    return await this.fetch.get(
-      "/api/v1/admin/setup/status"
-    );
+    return wrapAsync(async () => {
+      return await this.fetch.get(
+        "/api/v1/admin/setup/status"
+      );
+    });
   }
   /**
    * Perform initial admin setup
@@ -2306,12 +3244,14 @@ var FluxbaseAdmin = class {
    * ```
    */
   async setup(request) {
-    const response = await this.fetch.post(
-      "/api/v1/admin/setup",
-      request
-    );
-    this.setToken(response.access_token);
-    return response;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/admin/setup",
+        request
+      );
+      this.setToken(response.access_token);
+      return response;
+    });
   }
   /**
    * Admin login
@@ -2334,12 +3274,14 @@ var FluxbaseAdmin = class {
    * ```
    */
   async login(request) {
-    const response = await this.fetch.post(
-      "/api/v1/admin/login",
-      request
-    );
-    this.setToken(response.access_token);
-    return response;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/admin/login",
+        request
+      );
+      this.setToken(response.access_token);
+      return response;
+    });
   }
   /**
    * Refresh admin access token
@@ -2358,12 +3300,14 @@ var FluxbaseAdmin = class {
    * ```
    */
   async refreshToken(request) {
-    const response = await this.fetch.post(
-      "/api/v1/admin/refresh",
-      request
-    );
-    this.setToken(response.access_token);
-    return response;
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/admin/refresh",
+        request
+      );
+      this.setToken(response.access_token);
+      return response;
+    });
   }
   /**
    * Admin logout
@@ -2377,8 +3321,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async logout() {
-    await this.fetch.post("/api/v1/admin/logout", {});
-    this.clearToken();
+    return wrapAsyncVoid(async () => {
+      await this.fetch.post("/api/v1/admin/logout", {});
+      this.clearToken();
+    });
   }
   /**
    * Get current admin user information
@@ -2393,7 +3339,9 @@ var FluxbaseAdmin = class {
    * ```
    */
   async me() {
-    return await this.fetch.get("/api/v1/admin/me");
+    return wrapAsync(async () => {
+      return await this.fetch.get("/api/v1/admin/me");
+    });
   }
   // ============================================================================
   // User Management
@@ -2419,22 +3367,24 @@ var FluxbaseAdmin = class {
    * ```
    */
   async listUsers(options = {}) {
-    const params = new URLSearchParams();
-    if (options.exclude_admins !== void 0) {
-      params.append("exclude_admins", String(options.exclude_admins));
-    }
-    if (options.search) {
-      params.append("search", options.search);
-    }
-    if (options.limit !== void 0) {
-      params.append("limit", String(options.limit));
-    }
-    if (options.type) {
-      params.append("type", options.type);
-    }
-    const queryString = params.toString();
-    const url = queryString ? `/api/v1/admin/users?${queryString}` : "/api/v1/admin/users";
-    return await this.fetch.get(url);
+    return wrapAsync(async () => {
+      const params = new URLSearchParams();
+      if (options.exclude_admins !== void 0) {
+        params.append("exclude_admins", String(options.exclude_admins));
+      }
+      if (options.search) {
+        params.append("search", options.search);
+      }
+      if (options.limit !== void 0) {
+        params.append("limit", String(options.limit));
+      }
+      if (options.type) {
+        params.append("type", options.type);
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/api/v1/admin/users?${queryString}` : "/api/v1/admin/users";
+      return await this.fetch.get(url);
+    });
   }
   /**
    * Get a user by ID
@@ -2457,8 +3407,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async getUserById(userId, type = "app") {
-    const url = `/api/v1/admin/users/${userId}?type=${type}`;
-    return await this.fetch.get(url);
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}?type=${type}`;
+      return await this.fetch.get(url);
+    });
   }
   /**
    * Invite a new user
@@ -2482,8 +3434,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async inviteUser(request, type = "app") {
-    const url = `/api/v1/admin/users/invite?type=${type}`;
-    return await this.fetch.post(url, request);
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/invite?type=${type}`;
+      return await this.fetch.post(url, request);
+    });
   }
   /**
    * Delete a user
@@ -2501,8 +3455,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async deleteUser(userId, type = "app") {
-    const url = `/api/v1/admin/users/${userId}?type=${type}`;
-    return await this.fetch.delete(url);
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}?type=${type}`;
+      return await this.fetch.delete(url);
+    });
   }
   /**
    * Update user role
@@ -2521,8 +3477,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async updateUserRole(userId, role, type = "app") {
-    const url = `/api/v1/admin/users/${userId}/role?type=${type}`;
-    return await this.fetch.patch(url, { role });
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}/role?type=${type}`;
+      return await this.fetch.patch(url, { role });
+    });
   }
   /**
    * Reset user password
@@ -2540,8 +3498,10 @@ var FluxbaseAdmin = class {
    * ```
    */
   async resetUserPassword(userId, type = "app") {
-    const url = `/api/v1/admin/users/${userId}/reset-password?type=${type}`;
-    return await this.fetch.post(url, {});
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}/reset-password?type=${type}`;
+      return await this.fetch.post(url, {});
+    });
   }
 };
 
@@ -3099,24 +4059,47 @@ var QueryBuilder = class {
 var FluxbaseClient = class {
   /**
    * Create a new Fluxbase client instance
-   * @param options - Client configuration options
+   *
+   * @param fluxbaseUrl - The URL of your Fluxbase instance
+   * @param fluxbaseKey - The anon key (JWT token with "anon" role). Generate using scripts/generate-keys.sh
+   * @param options - Additional client configuration options
+   *
+   * @example
+   * ```typescript
+   * const client = new FluxbaseClient(
+   *   'http://localhost:8080',
+   *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',  // Anon JWT token
+   *   { timeout: 30000 }
+   * )
+   * ```
    */
-  constructor(options) {
-    this.fetch = new FluxbaseFetch(options.url, {
-      headers: options.headers,
-      timeout: options.timeout,
-      debug: options.debug
+  constructor(fluxbaseUrl, fluxbaseKey, options) {
+    this.fluxbaseUrl = fluxbaseUrl;
+    this.fluxbaseKey = fluxbaseKey;
+    const headers = {
+      "apikey": fluxbaseKey,
+      "Authorization": `Bearer ${fluxbaseKey}`,
+      ...options?.headers
+    };
+    this.fetch = new FluxbaseFetch(fluxbaseUrl, {
+      headers,
+      timeout: options?.timeout,
+      debug: options?.debug
     });
     this.auth = new FluxbaseAuth(
       this.fetch,
-      options.auth?.autoRefresh ?? true,
-      options.auth?.persist ?? true
+      options?.auth?.autoRefresh ?? true,
+      options?.auth?.persist ?? true
     );
-    if (options.auth?.token) {
+    if (options?.auth?.token) {
       this.fetch.setAuthToken(options.auth.token);
     }
-    this.realtime = new FluxbaseRealtime(options.url, options.auth?.token || null);
+    this.realtime = new FluxbaseRealtime(
+      fluxbaseUrl,
+      options?.auth?.token || null
+    );
     this.storage = new FluxbaseStorage(this.fetch);
+    this.functions = new FluxbaseFunctions(this.fetch);
     this.admin = new FluxbaseAdmin(this.fetch);
     this.management = new FluxbaseManagement(this.fetch);
     this.setupAuthSync();
@@ -3171,7 +4154,10 @@ var FluxbaseClient = class {
    */
   async rpc(functionName, params) {
     try {
-      const data = await this.fetch.post(`/api/v1/rpc/${functionName}`, params || {});
+      const data = await this.fetch.post(
+        `/api/v1/rpc/${functionName}`,
+        params || {}
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -3211,6 +4197,36 @@ var FluxbaseClient = class {
     this.fetch.setAuthToken(token);
     this.realtime.setToken(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
+   *
+   * @param name - Channel name
+   * @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)
+   *   })
+   *   .subscribe()
+   * ```
+   *
+   * @category Realtime
+   */
+  channel(name) {
+    return this.realtime.channel(name);
+  }
   /**
    * Get the internal HTTP client
    *
@@ -3230,18 +4246,24 @@ var FluxbaseClient = class {
     return this.fetch;
   }
 };
-function createClient(options) {
-  return new FluxbaseClient(options);
+function createClient(fluxbaseUrl, fluxbaseKey, options) {
+  return new FluxbaseClient(
+    fluxbaseUrl,
+    fluxbaseKey,
+    options
+  );
 }
 
 exports.APIKeysManager = APIKeysManager;
 exports.AppSettingsManager = AppSettingsManager;
 exports.AuthSettingsManager = AuthSettingsManager;
 exports.DDLManager = DDLManager;
+exports.EmailTemplateManager = EmailTemplateManager;
 exports.FluxbaseAdmin = FluxbaseAdmin;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
+exports.FluxbaseFunctions = FluxbaseFunctions;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;
 exports.FluxbaseRealtime = FluxbaseRealtime;