@boltic/sdk 0.0.4 → 0.0.6

package/dist/sdk.mjs

@@ -257,6 +257,39 @@ class AxiosAdapter {
         // Don't throw on non-2xx status codes
       };
       const response = await this.axios(axiosConfig);
+      if (response.status < 200 || response.status >= 300) {
+        const isHtmlError = typeof response.data === "string" && response.data.trim().startsWith("<!DOCTYPE") || typeof response.data === "string" && response.data.includes("<html");
+        if (isHtmlError) {
+          const htmlContent = response.data;
+          const preMatch = htmlContent.match(/<pre>(.*?)<\/pre>/s);
+          const errorMessage = preMatch ? preMatch[1].trim() : `HTTP ${response.status}: ${response.statusText}`;
+          throw createErrorWithContext(errorMessage, {
+            url: config.url,
+            method: config.method,
+            status: response.status,
+            statusText: response.statusText,
+            isHtmlError: true
+          });
+        }
+        if (response.data && typeof response.data === "object" && "error" in response.data) {
+          return {
+            data: response.data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers || {}
+          };
+        }
+        throw createErrorWithContext(
+          `HTTP ${response.status}: ${response.statusText}`,
+          {
+            url: config.url,
+            method: config.method,
+            status: response.status,
+            statusText: response.statusText,
+            responseData: response.data
+          }
+        );
+      }
       return {
         data: response.data,
         status: response.status,
@@ -355,6 +388,39 @@ class FetchAdapter {
       response.headers.forEach((value, key) => {
         headers[key] = value;
       });
+      if (response.status < 200 || response.status >= 300) {
+        const isHtmlError = typeof data === "string" && (data.trim().startsWith("<!DOCTYPE") || data.includes("<html"));
+        if (isHtmlError) {
+          const htmlContent = data;
+          const preMatch = htmlContent.match(/<pre>(.*?)<\/pre>/s);
+          const errorMessage = preMatch ? preMatch[1].trim() : `HTTP ${response.status}: ${response.statusText}`;
+          throw createErrorWithContext(errorMessage, {
+            url: config.url,
+            method: config.method,
+            status: response.status,
+            statusText: response.statusText,
+            isHtmlError: true
+          });
+        }
+        if (data && typeof data === "object" && "error" in data) {
+          return {
+            data,
+            status: response.status,
+            statusText: response.statusText,
+            headers
+          };
+        }
+        throw createErrorWithContext(
+          `HTTP ${response.status}: ${response.statusText}`,
+          {
+            url: config.url,
+            method: config.method,
+            status: response.status,
+            statusText: response.statusText,
+            responseData: data
+          }
+        );
+      }
       const httpResponse = {
         data,
         status: response.status,
@@ -2296,6 +2362,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",
@@ -2320,8 +2589,8 @@ const RECORD_ENDPOINTS = {
     rateLimit: { requests: 200, window: 6e4 }
   },
   update: {
-    path: "/tables/{table_id}/records",
-    method: "PATCH",
+    path: "/tables/{table_id}/records/bulk-update",
+    method: "PUT",
     authenticated: true
   },
   updateById: {
@@ -2526,26 +2795,34 @@ class RecordsApiClient {
    */
   async updateRecords(request) {
     try {
-      const { table_id, ...updateOptions } = request;
+      const { table_id, set, filters, fields, ...rest } = request;
       if (!table_id) {
         return this.formatErrorResponse(
           new Error("table_id is required for update operation")
         );
       }
+      const apiPayload = {
+        updates: set,
+        filters,
+        ...rest
+      };
+      if (fields) {
+        apiPayload.fields = fields;
+      }
       const endpoint = RECORD_ENDPOINTS.update;
       const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
         headers: this.buildHeaders(),
-        data: updateOptions,
+        data: apiPayload,
         timeout: this.config.timeout
       });
       const responseData = response.data;
-      if (updateOptions.fields && responseData.data) {
+      if (fields && responseData.data) {
         responseData.data = filterArrayFields(
           responseData.data,
-          updateOptions.fields
+          fields
         );
       }
       return responseData;
@@ -3762,6 +4039,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"
     };
@@ -3795,6 +4073,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 });
@@ -3827,6 +4113,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)
       })
     };
   }
@@ -3937,6 +4229,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() {