@bluecopa/core 0.1.23 → 0.1.25

package/dist/api/inputTable/deleteRow.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Delete one or more rows from an input table
+ * Row ID can be provided as a string (single ID) or array (multiple IDs)
+ *
+ * @param tableId - The ID of the input table
+ * @param rowId - Row ID(s) to delete (string for single, array for multiple)
+ * @param idField - Optional: Field name to use ('copa_id' or '_copa_id'), defaults to '_copa_id'
+ * @returns Promise<any> The delete response
+ * @throws Error if the request fails
+ *
+ * @example
+ * // Delete single row
+ * await deleteRow('table-123', 'row-123');
+ *
+ * @example
+ * // Delete multiple rows
+ * await deleteRow('table-123', ['row-123', 'row-456']);
+ *
+ * @example
+ * // Using copa_id field
+ * await deleteRow('table-123', 'row-123', 'copa_id');
+ */
+export declare const deleteRow: (tableId: string, rowId: string | string[], idField?: "copa_id" | "_copa_id") => Promise<any>;

package/dist/api/inputTable/getRows.d.ts

@@ -0,0 +1,38 @@
+export interface GetRowsOptions {
+    limit?: number;
+    offset?: number;
+    order?: string;
+    order_by?: string;
+    [key: string]: any;
+}
+export interface GetRowsResponse {
+    data: any[];
+    count: number;
+    total_count: number;
+}
+/**
+ * Get rows from an input table with optional filtering and pagination
+ * Supports Supabase-style filtering via query parameters
+ *
+ * @param tableId - The ID of the input table
+ * @param options - Query options including filters, pagination, and sorting
+ * @returns Promise<GetRowsResponse> The rows data with count information
+ * @throws Error if the request fails
+ *
+ * @example
+ * // Get all rows
+ * await getRows('table-123');
+ *
+ * @example
+ * // Filter by equality
+ * await getRows('table-123', { status: 'active' });
+ *
+ * @example
+ * // Filter with operators
+ * await getRows('table-123', { price: 'gte.100', status: 'in.(active,pending)' });
+ *
+ * @example
+ * // Pagination
+ * await getRows('table-123', { limit: 10, offset: 0 });
+ */
+export declare const getRows: (tableId: string, options?: GetRowsOptions) => Promise<GetRowsResponse>;

package/dist/api/inputTable/index.d.ts

@@ -1,3 +1,7 @@
 export * from './getData';
 export * from './getTableById';
 export * from './getInputTables';
+export * from './getRows';
+export * from './insertRow';
+export * from './updateRow';
+export * from './deleteRow';

package/dist/api/inputTable/insertRow.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Insert a new row into an input table
+ *
+ * @param tableId - The ID of the input table
+ * @param rowData - The row data object (column names as keys)
+ * @returns Promise<any> The inserted row data
+ * @throws Error if the request fails
+ *
+ * @example
+ * await insertRow('table-123', {
+ *   name: 'Item 1',
+ *   status: 'active',
+ *   price: 100
+ * });
+ */
+export declare const insertRow: (tableId: string, rowData: Record<string, any>) => Promise<any>;

package/dist/api/inputTable/updateRow.d.ts

@@ -0,0 +1,24 @@
+export interface UpdateRowOptions {
+    copa_id?: string;
+    _copa_id?: string;
+    [key: string]: any;
+}
+/**
+ * Update a row in an input table
+ * Row ID can be provided via copa_id/_copa_id in the updateData or as a separate parameter
+ *
+ * @param tableId - The ID of the input table
+ * @param updateData - The fields to update (may include copa_id or _copa_id)
+ * @param rowId - Optional: Row ID to update (alternative to including in updateData)
+ * @returns Promise<any> The updated row data
+ * @throws Error if the request fails
+ *
+ * @example
+ * // Using rowId parameter
+ * await updateRow('table-123', { status: 'completed' }, 'row-123');
+ *
+ * @example
+ * // Using copa_id in updateData
+ * await updateRow('table-123', { _copa_id: 'row-123', status: 'completed' });
+ */
+export declare const updateRow: (tableId: string, updateData: UpdateRowOptions, rowId?: string) => Promise<any>;

package/dist/index.d.ts

@@ -18,3 +18,5 @@ export type { FileDownloadRequest } from './api/file/fileDownload';
 export type { GetFileUrlRequest, GetFileUrlResponse } from './api/file/getFileUrlByFileId';
 export type { User } from './api/user/getAllUsers';
 export type { HttpTrigger } from './api/workflow/getAllHttpTriggers';
+export type { GetRowsOptions, GetRowsResponse } from './api/inputTable/getRows';
+export type { UpdateRowOptions } from './api/inputTable/updateRow';

package/dist/index.es.js

@@ -6226,11 +6226,147 @@ const getInputTables = async () => {
     throw { message, status };
   }
 };
+const getRows = async (tableId, options) => {
+  var _a, _b, _c;
+  try {
+    if (!tableId) {
+      throw { message: "Table ID is required", status: 400 };
+    }
+    const params = {};
+    if (options) {
+      Object.keys(options).forEach((key) => {
+        if (options[key] !== void 0 && options[key] !== null) {
+          params[key] = options[key];
+        }
+      });
+    }
+    const response = await apiClient.get(
+      `/input-table/${tableId}/rows`,
+      { params }
+    );
+    if (!response.data) {
+      throw { message: "Failed to fetch rows", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching rows";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const insertRow = async (tableId, rowData) => {
+  var _a, _b, _c;
+  try {
+    if (!tableId) {
+      throw { message: "Table ID is required", status: 400 };
+    }
+    if (!rowData || typeof rowData !== "object" || Array.isArray(rowData)) {
+      throw { message: "Row data must be an object", status: 400 };
+    }
+    const response = await apiClient.post(
+      `/input-table/${tableId}/rows`,
+      rowData
+    );
+    if (!response.data) {
+      throw { message: "Failed to insert row", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while inserting row";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const updateRow = async (tableId, updateData, rowId) => {
+  var _a, _b, _c;
+  try {
+    if (!tableId) {
+      throw { message: "Table ID is required", status: 400 };
+    }
+    if (!updateData || typeof updateData !== "object" || Array.isArray(updateData)) {
+      throw { message: "Update data must be an object", status: 400 };
+    }
+    const body = { ...updateData };
+    const params = {};
+    if (rowId) {
+      params._copa_id = rowId;
+      delete body.copa_id;
+      delete body._copa_id;
+    }
+    const fieldsToUpdate = Object.keys(body).filter(
+      (key) => key !== "copa_id" && key !== "_copa_id"
+    );
+    if (fieldsToUpdate.length === 0 && !rowId) {
+      throw {
+        message: "At least one field to update must be provided",
+        status: 400
+      };
+    }
+    const response = await apiClient.patch(
+      `/input-table/${tableId}/rows`,
+      body,
+      { params }
+    );
+    if (!response.data) {
+      throw { message: "Failed to update row", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while updating row";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const deleteRow = async (tableId, rowId, idField = "_copa_id") => {
+  var _a, _b, _c;
+  try {
+    if (!tableId) {
+      throw { message: "Table ID is required", status: 400 };
+    }
+    if (!rowId) {
+      throw { message: "Row ID is required", status: 400 };
+    }
+    const isMultiple = Array.isArray(rowId);
+    const params = {};
+    let body;
+    if (isMultiple && rowId.length === 0) {
+      throw { message: "At least one row ID must be provided", status: 400 };
+    }
+    if (isMultiple) {
+      body = { [idField]: rowId };
+    } else {
+      params[idField] = rowId;
+    }
+    const config = {
+      url: `/input-table/${tableId}/rows`,
+      method: "delete"
+    };
+    if (Object.keys(params).length > 0) {
+      config.params = params;
+    }
+    if (body) {
+      config.data = body;
+    }
+    const response = await apiClient.request(config);
+    if (!response.data) {
+      throw { message: "Failed to delete row(s)", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while deleting row(s)";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
 const index$9 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  deleteRow,
   getData: getData$1,
   getInputTables,
-  getTableById
+  getRows,
+  getTableById,
+  insertRow,
+  updateRow
 }, Symbol.toStringTag, { value: "Module" }));
 const getWorkbooksByType = async (type) => {
   var _a, _b, _c;