@fluxbase/sdk 2026.2.3-rc.8 → 2026.2.3

package/dist/index.cjs

@@ -3645,8 +3645,43 @@ var FluxbaseFunctions = class {
 
 // src/jobs.ts
 var FluxbaseJobs = class {
-  constructor(fetch2) {
+  constructor(fetch2, isServiceRole = false) {
+    this.cachedRole = null;
+    this.ROLE_CACHE_TTL = 5 * 60 * 1e3;
     this.fetch = fetch2;
+    this.isServiceRole = isServiceRole;
+  }
+  /**
+   * Get the current user's role from user_profiles table
+   * This is used to auto-populate the onBehalfOf parameter when submitting jobs
+   *
+   * @returns Promise resolving to the user's role or null if not found
+   */
+  async getCurrentUserRole(userId) {
+    try {
+      const now = Date.now();
+      if (this.cachedRole && this.cachedRole.userId === userId && this.cachedRole.expiresAt > now) {
+        return this.cachedRole.role;
+      }
+      const profileResult = await this.fetch.get(
+        `/rest/v1/user_profiles?id=eq.${userId}&select=role`
+      );
+      if (!profileResult || !profileResult[0]) {
+        return null;
+      }
+      const role = profileResult[0].role;
+      if (role) {
+        this.cachedRole = {
+          userId,
+          role,
+          expiresAt: now + this.ROLE_CACHE_TTL
+        };
+      }
+      return role;
+    } catch (error) {
+      console.warn("[FluxbaseJobs] Failed to fetch user role:", error);
+      return null;
+    }
   }
   /**
    * Submit a new job for execution
@@ -3691,13 +3726,27 @@ var FluxbaseJobs = class {
    */
   async submit(jobName, payload, options) {
     try {
+      let finalOnBehalfOf = options?.onBehalfOf;
+      if (this.isServiceRole && !finalOnBehalfOf) {
+        const userResponse = await this.fetch.get("/api/v1/auth/user");
+        if (userResponse?.user) {
+          const user = userResponse.user;
+          const role = await this.getCurrentUserRole(user.id);
+          finalOnBehalfOf = {
+            user_id: user.id,
+            user_email: user.email,
+            user_role: role || void 0
+            // Include role if found
+          };
+        }
+      }
       const request = {
         job_name: jobName,
         payload,
         priority: options?.priority,
         namespace: options?.namespace,
         scheduled: options?.scheduled,
-        on_behalf_of: options?.onBehalfOf
+        on_behalf_of: finalOnBehalfOf
       };
       const data = await this.fetch.post("/api/v1/jobs/submit", request);
       return { data, error: null };
@@ -8514,6 +8563,454 @@ var FluxbaseAdminAI = class {
       return { data: null, error };
     }
   }
+  // ============================================================================
+  // DOCUMENT UPDATE AND BULK DELETE
+  // ============================================================================
+  /**
+   * Update a document in a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param documentId - Document ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated document
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.updateDocument('kb-uuid', 'doc-uuid', {
+   *   title: 'Updated Title',
+   *   tags: ['updated', 'tag'],
+   *   metadata: { category: 'updated' },
+   * })
+   * ```
+   */
+  async updateDocument(knowledgeBaseId, documentId, updates) {
+    try {
+      const data = await this.fetch.patch(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents/${documentId}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete documents from a knowledge base by filter
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param filter - Filter criteria for deletion
+   * @returns Promise resolving to { data, error } tuple with deletion count
+   *
+   * @example
+   * ```typescript
+   * // Delete by tags
+   * const { data, error } = await client.admin.ai.deleteDocumentsByFilter('kb-uuid', {
+   *   tags: ['deprecated', 'archive'],
+   * })
+   *
+   * // Delete by metadata
+   * const { data, error } = await client.admin.ai.deleteDocumentsByFilter('kb-uuid', {
+   *   metadata: { source: 'legacy-system' },
+   * })
+   *
+   * if (data) {
+   *   console.log(`Deleted ${data.deleted_count} documents`)
+   * }
+   * ```
+   */
+  async deleteDocumentsByFilter(knowledgeBaseId, filter) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents/delete-by-filter`,
+        filter
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // KNOWLEDGE BASE CAPABILITIES
+  // ============================================================================
+  /**
+   * Get knowledge base system capabilities
+   *
+   * Returns information about OCR support, supported file types, etc.
+   *
+   * @returns Promise resolving to { data, error } tuple with capabilities
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getCapabilities()
+   * if (data) {
+   *   console.log('OCR available:', data.ocr_available)
+   *   console.log('Supported types:', data.supported_file_types)
+   * }
+   * ```
+   */
+  async getCapabilities() {
+    try {
+      const data = await this.fetch.get(
+        "/api/v1/admin/ai/knowledge-bases/capabilities"
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // KNOWLEDGE GRAPH / ENTITIES
+  // ============================================================================
+  /**
+   * List entities in a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param entityType - Optional entity type filter
+   * @returns Promise resolving to { data, error } tuple with array of entities
+   *
+   * @example
+   * ```typescript
+   * // List all entities
+   * const { data, error } = await client.admin.ai.listEntities('kb-uuid')
+   *
+   * // Filter by type
+   * const { data, error } = await client.admin.ai.listEntities('kb-uuid', 'person')
+   *
+   * if (data) {
+   *   console.log('Entities:', data.map(e => e.name))
+   * }
+   * ```
+   */
+  async listEntities(knowledgeBaseId, entityType) {
+    try {
+      const params = entityType ? `?entity_type=${entityType}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/entities${params}`
+      );
+      return { data: response.entities || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Search for entities in a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param query - Search query
+   * @param types - Optional entity type filters
+   * @returns Promise resolving to { data, error } tuple with matching entities
+   *
+   * @example
+   * ```typescript
+   * // Search all entity types
+   * const { data, error } = await client.admin.ai.searchEntities('kb-uuid', 'John')
+   *
+   * // Search specific types
+   * const { data, error } = await client.admin.ai.searchEntities('kb-uuid', 'Apple', ['organization', 'product'])
+   *
+   * if (data) {
+   *   console.log('Found entities:', data.map(e => `${e.name} (${e.entity_type})`))
+   * }
+   * ```
+   */
+  async searchEntities(knowledgeBaseId, query, types) {
+    try {
+      const params = new URLSearchParams({ query });
+      if (types && types.length > 0) {
+        params.append("types", types.join(","));
+      }
+      const response = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/entities/search?${params.toString()}`
+      );
+      return { data: response.entities || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get relationships for a specific entity
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param entityId - Entity ID
+   * @returns Promise resolving to { data, error } tuple with entity relationships
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getEntityRelationships('kb-uuid', 'entity-uuid')
+   * if (data) {
+   *   console.log('Relationships:', data.map(r => `${r.relationship_type} -> ${r.target_entity?.name}`))
+   * }
+   * ```
+   */
+  async getEntityRelationships(knowledgeBaseId, entityId) {
+    try {
+      const response = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/entities/${entityId}/relationships`
+      );
+      return { data: response.relationships || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get the knowledge graph for a knowledge base
+   *
+   * Returns all entities and relationships for visualization.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple with graph data
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getKnowledgeGraph('kb-uuid')
+   * if (data) {
+   *   console.log('Graph:', data.entity_count, 'entities,', data.relationship_count, 'relationships')
+   *   // Use with visualization libraries like D3.js, Cytoscape.js, etc.
+   * }
+   * ```
+   */
+  async getKnowledgeGraph(knowledgeBaseId) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/graph`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // KNOWLEDGE BASE REVERSE LOOKUP
+  // ============================================================================
+  /**
+   * List all chatbots that use a specific knowledge base
+   *
+   * Reverse lookup to find which chatbots are linked to a knowledge base.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple with array of chatbot summaries
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listChatbotsUsingKB('kb-uuid')
+   * if (data) {
+   *   console.log('Used by chatbots:', data.map(c => c.name))
+   * }
+   * ```
+   */
+  async listChatbotsUsingKB(knowledgeBaseId) {
+    try {
+      const response = await this.fetch.get(`/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/chatbots`);
+      return { data: response.chatbots || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // TABLE EXPORT
+  // ============================================================================
+  /**
+   * Export a database table to a knowledge base
+   *
+   * The table schema will be exported as a markdown document and indexed.
+   * Optionally filter which columns to export for security or relevance.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param options - Export options including column selection
+   * @returns Promise resolving to { data, error } tuple with export result
+   *
+   * @example
+   * ```typescript
+   * // Export all columns
+   * const { data, error } = await client.admin.ai.exportTable('kb-uuid', {
+   *   schema: 'public',
+   *   table: 'users',
+   *   include_foreign_keys: true,
+   * })
+   *
+   * // Export specific columns (recommended for sensitive data)
+   * const { data, error } = await client.admin.ai.exportTable('kb-uuid', {
+   *   schema: 'public',
+   *   table: 'users',
+   *   columns: ['id', 'name', 'email', 'created_at'],
+   * })
+   * ```
+   */
+  async exportTable(knowledgeBaseId, options) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/tables/export`,
+        options
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get detailed table information including columns
+   *
+   * Use this to discover available columns before exporting.
+   *
+   * @param schema - Schema name (e.g., 'public')
+   * @param table - Table name
+   * @returns Promise resolving to { data, error } tuple with table details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getTableDetails('public', 'users')
+   * if (data) {
+   *   console.log('Columns:', data.columns.map(c => c.name))
+   *   console.log('Primary key:', data.primary_key)
+   * }
+   * ```
+   */
+  async getTableDetails(schema, table) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/tables/${schema}/${table}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // TABLE EXPORT PRESETS
+  // ============================================================================
+  /**
+   * Create a table export preset
+   *
+   * Saves a table export configuration for easy re-export. Use triggerTableExportSync
+   * to re-export when the schema changes.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param config - Export preset configuration
+   * @returns Promise resolving to { data, error } tuple with created preset
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.createTableExportSync('kb-uuid', {
+   *   schema_name: 'public',
+   *   table_name: 'products',
+   *   columns: ['id', 'name', 'description', 'price'],
+   *   include_foreign_keys: true,
+   *   export_now: true, // Trigger initial export
+   * })
+   * ```
+   */
+  async createTableExportSync(knowledgeBaseId, config) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/sync-configs`,
+        config
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List table export presets for a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple with array of presets
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listTableExportSyncs('kb-uuid')
+   * if (data) {
+   *   data.forEach(config => {
+   *     console.log(`${config.schema_name}.${config.table_name}`)
+   *   })
+   * }
+   * ```
+   */
+  async listTableExportSyncs(knowledgeBaseId) {
+    try {
+      const response = await this.fetch.get(`/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/sync-configs`);
+      return { data: response.sync_configs || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update a table export preset
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param syncId - Preset ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated preset
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.updateTableExportSync('kb-uuid', 'sync-id', {
+   *   columns: ['id', 'name', 'email', 'updated_at'],
+   * })
+   * ```
+   */
+  async updateTableExportSync(knowledgeBaseId, syncId, updates) {
+    try {
+      const data = await this.fetch.patch(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/sync-configs/${syncId}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a table export sync configuration
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param syncId - Sync config ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.deleteTableExportSync('kb-uuid', 'sync-id')
+   * ```
+   */
+  async deleteTableExportSync(knowledgeBaseId, syncId) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/sync-configs/${syncId}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Manually trigger a table export sync
+   *
+   * Immediately re-exports the table to the knowledge base,
+   * regardless of the sync mode.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param syncId - Sync config ID
+   * @returns Promise resolving to { data, error } tuple with export result
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.triggerTableExportSync('kb-uuid', 'sync-id')
+   * if (data) {
+   *   console.log('Exported document:', data.document_id)
+   * }
+   * ```
+   */
+  async triggerTableExportSync(knowledgeBaseId, syncId) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/sync-configs/${syncId}/trigger`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
 };
 
 // src/admin-rpc.ts
@@ -12090,7 +12587,7 @@ var FluxbaseClient = class {
     );
     this.storage = new FluxbaseStorage(this.fetch);
     this.functions = new FluxbaseFunctions(this.fetch);
-    this.jobs = new FluxbaseJobs(this.fetch);
+    this.jobs = new FluxbaseJobs(this.fetch, options?.serviceRole ?? false);
     this.admin = new FluxbaseAdmin(this.fetch);
     this.management = new FluxbaseManagement(this.fetch);
     this.settings = new SettingsClient(this.fetch);
@@ -12292,18 +12789,28 @@ function getEnvVar(name) {
 }
 function createClient(fluxbaseUrl, fluxbaseKey, options) {
   const url = fluxbaseUrl || getEnvVar("FLUXBASE_URL") || getEnvVar("NEXT_PUBLIC_FLUXBASE_URL") || getEnvVar("VITE_FLUXBASE_URL");
-  const key = fluxbaseKey || getEnvVar("FLUXBASE_ANON_KEY") || getEnvVar("FLUXBASE_SERVICE_TOKEN") || getEnvVar("FLUXBASE_JOB_TOKEN") || getEnvVar("NEXT_PUBLIC_FLUXBASE_ANON_KEY") || getEnvVar("VITE_FLUXBASE_ANON_KEY");
+  const resolvedKey = fluxbaseKey || getEnvVar("FLUXBASE_SERVICE_TOKEN") || getEnvVar("FLUXBASE_ANON_KEY") || getEnvVar("FLUXBASE_JOB_TOKEN") || getEnvVar("NEXT_PUBLIC_FLUXBASE_ANON_KEY") || getEnvVar("VITE_FLUXBASE_ANON_KEY");
+  let isServiceRole = options?.serviceRole ?? false;
+  if (!fluxbaseKey && getEnvVar("FLUXBASE_SERVICE_TOKEN")) {
+    isServiceRole = true;
+  }
+  if (options?.serviceRole !== void 0) {
+    isServiceRole = options.serviceRole;
+  }
   if (!url) {
     throw new Error(
       "Fluxbase URL is required. Pass it as the first argument or set FLUXBASE_URL environment variable."
     );
   }
-  if (!key) {
+  if (!resolvedKey) {
     throw new Error(
       "Fluxbase key is required. Pass it as the second argument or set FLUXBASE_ANON_KEY environment variable."
     );
   }
-  return new FluxbaseClient(url, key, options);
+  return new FluxbaseClient(url, resolvedKey, {
+    ...options,
+    serviceRole: isServiceRole
+  });
 }
 
 // src/type-guards.ts