@boltic/sdk 0.0.3 → 0.0.5

package/dist/sdk.mjs

@@ -1634,6 +1634,7 @@ class TableResource extends BaseResource {
     const config = client.getConfig();
     this.tablesApiClient = new TablesApiClient(config.apiKey, {
       environment: config.environment,
+      region: config.region,
       timeout: config.timeout,
       debug: config.debug,
       retryAttempts: config.retryAttempts,
@@ -1927,6 +1928,7 @@ class ColumnResource extends BaseResource {
     const config = client.getConfig();
     this.columnsApiClient = new ColumnsApiClient(config.apiKey, {
       environment: config.environment,
+      region: config.region,
       timeout: config.timeout,
       debug: config.debug,
       retryAttempts: config.retryAttempts,
@@ -1935,6 +1937,7 @@ class ColumnResource extends BaseResource {
     });
     this.tablesApiClient = new TablesApiClient(config.apiKey, {
       environment: config.environment,
+      region: config.region,
       timeout: config.timeout,
       debug: config.debug,
       retryAttempts: config.retryAttempts,
@@ -2293,6 +2296,209 @@ class ColumnResource extends BaseResource {
     return tableInfo?.id || null;
   }
 }
+const INDEX_ENDPOINTS = {
+  create: {
+    path: "/tables/indexes/{table_id}",
+    method: "POST",
+    authenticated: true
+  },
+  list: {
+    path: "/tables/indexes/{table_id}/list",
+    method: "POST",
+    authenticated: true
+  },
+  delete: {
+    path: "/tables/indexes/{table_id}",
+    method: "DELETE",
+    authenticated: true
+  }
+};
+const buildIndexEndpointPath = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  });
+  const unreplacedParams = path.match(/\{([^}]+)\}/g);
+  if (unreplacedParams) {
+    throw new Error(`Missing path parameters: ${unreplacedParams.join(", ")}`);
+  }
+  return path;
+};
+class IndexesApiClient {
+  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`;
+  }
+  async addIndex(tableId, request) {
+    try {
+      const endpoint = INDEX_ENDPOINTS.create;
+      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: request,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  async listIndexes(tableId, query) {
+    try {
+      const endpoint = INDEX_ENDPOINTS.list;
+      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: query,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  async deleteIndex(tableId, request) {
+    try {
+      const endpoint = INDEX_ENDPOINTS.delete;
+      const url = `${this.baseURL}${buildIndexEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: request,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  formatErrorResponse(error) {
+    if (this.config.debug) {
+      console.error("Indexes API Error:", error);
+    }
+    if (error && typeof error === "object" && "response" in error) {
+      const apiError = error;
+      if (apiError.response?.data?.error) {
+        return apiError.response.data;
+      }
+      return {
+        error: {
+          code: "API_ERROR",
+          message: error.message || "Unknown API error",
+          meta: [`Status: ${apiError.response?.status || "unknown"}`]
+        }
+      };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error.message,
+          meta: ["Client-side error occurred"]
+        }
+      };
+    }
+    return {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: "An unexpected error occurred",
+        meta: ["Unknown error type"]
+      }
+    };
+  }
+}
+class IndexResource {
+  constructor(client) {
+    this.client = client;
+    const config = client.getConfig();
+    this.apiClient = new IndexesApiClient(config.apiKey, {
+      environment: config.environment,
+      region: config.region,
+      timeout: config.timeout,
+      debug: config.debug,
+      retryAttempts: config.retryAttempts,
+      retryDelay: config.retryDelay,
+      headers: config.headers
+    });
+    this.tableResource = new TableResource(client);
+  }
+  async resolveTableId(tableName) {
+    const tableResult = await this.tableResource.findByName(tableName);
+    if (!tableResult.data) throw new Error(`Table not found: ${tableName}`);
+    return tableResult.data.id;
+  }
+  async addIndex(tableName, request) {
+    try {
+      const tableId = await this.resolveTableId(tableName);
+      return await this.apiClient.addIndex(tableId, request);
+    } catch (error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error?.message || "Failed to add index",
+          meta: ["IndexResource.addIndex"]
+        }
+      };
+    }
+  }
+  async listIndexes(tableName, query) {
+    try {
+      const tableId = await this.resolveTableId(tableName);
+      return await this.apiClient.listIndexes(tableId, query);
+    } catch (error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error?.message || "Failed to list indexes",
+          meta: ["IndexResource.listIndexes"]
+        }
+      };
+    }
+  }
+  async deleteIndex(tableName, indexName) {
+    try {
+      const tableId = await this.resolveTableId(tableName);
+      const request = { index_name: indexName };
+      return await this.apiClient.deleteIndex(tableId, request);
+    } catch (error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error?.message || "Failed to delete index",
+          meta: ["IndexResource.deleteIndex"]
+        }
+      };
+    }
+  }
+}
 const RECORD_ENDPOINTS = {
   insert: {
     path: "/tables/{table_id}/records",
@@ -2667,11 +2873,13 @@ class RecordResource {
     this.client = client;
     this.apiClient = new RecordsApiClient(client.getConfig().apiKey, {
       environment: client.getConfig().environment,
+      region: client.getConfig().region,
       timeout: client.getConfig().timeout,
       debug: client.getConfig().debug
     });
     this.tablesApiClient = new TablesApiClient(client.getConfig().apiKey, {
       environment: client.getConfig().environment,
+      region: client.getConfig().region,
       timeout: client.getConfig().timeout,
       debug: client.getConfig().debug
     });
@@ -3757,6 +3965,7 @@ class BolticClient {
     this.columnResource = new ColumnResource(this.baseClient);
     this.recordResource = new RecordResource(this.baseClient);
     this.sqlResource = new SqlResource(this.baseClient);
+    this.indexResource = new IndexResource(this.baseClient);
     this.currentDatabase = {
       databaseName: "Default"
     };
@@ -3790,6 +3999,14 @@ class BolticClient {
       delete: (tableName, columnName) => this.columnResource.delete(tableName, columnName)
     };
   }
+  // Direct index operations
+  get indexes() {
+    return {
+      addIndex: (tableName, payload) => this.indexResource.addIndex(tableName, payload),
+      listIndexes: (tableName, query) => this.indexResource.listIndexes(tableName, query),
+      deleteIndex: (tableName, indexName) => this.indexResource.deleteIndex(tableName, indexName)
+    };
+  }
   // Fluent table operations
   table(name) {
     const tableBuilder = createTableBuilder({ name });
@@ -3822,6 +4039,12 @@ class BolticClient {
       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)
       })
     };
   }
@@ -3932,6 +4155,7 @@ class BolticClient {
     this.columnResource = new ColumnResource(this.baseClient);
     this.recordResource = new RecordResource(this.baseClient);
     this.sqlResource = new SqlResource(this.baseClient);
+    this.indexResource = new IndexResource(this.baseClient);
   }
   // Security methods to prevent API key exposure
   toString() {