@fluxbase/sdk 0.0.1-rc.41 → 0.0.1-rc.42

package/dist/index.cjs

@@ -901,6 +901,7 @@ var RealtimeChannel = class {
     this.presenceCallbacks = /* @__PURE__ */ new Map();
     this.broadcastCallbacks = /* @__PURE__ */ new Map();
     this.subscriptionConfig = null;
+    this.subscriptionId = null;
     this._presenceState = {};
     this.myPresenceKey = null;
     this.reconnectAttempts = 0;
@@ -990,7 +991,8 @@ var RealtimeChannel = class {
       if (this.ws) {
         this.sendMessage({
           type: "unsubscribe",
-          channel: this.channelName
+          channel: this.channelName,
+          subscription_id: this.subscriptionId || void 0
         });
         const startTime = Date.now();
         const maxWait = timeout || 5e3;
@@ -1249,7 +1251,12 @@ var RealtimeChannel = class {
             ackHandler.resolve(message.status || "ok");
           }
         } else {
-          console.log("[Fluxbase Realtime] Acknowledged:", message);
+          if (message.payload && typeof message.payload === "object" && "subscription_id" in message.payload) {
+            this.subscriptionId = message.payload.subscription_id;
+            console.log("[Fluxbase Realtime] Subscription ID received:", this.subscriptionId);
+          } else {
+            console.log("[Fluxbase Realtime] Acknowledged:", message);
+          }
         }
         break;
       case "error":
@@ -1846,16 +1853,22 @@ var FluxbaseFunctions = class {
    * 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
+   * @param options - Invocation options including body, headers, HTTP method, and namespace
    * @returns Promise resolving to { data, error } tuple
    *
    * @example
    * ```typescript
-   * // Simple invocation
+   * // Simple invocation (uses first matching function by namespace alphabetically)
    * const { data, error } = await client.functions.invoke('hello', {
    *   body: { name: 'World' }
    * })
    *
+   * // Invoke a specific namespace's function
+   * const { data, error } = await client.functions.invoke('hello', {
+   *   body: { name: 'World' },
+   *   namespace: 'my-app'
+   * })
+   *
    * // With GET method
    * const { data, error } = await client.functions.invoke('get-data', {
    *   method: 'GET'
@@ -1874,7 +1887,8 @@ var FluxbaseFunctions = class {
       const method = options?.method || "POST";
       const headers = options?.headers || {};
       const body = options?.body;
-      const endpoint = `/api/v1/functions/${functionName}/invoke`;
+      const namespace = options?.namespace;
+      const endpoint = namespace ? `/api/v1/functions/${functionName}/invoke?namespace=${encodeURIComponent(namespace)}` : `/api/v1/functions/${functionName}/invoke`;
       let response;
       switch (method) {
         case "GET":
@@ -1900,136 +1914,209 @@ var FluxbaseFunctions = class {
     }
   }
   /**
-   * Create a new edge function
+   * List all public edge functions
    *
-   * @param request - Function configuration and code
-   * @returns Promise resolving to { data, error } tuple with created function metadata
+   * @returns Promise resolving to { data, error } tuple with array of public functions
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.functions.create({
-   *   name: 'my-function',
-   *   code: 'export default async function handler(req) { return { hello: "world" } }',
-   *   enabled: true
-   * })
+   * const { data, error } = await client.functions.list()
+   * if (data) {
+   *   console.log('Functions:', data.map(f => f.name))
+   * }
    * ```
    */
-  async create(request) {
+  async list() {
     try {
-      const data = await this.fetch.post("/api/v1/functions", request);
+      const data = await this.fetch.get("/api/v1/functions");
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
   /**
-   * List all edge functions
+   * Get details of a specific edge function
    *
-   * @returns Promise resolving to { data, error } tuple with array of functions
+   * @param name - Function name
+   * @returns Promise resolving to { data, error } tuple with function metadata
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.functions.list()
+   * const { data, error } = await client.functions.get('my-function')
    * if (data) {
-   *   console.log('Functions:', data.map(f => f.name))
+   *   console.log('Function version:', data.version)
    * }
    * ```
    */
-  async list() {
+  async get(name) {
     try {
-      const data = await this.fetch.get("/api/v1/functions");
+      const data = await this.fetch.get(`/api/v1/functions/${name}`);
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
+};
+
+// src/jobs.ts
+var FluxbaseJobs = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
   /**
-   * Get details of a specific edge function
+   * Submit a new job for execution
    *
-   * @param name - Function name
-   * @returns Promise resolving to { data, error } tuple with function metadata
+   * @param jobName - Name of the job function to execute
+   * @param payload - Job input data
+   * @param options - Additional options (priority, namespace, scheduled time)
+   * @returns Promise resolving to { data, error } tuple with submitted job details
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.functions.get('my-function')
+   * // Submit a simple job
+   * const { data, error } = await client.jobs.submit('send-email', {
+   *   to: 'user@example.com',
+   *   subject: 'Hello',
+   *   body: 'Welcome!'
+   * })
+   *
    * if (data) {
-   *   console.log('Function version:', data.version)
+   *   console.log('Job submitted:', data.id)
+   *   console.log('Status:', data.status)
    * }
+   *
+   * // Submit with priority
+   * const { data } = await client.jobs.submit('high-priority-task', payload, {
+   *   priority: 10
+   * })
+   *
+   * // Schedule for later
+   * const { data } = await client.jobs.submit('scheduled-task', payload, {
+   *   scheduled: '2025-01-01T00:00:00Z'
+   * })
    * ```
    */
-  async get(name) {
+  async submit(jobName, payload, options) {
     try {
-      const data = await this.fetch.get(`/api/v1/functions/${name}`);
+      const request = {
+        job_name: jobName,
+        payload,
+        ...options
+      };
+      const data = await this.fetch.post("/api/v1/jobs/submit", request);
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
   /**
-   * Update an existing edge function
+   * Get status and details of a specific job
    *
-   * @param name - Function name
-   * @param updates - Fields to update
-   * @returns Promise resolving to { data, error } tuple with updated function metadata
+   * @param jobId - Job ID
+   * @returns Promise resolving to { data, error } tuple with job details
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.functions.update('my-function', {
-   *   enabled: false,
-   *   description: 'Updated description'
+   * const { data: job, error } = await client.jobs.get('550e8400-e29b-41d4-a716-446655440000')
+   *
+   * if (job) {
+   *   console.log('Status:', job.status)
+   *   console.log('Progress:', job.progress_percent + '%')
+   *   console.log('Result:', job.result)
+   *   console.log('Logs:', job.logs)
+   * }
+   * ```
+   */
+  async get(jobId) {
+    try {
+      const data = await this.fetch.get(`/api/v1/jobs/${jobId}`);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List jobs submitted by the current user
+   *
+   * @param filters - Optional filters (status, namespace, limit, offset)
+   * @returns Promise resolving to { data, error } tuple with array of jobs
+   *
+   * @example
+   * ```typescript
+   * // List all your jobs
+   * const { data: jobs, error } = await client.jobs.list()
+   *
+   * // Filter by status
+   * const { data: running } = await client.jobs.list({
+   *   status: 'running'
+   * })
+   *
+   * // Paginate
+   * const { data: page } = await client.jobs.list({
+   *   limit: 20,
+   *   offset: 40
    * })
    * ```
    */
-  async update(name, updates) {
+  async list(filters) {
     try {
-      const data = await this.fetch.put(`/api/v1/functions/${name}`, updates);
+      const params = new URLSearchParams();
+      if (filters?.status) params.append("status", filters.status);
+      if (filters?.namespace) params.append("namespace", filters.namespace);
+      if (filters?.limit) params.append("limit", filters.limit.toString());
+      if (filters?.offset) params.append("offset", filters.offset.toString());
+      const queryString = params.toString();
+      const data = await this.fetch.get(
+        `/api/v1/jobs${queryString ? `?${queryString}` : ""}`
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
   /**
-   * Delete an edge function
+   * Cancel a pending or running job
    *
-   * @param name - Function name
+   * @param jobId - Job ID to cancel
    * @returns Promise resolving to { data, error } tuple
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.functions.delete('my-function')
+   * const { error } = await client.jobs.cancel('550e8400-e29b-41d4-a716-446655440000')
+   *
+   * if (!error) {
+   *   console.log('Job cancelled successfully')
+   * }
    * ```
    */
-  async delete(name) {
+  async cancel(jobId) {
     try {
-      await this.fetch.delete(`/api/v1/functions/${name}`);
+      await this.fetch.post(`/api/v1/jobs/${jobId}/cancel`, {});
       return { data: null, error: null };
     } catch (error) {
       return { data: null, error };
     }
   }
   /**
-   * Get execution history for an edge function
+   * Retry a failed job
    *
-   * @param name - Function name
-   * @param limit - Maximum number of executions to return (optional)
-   * @returns Promise resolving to { data, error } tuple with execution records
+   * Creates a new job execution with the same parameters
+   *
+   * @param jobId - Job ID to retry
+   * @returns Promise resolving to { data, error } tuple with new job
    *
    * @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)`)
-   *   })
+   * const { data: newJob, error } = await client.jobs.retry('550e8400-e29b-41d4-a716-446655440000')
+   *
+   * if (newJob) {
+   *   console.log('Job retried, new ID:', newJob.id)
    * }
    * ```
    */
-  async getExecutions(name, limit) {
+  async retry(jobId) {
     try {
-      const params = limit ? `?limit=${limit}` : "";
-      const data = await this.fetch.get(
-        `/api/v1/functions/${name}/executions${params}`
-      );
+      const data = await this.fetch.post(`/api/v1/jobs/${jobId}/retry`, {});
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -3854,6 +3941,1215 @@ var FluxbaseManagement = class {
   }
 };
 
+// src/admin-functions.ts
+var FluxbaseAdminFunctions = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * 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.admin.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 namespaces that have edge functions
+   *
+   * @returns Promise resolving to { data, error } tuple with array of namespace strings
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.functions.listNamespaces()
+   * if (data) {
+   *   console.log('Available namespaces:', data)
+   * }
+   * ```
+   */
+  async listNamespaces() {
+    try {
+      const response = await this.fetch.get(
+        "/api/v1/admin/functions/namespaces"
+      );
+      return { data: response.namespaces || ["default"], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all edge functions (admin view)
+   *
+   * @param namespace - Optional namespace filter (if not provided, lists all public functions)
+   * @returns Promise resolving to { data, error } tuple with array of functions
+   *
+   * @example
+   * ```typescript
+   * // List all public functions
+   * const { data, error } = await client.admin.functions.list()
+   *
+   * // List functions in a specific namespace
+   * const { data, error } = await client.admin.functions.list('my-namespace')
+   * if (data) {
+   *   console.log('Functions:', data.map(f => f.name))
+   * }
+   * ```
+   */
+  async list(namespace) {
+    try {
+      const params = namespace ? `?namespace=${namespace}` : "";
+      const data = await this.fetch.get(
+        `/api/v1/functions${params}`
+      );
+      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.admin.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.admin.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.admin.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.admin.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 };
+    }
+  }
+  /**
+   * Sync multiple functions to a namespace
+   *
+   * Bulk create/update/delete functions in a specific namespace. This is useful for
+   * deploying functions from your application to Fluxbase in Kubernetes or other
+   * container environments.
+   *
+   * Requires service_role or admin authentication.
+   *
+   * @param options - Sync configuration including namespace, functions, and options
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * // Sync functions to "payment-service" namespace
+   * const { data, error } = await client.admin.functions.sync({
+   *   namespace: 'payment-service',
+   *   functions: [
+   *     {
+   *       name: 'process-payment',
+   *       code: 'export default async function handler(req) { ... }',
+   *       enabled: true,
+   *       allow_net: true
+   *     },
+   *     {
+   *       name: 'refund-payment',
+   *       code: 'export default async function handler(req) { ... }',
+   *       enabled: true
+   *     }
+   *   ],
+   *   options: {
+   *     delete_missing: true  // Remove functions not in this list
+   *   }
+   * })
+   *
+   * if (data) {
+   *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+   * }
+   *
+   * // Dry run to preview changes
+   * const { data, error } = await client.admin.functions.sync({
+   *   namespace: 'myapp',
+   *   functions: [...],
+   *   options: { dry_run: true }
+   * })
+   * ```
+   */
+  async sync(options) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/functions/sync",
+        options
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/admin-migrations.ts
+var FluxbaseAdminMigrations = class {
+  constructor(fetch2) {
+    this.localMigrations = /* @__PURE__ */ new Map();
+    this.fetch = fetch2;
+  }
+  /**
+   * Register a migration locally for smart sync
+   *
+   * Call this method to register migrations in your application code.
+   * When you call sync(), only new or changed migrations will be sent to the server.
+   *
+   * @param migration - Migration definition
+   * @returns { error } tuple (always succeeds unless validation fails)
+   *
+   * @example
+   * ```typescript
+   * // In your app initialization
+   * const { error: err1 } = client.admin.migrations.register({
+   *   name: '001_create_users_table',
+   *   namespace: 'myapp',
+   *   up_sql: 'CREATE TABLE app.users (...)',
+   *   down_sql: 'DROP TABLE app.users',
+   *   description: 'Initial users table'
+   * })
+   *
+   * const { error: err2 } = client.admin.migrations.register({
+   *   name: '002_add_posts_table',
+   *   namespace: 'myapp',
+   *   up_sql: 'CREATE TABLE app.posts (...)',
+   *   down_sql: 'DROP TABLE app.posts'
+   * })
+   *
+   * // Sync all registered migrations
+   * await client.admin.migrations.sync()
+   * ```
+   */
+  register(migration) {
+    try {
+      if (!migration.name || !migration.up_sql) {
+        return {
+          error: new Error("Migration name and up_sql are required")
+        };
+      }
+      const key = `${migration.namespace || "default"}:${migration.name}`;
+      this.localMigrations.set(key, migration);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  /**
+   * Trigger schema refresh which will restart the server
+   * Handles the restart gracefully by waiting for the server to come back online
+   *
+   * @private
+   */
+  async triggerSchemaRefreshWithRestart() {
+    console.log("Triggering schema refresh (server will restart)...");
+    try {
+      const response = await this.fetch.post(
+        "/api/v1/admin/schema/refresh",
+        {}
+      );
+      console.log("Server restart initiated:", response.message || "Schema refresh in progress");
+    } catch (error) {
+      const isConnectionError = error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED") || error.message?.includes("ECONNRESET") || error.code === "ECONNREFUSED" || error.code === "ECONNRESET";
+      if (!isConnectionError) {
+        throw error;
+      }
+      console.log("Connection dropped (expected during restart)...");
+    }
+    console.log("Waiting 6 seconds for server to restart...");
+    await this.sleep(6e3);
+    const maxAttempts = 5;
+    const baseDelay = 1e3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await this.fetch.get("/health");
+        console.log("Server is back online and ready");
+        return;
+      } catch (error) {
+        const isLastAttempt = attempt === maxAttempts;
+        if (isLastAttempt) {
+          throw new Error(
+            `Server did not come back online after ${maxAttempts} attempts. Please check server logs and try again.`
+          );
+        }
+        const delay = baseDelay * Math.pow(2, attempt - 1);
+        console.log(`Server not ready yet, retrying in ${delay}ms... (attempt ${attempt}/${maxAttempts})`);
+        await this.sleep(delay);
+      }
+    }
+  }
+  /**
+   * Helper function to sleep for a given duration
+   * @private
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Smart sync all registered migrations
+   *
+   * Automatically determines which migrations need to be created or updated by:
+   * 1. Fetching existing migrations from the server
+   * 2. Comparing content hashes to detect changes
+   * 3. Only sending new or changed migrations
+   *
+   * After successful sync, can optionally auto-apply new migrations and refresh
+   * the server's schema cache.
+   *
+   * @param options - Sync options
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * // Basic sync (idempotent - safe to call on every app startup)
+   * const { data, error } = await client.admin.migrations.sync()
+   * if (data) {
+   *   console.log(`Created: ${data.summary.created}, Updated: ${data.summary.updated}`)
+   * }
+   *
+   * // Sync with auto-apply (applies new migrations automatically)
+   * const { data, error } = await client.admin.migrations.sync({
+   *   auto_apply: true
+   * })
+   *
+   * // Dry run to preview changes without applying
+   * const { data, error } = await client.admin.migrations.sync({
+   *   dry_run: true
+   * })
+   * ```
+   */
+  async sync(options = {}) {
+    try {
+      const byNamespace = /* @__PURE__ */ new Map();
+      for (const migration of this.localMigrations.values()) {
+        const ns = migration.namespace || "default";
+        if (!byNamespace.has(ns)) {
+          byNamespace.set(ns, []);
+        }
+        byNamespace.get(ns).push(migration);
+      }
+      const results = [];
+      const errors = [];
+      for (const [namespace, migrations] of byNamespace) {
+        try {
+          const result = await this.fetch.post(
+            "/api/v1/admin/migrations/sync",
+            {
+              namespace,
+              migrations: migrations.map((m) => ({
+                name: m.name,
+                description: m.description,
+                up_sql: m.up_sql,
+                down_sql: m.down_sql
+              })),
+              options: {
+                update_if_changed: options.update_if_changed ?? true,
+                auto_apply: options.auto_apply ?? false,
+                dry_run: options.dry_run ?? false
+              }
+            }
+          );
+          results.push(result);
+        } catch (error) {
+          const err = error;
+          if (err.status === 422 && err.details) {
+            results.push(err.details);
+            errors.push(err);
+          } else {
+            throw error;
+          }
+        }
+      }
+      const combined = {
+        message: results.map((r) => r.message).join("; "),
+        namespace: Array.from(byNamespace.keys()).join(", "),
+        summary: {
+          created: results.reduce((sum, r) => sum + r.summary.created, 0),
+          updated: results.reduce((sum, r) => sum + r.summary.updated, 0),
+          unchanged: results.reduce((sum, r) => sum + r.summary.unchanged, 0),
+          skipped: results.reduce((sum, r) => sum + r.summary.skipped, 0),
+          applied: results.reduce((sum, r) => sum + r.summary.applied, 0),
+          errors: results.reduce((sum, r) => sum + r.summary.errors, 0)
+        },
+        details: {
+          created: results.flatMap((r) => r.details.created),
+          updated: results.flatMap((r) => r.details.updated),
+          unchanged: results.flatMap((r) => r.details.unchanged),
+          skipped: results.flatMap((r) => r.details.skipped),
+          applied: results.flatMap((r) => r.details.applied),
+          errors: results.flatMap((r) => r.details.errors)
+        },
+        dry_run: options.dry_run ?? false,
+        warnings: results.flatMap((r) => r.warnings || [])
+      };
+      const hasChanges = combined.summary.created > 0 || combined.summary.updated > 0;
+      if (!combined.dry_run && hasChanges) {
+        try {
+          await this.triggerSchemaRefreshWithRestart();
+        } catch (refreshError) {
+          console.warn("Schema refresh completed with warnings:", refreshError);
+        }
+      }
+      if (errors.length > 0 || combined.summary.errors > 0) {
+        const error = new Error(combined.message);
+        error.syncResult = combined;
+        error.details = combined.details.errors;
+        return { data: combined, error };
+      }
+      return { data: combined, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new migration
+   *
+   * @param request - Migration configuration
+   * @returns Promise resolving to { data, error } tuple with created migration
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.create({
+   *   namespace: 'myapp',
+   *   name: '001_create_users',
+   *   up_sql: 'CREATE TABLE app.users (id UUID PRIMARY KEY, email TEXT)',
+   *   down_sql: 'DROP TABLE app.users',
+   *   description: 'Create users table'
+   * })
+   * ```
+   */
+  async create(request) {
+    try {
+      const data = await this.fetch.post("/api/v1/admin/migrations", request);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List migrations in a namespace
+   *
+   * @param namespace - Migration namespace (default: 'default')
+   * @param status - Filter by status: 'pending', 'applied', 'failed', 'rolled_back'
+   * @returns Promise resolving to { data, error } tuple with migrations array
+   *
+   * @example
+   * ```typescript
+   * // List all migrations
+   * const { data, error } = await client.admin.migrations.list('myapp')
+   *
+   * // List only pending migrations
+   * const { data, error } = await client.admin.migrations.list('myapp', 'pending')
+   * ```
+   */
+  async list(namespace = "default", status) {
+    try {
+      const params = new URLSearchParams({ namespace });
+      if (status) params.append("status", status);
+      const data = await this.fetch.get(
+        `/api/v1/admin/migrations?${params.toString()}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific migration
+   *
+   * @param name - Migration name
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple with migration details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.get('001_create_users', 'myapp')
+   * ```
+   */
+  async get(name, namespace = "default") {
+    try {
+      const params = new URLSearchParams({ namespace });
+      const data = await this.fetch.get(
+        `/api/v1/admin/migrations/${name}?${params.toString()}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update a migration (only if status is pending)
+   *
+   * @param name - Migration name
+   * @param updates - Fields to update
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple with updated migration
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.update(
+   *   '001_create_users',
+   *   { description: 'Updated description' },
+   *   'myapp'
+   * )
+   * ```
+   */
+  async update(name, updates, namespace = "default") {
+    try {
+      const params = new URLSearchParams({ namespace });
+      const data = await this.fetch.put(
+        `/api/v1/admin/migrations/${name}?${params.toString()}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a migration (only if status is pending)
+   *
+   * @param name - Migration name
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.delete('001_create_users', 'myapp')
+   * ```
+   */
+  async delete(name, namespace = "default") {
+    try {
+      const params = new URLSearchParams({ namespace });
+      await this.fetch.delete(`/api/v1/admin/migrations/${name}?${params.toString()}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Apply a specific migration
+   *
+   * @param name - Migration name
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple with result message
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.apply('001_create_users', 'myapp')
+   * if (data) {
+   *   console.log(data.message) // "Migration applied successfully"
+   * }
+   * ```
+   */
+  async apply(name, namespace = "default") {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/migrations/${name}/apply`,
+        { namespace }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Rollback a specific migration
+   *
+   * @param name - Migration name
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple with result message
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.rollback('001_create_users', 'myapp')
+   * ```
+   */
+  async rollback(name, namespace = "default") {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/migrations/${name}/rollback`,
+        { namespace }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Apply all pending migrations in order
+   *
+   * @param namespace - Migration namespace (default: 'default')
+   * @returns Promise resolving to { data, error } tuple with applied/failed counts
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.applyPending('myapp')
+   * if (data) {
+   *   console.log(`Applied: ${data.applied.length}, Failed: ${data.failed.length}`)
+   * }
+   * ```
+   */
+  async applyPending(namespace = "default") {
+    try {
+      const data = await this.fetch.post("/api/v1/admin/migrations/apply-pending", { namespace });
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution history for a migration
+   *
+   * @param name - Migration name
+   * @param namespace - Migration namespace (default: 'default')
+   * @param limit - Maximum number of executions to return (default: 50, max: 100)
+   * @returns Promise resolving to { data, error } tuple with execution records
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.migrations.getExecutions(
+   *   '001_create_users',
+   *   'myapp',
+   *   10
+   * )
+   * if (data) {
+   *   data.forEach(exec => {
+   *     console.log(`${exec.executed_at}: ${exec.action} - ${exec.status}`)
+   *   })
+   * }
+   * ```
+   */
+  async getExecutions(name, namespace = "default", limit = 50) {
+    try {
+      const params = new URLSearchParams({ namespace, limit: limit.toString() });
+      const data = await this.fetch.get(
+        `/api/v1/admin/migrations/${name}/executions?${params.toString()}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/admin-jobs.ts
+var esbuild = null;
+async function loadEsbuild() {
+  if (esbuild) return true;
+  try {
+    esbuild = await import('esbuild');
+    return true;
+  } catch {
+    return false;
+  }
+}
+var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Create a new job function
+   *
+   * @param request - Job function configuration and code
+   * @returns Promise resolving to { data, error } tuple with created job function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.create({
+   *   name: 'process-data',
+   *   code: 'export async function handler(req) { return { success: true } }',
+   *   enabled: true,
+   *   timeout_seconds: 300
+   * })
+   * ```
+   */
+  async create(request) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/jobs/functions",
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all namespaces that have job functions
+   *
+   * @returns Promise resolving to { data, error } tuple with array of namespace strings
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.listNamespaces()
+   * if (data) {
+   *   console.log('Available namespaces:', data)
+   * }
+   * ```
+   */
+  async listNamespaces() {
+    try {
+      const response = await this.fetch.get(
+        "/api/v1/admin/jobs/namespaces"
+      );
+      return { data: response.namespaces || ["default"], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all job functions (admin view)
+   *
+   * @param namespace - Optional namespace filter
+   * @returns Promise resolving to { data, error } tuple with array of job functions
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.list('default')
+   * if (data) {
+   *   console.log('Job functions:', data.map(f => f.name))
+   * }
+   * ```
+   */
+  async list(namespace) {
+    try {
+      const params = namespace ? `?namespace=${namespace}` : "";
+      const data = await this.fetch.get(
+        `/api/v1/admin/jobs/functions${params}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific job function
+   *
+   * @param namespace - Namespace
+   * @param name - Job function name
+   * @returns Promise resolving to { data, error } tuple with job function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.get('default', 'process-data')
+   * if (data) {
+   *   console.log('Job function version:', data.version)
+   * }
+   * ```
+   */
+  async get(namespace, name) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/jobs/functions/${namespace}/${name}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an existing job function
+   *
+   * @param namespace - Namespace
+   * @param name - Job function name
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated job function metadata
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.update('default', 'process-data', {
+   *   enabled: false,
+   *   timeout_seconds: 600
+   * })
+   * ```
+   */
+  async update(namespace, name, updates) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/jobs/functions/${namespace}/${name}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a job function
+   *
+   * @param namespace - Namespace
+   * @param name - Job function name
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.delete('default', 'process-data')
+   * ```
+   */
+  async delete(namespace, name) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/jobs/functions/${namespace}/${name}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all jobs (executions) across all namespaces (admin view)
+   *
+   * @param filters - Optional filters (status, namespace, limit, offset)
+   * @returns Promise resolving to { data, error } tuple with array of jobs
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.listJobs({
+   *   status: 'running',
+   *   namespace: 'default',
+   *   limit: 50
+   * })
+   * if (data) {
+   *   data.forEach(job => {
+   *     console.log(`${job.job_name}: ${job.status}`)
+   *   })
+   * }
+   * ```
+   */
+  async listJobs(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters?.status) params.append("status", filters.status);
+      if (filters?.namespace) params.append("namespace", filters.namespace);
+      if (filters?.limit) params.append("limit", filters.limit.toString());
+      if (filters?.offset) params.append("offset", filters.offset.toString());
+      const queryString = params.toString();
+      const data = await this.fetch.get(
+        `/api/v1/admin/jobs/queue${queryString ? `?${queryString}` : ""}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific job (execution)
+   *
+   * @param jobId - Job ID
+   * @returns Promise resolving to { data, error } tuple with job details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.getJob('550e8400-e29b-41d4-a716-446655440000')
+   * if (data) {
+   *   console.log(`Job ${data.job_name}: ${data.status}`)
+   * }
+   * ```
+   */
+  async getJob(jobId) {
+    try {
+      const data = await this.fetch.get(`/api/v1/admin/jobs/queue/${jobId}`);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Cancel a running or pending job
+   *
+   * @param jobId - Job ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.cancel('550e8400-e29b-41d4-a716-446655440000')
+   * ```
+   */
+  async cancel(jobId) {
+    try {
+      await this.fetch.post(`/api/v1/admin/jobs/queue/${jobId}/cancel`, {});
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Terminate a running job immediately
+   *
+   * @param jobId - Job ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.terminate('550e8400-e29b-41d4-a716-446655440000')
+   * ```
+   */
+  async terminate(jobId) {
+    try {
+      await this.fetch.post(`/api/v1/admin/jobs/queue/${jobId}/terminate`, {});
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Retry a failed job
+   *
+   * @param jobId - Job ID
+   * @returns Promise resolving to { data, error } tuple with new job
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.retry('550e8400-e29b-41d4-a716-446655440000')
+   * ```
+   */
+  async retry(jobId) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/jobs/queue/${jobId}/retry`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get job statistics
+   *
+   * @param namespace - Optional namespace filter
+   * @returns Promise resolving to { data, error } tuple with job stats
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.getStats('default')
+   * if (data) {
+   *   console.log(`Pending: ${data.pending}, Running: ${data.running}`)
+   * }
+   * ```
+   */
+  async getStats(namespace) {
+    try {
+      const params = namespace ? `?namespace=${namespace}` : "";
+      const data = await this.fetch.get(
+        `/api/v1/admin/jobs/stats${params}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List active workers
+   *
+   * @returns Promise resolving to { data, error } tuple with array of workers
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.listWorkers()
+   * if (data) {
+   *   data.forEach(worker => {
+   *     console.log(`Worker ${worker.id}: ${worker.current_jobs} jobs`)
+   *   })
+   * }
+   * ```
+   */
+  async listWorkers() {
+    try {
+      const data = await this.fetch.get(
+        "/api/v1/admin/jobs/workers"
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Sync multiple job functions to a namespace
+   *
+   * Can sync from:
+   * 1. Filesystem (if no jobs provided) - loads from configured jobs directory
+   * 2. API payload (if jobs array provided) - syncs provided job specifications
+   *
+   * Requires service_role or admin authentication.
+   *
+   * @param options - Sync options including namespace and optional jobs array
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * // Sync from filesystem
+   * const { data, error } = await client.admin.jobs.sync({ namespace: 'default' })
+   *
+   * // Sync with pre-bundled code (client-side bundling)
+   * const bundled = await FluxbaseAdminJobs.bundleCode({ code: myJobCode })
+   * const { data, error } = await client.admin.jobs.sync({
+   *   namespace: 'default',
+   *   functions: [{
+   *     name: 'my-job',
+   *     code: bundled.code,
+   *     is_pre_bundled: true,
+   *     original_code: myJobCode,
+   *   }],
+   *   options: {
+   *     delete_missing: true, // Remove jobs not in this sync
+   *     dry_run: false,       // Preview changes without applying
+   *   }
+   * })
+   *
+   * if (data) {
+   *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+   * }
+   * ```
+   */
+  async sync(options) {
+    try {
+      const syncOptions = typeof options === "string" ? { namespace: options } : options;
+      const data = await this.fetch.post(
+        "/api/v1/admin/jobs/sync",
+        {
+          namespace: syncOptions.namespace,
+          jobs: syncOptions.functions,
+          options: {
+            delete_missing: syncOptions.options?.delete_missing ?? false,
+            dry_run: syncOptions.options?.dry_run ?? false
+          }
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Sync job functions with automatic client-side bundling
+   *
+   * This is a convenience method that bundles all job code using esbuild
+   * before sending to the server. Requires esbuild as a peer dependency.
+   *
+   * @param options - Sync options including namespace and jobs array
+   * @param bundleOptions - Optional bundling configuration
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.jobs.syncWithBundling({
+   *   namespace: 'default',
+   *   functions: [
+   *     { name: 'process-data', code: processDataCode },
+   *     { name: 'send-email', code: sendEmailCode },
+   *   ],
+   *   options: { delete_missing: true }
+   * })
+   * ```
+   */
+  async syncWithBundling(options, bundleOptions) {
+    if (!options.functions || options.functions.length === 0) {
+      return this.sync(options);
+    }
+    const hasEsbuild = await loadEsbuild();
+    if (!hasEsbuild) {
+      return {
+        data: null,
+        error: new Error(
+          "esbuild is required for client-side bundling. Install it with: npm install esbuild"
+        )
+      };
+    }
+    try {
+      const bundledFunctions = await Promise.all(
+        options.functions.map(async (fn) => {
+          if (fn.is_pre_bundled) {
+            return fn;
+          }
+          const bundled = await _FluxbaseAdminJobs.bundleCode({
+            code: fn.code,
+            ...bundleOptions
+          });
+          return {
+            ...fn,
+            code: bundled.code,
+            original_code: fn.code,
+            is_pre_bundled: true
+          };
+        })
+      );
+      return this.sync({
+        ...options,
+        functions: bundledFunctions
+      });
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Bundle job code using esbuild (client-side)
+   *
+   * Transforms and bundles TypeScript/JavaScript code into a single file
+   * that can be executed by the Fluxbase jobs runtime.
+   *
+   * Requires esbuild as a peer dependency.
+   *
+   * @param options - Bundle options including source code
+   * @returns Promise resolving to bundled code
+   * @throws Error if esbuild is not available
+   *
+   * @example
+   * ```typescript
+   * const bundled = await FluxbaseAdminJobs.bundleCode({
+   *   code: `
+   *     import { helper } from './utils'
+   *     export async function handler(req) {
+   *       return helper(req.payload)
+   *     }
+   *   `,
+   *   minify: true,
+   * })
+   *
+   * // Use bundled code in sync
+   * await client.admin.jobs.sync({
+   *   namespace: 'default',
+   *   functions: [{
+   *     name: 'my-job',
+   *     code: bundled.code,
+   *     is_pre_bundled: true,
+   *   }]
+   * })
+   * ```
+   */
+  static async bundleCode(options) {
+    const hasEsbuild = await loadEsbuild();
+    if (!hasEsbuild || !esbuild) {
+      throw new Error(
+        "esbuild is required for bundling. Install it with: npm install esbuild"
+      );
+    }
+    const result = await esbuild.build({
+      stdin: {
+        contents: options.code,
+        loader: "ts",
+        resolveDir: process.cwd?.() || "/"
+      },
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "neutral",
+      target: "esnext",
+      minify: options.minify ?? false,
+      sourcemap: options.sourcemap ? "inline" : false,
+      external: options.external ?? [],
+      // Preserve handler export
+      treeShaking: true
+    });
+    const output = result.outputFiles?.[0];
+    if (!output) {
+      throw new Error("Bundling failed: no output generated");
+    }
+    return {
+      code: output.text,
+      sourceMap: options.sourcemap ? output.text : void 0
+    };
+  }
+};
+
 // src/admin.ts
 var FluxbaseAdmin = class {
   constructor(fetch2) {
@@ -3865,6 +5161,9 @@ var FluxbaseAdmin = class {
     this.impersonation = new ImpersonationManager(fetch2);
     this.management = new FluxbaseManagement(fetch2);
     this.emailTemplates = new EmailTemplateManager(fetch2);
+    this.functions = new FluxbaseAdminFunctions(fetch2);
+    this.jobs = new FluxbaseAdminJobs(fetch2);
+    this.migrations = new FluxbaseAdminMigrations(fetch2);
   }
   /**
    * Set admin authentication token
@@ -5061,6 +6360,7 @@ var FluxbaseClient = class {
     );
     this.storage = new FluxbaseStorage(this.fetch);
     this.functions = new FluxbaseFunctions(this.fetch);
+    this.jobs = new FluxbaseJobs(this.fetch);
     this.admin = new FluxbaseAdmin(this.fetch);
     this.management = new FluxbaseManagement(this.fetch);
     this.settings = new SettingsClient(this.fetch);
@@ -5233,10 +6533,14 @@ exports.AuthSettingsManager = AuthSettingsManager;
 exports.DDLManager = DDLManager;
 exports.EmailTemplateManager = EmailTemplateManager;
 exports.FluxbaseAdmin = FluxbaseAdmin;
+exports.FluxbaseAdminFunctions = FluxbaseAdminFunctions;
+exports.FluxbaseAdminJobs = FluxbaseAdminJobs;
+exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
 exports.FluxbaseFunctions = FluxbaseFunctions;
+exports.FluxbaseJobs = FluxbaseJobs;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;
 exports.FluxbaseRealtime = FluxbaseRealtime;