@fluxbase/sdk 0.0.1-rc.106 → 0.0.1-rc.108

package/dist/index.cjs

@@ -476,7 +476,14 @@ var FluxbaseAuth = class {
    */
   async signIn(credentials) {
     return wrapAsync(async () => {
-      const response = await this.fetch.post("/api/v1/auth/signin", credentials);
+      const requestBody = {
+        email: credentials.email,
+        password: credentials.password
+      };
+      if (credentials.captchaToken) {
+        requestBody.captcha_token = credentials.captchaToken;
+      }
+      const response = await this.fetch.post("/api/v1/auth/signin", requestBody);
       if ("requires_2fa" in response && response.requires_2fa) {
         return response;
       }
@@ -511,6 +518,9 @@ var FluxbaseAuth = class {
       if (credentials.options?.data) {
         requestBody.user_metadata = credentials.options.data;
       }
+      if (credentials.captchaToken) {
+        requestBody.captcha_token = credentials.captchaToken;
+      }
       const response = await this.fetch.post(
         "/api/v1/auth/signup",
         requestBody
@@ -526,6 +536,16 @@ var FluxbaseAuth = class {
       return { user: response.user, session: null };
     });
   }
+  /**
+   * Get CAPTCHA configuration from the server
+   * Use this to determine which CAPTCHA provider to load and configure
+   * @returns Promise with CAPTCHA configuration (provider, site key, enabled endpoints)
+   */
+  async getCaptchaConfig() {
+    return wrapAsync(async () => {
+      return await this.fetch.get("/api/v1/auth/captcha/config");
+    });
+  }
   /**
    * Sign out the current user
    */
@@ -737,22 +757,29 @@ var FluxbaseAuth = class {
    * Send password reset email (Supabase-compatible)
    * Sends a password reset link to the provided email address
    * @param email - Email address to send reset link to
+   * @param options - Optional configuration including CAPTCHA token
    * @returns Promise with OTP-style response
    */
-  async sendPasswordReset(email) {
+  async sendPasswordReset(email, options) {
     return wrapAsync(async () => {
-      await this.fetch.post("/api/v1/auth/password/reset", { email });
+      const requestBody = { email };
+      if (options?.captchaToken) {
+        requestBody.captcha_token = options.captchaToken;
+      }
+      await this.fetch.post("/api/v1/auth/password/reset", requestBody);
       return { user: null, session: null };
     });
   }
   /**
    * Supabase-compatible alias for sendPasswordReset()
    * @param email - Email address to send reset link to
-   * @param _options - Optional redirect configuration (currently not used)
+   * @param options - Optional redirect and CAPTCHA configuration
    * @returns Promise with OTP-style response
    */
-  async resetPasswordForEmail(email, _options) {
-    return this.sendPasswordReset(email);
+  async resetPasswordForEmail(email, options) {
+    return this.sendPasswordReset(email, {
+      captchaToken: options?.captchaToken
+    });
   }
   /**
    * Verify password reset token
@@ -801,10 +828,14 @@ var FluxbaseAuth = class {
    */
   async sendMagicLink(email, options) {
     return wrapAsync(async () => {
-      await this.fetch.post("/api/v1/auth/magiclink", {
+      const requestBody = {
         email,
         redirect_to: options?.redirect_to
-      });
+      };
+      if (options?.captchaToken) {
+        requestBody.captcha_token = options.captchaToken;
+      }
+      await this.fetch.post("/api/v1/auth/magiclink", requestBody);
       return { user: null, session: null };
     });
   }
@@ -1047,6 +1078,139 @@ var FluxbaseAuth = class {
       return { user: session.user, session };
     });
   }
+  // ==========================================================================
+  // SAML SSO Methods
+  // ==========================================================================
+  /**
+   * Get list of available SAML SSO providers
+   * @returns Promise with list of configured SAML providers
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.auth.getSAMLProviders()
+   * if (!error) {
+   *   console.log('Available providers:', data.providers)
+   * }
+   * ```
+   */
+  async getSAMLProviders() {
+    return wrapAsync(async () => {
+      return await this.fetch.get(
+        "/api/v1/auth/saml/providers"
+      );
+    });
+  }
+  /**
+   * Get SAML login URL for a specific provider
+   * Use this to redirect the user to the IdP for authentication
+   * @param provider - SAML provider name/ID
+   * @param options - Optional login configuration
+   * @returns Promise with SAML login URL
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.auth.getSAMLLoginUrl('okta')
+   * if (!error) {
+   *   window.location.href = data.url
+   * }
+   * ```
+   */
+  async getSAMLLoginUrl(provider, options) {
+    return wrapAsync(async () => {
+      const params = new URLSearchParams();
+      if (options?.redirectUrl) {
+        params.append("redirect_url", options.redirectUrl);
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/api/v1/auth/saml/login/${provider}?${queryString}` : `/api/v1/auth/saml/login/${provider}`;
+      const response = await this.fetch.get(url);
+      return response;
+    });
+  }
+  /**
+   * Initiate SAML login and redirect to IdP
+   * This is a convenience method that redirects the user to the SAML IdP
+   * @param provider - SAML provider name/ID
+   * @param options - Optional login configuration
+   * @returns Promise with provider and URL (browser will redirect)
+   *
+   * @example
+   * ```typescript
+   * // In browser, this will redirect to the SAML IdP
+   * await client.auth.signInWithSAML('okta')
+   * ```
+   */
+  async signInWithSAML(provider, options) {
+    return wrapAsync(async () => {
+      const result = await this.getSAMLLoginUrl(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(
+          "signInWithSAML can only be called in a browser environment"
+        );
+      }
+      return { provider, url };
+    });
+  }
+  /**
+   * Handle SAML callback after IdP authentication
+   * Call this from your SAML callback page to complete authentication
+   * @param samlResponse - Base64-encoded SAML response from the ACS endpoint
+   * @param provider - SAML provider name (optional, extracted from RelayState)
+   * @returns Promise with user and session
+   *
+   * @example
+   * ```typescript
+   * // In your SAML callback page
+   * const urlParams = new URLSearchParams(window.location.search)
+   * const samlResponse = urlParams.get('SAMLResponse')
+   *
+   * if (samlResponse) {
+   *   const { data, error } = await client.auth.handleSAMLCallback(samlResponse)
+   *   if (!error) {
+   *     console.log('Logged in:', data.user)
+   *   }
+   * }
+   * ```
+   */
+  async handleSAMLCallback(samlResponse, provider) {
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/auth/saml/acs",
+        {
+          saml_response: samlResponse,
+          provider
+        }
+      );
+      const session = {
+        ...response,
+        expires_at: Date.now() + response.expires_in * 1e3
+      };
+      this.setSessionInternal(session);
+      return { user: session.user, session };
+    });
+  }
+  /**
+   * Get SAML Service Provider metadata for a specific provider configuration
+   * Use this when configuring your IdP to download the SP metadata XML
+   * @param provider - SAML provider name/ID
+   * @returns Promise with SP metadata URL
+   *
+   * @example
+   * ```typescript
+   * const metadataUrl = client.auth.getSAMLMetadataUrl('okta')
+   * // Share this URL with your IdP administrator
+   * ```
+   */
+  getSAMLMetadataUrl(provider) {
+    const baseUrl = this.fetch["baseUrl"];
+    return `${baseUrl}/api/v1/auth/saml/metadata/${provider}`;
+  }
   /**
    * Internal: Set the session and persist it
    */
@@ -2785,17 +2949,114 @@ var StorageBucket = class {
     const publicUrl = `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`;
     return { data: { publicUrl } };
   }
+  /**
+   * Build query string from transform options
+   * @private
+   */
+  buildTransformQuery(transform) {
+    const params = new URLSearchParams();
+    if (transform.width !== void 0 && transform.width > 0) {
+      params.set("w", String(transform.width));
+    }
+    if (transform.height !== void 0 && transform.height > 0) {
+      params.set("h", String(transform.height));
+    }
+    if (transform.format) {
+      params.set("fmt", transform.format);
+    }
+    if (transform.quality !== void 0 && transform.quality > 0) {
+      params.set("q", String(transform.quality));
+    }
+    if (transform.fit) {
+      params.set("fit", transform.fit);
+    }
+    return params.toString();
+  }
+  /**
+   * Get a public URL for a file with image transformations applied
+   * Only works for image files (JPEG, PNG, WebP, GIF, AVIF, etc.)
+   *
+   * @param path - The file path
+   * @param transform - Transformation options (width, height, format, quality, fit)
+   *
+   * @example
+   * ```typescript
+   * // Get a 300x200 WebP thumbnail
+   * const url = storage.from('images').getTransformUrl('photo.jpg', {
+   *   width: 300,
+   *   height: 200,
+   *   format: 'webp',
+   *   quality: 85,
+   *   fit: 'cover'
+   * });
+   *
+   * // Get a resized image maintaining aspect ratio
+   * const url = storage.from('images').getTransformUrl('photo.jpg', {
+   *   width: 800,
+   *   format: 'webp'
+   * });
+   * ```
+   */
+  getTransformUrl(path, transform) {
+    const baseUrl = `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/${path}`;
+    const queryString = this.buildTransformQuery(transform);
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+  }
   /**
    * Create a signed URL for temporary access to a file
+   * Optionally include image transformation parameters
+   *
    * @param path - The file path
-   * @param options - Signed URL options
+   * @param options - Signed URL options including expiration and transforms
+   *
+   * @example
+   * ```typescript
+   * // Simple signed URL (1 hour expiry)
+   * const { data, error } = await storage.from('images').createSignedUrl('photo.jpg');
+   *
+   * // Signed URL with custom expiry
+   * const { data, error } = await storage.from('images').createSignedUrl('photo.jpg', {
+   *   expiresIn: 7200 // 2 hours
+   * });
+   *
+   * // Signed URL with image transformation
+   * const { data, error } = await storage.from('images').createSignedUrl('photo.jpg', {
+   *   expiresIn: 3600,
+   *   transform: {
+   *     width: 400,
+   *     height: 300,
+   *     format: 'webp',
+   *     quality: 85,
+   *     fit: 'cover'
+   *   }
+   * });
+   * ```
    */
   async createSignedUrl(path, options) {
     try {
       const expiresIn = options?.expiresIn || 3600;
+      const requestBody = { expires_in: expiresIn };
+      if (options?.transform) {
+        const transform = options.transform;
+        if (transform.width !== void 0 && transform.width > 0) {
+          requestBody.width = transform.width;
+        }
+        if (transform.height !== void 0 && transform.height > 0) {
+          requestBody.height = transform.height;
+        }
+        if (transform.format) {
+          requestBody.format = transform.format;
+        }
+        if (transform.quality !== void 0 && transform.quality > 0) {
+          requestBody.quality = transform.quality;
+        }
+        if (transform.fit) {
+          requestBody.fit = transform.fit;
+        }
+      }
       const data = await this.fetch.post(
         `/api/v1/storage/${this.bucketName}/sign/${path}`,
-        { expires_in: expiresIn }
+        requestBody
       );
       return { data: { signedUrl: data.signed_url }, error: null };
     } catch (error) {
@@ -9203,6 +9464,239 @@ var FluxbaseVector = class {
   }
 };
 
+// src/graphql.ts
+var FluxbaseGraphQL = class {
+  /**
+   * Create a new GraphQL client
+   * @param fetch - The HTTP client to use for requests
+   */
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Execute a GraphQL query
+   *
+   * @typeParam T - The expected response data type
+   * @param query - The GraphQL query string
+   * @param variables - Variables to pass to the query
+   * @param options - Additional request options
+   * @returns Promise resolving to the GraphQL response
+   *
+   * @example
+   * ```typescript
+   * interface UsersQuery {
+   *   users: Array<{ id: string; email: string }>
+   * }
+   *
+   * const { data, errors } = await client.graphql.query<UsersQuery>(`
+   *   query {
+   *     users { id email }
+   *   }
+   * `)
+   *
+   * if (data) {
+   *   console.log(data.users)
+   * }
+   * ```
+   */
+  async query(query, variables, options) {
+    return this.execute(query, variables, void 0, options);
+  }
+  /**
+   * Execute a GraphQL mutation
+   *
+   * @typeParam T - The expected response data type
+   * @param mutation - The GraphQL mutation string
+   * @param variables - Variables to pass to the mutation
+   * @param options - Additional request options
+   * @returns Promise resolving to the GraphQL response
+   *
+   * @example
+   * ```typescript
+   * interface CreateUserMutation {
+   *   insertUser: { id: string; email: string }
+   * }
+   *
+   * const { data, errors } = await client.graphql.mutation<CreateUserMutation>(`
+   *   mutation CreateUser($data: UserInput!) {
+   *     insertUser(data: $data) {
+   *       id
+   *       email
+   *     }
+   *   }
+   * `, { data: { email: 'user@example.com' } })
+   * ```
+   */
+  async mutation(mutation, variables, options) {
+    return this.execute(mutation, variables, void 0, options);
+  }
+  /**
+   * Execute a GraphQL request with an operation name
+   *
+   * Use this when your query document contains multiple operations
+   * and you need to specify which one to execute.
+   *
+   * @typeParam T - The expected response data type
+   * @param query - The GraphQL document containing one or more operations
+   * @param variables - Variables to pass to the operation
+   * @param operationName - The name of the operation to execute
+   * @param options - Additional request options
+   * @returns Promise resolving to the GraphQL response
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.graphql.execute(`
+   *   query GetUser($id: ID!) {
+   *     user(id: $id) { id email }
+   *   }
+   *   query ListUsers {
+   *     users { id email }
+   *   }
+   * `, { id: '123' }, 'GetUser')
+   * ```
+   */
+  async execute(query, variables, operationName, options) {
+    const body = { query };
+    if (variables && Object.keys(variables).length > 0) {
+      body.variables = variables;
+    }
+    if (operationName) {
+      body.operationName = operationName;
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options?.headers
+    };
+    try {
+      const response = await this.fetch.post(
+        "/api/v1/graphql",
+        body,
+        { headers }
+      );
+      return response || { errors: [{ message: "No response received" }] };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "GraphQL request failed";
+      return {
+        errors: [{ message }]
+      };
+    }
+  }
+  /**
+   * Fetch the GraphQL schema via introspection
+   *
+   * Returns the full schema information including types, fields, and directives.
+   * Useful for tooling and documentation.
+   *
+   * @param options - Additional request options
+   * @returns Promise resolving to the introspection result
+   *
+   * @example
+   * ```typescript
+   * const { data, errors } = await client.graphql.introspect()
+   *
+   * if (data) {
+   *   console.log('Types:', data.__schema.types.length)
+   * }
+   * ```
+   */
+  async introspect(options) {
+    return this.query(INTROSPECTION_QUERY, void 0, options);
+  }
+};
+var INTROSPECTION_QUERY = `
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      args {
+        ...InputValue
+      }
+    }
+  }
+}
+
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args {
+      ...InputValue
+    }
+    type {
+      ...TypeRef
+    }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields {
+    ...InputValue
+  }
+  interfaces {
+    ...TypeRef
+  }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes {
+    ...TypeRef
+  }
+}
+
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+}
+
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+
 // src/query-builder.ts
 var URL_LENGTH_THRESHOLD = 4096;
 var QueryBuilder = class {
@@ -10535,6 +11029,7 @@ var FluxbaseClient = class {
     const wsBaseUrl = fluxbaseUrl.replace(/^https?:/, wsProtocol + ":");
     this.ai = new FluxbaseAI(this.fetch, wsBaseUrl);
     this.vector = new FluxbaseVector(this.fetch);
+    this.graphql = new FluxbaseGraphQL(this.fetch);
     const rpcInstance = new FluxbaseRPC(this.fetch);
     const rpcCallable = async (fn, params) => {
       const result = await rpcInstance.invoke(fn, params);
@@ -10801,6 +11296,7 @@ exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
 exports.FluxbaseFunctions = FluxbaseFunctions;
+exports.FluxbaseGraphQL = FluxbaseGraphQL;
 exports.FluxbaseJobs = FluxbaseJobs;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;