@fluxbase/sdk 0.0.1-rc.17 → 0.0.1-rc.19

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,17 +210,19 @@ 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
@@ -211,70 +236,81 @@ var FluxbaseAuth = class {
    * 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 session = {
-      ...response,
-      expires_at: Date.now() + response.expires_in * 1e3
-    };
-    this.setSession(session, "TOKEN_REFRESHED");
-    return session;
+      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 };
+    });
   }
   /**
    * 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
@@ -287,65 +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
@@ -353,10 +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
@@ -364,12 +420,14 @@ 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
+        }
+      );
+    });
   }
   /**
    * Reset password with token
@@ -378,13 +436,15 @@ 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
+        }
+      );
+    });
   }
   /**
    * Send magic link for passwordless authentication
@@ -392,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
+        }
+      );
     });
   }
   /**
@@ -402,41 +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
-      }
-    );
-    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/magiclink/verify",
+        {
+          token
+        }
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSession(session);
+      return { user: session.user, 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
@@ -444,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
@@ -462,16 +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
@@ -480,14 +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
@@ -535,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);
     }
   }
@@ -3131,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
@@ -3159,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
@@ -3187,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
@@ -3211,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
@@ -3230,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
@@ -3246,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
@@ -3272,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
@@ -3310,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
@@ -3335,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
@@ -3354,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
@@ -3374,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
@@ -3393,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, {});
+    });
   }
 };
 
@@ -3952,25 +4059,44 @@ 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
+      fluxbaseUrl,
+      options?.auth?.token || null
     );
     this.storage = new FluxbaseStorage(this.fetch);
     this.functions = new FluxbaseFunctions(this.fetch);
@@ -4120,8 +4246,12 @@ 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;