@fluxbase/sdk 0.0.1-rc.112 → 0.0.1-rc.114

package/dist/index.cjs

@@ -4610,7 +4610,7 @@ var EmailSettingsManager = class {
   /**
    * Get current email provider settings
    *
-   * Returns the current email configuration. Sensitive values (passwords, API keys)
+   * Returns the current email configuration. Sensitive values (passwords, client keys)
    * are not returned - instead, boolean flags indicate whether they are set.
    *
    * @returns Promise resolving to EmailProviderSettings
@@ -4638,7 +4638,7 @@ var EmailSettingsManager = class {
    * Update email provider settings
    *
    * Supports partial updates - only provide the fields you want to change.
-   * Secret fields (passwords, API keys) are only updated if provided.
+   * Secret fields (passwords, client keys) are only updated if provided.
    *
    * @param request - Settings to update (partial update supported)
    * @returns Promise resolving to EmailProviderSettings - Updated settings
@@ -5572,118 +5572,119 @@ var ImpersonationManager = class {
 };
 
 // src/management.ts
-var APIKeysManager = class {
+var ClientKeysManager = class {
   constructor(fetch2) {
     this.fetch = fetch2;
   }
   /**
-   * Create a new API key
+   * Create a new client key
    *
-   * @param request - API key configuration
-   * @returns Created API key with the full key value (only shown once)
+   * @param request - Client key configuration
+   * @returns Created client key with the full key value (only shown once)
    *
    * @example
    * ```typescript
-   * const { api_key, key } = await client.management.apiKeys.create({
+   * const { client_key, key } = await client.management.clientKeys.create({
    *   name: 'Production Service',
-   *   description: 'API key for production service',
+   *   description: 'Client key for production service',
    *   scopes: ['read:users', 'write:users'],
    *   rate_limit_per_minute: 100,
    *   expires_at: '2025-12-31T23:59:59Z'
    * })
    *
    * // Store the key securely - it won't be shown again
-   * console.log('API Key:', key)
+   * console.log('Client Key:', key)
    * ```
    */
   async create(request) {
-    return await this.fetch.post("/api/v1/api-keys", request);
+    return await this.fetch.post("/api/v1/client-keys", request);
   }
   /**
-   * List all API keys for the authenticated user
+   * List all client keys for the authenticated user
    *
-   * @returns List of API keys (without full key values)
+   * @returns List of client keys (without full key values)
    *
    * @example
    * ```typescript
-   * const { api_keys, total } = await client.management.apiKeys.list()
+   * const { client_keys, total } = await client.management.clientKeys.list()
    *
-   * api_keys.forEach(key => {
+   * client_keys.forEach(key => {
    *   console.log(`${key.name}: ${key.key_prefix}... (expires: ${key.expires_at})`)
    * })
    * ```
    */
   async list() {
-    return await this.fetch.get("/api/v1/api-keys");
+    return await this.fetch.get("/api/v1/client-keys");
   }
   /**
-   * Get a specific API key by ID
+   * Get a specific client key by ID
    *
-   * @param keyId - API key ID
-   * @returns API key details
+   * @param keyId - Client key ID
+   * @returns Client key details
    *
    * @example
    * ```typescript
-   * const apiKey = await client.management.apiKeys.get('key-uuid')
-   * console.log('Last used:', apiKey.last_used_at)
+   * const clientKey = await client.management.clientKeys.get('key-uuid')
+   * console.log('Last used:', clientKey.last_used_at)
    * ```
    */
   async get(keyId) {
-    return await this.fetch.get(`/api/v1/api-keys/${keyId}`);
+    return await this.fetch.get(`/api/v1/client-keys/${keyId}`);
   }
   /**
-   * Update an API key
+   * Update a client key
    *
-   * @param keyId - API key ID
+   * @param keyId - Client key ID
    * @param updates - Fields to update
-   * @returns Updated API key
+   * @returns Updated client key
    *
    * @example
    * ```typescript
-   * const updated = await client.management.apiKeys.update('key-uuid', {
+   * const updated = await client.management.clientKeys.update('key-uuid', {
    *   name: 'Updated Name',
    *   rate_limit_per_minute: 200
    * })
    * ```
    */
   async update(keyId, updates) {
-    return await this.fetch.patch(`/api/v1/api-keys/${keyId}`, updates);
+    return await this.fetch.patch(`/api/v1/client-keys/${keyId}`, updates);
   }
   /**
-   * Revoke an API key
+   * Revoke a client key
    *
    * Revoked keys can no longer be used but remain in the system for audit purposes.
    *
-   * @param keyId - API key ID
+   * @param keyId - Client key ID
    * @returns Revocation confirmation
    *
    * @example
    * ```typescript
-   * await client.management.apiKeys.revoke('key-uuid')
-   * console.log('API key revoked')
+   * await client.management.clientKeys.revoke('key-uuid')
+   * console.log('Client key revoked')
    * ```
    */
   async revoke(keyId) {
-    return await this.fetch.post(`/api/v1/api-keys/${keyId}/revoke`, {});
+    return await this.fetch.post(`/api/v1/client-keys/${keyId}/revoke`, {});
   }
   /**
-   * Delete an API key
+   * Delete a client key
    *
-   * Permanently removes the API key from the system.
+   * Permanently removes the client key from the system.
    *
-   * @param keyId - API key ID
+   * @param keyId - Client key ID
    * @returns Deletion confirmation
    *
    * @example
    * ```typescript
-   * await client.management.apiKeys.delete('key-uuid')
-   * console.log('API key deleted')
+   * await client.management.clientKeys.delete('key-uuid')
+   * console.log('Client key deleted')
    * ```
    */
   async delete(keyId) {
-    return await this.fetch.delete(`/api/v1/api-keys/${keyId}`);
+    return await this.fetch.delete(`/api/v1/client-keys/${keyId}`);
   }
 };
+var APIKeysManager = ClientKeysManager;
 var WebhooksManager = class {
   constructor(fetch2) {
     this.fetch = fetch2;
@@ -5932,7 +5933,8 @@ var InvitationsManager = class {
 };
 var FluxbaseManagement = class {
   constructor(fetch2) {
-    this.apiKeys = new APIKeysManager(fetch2);
+    this.clientKeys = new ClientKeysManager(fetch2);
+    this.apiKeys = this.clientKeys;
     this.webhooks = new WebhooksManager(fetch2);
     this.invitations = new InvitationsManager(fetch2);
   }
@@ -9697,6 +9699,355 @@ fragment TypeRef on __Type {
 }
 `;
 
+// src/branching.ts
+var FluxbaseBranching = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List all database branches
+   *
+   * @param options - Filter and pagination options
+   * @returns Promise resolving to { data, error } tuple with branches list
+   *
+   * @example
+   * ```typescript
+   * // List all branches
+   * const { data, error } = await client.branching.list()
+   *
+   * // Filter by status
+   * const { data } = await client.branching.list({ status: 'ready' })
+   *
+   * // Filter by type
+   * const { data } = await client.branching.list({ type: 'preview' })
+   *
+   * // Only show my branches
+   * const { data } = await client.branching.list({ mine: true })
+   *
+   * // Pagination
+   * const { data } = await client.branching.list({ limit: 10, offset: 20 })
+   * ```
+   */
+  async list(options) {
+    try {
+      const params = new URLSearchParams();
+      if (options?.status) {
+        params.append("status", options.status);
+      }
+      if (options?.type) {
+        params.append("type", options.type);
+      }
+      if (options?.githubRepo) {
+        params.append("github_repo", options.githubRepo);
+      }
+      if (options?.mine) {
+        params.append("mine", "true");
+      }
+      if (options?.limit !== void 0) {
+        params.append("limit", options.limit.toString());
+      }
+      if (options?.offset !== void 0) {
+        params.append("offset", options.offset.toString());
+      }
+      const queryString = params.toString();
+      const url = `/api/v1/admin/branches${queryString ? `?${queryString}` : ""}`;
+      const response = await this.fetch.get(url);
+      return { data: response, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Get a specific branch by ID or slug
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @returns Promise resolving to { data, error } tuple with branch details
+   *
+   * @example
+   * ```typescript
+   * // Get by slug
+   * const { data, error } = await client.branching.get('feature/add-auth')
+   *
+   * // Get by ID
+   * const { data } = await client.branching.get('123e4567-e89b-12d3-a456-426614174000')
+   * ```
+   */
+  async get(idOrSlug) {
+    try {
+      const response = await this.fetch.get(
+        `/api/v1/admin/branches/${encodeURIComponent(idOrSlug)}`
+      );
+      return { data: response, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Create a new database branch
+   *
+   * @param name - Branch name (will be converted to a slug)
+   * @param options - Branch creation options
+   * @returns Promise resolving to { data, error } tuple with created branch
+   *
+   * @example
+   * ```typescript
+   * // Create a simple branch
+   * const { data, error } = await client.branching.create('feature/add-auth')
+   *
+   * // Create with options
+   * const { data } = await client.branching.create('feature/add-auth', {
+   *   dataCloneMode: 'schema_only',  // Don't clone data
+   *   expiresIn: '7d',               // Auto-delete after 7 days
+   *   type: 'persistent'             // Won't auto-delete on PR merge
+   * })
+   *
+   * // Create a PR preview branch
+   * const { data } = await client.branching.create('pr-123', {
+   *   type: 'preview',
+   *   githubPRNumber: 123,
+   *   githubRepo: 'owner/repo',
+   *   expiresIn: '7d'
+   * })
+   *
+   * // Clone with full data (for debugging)
+   * const { data } = await client.branching.create('debug-issue-456', {
+   *   dataCloneMode: 'full_clone'
+   * })
+   * ```
+   */
+  async create(name, options) {
+    try {
+      const body = { name };
+      if (options?.parentBranchId) {
+        body.parent_branch_id = options.parentBranchId;
+      }
+      if (options?.dataCloneMode) {
+        body.data_clone_mode = options.dataCloneMode;
+      }
+      if (options?.type) {
+        body.type = options.type;
+      }
+      if (options?.githubPRNumber !== void 0) {
+        body.github_pr_number = options.githubPRNumber;
+      }
+      if (options?.githubPRUrl) {
+        body.github_pr_url = options.githubPRUrl;
+      }
+      if (options?.githubRepo) {
+        body.github_repo = options.githubRepo;
+      }
+      if (options?.expiresIn) {
+        body.expires_in = options.expiresIn;
+      }
+      const response = await this.fetch.post(
+        "/api/v1/admin/branches",
+        body
+      );
+      return { data: response, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Delete a database branch
+   *
+   * This permanently deletes the branch database and all its data.
+   * Cannot delete the main branch.
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @returns Promise resolving to { error } (null on success)
+   *
+   * @example
+   * ```typescript
+   * // Delete a branch
+   * const { error } = await client.branching.delete('feature/add-auth')
+   *
+   * if (error) {
+   *   console.error('Failed to delete branch:', error.message)
+   * }
+   * ```
+   */
+  async delete(idOrSlug) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/branches/${encodeURIComponent(idOrSlug)}`
+      );
+      return { error: null };
+    } catch (err) {
+      return { error: err };
+    }
+  }
+  /**
+   * Reset a branch to its parent state
+   *
+   * This drops and recreates the branch database, resetting all data
+   * to match the parent branch. Cannot reset the main branch.
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @returns Promise resolving to { data, error } tuple with reset branch
+   *
+   * @example
+   * ```typescript
+   * // Reset a branch
+   * const { data, error } = await client.branching.reset('feature/add-auth')
+   *
+   * if (data) {
+   *   console.log('Branch reset, status:', data.status)
+   * }
+   * ```
+   */
+  async reset(idOrSlug) {
+    try {
+      const response = await this.fetch.post(
+        `/api/v1/admin/branches/${encodeURIComponent(idOrSlug)}/reset`,
+        {}
+      );
+      return { data: response, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Get activity log for a branch
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @param limit - Maximum number of entries to return (default: 50, max: 100)
+   * @returns Promise resolving to { data, error } tuple with activity entries
+   *
+   * @example
+   * ```typescript
+   * // Get recent activity
+   * const { data, error } = await client.branching.getActivity('feature/add-auth')
+   *
+   * if (data) {
+   *   for (const entry of data) {
+   *     console.log(`${entry.action}: ${entry.status}`)
+   *   }
+   * }
+   *
+   * // Get more entries
+   * const { data } = await client.branching.getActivity('feature/add-auth', 100)
+   * ```
+   */
+  async getActivity(idOrSlug, limit = 50) {
+    try {
+      const response = await this.fetch.get(
+        `/api/v1/admin/branches/${encodeURIComponent(idOrSlug)}/activity?limit=${limit}`
+      );
+      return { data: response.activity, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Get connection pool statistics for all branches
+   *
+   * This is useful for monitoring and debugging branch connections.
+   *
+   * @returns Promise resolving to { data, error } tuple with pool stats
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.branching.getPoolStats()
+   *
+   * if (data) {
+   *   for (const pool of data) {
+   *     console.log(`${pool.slug}: ${pool.active_connections} active`)
+   *   }
+   * }
+   * ```
+   */
+  async getPoolStats() {
+    try {
+      const response = await this.fetch.get(
+        "/api/v1/admin/branches/stats/pools"
+      );
+      return { data: response.pools, error: null };
+    } catch (err) {
+      return { data: null, error: err };
+    }
+  }
+  /**
+   * Check if a branch exists
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @returns Promise resolving to true if branch exists, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const exists = await client.branching.exists('feature/add-auth')
+   *
+   * if (!exists) {
+   *   await client.branching.create('feature/add-auth')
+   * }
+   * ```
+   */
+  async exists(idOrSlug) {
+    const { data, error } = await this.get(idOrSlug);
+    return !error && data !== null;
+  }
+  /**
+   * Wait for a branch to be ready
+   *
+   * Polls the branch status until it reaches 'ready' or an error state.
+   *
+   * @param idOrSlug - Branch ID (UUID) or slug
+   * @param options - Polling options
+   * @returns Promise resolving to { data, error } tuple with ready branch
+   *
+   * @example
+   * ```typescript
+   * // Create branch and wait for it to be ready
+   * const { data: branch } = await client.branching.create('feature/add-auth')
+   *
+   * const { data: ready, error } = await client.branching.waitForReady(branch!.slug, {
+   *   timeout: 60000,     // 60 seconds
+   *   pollInterval: 1000  // Check every second
+   * })
+   *
+   * if (ready) {
+   *   console.log('Branch is ready!')
+   * }
+   * ```
+   */
+  async waitForReady(idOrSlug, options) {
+    const timeout = options?.timeout ?? 3e4;
+    const pollInterval = options?.pollInterval ?? 1e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const { data, error } = await this.get(idOrSlug);
+      if (error) {
+        return { data: null, error };
+      }
+      if (!data) {
+        return { data: null, error: new Error("Branch not found") };
+      }
+      if (data.status === "ready") {
+        return { data, error: null };
+      }
+      if (data.status === "error") {
+        return {
+          data: null,
+          error: new Error(data.error_message ?? "Branch creation failed")
+        };
+      }
+      if (data.status === "deleted" || data.status === "deleting") {
+        return {
+          data: null,
+          error: new Error("Branch was deleted")
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return {
+      data: null,
+      error: new Error(
+        `Timeout waiting for branch to be ready after ${timeout}ms`
+      )
+    };
+  }
+};
+
 // src/query-builder.ts
 var URL_LENGTH_THRESHOLD = 4096;
 var QueryBuilder = class {
@@ -11030,6 +11381,7 @@ var FluxbaseClient = class {
     this.ai = new FluxbaseAI(this.fetch, wsBaseUrl);
     this.vector = new FluxbaseVector(this.fetch);
     this.graphql = new FluxbaseGraphQL(this.fetch);
+    this.branching = new FluxbaseBranching(this.fetch);
     const rpcInstance = new FluxbaseRPC(this.fetch);
     const rpcCallable = async (fn, params) => {
       const result = await rpcInstance.invoke(fn, params);
@@ -11279,6 +11631,7 @@ function assertType(value, validator, errorMessage = "Type assertion failed") {
 exports.APIKeysManager = APIKeysManager;
 exports.AppSettingsManager = AppSettingsManager;
 exports.AuthSettingsManager = AuthSettingsManager;
+exports.ClientKeysManager = ClientKeysManager;
 exports.DDLManager = DDLManager;
 exports.EmailSettingsManager = EmailSettingsManager;
 exports.EmailTemplateManager = EmailTemplateManager;
@@ -11293,6 +11646,7 @@ exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
 exports.FluxbaseAdminRPC = FluxbaseAdminRPC;
 exports.FluxbaseAdminStorage = FluxbaseAdminStorage;
 exports.FluxbaseAuth = FluxbaseAuth;
+exports.FluxbaseBranching = FluxbaseBranching;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
 exports.FluxbaseFunctions = FluxbaseFunctions;