@boltic/sdk 0.0.6 → 0.0.8

package/dist/sdk.mjs

@@ -109,6 +109,12 @@ let AuthManager$1 = class AuthManager {
     }
   }
 };
+function isErrorResponse(response) {
+  return "error" in response && response.error !== void 0;
+}
+function isListResponse(response) {
+  return "pagination" in response;
+}
 class ValidationError extends Error {
   constructor(message, failures = []) {
     super(message);
@@ -228,7 +234,7 @@ class AuthManager2 {
     };
   }
   // Custom inspect method for Node.js console logging
-  [Symbol.for("nodejs.util.inspect.custom")]() {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return this.toString();
   }
 }
@@ -505,14 +511,16 @@ class InterceptorManagerImpl {
   }
   async executeRequestInterceptors(config) {
     let result = config;
-    for (const interceptor of this.requestInterceptors.values()) {
+    for (const interceptor of Array.from(this.requestInterceptors.values())) {
       result = await interceptor(result);
     }
     return result;
   }
   async executeResponseInterceptors(response) {
     let result = response;
-    for (const { fulfilled } of this.responseInterceptors.values()) {
+    for (const { fulfilled } of Array.from(
+      this.responseInterceptors.values()
+    )) {
       if (fulfilled) {
         result = await fulfilled(result);
       }
@@ -521,7 +529,7 @@ class InterceptorManagerImpl {
   }
   async executeErrorInterceptors(error) {
     let result = error;
-    for (const { rejected } of this.responseInterceptors.values()) {
+    for (const { rejected } of Array.from(this.responseInterceptors.values())) {
       if (rejected) {
         result = await rejected(result);
       }
@@ -728,7 +736,7 @@ class ConfigManager {
     return safeConfig;
   }
   // Custom inspect method for Node.js console logging
-  [Symbol.for("nodejs.util.inspect.custom")]() {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return this.toString();
   }
 }
@@ -750,6 +758,13 @@ function filterArrayFields(arr, fields) {
   }
   return arr.map((obj) => filterObjectFields(obj, fields));
 }
+function addDbIdToUrl(url, dbId) {
+  if (!dbId || dbId === "") {
+    return url;
+  }
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}db_id=${encodeURIComponent(dbId)}`;
+}
 const COLUMN_ENDPOINTS = {
   list: {
     path: "/tables/{table_id}/fields/list",
@@ -983,7 +998,8 @@ class ColumnsApiClient {
   async listColumns(tableId, options = {}) {
     try {
       const endpoint = COLUMN_ENDPOINTS.list;
-      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, { table_id: tableId })}?no_cache=true`;
+      let url = `${this.baseURL}${buildEndpointPath$1(endpoint, { table_id: tableId })}?no_cache=true`;
+      url = addDbIdToUrl(url, options.db_id);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -1452,7 +1468,8 @@ class TablesApiClient {
   async createTable(request, options = {}) {
     try {
       const endpoint = TABLE_ENDPOINTS.create;
-      const url = `${this.baseURL}${endpoint.path}`;
+      let url = `${this.baseURL}${endpoint.path}`;
+      url = addDbIdToUrl(url, options.db_id);
       const transformedRequest = transformTableCreateRequest(request, options);
       const response = await this.httpAdapter.request({
         url,
@@ -1472,7 +1489,8 @@ class TablesApiClient {
   async listTables(options = {}) {
     try {
       const endpoint = TABLE_ENDPOINTS.list;
-      const url = `${this.baseURL}${endpoint.path}`;
+      let url = `${this.baseURL}${endpoint.path}`;
+      url = addDbIdToUrl(url, options.db_id);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -1498,7 +1516,8 @@ class TablesApiClient {
   async getTable(tableId, options = {}) {
     try {
       const endpoint = TABLE_ENDPOINTS.get;
-      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, options.db_id);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -1522,9 +1541,10 @@ class TablesApiClient {
    */
   async updateTable(tableId, updates) {
     try {
-      const { fields, ...updateData } = updates;
+      const { fields, db_id, ...updateData } = updates;
       const endpoint = TABLE_ENDPOINTS.update;
-      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, db_id);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -1547,10 +1567,11 @@ class TablesApiClient {
   /**
    * Delete a table
    */
-  async deleteTable(tableId) {
+  async deleteTable(tableId, options = {}) {
     try {
       const endpoint = TABLE_ENDPOINTS.delete;
-      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, options.db_id);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -1605,12 +1626,6 @@ class TablesApiClient {
     };
   }
 }
-function isErrorResponse(response) {
-  return "error" in response && response.error !== void 0;
-}
-function isListResponse(response) {
-  return "pagination" in response;
-}
 class BaseResource {
   constructor(client, basePath) {
     this.client = client;
@@ -1711,13 +1726,16 @@ class TableResource extends BaseResource {
   /**
    * Create a new table
    */
-  async create(data) {
+  async create(data, dbId) {
     try {
       const processedData = { ...data };
       if (data.fields && data.fields.length > 0) {
         processedData.fields = await this.processFieldsDefaults(data.fields);
       }
-      const result = await this.tablesApiClient.createTable(processedData);
+      const result = await this.tablesApiClient.createTable(
+        processedData,
+        dbId ? { db_id: dbId } : {}
+      );
       if (isErrorResponse(result)) {
         throw new ApiError(
           result.error.message || "Create table failed",
@@ -1800,12 +1818,17 @@ class TableResource extends BaseResource {
   /**
    * Find all tables with optional filtering
    */
-  async findAll(options = {}) {
+  async findAll(options = {}, dbId) {
     try {
       const apiRequest = this.transformTableQueryToApiRequest(options);
-      const result = await this.tablesApiClient.listTables(
-        apiRequest
-      );
+      const requestPayload = {
+        page: apiRequest.page,
+        filters: apiRequest.filters,
+        sort: apiRequest.sort,
+        ...dbId && { db_id: dbId },
+        ...options.fields && { fields: options.fields }
+      };
+      const result = await this.tablesApiClient.listTables(requestPayload);
       if (isErrorResponse(result)) {
         throw new ApiError(
           result.error.message || "List tables failed",
@@ -1821,7 +1844,7 @@ class TableResource extends BaseResource {
   /**
    * Find a single table by ID or name
    */
-  async findOne(options) {
+  async findOne(options, dbId) {
     try {
       if (!options.where?.id && !options.where?.name) {
         throw new ValidationError(
@@ -1830,7 +1853,8 @@ class TableResource extends BaseResource {
       }
       if (options.where?.id) {
         const result = await this.tablesApiClient.getTable(
-          options.where.id
+          options.where.id,
+          dbId ? { db_id: dbId } : {}
         );
         if (isErrorResponse(result)) {
           if (result.error.code === "TABLE_NOT_FOUND") {
@@ -1858,9 +1882,13 @@ class TableResource extends BaseResource {
           ],
           sort: []
         };
-        const listResult = await this.tablesApiClient.listTables(
-          apiRequest
-        );
+        const requestPayload = {
+          page: apiRequest.page,
+          filters: apiRequest.filters,
+          sort: apiRequest.sort,
+          ...dbId && { db_id: dbId }
+        };
+        const listResult = await this.tablesApiClient.listTables(requestPayload);
         if (isErrorResponse(listResult)) {
           throw new ApiError(
             listResult.error.message || "Find table by name failed",
@@ -1881,21 +1909,21 @@ class TableResource extends BaseResource {
   /**
    * Find a single table by name
    */
-  async findByName(name) {
-    return this.findOne({ where: { name } });
+  async findByName(name, dbId) {
+    return this.findOne({ where: { name } }, dbId);
   }
   /**
    * Find a single table by ID
    */
-  async findById(id) {
-    return this.findOne({ where: { id } });
+  async findById(id, dbId) {
+    return this.findOne({ where: { id } }, dbId);
   }
   /**
    * Update a table by name
    */
-  async update(name, data) {
+  async update(name, data, dbId) {
     try {
-      const tableResult = await this.findByName(name);
+      const tableResult = await this.findByName(name, dbId);
       if (!tableResult.data) {
         throw new ApiError(`Table '${name}' not found`, 404);
       }
@@ -1907,7 +1935,7 @@ class TableResource extends BaseResource {
       }
       const result = await this.tablesApiClient.updateTable(
         tableResult.data.id,
-        data
+        dbId ? { ...data, db_id: dbId } : data
       );
       if (isErrorResponse(result)) {
         throw new ApiError(
@@ -1924,9 +1952,9 @@ class TableResource extends BaseResource {
   /**
    * Delete a table by name
    */
-  async delete(name) {
+  async delete(name, dbId) {
     try {
-      const tableResult = await this.findByName(name);
+      const tableResult = await this.findByName(name, dbId);
       if (!tableResult.data) {
         throw new ApiError(`Table '${name}' not found`, 404);
       }
@@ -1937,7 +1965,8 @@ class TableResource extends BaseResource {
         );
       }
       const result = await this.tablesApiClient.deleteTable(
-        tableResult.data.id
+        tableResult.data.id,
+        dbId ? { db_id: dbId } : {}
       );
       if (isErrorResponse(result)) {
         throw new ApiError(
@@ -1954,11 +1983,15 @@ class TableResource extends BaseResource {
   /**
    * Rename a table
    */
-  async rename(oldName, newName) {
+  async rename(oldName, newName, dbId) {
     try {
-      const result = await this.update(oldName, {
-        name: newName
-      });
+      const result = await this.update(
+        oldName,
+        {
+          name: newName
+        },
+        dbId
+      );
       return result;
     } catch (error) {
       throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
@@ -1967,11 +2000,15 @@ class TableResource extends BaseResource {
   /**
    * Set table access permissions
    */
-  async setAccess(request) {
+  async setAccess(request, dbId) {
     try {
-      const result = await this.update(request.table_name, {
-        is_shared: request.is_shared
-      });
+      const result = await this.update(
+        request.table_name,
+        {
+          is_shared: request.is_shared
+        },
+        dbId
+      );
       return result;
     } catch (error) {
       throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
@@ -2362,6 +2399,658 @@ class ColumnResource extends BaseResource {
     return tableInfo?.id || null;
   }
 }
+const DATABASE_ENDPOINTS = {
+  create: {
+    path: "/tables/databases",
+    method: "POST",
+    authenticated: true
+  },
+  list: {
+    path: "/tables/databases/list",
+    method: "POST",
+    authenticated: true
+  },
+  update: {
+    path: "/tables/databases/{db_id}",
+    method: "PATCH",
+    authenticated: true
+  },
+  delete: {
+    path: "/tables/databases/{db_id}",
+    method: "DELETE",
+    authenticated: true
+  },
+  listJobs: {
+    path: "/tables/databases/jobs/list",
+    method: "POST",
+    authenticated: true
+  },
+  pollDeleteStatus: {
+    path: "/tables/databases/delete-status/{job_id}",
+    method: "GET",
+    authenticated: true
+  }
+};
+const buildDatabaseEndpointPath = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, value);
+  });
+  return path;
+};
+class DatabasesApiClient {
+  constructor(apiKey, config = {}) {
+    this.config = { apiKey, ...config };
+    this.httpAdapter = createHttpAdapter();
+    const environment = config.environment || "prod";
+    const region = config.region || "asia-south1";
+    this.baseURL = this.getBaseURL(environment, region);
+  }
+  getBaseURL(environment, region) {
+    const regionConfig = REGION_CONFIGS[region];
+    if (!regionConfig) {
+      throw new Error(`Unsupported region: ${region}`);
+    }
+    const envConfig = regionConfig[environment];
+    if (!envConfig) {
+      throw new Error(
+        `Unsupported environment: ${environment} for region: ${region}`
+      );
+    }
+    return `${envConfig.baseURL}/v1`;
+  }
+  /**
+   * Create a new database
+   */
+  async createDatabase(request) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.create;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        data: request,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * List databases with pagination, sorting, and filtering
+   */
+  async listDatabases(request = {}, queryParams, options) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.list;
+      let url = `${this.baseURL}${endpoint.path}`;
+      const params = new URLSearchParams();
+      if (queryParams?.connector_id) {
+        params.append("connector_id", queryParams.connector_id);
+      }
+      if (queryParams?.add_default_if_missing) {
+        params.append(
+          "add_default_if_missing",
+          queryParams.add_default_if_missing
+        );
+      }
+      if (params.toString()) {
+        url += `?${params.toString()}`;
+      }
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        data: request,
+        timeout: this.config.timeout
+      });
+      const result = response.data;
+      if (options?.fields && !("error" in result)) {
+        return {
+          ...result,
+          data: filterArrayFields(
+            result.data,
+            options.fields
+          )
+        };
+      }
+      return result;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * Update a database
+   */
+  async updateDatabase(dbId, request) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.update;
+      const path = buildDatabaseEndpointPath(endpoint, { db_id: dbId });
+      const url = `${this.baseURL}${path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        data: request,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * Delete a database (initiates deletion job)
+   */
+  async deleteDatabase(dbId) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.delete;
+      const path = buildDatabaseEndpointPath(endpoint, { db_id: dbId });
+      const url = `${this.baseURL}${path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * List database jobs
+   */
+  async listDatabaseJobs(request = {}, options) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.listJobs;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        data: request,
+        timeout: this.config.timeout
+      });
+      const result = response.data;
+      if (options?.fields && !("error" in result)) {
+        return {
+          ...result,
+          data: filterArrayFields(
+            result.data,
+            options.fields
+          )
+        };
+      }
+      return result;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * Poll deletion status for a database job
+   */
+  async pollDeleteStatus(jobId) {
+    try {
+      const endpoint = DATABASE_ENDPOINTS.pollDeleteStatus;
+      const path = buildDatabaseEndpointPath(endpoint, { job_id: jobId });
+      const url = `${this.baseURL}${path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-boltic-token": this.config.apiKey
+        },
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.handleError(error);
+    }
+  }
+  /**
+   * Handle API errors and convert to standard error format
+   */
+  handleError(error) {
+    if (this.config.debug) {
+      console.error("[DatabasesApiClient] Error:", error);
+    }
+    const hasErrorProperty = (err) => {
+      return typeof err === "object" && err !== null && "error" in err && typeof err.error === "object" && err.error !== null;
+    };
+    const hasResponseError = (err) => {
+      return typeof err === "object" && err !== null && "response" in err && typeof err.response === "object" && err.response !== null && "data" in err.response && typeof err.response.data === "object" && err.response.data !== null && "error" in err.response.data;
+    };
+    const isStandardError = (err) => {
+      return err instanceof Error;
+    };
+    if (hasErrorProperty(error)) {
+      const errorWithError = error;
+      return {
+        error: {
+          code: typeof errorWithError.error.code === "number" ? String(errorWithError.error.code) : errorWithError.error.code || "UNKNOWN_ERROR",
+          message: errorWithError.error.message || "An error occurred",
+          meta: errorWithError.error.meta || []
+        }
+      };
+    }
+    if (hasResponseError(error)) {
+      const errorWithResponse = error;
+      return {
+        error: {
+          code: typeof errorWithResponse.response.data.error.code === "number" ? String(errorWithResponse.response.data.error.code) : errorWithResponse.response.data.error.code || "UNKNOWN_ERROR",
+          message: errorWithResponse.response.data.error.message || "An error occurred",
+          meta: errorWithResponse.response.data.error.meta || []
+        }
+      };
+    }
+    if (isStandardError(error)) {
+      const standardError = error;
+      return {
+        error: {
+          code: standardError.code || "UNKNOWN_ERROR",
+          message: standardError.message || "An unexpected error occurred",
+          meta: []
+        }
+      };
+    }
+    return {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: "An unexpected error occurred",
+        meta: []
+      }
+    };
+  }
+}
+class DatabaseResource extends BaseResource {
+  constructor(client) {
+    super(client, "/v1/tables/databases");
+    this.apiClient = new DatabasesApiClient(client.getConfig().apiKey, {
+      environment: client.getConfig().environment,
+      region: client.getConfig().region,
+      timeout: client.getConfig().timeout,
+      debug: client.getConfig().debug
+    });
+  }
+  /**
+   * Create a new database
+   *
+   * @param request - Database creation request
+   * @returns Promise with created database or error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.databases.create({
+   *   db_name: 'My Database',
+   *   db_internal_name: 'my-database',
+   *   resource_id: 'boltic'
+   * });
+   * ```
+   */
+  async create(request) {
+    const result = await this.apiClient.createDatabase(request);
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    return result;
+  }
+  /**
+   * List all databases with optional filtering and pagination
+   * By default, only shows active databases
+   *
+   * @param options - Query options for listing databases
+   * @returns Promise with list of databases or error
+   *
+   * @example
+   * ```typescript
+   * // List all active databases (default)
+   * const result = await client.databases.findAll();
+   *
+   * // List with pagination
+   * const result = await client.databases.findAll({
+   *   page: { page_no: 1, page_size: 10 }
+   * });
+   *
+   * // List with sorting
+   * const result = await client.databases.findAll({
+   *   sort: [{ field: 'db_name', direction: 'asc' }]
+   * });
+   * ```
+   */
+  async findAll(options) {
+    const request = {};
+    if (options?.page) {
+      request.page = options.page;
+    }
+    if (options?.sort) {
+      request.sort = options.sort;
+    }
+    if (options?.filters) {
+      const filtersWithoutStatus = options.filters.filter(
+        (f) => f.field !== "status"
+      );
+      request.filters = [
+        ...filtersWithoutStatus,
+        { field: "status", operator: "=", values: ["ACTIVE"] }
+      ];
+    } else {
+      request.filters = [
+        { field: "status", operator: "=", values: ["ACTIVE"] }
+      ];
+    }
+    const queryParams = {};
+    if (options?.connector_id) {
+      queryParams.connector_id = options.connector_id;
+    }
+    if (options?.add_default_if_missing !== void 0) {
+      queryParams.add_default_if_missing = options.add_default_if_missing ? "true" : "false";
+    }
+    const result = await this.apiClient.listDatabases(
+      request,
+      queryParams,
+      options
+    );
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    if ("pagination" in result && result.pagination) {
+      const pagination = result.pagination;
+      return {
+        ...result,
+        pagination: {
+          total_count: pagination.total_count,
+          total_pages: pagination.total_pages ?? Math.ceil(pagination.total_count / pagination.per_page),
+          current_page: pagination.current_page,
+          per_page: pagination.per_page,
+          type: "page"
+        }
+      };
+    }
+    return result;
+  }
+  /**
+   * Get a specific database by internal name (slug)
+   *
+   * @param dbInternalName - Database internal name (slug)
+   * @param options - Query options (e.g., fields to return)
+   * @returns Promise with database or error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.databases.findOne('my_database_slug');
+   * ```
+   */
+  async findOne(dbInternalName, options) {
+    const result = await this.findAll({
+      filters: [
+        {
+          field: "db_internal_name",
+          operator: "=",
+          values: [dbInternalName]
+        }
+      ],
+      fields: options?.fields,
+      page: { page_no: 1, page_size: 1 }
+    });
+    if (isErrorResponse(result)) {
+      return result;
+    }
+    if (result.data.length === 0) {
+      return {
+        error: {
+          code: "NOT_FOUND",
+          message: `Database with internal name '${dbInternalName}' not found`,
+          meta: []
+        }
+      };
+    }
+    return {
+      data: result.data[0],
+      message: "Database found"
+    };
+  }
+  /**
+   * Get the default database
+   *
+   * @returns Promise with default database or error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.databases.getDefault();
+   * ```
+   */
+  async getDefault() {
+    const result = await this.findAll({
+      filters: [{ field: "is_default", operator: "=", values: [true] }],
+      page: { page_no: 1, page_size: 1 }
+    });
+    if (isErrorResponse(result)) {
+      return result;
+    }
+    if (result.data.length === 0) {
+      return {
+        error: {
+          code: "NOT_FOUND",
+          message: "Default database not found",
+          meta: []
+        }
+      };
+    }
+    return {
+      data: result.data[0],
+      message: "Default database found"
+    };
+  }
+  /**
+   * Update a database
+   * Only allows updating the display name (db_name)
+   *
+   * @param dbInternalName - Database internal name (slug)
+   * @param request - Update request (only db_name is allowed)
+   * @returns Promise with updated database or error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.databases.update('my_database_slug', {
+   *   db_name: 'Updated Database Name'
+   * });
+   * ```
+   */
+  async update(dbInternalName, request) {
+    const dbInfo = await this.findOne(dbInternalName);
+    if (isErrorResponse(dbInfo)) {
+      return {
+        error: {
+          code: "DATABASE_NOT_FOUND",
+          message: `Database with internal name '${dbInternalName}' not found`,
+          meta: []
+        }
+      };
+    }
+    const dbId = dbInfo.data.id;
+    const updateRequest = {
+      db_name: request.db_name
+    };
+    const result = await this.apiClient.updateDatabase(dbId, updateRequest);
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    return result;
+  }
+  /**
+   * Delete a database (initiates async deletion job)
+   *
+   * @param dbInternalName - Database internal name (slug)
+   * @returns Promise with job details or error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.databases.delete('my_database_slug');
+   * if (!result.error) {
+   *   console.log('Deletion job started:', result.data.job_id);
+   *   // Poll for status
+   *   const status = await client.databases.pollDeleteStatus(result.data.job_id);
+   * }
+   * ```
+   */
+  async delete(dbInternalName) {
+    const dbInfo = await this.findOne(dbInternalName);
+    if (isErrorResponse(dbInfo)) {
+      return {
+        error: {
+          code: "DATABASE_NOT_FOUND",
+          message: `Database with internal name '${dbInternalName}' not found`,
+          meta: []
+        }
+      };
+    }
+    if (dbInfo.data.is_default) {
+      return {
+        error: {
+          code: "CANNOT_DELETE_DEFAULT",
+          message: "Cannot delete the default database",
+          meta: []
+        }
+      };
+    }
+    const dbId = dbInfo.data.id;
+    const result = await this.apiClient.deleteDatabase(dbId);
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    return result;
+  }
+  /**
+   * List database jobs (e.g., deletion jobs)
+   *
+   * @param options - Query options for listing jobs
+   * @returns Promise with list of jobs or error
+   *
+   * @example
+   * ```typescript
+   * // List all jobs
+   * const result = await client.databases.listJobs();
+   *
+   * // List jobs deleted by current user
+   * const result = await client.databases.listJobs({
+   *   deleted_by_me: true
+   * });
+   * ```
+   */
+  async listJobs(options) {
+    const request = {};
+    if (options?.deleted_by_me !== void 0) {
+      request.deleted_by_me = options.deleted_by_me;
+    }
+    if (options?.page) {
+      request.page = options.page;
+    }
+    if (options?.sort) {
+      request.sort = options.sort;
+    }
+    if (options?.filters) {
+      request.filters = options.filters;
+    }
+    const result = await this.apiClient.listDatabaseJobs(request, options);
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    if ("pagination" in result && result.pagination) {
+      const pagination = result.pagination;
+      const normalizedResult = {
+        ...result,
+        pagination: {
+          total_count: pagination.total_count,
+          total_pages: pagination.total_pages ?? Math.ceil(pagination.total_count / pagination.per_page),
+          current_page: pagination.current_page,
+          per_page: pagination.per_page,
+          type: "page"
+        }
+      };
+      return normalizedResult;
+    }
+    return {
+      ...result,
+      data: result.data || []
+    };
+  }
+  /**
+   * Poll the status of a database deletion job
+   *
+   * @param jobId - Job ID
+   * @returns Promise with job status or error
+   *
+   * @example
+   * ```typescript
+   * const status = await client.databases.pollDeleteStatus('job-uuid');
+   * if (!status.error) {
+   *   console.log('Job status:', status.data.status);
+   *   console.log('Message:', status.data.message);
+   * }
+   * ```
+   */
+  async pollDeleteStatus(jobId) {
+    const result = await this.apiClient.pollDeleteStatus(jobId);
+    if ("error" in result) {
+      return {
+        error: {
+          code: typeof result.error.code === "number" ? String(result.error.code) : result.error.code,
+          message: result.error.message,
+          meta: result.error.meta
+        }
+      };
+    }
+    return result;
+  }
+}
 const INDEX_ENDPOINTS = {
   create: {
     path: "/tables/indexes/{table_id}",
@@ -2411,10 +3100,11 @@ class IndexesApiClient {
     }
     return `${envConfig.baseURL}/v1`;
   }
-  async addIndex(tableId, request) {
+  async addIndex(tableId, request, dbId) {
     try {
       const endpoint = INDEX_ENDPOINTS.create;
-      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2427,10 +3117,11 @@ class IndexesApiClient {
       return this.formatErrorResponse(error);
     }
   }
-  async listIndexes(tableId, query) {
+  async listIndexes(tableId, query, dbId) {
     try {
       const endpoint = INDEX_ENDPOINTS.list;
-      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2443,10 +3134,11 @@ class IndexesApiClient {
       return this.formatErrorResponse(error);
     }
   }
-  async deleteIndex(tableId, request) {
+  async deleteIndex(tableId, request, dbId) {
     try {
       const endpoint = INDEX_ENDPOINTS.delete;
-      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      let url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2516,15 +3208,15 @@ class IndexResource {
     });
     this.tableResource = new TableResource(client);
   }
-  async resolveTableId(tableName) {
-    const tableResult = await this.tableResource.findByName(tableName);
+  async resolveTableId(tableName, dbId) {
+    const tableResult = await this.tableResource.findByName(tableName, dbId);
     if (!tableResult.data) throw new Error(`Table not found: ${tableName}`);
     return tableResult.data.id;
   }
-  async addIndex(tableName, request) {
+  async addIndex(tableName, request, dbId) {
     try {
-      const tableId = await this.resolveTableId(tableName);
-      return await this.apiClient.addIndex(tableId, request);
+      const tableId = await this.resolveTableId(tableName, dbId);
+      return await this.apiClient.addIndex(tableId, request, dbId);
     } catch (error) {
       return {
         error: {
@@ -2535,10 +3227,10 @@ class IndexResource {
       };
     }
   }
-  async listIndexes(tableName, query) {
+  async listIndexes(tableName, query, dbId) {
     try {
-      const tableId = await this.resolveTableId(tableName);
-      return await this.apiClient.listIndexes(tableId, query);
+      const tableId = await this.resolveTableId(tableName, dbId);
+      return await this.apiClient.listIndexes(tableId, query, dbId);
     } catch (error) {
       return {
         error: {
@@ -2549,11 +3241,11 @@ class IndexResource {
       };
     }
   }
-  async deleteIndex(tableName, indexName) {
+  async deleteIndex(tableName, indexName, dbId) {
     try {
-      const tableId = await this.resolveTableId(tableName);
+      const tableId = await this.resolveTableId(tableName, dbId);
       const request = { index_name: indexName };
-      return await this.apiClient.deleteIndex(tableId, request);
+      return await this.apiClient.deleteIndex(tableId, request, dbId);
     } catch (error) {
       return {
         error: {
@@ -2660,7 +3352,7 @@ class RecordsApiClient {
   /**
    * Insert a single record
    */
-  async insertRecord(request) {
+  async insertRecord(request, dbId) {
     try {
       const { table_id, fields, ...recordData } = request;
       if (!table_id) {
@@ -2669,7 +3361,8 @@ class RecordsApiClient {
         );
       }
       const endpoint = RECORD_ENDPOINTS.insert;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2692,7 +3385,7 @@ class RecordsApiClient {
   /**
    * Insert multiple records in bulk
    */
-  async insertManyRecords(records, tableId, options = { validation: true }) {
+  async insertManyRecords(records, tableId, options = { validation: true }, dbId) {
     try {
       if (!tableId) {
         return this.formatErrorResponse(
@@ -2713,6 +3406,7 @@ class RecordsApiClient {
       if (queryParams.toString()) {
         url += `?${queryParams.toString()}`;
       }
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2728,7 +3422,7 @@ class RecordsApiClient {
   /**
    * Get a single record by ID
    */
-  async getRecord(recordId, tableId, options = {}) {
+  async getRecord(recordId, tableId, options = {}, dbId) {
     try {
       if (!tableId) {
         return this.formatErrorResponse(
@@ -2736,10 +3430,11 @@ class RecordsApiClient {
         );
       }
       const endpoint = RECORD_ENDPOINTS.get;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
         table_id: tableId,
         record_id: recordId
       })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2761,7 +3456,7 @@ class RecordsApiClient {
   /**
    * List records with filtering and pagination
    */
-  async listRecords(options = {}) {
+  async listRecords(options = {}, dbId) {
     try {
       const { table_id, ...queryOptions } = options;
       if (!table_id) {
@@ -2770,7 +3465,8 @@ class RecordsApiClient {
         );
       }
       const endpoint = RECORD_ENDPOINTS.list;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2793,7 +3489,7 @@ class RecordsApiClient {
   /**
    * Update records by filters
    */
-  async updateRecords(request) {
+  async updateRecords(request, dbId) {
     try {
       const { table_id, set, filters, fields, ...rest } = request;
       if (!table_id) {
@@ -2810,7 +3506,8 @@ class RecordsApiClient {
         apiPayload.fields = fields;
       }
       const endpoint = RECORD_ENDPOINTS.update;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2833,7 +3530,7 @@ class RecordsApiClient {
   /**
    * Update a single record by ID
    */
-  async updateRecordById(recordId, request) {
+  async updateRecordById(recordId, request, dbId) {
     try {
       const { table_id, ...updateOptions } = request;
       if (!table_id) {
@@ -2842,10 +3539,11 @@ class RecordsApiClient {
         );
       }
       const endpoint = RECORD_ENDPOINTS.updateById;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
         record_id: recordId,
         table_id
       })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2868,7 +3566,7 @@ class RecordsApiClient {
   /**
    * Unified delete records method that supports both record_ids and filters
    */
-  async deleteRecords(request) {
+  async deleteRecords(request, dbId) {
     try {
       const { table_id } = request;
       if (!table_id) {
@@ -2878,7 +3576,8 @@ class RecordsApiClient {
       }
       const transformedRequest = transformDeleteRequest(request);
       const endpoint = RECORD_ENDPOINTS.delete;
-      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      url = addDbIdToUrl(url, dbId);
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -2894,11 +3593,14 @@ class RecordsApiClient {
   /**
    * Delete a single record by ID
    */
-  async deleteRecordById(recordId, request) {
-    return this.deleteRecords({
-      record_ids: [recordId],
-      table_id: request.table_id
-    });
+  async deleteRecordById(recordId, request, dbId) {
+    return this.deleteRecords(
+      {
+        record_ids: [recordId],
+        table_id: request.table_id
+      },
+      dbId
+    );
   }
   buildHeaders() {
     return {
@@ -2961,9 +3663,9 @@ class RecordResource {
   /**
    * Insert a single record
    */
-  async insert(tableName, data) {
+  async insert(tableName, data, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -2983,7 +3685,7 @@ class RecordResource {
         ...completeDataResult,
         table_id: tableInfo.id
       };
-      const result = await this.apiClient.insertRecord(requestData);
+      const result = await this.apiClient.insertRecord(requestData, dbId);
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3000,7 +3702,7 @@ class RecordResource {
   /**
    * Insert multiple records in bulk
    */
-  async insertMany(tableName, records, options = { validation: true }) {
+  async insertMany(tableName, records, options = { validation: true }, dbId) {
     try {
       if (!records || !Array.isArray(records) || records.length === 0) {
         return {
@@ -3010,7 +3712,7 @@ class RecordResource {
           }
         };
       }
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3022,7 +3724,8 @@ class RecordResource {
       const result = await this.apiClient.insertManyRecords(
         records,
         tableInfo.id,
-        options
+        options,
+        dbId
       );
       if (isErrorResponse(result)) {
         return result;
@@ -3040,9 +3743,9 @@ class RecordResource {
   /**
    * Get a single record by ID
    */
-  async get(tableName, recordId) {
+  async get(tableName, recordId, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3051,7 +3754,12 @@ class RecordResource {
           }
         };
       }
-      const result = await this.apiClient.getRecord(recordId, tableInfo.id);
+      const result = await this.apiClient.getRecord(
+        recordId,
+        tableInfo.id,
+        { fields: void 0 },
+        dbId
+      );
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3068,9 +3776,9 @@ class RecordResource {
   /**
    * List records with filtering and pagination
    */
-  async list(tableName, options = {}) {
+  async list(tableName, options = {}, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3080,7 +3788,7 @@ class RecordResource {
         };
       }
       const requestOptions = { ...options, table_id: tableInfo.id };
-      const result = await this.apiClient.listRecords(requestOptions);
+      const result = await this.apiClient.listRecords(requestOptions, dbId);
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3097,9 +3805,9 @@ class RecordResource {
   /**
    * Update records by filters
    */
-  async update(tableName, options) {
+  async update(tableName, options, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3109,7 +3817,7 @@ class RecordResource {
         };
       }
       const requestOptions = { ...options, table_id: tableInfo.id };
-      const result = await this.apiClient.updateRecords(requestOptions);
+      const result = await this.apiClient.updateRecords(requestOptions, dbId);
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3126,9 +3834,9 @@ class RecordResource {
   /**
    * Update a single record by ID
    */
-  async updateById(tableName, recordId, data) {
+  async updateById(tableName, recordId, data, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3144,7 +3852,8 @@ class RecordResource {
       };
       const result = await this.apiClient.updateRecordById(
         recordId,
-        requestOptions
+        requestOptions,
+        dbId
       );
       if (isErrorResponse(result)) {
         return result;
@@ -3162,9 +3871,9 @@ class RecordResource {
   /**
    * Unified delete method that supports both record IDs and filters
    */
-  async delete(tableName, options) {
+  async delete(tableName, options, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3174,7 +3883,7 @@ class RecordResource {
         };
       }
       const requestOptions = { ...options, table_id: tableInfo.id };
-      const result = await this.apiClient.deleteRecords(requestOptions);
+      const result = await this.apiClient.deleteRecords(requestOptions, dbId);
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3191,9 +3900,9 @@ class RecordResource {
   /**
    * Delete a single record by ID
    */
-  async deleteById(tableName, recordId) {
+  async deleteById(tableName, recordId, dbId) {
     try {
-      const tableInfo = await this.getTableInfo(tableName);
+      const tableInfo = await this.getTableInfo(tableName, dbId);
       if (!tableInfo) {
         return {
           error: {
@@ -3202,9 +3911,13 @@ class RecordResource {
           }
         };
       }
-      const result = await this.apiClient.deleteRecordById(recordId, {
-        table_id: tableInfo.id
-      });
+      const result = await this.apiClient.deleteRecordById(
+        recordId,
+        {
+          table_id: tableInfo.id
+        },
+        dbId
+      );
       if (isErrorResponse(result)) {
         return result;
       }
@@ -3221,10 +3934,10 @@ class RecordResource {
   /**
    * Helper method to get table information by name
    */
-  async getTableInfo(tableName) {
+  async getTableInfo(tableName, dbId) {
     try {
       const tableResource = new TableResource(this.client);
-      const tableResult = await tableResource.findByName(tableName);
+      const tableResult = await tableResource.findByName(tableName, dbId);
       if (tableResult.data) {
         return {
           id: tableResult.data.id,
@@ -3576,7 +4289,7 @@ class BaseApiClient {
     };
   }
   // Custom inspect method for Node.js console logging
-  [Symbol.for("nodejs.util.inspect.custom")]() {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return this.toString();
   }
 }
@@ -3587,10 +4300,13 @@ class SqlApiClient extends BaseApiClient {
   /**
    * Convert natural language to SQL query (streaming)
    */
-  async textToSQL(request) {
+  async textToSQL(request, dbId) {
     try {
       const endpoint = SQL_ENDPOINTS.textToSQL;
-      const url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      let url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      if (dbId) {
+        url += `?db_id=${encodeURIComponent(dbId)}`;
+      }
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -3615,10 +4331,13 @@ class SqlApiClient extends BaseApiClient {
   /**
    * Execute SQL query
    */
-  async executeSQL(request) {
+  async executeSQL(request, dbId) {
     try {
       const endpoint = SQL_ENDPOINTS.executeSQL;
-      const url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      let url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      if (dbId) {
+        url += `?db_id=${encodeURIComponent(dbId)}`;
+      }
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
@@ -3675,9 +4394,9 @@ class SqlResource {
    * @returns AsyncIterable<string> for streaming SQL generation
    *
    */
-  async textToSQL(prompt, options = {}) {
+  async textToSQL(prompt, options = {}, dbId) {
     const request = transformTextToSQLRequest(prompt, options);
-    const response = await this.sqlApiClient.textToSQL(request);
+    const response = await this.sqlApiClient.textToSQL(request, dbId);
     if ("error" in response && response.error !== void 0) {
       throw response;
     }
@@ -3690,8 +4409,8 @@ class SqlResource {
    * @returns Promise<ExecuteSQLApiResponse> with raw API response following Boltic API Response Structure
    *
    */
-  async executeSQL(query) {
-    const response = await this.sqlApiClient.executeSQL({ query });
+  async executeSQL(query, dbId) {
+    const response = await this.sqlApiClient.executeSQL({ query }, dbId);
     if (isErrorResponse(response)) {
       return response;
     }
@@ -4040,25 +4759,75 @@ class BolticClient {
     this.recordResource = new RecordResource(this.baseClient);
     this.sqlResource = new SqlResource(this.baseClient);
     this.indexResource = new IndexResource(this.baseClient);
-    this.currentDatabase = {
-      databaseName: "Default"
-    };
+    this.databaseResource = new DatabaseResource(this.baseClient);
+    this.currentDatabase = null;
   }
+  /**
+   * Get current database context
+   */
   getCurrentDatabase() {
     return this.currentDatabase;
   }
+  /**
+   * Switch to a different database using its internal name (slug).
+   * All subsequent operations will use this database.
+   *
+   * If no internal name is provided, the SDK will switch back to the default database.
+   *
+   * @param dbInternalName - Database internal name/slug to switch to. If omitted or empty, default DB is used.
+   *
+   * @example
+   * ```typescript
+   * // Switch to a specific database by slug
+   * await client.useDatabase('my_database_slug');
+   *
+   * // Switch back to default database
+   * await client.useDatabase();
+   * ```
+   */
+  async useDatabase(dbInternalName) {
+    if (!dbInternalName || dbInternalName === "") {
+      this.currentDatabase = null;
+      return;
+    }
+    const result = await this.databaseResource.findOne(dbInternalName);
+    if (isErrorResponse(result)) {
+      throw new Error(
+        result.error.message || `Failed to switch database to internal name '${dbInternalName}'`
+      );
+    }
+    const db = result.data;
+    this.currentDatabase = {
+      databaseId: db.id,
+      dbInternalName: db.db_internal_name || dbInternalName
+    };
+  }
+  // Direct database operations
+  get databases() {
+    return {
+      create: (data) => this.databaseResource.create(data),
+      findAll: (options) => this.databaseResource.findAll(options),
+      findOne: (dbInternalName, options) => this.databaseResource.findOne(dbInternalName, options),
+      getDefault: () => this.databaseResource.getDefault(),
+      update: (dbInternalName, data) => this.databaseResource.update(dbInternalName, data),
+      delete: (dbInternalName) => this.databaseResource.delete(dbInternalName),
+      listJobs: (options) => this.databaseResource.listJobs(options),
+      pollDeleteStatus: (jobId) => this.databaseResource.pollDeleteStatus(jobId)
+    };
+  }
   // Direct table operations
   get tables() {
+    const dbId = this.currentDatabase?.databaseId;
     return {
-      create: (data) => this.tableResource.create(data),
-      findAll: (options) => this.tableResource.findAll(options),
-      findById: (id) => this.tableResource.findById(id),
-      findByName: (name) => this.tableResource.findByName(name),
-      findOne: (options) => this.tableResource.findOne(options),
-      update: (name, data) => this.tableResource.update(name, data),
-      delete: (name) => this.tableResource.delete(name),
-      rename: (oldName, newName) => this.tableResource.rename(oldName, newName),
-      setAccess: (request) => this.tableResource.setAccess(request)
+      create: (data) => this.tableResource.create(data, dbId),
+      findAll: (options) => this.tableResource.findAll(options, dbId),
+      findById: (id) => this.tableResource.findById(id, dbId),
+      findByName: (name) => this.tableResource.findByName(name, dbId),
+      findOne: (options) => this.tableResource.findOne(options, dbId),
+      update: (name, data) => this.tableResource.update(name, data, dbId),
+      delete: (name) => this.tableResource.delete(name, dbId),
+      rename: (oldName, newName) => this.tableResource.rename(oldName, newName, dbId),
+      setAccess: (request) => this.tableResource.setAccess(request, dbId)
     };
   }
   // Direct column operations
@@ -4086,53 +4855,40 @@ class BolticClient {
     const tableBuilder = createTableBuilder({ name });
     return tableBuilder;
   }
-  // Method 3: Table-scoped operations
+  // Table-scoped operations for method chaining
   from(tableName) {
+    const dbId = this.currentDatabase?.databaseId;
     return {
-      // Column operations for this table
-      columns: () => ({
-        create: (column) => this.columnResource.create(tableName, column),
-        findAll: (options) => this.columnResource.findAll(tableName, options),
-        get: (columnName) => this.columnResource.get(tableName, columnName),
-        update: (columnName, updates) => this.columnResource.update(tableName, columnName, updates),
-        delete: (columnName) => this.columnResource.delete(tableName, columnName)
+      // Index operations for this table
+      indexes: () => ({
+        addIndex: (payload) => this.indexResource.addIndex(tableName, payload, dbId),
+        listIndexes: (query) => this.indexResource.listIndexes(tableName, query, dbId),
+        deleteIndex: (indexName) => this.indexResource.deleteIndex(tableName, indexName, dbId)
       }),
       // Record operations for this table
       records: () => ({
-        insert: (data) => this.recordResource.insert(tableName, data),
-        insertMany: (records, options) => this.recordResource.insertMany(tableName, records, options),
-        findOne: (recordId) => this.recordResource.get(tableName, recordId),
-        update: (options) => this.recordResource.update(tableName, options),
-        updateById: (recordId, data) => this.recordResource.updateById(tableName, recordId, data),
-        // Unified delete method
-        delete: (options) => this.recordResource.delete(tableName, options),
-        // Single record delete method
-        deleteById: (recordId) => this.recordResource.deleteById(tableName, recordId)
-      }),
-      // Fluent record builder for this table
-      record: () => createRecordBuilder({
-        tableName,
-        recordResource: this.recordResource
-      }),
-      // Indexes - Method 2: Function chaining under from(tableName)
-      indexes: () => ({
-        addIndex: (payload) => this.indexResource.addIndex(tableName, payload),
-        listIndexes: (query) => this.indexResource.listIndexes(tableName, query),
-        deleteIndex: (indexName) => this.indexResource.deleteIndex(tableName, indexName)
+        insert: (data) => this.recordResource.insert(tableName, data, dbId),
+        insertMany: (records, options) => this.recordResource.insertMany(tableName, records, options, dbId),
+        findOne: (recordId) => this.recordResource.get(tableName, recordId, dbId),
+        update: (options) => this.recordResource.update(tableName, options, dbId),
+        updateById: (recordId, data) => this.recordResource.updateById(tableName, recordId, data, dbId),
+        delete: (options) => this.recordResource.delete(tableName, options, dbId),
+        deleteById: (recordId) => this.recordResource.deleteById(tableName, recordId, dbId)
       })
     };
   }
   // Direct record operations
   get records() {
+    const dbId = this.currentDatabase?.databaseId;
     return {
-      insert: (tableName, data) => this.recordResource.insert(tableName, data),
-      insertMany: (tableName, records, options) => this.recordResource.insertMany(tableName, records, options),
-      findAll: (tableName, options) => this.recordResource.list(tableName, options),
-      findOne: (tableName, recordId) => this.recordResource.get(tableName, recordId),
-      update: (tableName, options) => this.recordResource.update(tableName, options),
-      updateById: (tableName, recordId, data) => this.recordResource.updateById(tableName, recordId, data),
-      delete: (tableName, options) => this.recordResource.delete(tableName, options),
-      deleteById: (tableName, recordId) => this.recordResource.deleteById(tableName, recordId)
+      insert: (tableName, data) => this.recordResource.insert(tableName, data, dbId),
+      insertMany: (tableName, records, options) => this.recordResource.insertMany(tableName, records, options, dbId),
+      findAll: (tableName, options) => this.recordResource.list(tableName, options, dbId),
+      findOne: (tableName, recordId) => this.recordResource.get(tableName, recordId, dbId),
+      update: (tableName, options) => this.recordResource.update(tableName, options, dbId),
+      updateById: (tableName, recordId, data) => this.recordResource.updateById(tableName, recordId, data, dbId),
+      delete: (tableName, options) => this.recordResource.delete(tableName, options, dbId),
+      deleteById: (tableName, recordId) => this.recordResource.deleteById(tableName, recordId, dbId)
     };
   }
   // Method 4: Create fluent record builder
@@ -4144,9 +4900,10 @@ class BolticClient {
   }
   // Direct SQL operations
   get sql() {
+    const dbId = this.currentDatabase?.databaseId;
     return {
-      textToSQL: (prompt, options) => this.sqlResource.textToSQL(prompt, options),
-      executeSQL: (query) => this.sqlResource.executeSQL(query)
+      textToSQL: (prompt, options) => this.sqlResource.textToSQL(prompt, options, dbId),
+      executeSQL: (query) => this.sqlResource.executeSQL(query, dbId)
     };
   }
   // SQL resource access for testing
@@ -4230,6 +4987,7 @@ class BolticClient {
     this.recordResource = new RecordResource(this.baseClient);
     this.sqlResource = new SqlResource(this.baseClient);
     this.indexResource = new IndexResource(this.baseClient);
+    this.databaseResource = new DatabaseResource(this.baseClient);
   }
   // Security methods to prevent API key exposure
   toString() {
@@ -4247,7 +5005,7 @@ class BolticClient {
     };
   }
   // Custom inspect method for Node.js console logging
-  [Symbol.for("nodejs.util.inspect.custom")]() {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return this.toString();
   }
 }