@boltic/sdk 0.0.4 → 0.0.5

package/dist/databases/testing.d.ts

@@ -1,3 +1,17 @@
+declare interface AddIndexRequest {
+    field_names: string[];
+    method: 'btree' | 'hash' | 'spgist' | 'gin' | 'brin';
+}
+
+declare interface AddIndexResponse {
+    index_name: string;
+    method: string;
+    fields: string[];
+    field_ids?: string[];
+    created_at?: string;
+    created_by?: string;
+}
+
 declare type AlignmentType = 'left' | 'center' | 'right';
 
 /**
@@ -64,6 +78,7 @@ declare class BolticClient {
     private columnResource;
     private recordResource;
     private sqlResource;
+    private indexResource;
     private currentDatabase;
     private clientOptions;
     constructor(apiKey: string, options?: ClientOptions);
@@ -96,6 +111,11 @@ declare class BolticClient {
         message?: string | undefined;
         }>>;
     };
+    get indexes(): {
+        addIndex: (tableName: string, payload: AddIndexRequest) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<AddIndexResponse>>;
+        listIndexes: (tableName: string, query: ListIndexesQuery) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<ListIndexesResponse>>;
+        deleteIndex: (tableName: string, indexName: string) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<DeleteIndexResponse>>;
+    };
     table(name: string): TableBuilder;
     from(tableName: string): {
         columns: () => {
@@ -124,6 +144,11 @@ declare class BolticClient {
             }>>;
         };
         record: () => RecordBuilder;
+        indexes: () => {
+            addIndex: (payload: AddIndexRequest) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<AddIndexResponse>>;
+            listIndexes: (query: ListIndexesQuery) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<ListIndexesResponse>>;
+            deleteIndex: (indexName: string) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<DeleteIndexResponse>>;
+        };
     };
     get records(): {
         insert: (tableName: string, data: RecordData) => Promise<BolticErrorResponse_2 | BolticSuccessResponse<RecordWithId>>;
@@ -397,6 +422,10 @@ declare const DateFormatEnum: Readonly<{
 
 declare type DecimalType = '00' | '0.0' | '0.00' | '0.000' | '0.0000' | '0.00000' | '0.000000';
 
+declare interface DeleteIndexResponse {
+    message?: string;
+}
+
 declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
 
 declare interface EnvironmentConfig {
@@ -492,6 +521,20 @@ declare interface HttpResponse<T = unknown> {
     headers: Record<string, string>;
 }
 
+declare interface IndexListItem {
+    schemaname?: string;
+    relname?: string;
+    indexrelname: string;
+    method?: string;
+    idx_scan?: number;
+    idx_tup_read?: number;
+    idx_tup_fetch?: number;
+    field_ids?: string[];
+    fields?: string[];
+    created_at?: string;
+    created_by?: string;
+}
+
 declare interface InterceptorManager {
     request: {
         use(interceptor: RequestInterceptor): number;
@@ -520,6 +563,31 @@ declare class InterceptorManagerImpl implements InterceptorManager {
     executeErrorInterceptors(error: unknown): Promise<unknown>;
 }
 
+declare interface ListIndexesQuery {
+    page?: {
+        page_no: number;
+        page_size: number;
+    };
+    filters?: Array<{
+        field: string;
+        operator: string;
+        values: unknown[];
+    }>;
+    sort?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
+
+declare interface ListIndexesResponse {
+    items: IndexListItem[];
+    page?: {
+        page_no: number;
+        page_size: number;
+        total?: number;
+    };
+}
+
 export declare interface MockClientOptions {
     apiKey?: string;
     environment?: 'local' | 'sit' | 'uat' | 'prod';

package/dist/databases/testing.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./test-client-BI3VkYA6.js");class t{static async*fromSSE(e){if(!e.body)throw new Error("Response body is null");const t=e.body.getReader(),s=new TextDecoder;try{for(;;){const{done:e,value:o}=await t.read();if(e)break;const r=s.decode(o,{stream:!0}).split("\n");for(const t of r)if(t.startsWith("data: ")){const e=t.slice(6);"[DONE]"!==e&&(yield e)}}}finally{t.releaseLock()}}static async*fromChunked(e){if(!e.body)throw new Error("Response body is null");const t=e.body.getReader(),s=new TextDecoder;try{for(;;){const{done:e,value:o}=await t.read();if(e)break;const r=s.decode(o,{stream:!0});yield r}}finally{t.releaseLock()}}static async collectAll(e){let t="";for await(const s of e)t+=s;return t}static async*fromString(e,t=10){for(let s=0;s<e.length;s+=t)yield e.slice(s,s+t),await new Promise(e=>setTimeout(e,50))}static async*map(e,t){for await(const s of e)yield await t(s)}static async*filter(e,t){for await(const s of e)await t(s)&&(yield s)}static async*take(e,t){let s=0;for await(const o of e){if(s>=t)break;yield o,s++}}}exports.createErrorResponse=e.createErrorResponse,exports.createMockResponse=e.createMockResponse,exports.createTestClient=e.createTestClient,exports.SqlTestClient=class{constructor(e){this.sql=e}async generateSQL(e,s){const o=await this.sql.textToSQL(e,s);return t.collectAll(o)}async executeSQL(e){return this.sql.executeSQL(e)}async*simulateStreamingSQL(e,t=10,s=50){for(let o=0;o<e.length;o+=t)yield e.slice(o,o+t),await new Promise(e=>setTimeout(e,s))}},exports.TEST_UTILS_VERSION="1.0.0";
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./test-client-DfOmma3t.js");class t{static async*fromSSE(e){if(!e.body)throw new Error("Response body is null");const t=e.body.getReader(),s=new TextDecoder;try{for(;;){const{done:e,value:o}=await t.read();if(e)break;const r=s.decode(o,{stream:!0}).split("\n");for(const t of r)if(t.startsWith("data: ")){const e=t.slice(6);"[DONE]"!==e&&(yield e)}}}finally{t.releaseLock()}}static async*fromChunked(e){if(!e.body)throw new Error("Response body is null");const t=e.body.getReader(),s=new TextDecoder;try{for(;;){const{done:e,value:o}=await t.read();if(e)break;const r=s.decode(o,{stream:!0});yield r}}finally{t.releaseLock()}}static async collectAll(e){let t="";for await(const s of e)t+=s;return t}static async*fromString(e,t=10){for(let s=0;s<e.length;s+=t)yield e.slice(s,s+t),await new Promise(e=>setTimeout(e,50))}static async*map(e,t){for await(const s of e)yield await t(s)}static async*filter(e,t){for await(const s of e)await t(s)&&(yield s)}static async*take(e,t){let s=0;for await(const o of e){if(s>=t)break;yield o,s++}}}exports.createErrorResponse=e.createErrorResponse,exports.createMockResponse=e.createMockResponse,exports.createTestClient=e.createTestClient,exports.SqlTestClient=class{constructor(e){this.sql=e}async generateSQL(e,s){const o=await this.sql.textToSQL(e,s);return t.collectAll(o)}async executeSQL(e){return this.sql.executeSQL(e)}async*simulateStreamingSQL(e,t=10,s=50){for(let o=0;o<e.length;o+=t)yield e.slice(o,o+t),await new Promise(e=>setTimeout(e,s))}},exports.TEST_UTILS_VERSION="1.0.0";
 //# sourceMappingURL=testing.js.map

package/dist/databases/testing.mjs

@@ -1,4 +1,4 @@
-import { o, p, q } from "./test-client-BffJwqJq.mjs";
+import { o, p, q } from "./test-client-rQ1AmTo6.mjs";
 class StreamingUtils {
   /**
    * Convert Server-Sent Events to AsyncIterable

package/dist/sdk.js

@@ -2298,6 +2298,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",
@@ -3764,6 +3967,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"
     };
@@ -3797,6 +4001,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 });
@@ -3829,6 +4041,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)
       })
     };
   }
@@ -3939,6 +4157,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() {