@ptkl/sdk 0.9.15 → 0.10.1

package/dist/index.esm.js

@@ -531,12 +531,210 @@ class Thunder extends PlatformBaseClient {
 }
 
 class Ratchet extends PlatformBaseClient {
+    /**
+     * Get all database connections for the current project
+     *
+     * @returns List of all configured ratchet connections
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * const connections = await ratchet.getConnections();
+     * console.log(connections.data); // Array of connections
+     * ```
+     */
+    async getConnections() {
+        return await this.client.get("/v1/ratchet/connection");
+    }
+    /**
+     * Get a specific database connection by ID
+     *
+     * @param id - Connection ID
+     * @returns Connection details including queries
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * const connection = await ratchet.getConnection('users_db');
+     * console.log(connection.data.queries); // Available queries for this connection
+     * ```
+     */
+    async getConnection(id) {
+        return await this.client.get(`/v1/ratchet/connection/${id}`);
+    }
+    /**
+     * Create a new database connection
+     *
+     * Supports multiple database types:
+     * - MySQL: Use credentials with host, dbname, user, password
+     * - PostgreSQL: Use credentials with host, dbname, user, password
+     * - MongoDB: Use DSN connection string
+     * - BigQuery: Use service_account_json and project_id
+     *
+     * @param connection - Connection configuration
+     * @returns Created connection details
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     *
+     * // MySQL/PostgreSQL connection
+     * await ratchet.createConnection({
+     *   id: 'users_db',
+     *   type: 'MySQL',
+     *   credentials: {
+     *     type: 'Credentials',
+     *     host: 'localhost',
+     *     dbname: 'users',
+     *     user: 'admin',
+     *     password: 'secret'
+     *   }
+     * });
+     *
+     * // MongoDB connection
+     * await ratchet.createConnection({
+     *   id: 'mongo_db',
+     *   type: 'MongoDB',
+     *   credentials: {
+     *     type: 'DSN',
+     *     dsn: 'mongodb://localhost:27017/mydb'
+     *   }
+     * });
+     *
+     * // BigQuery connection
+     * await ratchet.createConnection({
+     *   id: 'analytics_bq',
+     *   type: 'BigQuery',
+     *   credentials: {
+     *     type: 'ServiceAccount',
+     *     service_account_json: '{"type":"service_account",...}',
+     *     project_id: 'my-project-id'
+     *   }
+     * });
+     * ```
+     */
+    async createConnection(connection) {
+        return await this.client.post("/v1/ratchet/connection", connection);
+    }
+    /**
+     * Update an existing database connection
+     *
+     * @param connection - Updated connection configuration
+     * @returns Success status
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * await ratchet.updateConnection({
+     *   id: 'users_db',
+     *   type: 'postgres',
+     *   credentials: {
+     *     type: 'postgres',
+     *     host: 'localhost',
+     *     dbname: 'users',
+     *     user: 'admin',
+     *     password: 'new_secret'
+     *   },
+     *   queries: [
+     *     { id: 'get_user', expression: 'SELECT * FROM users WHERE id = $1' }
+     *   ]
+     * });
+     * ```
+     */
+    async updateConnection(connection) {
+        return await this.client.put("/v1/ratchet/connection", connection);
+    }
+    /**
+     * Delete a database connection
+     *
+     * @param id - Connection ID to delete
+     * @returns Success status
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * await ratchet.deleteConnection('users_db');
+     * ```
+     */
+    async deleteConnection(id) {
+        return await this.client.delete(`/v1/ratchet/connection/${id}`);
+    }
+    /**
+     * Test a database connection without saving it
+     *
+     * @param connection - Connection configuration to test
+     * @returns Success status if connection is valid
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * const isValid = await ratchet.testConnection({
+     *   id: 'test_db',
+     *   type: 'postgres',
+     *   credentials: {
+     *     type: 'postgres',
+     *     host: 'localhost',
+     *     dbname: 'test',
+     *     user: 'admin',
+     *     password: 'secret'
+     *   }
+     * });
+     * ```
+     */
+    async testConnection(connection) {
+        return await this.client.post("/v1/ratchet/test/connection", connection);
+    }
+    /**
+     * Execute a predefined database query
+     *
+     * Runs a query that has been previously configured in a ratchet connection.
+     * The query is identified by a qualified name in the format: `connectionId.queryId`
+     *
+     * @param name - Qualified name of the query (format: `connectionId.queryId`)
+     * @param params - Array of parameters to pass to the query
+     * @returns Query execution results
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     *
+     * // Execute a query with parameters
+     * const result = await ratchet.query('users_db.get_user_by_id', [123]);
+     *
+     * // Execute a query without parameters
+     * const allUsers = await ratchet.query('users_db.get_all_users', []);
+     * ```
+     */
     async query(name, params) {
-        return await this.client.post('/v1/ratchet/query', {
+        return await this.client.post("/v1/ratchet/query", {
             name: name,
-            params: params
+            params: params,
         });
     }
+    /**
+     * Inspect and execute a custom query without saving it
+     *
+     * This allows you to test queries before saving them to a connection.
+     *
+     * @param request - Query inspection request with connection name, query, and params
+     * @returns Query execution results
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * const result = await ratchet.inspectQuery({
+     *   name: 'users_db.test_query',
+     *   query: {
+     *     id: 'test_query',
+     *     expression: 'SELECT * FROM users WHERE email = $1'
+     *   },
+     *   params: ['user@example.com']
+     * });
+     * ```
+     */
+    async inspectQuery(request) {
+        return await this.client.post("/v1/ratchet/query/inspect", request);
+    }
 }
 
 class Sandbox extends PlatformBaseClient {
@@ -996,6 +1194,23 @@ class DMS extends IntegrationsBaseClient {
     async libraries() {
         return await this.requestv1("GET", "media/library/list");
     }
+    /**
+     * Upload files using multipart form data
+     *
+     * @param payload - Upload configuration with files, directory, and options
+     * @returns Upload response from the server
+     *
+     * @example
+     * ```typescript
+     * const result = await dms.upload({
+     *   files: [file1, file2],
+     *   uploadDir: '/documents/invoices',
+     *   public: true,
+     *   replace: true,
+     *   metadata: { category: 'finance' }
+     * });
+     * ```
+     */
     async upload(payload) {
         let files = payload.files;
         let formData = new FormData();
@@ -1009,13 +1224,15 @@ class DMS extends IntegrationsBaseClient {
         });
         if (count == files.length) {
             formData.append('path', payload.uploadDir);
-            formData.append('ref', payload.uuid);
             if (payload.public) {
                 formData.append('is_public', "true");
             }
+            if (payload.replace) {
+                formData.append('replace', "true");
+            }
             if (payload.expiresAt)
                 formData.append('expiresAt', new Date(payload.expiresAt).toISOString());
-            if (Object.keys(payload.metadata).length > 0)
+            if (payload.metadata && Object.keys(payload.metadata).length > 0)
                 formData.append('metadata', JSON.stringify(payload.metadata));
             return await this.request("POST", "media/upload", {
                 data: formData,
@@ -1028,6 +1245,28 @@ class DMS extends IntegrationsBaseClient {
     async delete(data) {
         return this.request('POST', 'media/delete', data);
     }
+    /**
+     * Upload files using base64-encoded content
+     *
+     * @param data - Upload payload with base64-encoded files
+     * @returns Upload response from the server
+     *
+     * @example
+     * ```typescript
+     * const result = await dms.uploadBase64({
+     *   path: '/documents/reports',
+     *   is_public: false,
+     *   replace: true,
+     *   files: [
+     *     {
+     *       name: 'report.pdf',
+     *       content_type: 'application/pdf',
+     *       data: 'base64EncodedContent...'
+     *     }
+     *   ]
+     * });
+     * ```
+     */
     async uploadBase64(data) {
         return this.request('POST', `media/upload`, {
             data,
@@ -1036,30 +1275,30 @@ class DMS extends IntegrationsBaseClient {
             }
         });
     }
-    async getMedia(lib, key, encoding) {
-        return this.request('GET', `media/library/${lib}/get/${key}`, {
+    async getMedia(key, encoding) {
+        return this.request('GET', `media/get/${key}`, {
             params: {
                 encoding
             },
             responseType: (!encoding) ? 'blob' : null
         });
     }
-    async download(lib, key) {
-        return this.request('POST', `media/library/${lib}/download`, {
+    async download(key) {
+        return this.request('POST', `media/download`, {
             data: {
                 key
             },
             responseType: 'blob'
         });
     }
-    async getExifData(lib, key) {
-        return this.request('GET', `media/library/${lib}/exif/${key}`);
+    async getExifData(key) {
+        return this.request('GET', `media/exif/${key}`);
     }
-    async html2pdf(lib, data) {
-        const { output_pdf = false, input_path, input_html, output_path, output_file_name, output_type, data: templateData } = data;
+    async html2pdf(data) {
+        const { output_pdf = false, input_path, input_html, output_path, output_file_name, output_type, data: templateData, replace, } = data;
         const type = output_pdf ? 'arraybuffer' : 'json';
         const contentType = output_pdf ? 'application/pdf' : 'application/json';
-        return this.request('POST', `media/library/${lib}/html2pdf`, {
+        return this.request('POST', `media/pdf/html2pdf`, {
             data: {
                 output_pdf,
                 input_path,
@@ -1067,7 +1306,27 @@ class DMS extends IntegrationsBaseClient {
                 input_html,
                 output_file_name,
                 output_type,
-                data: templateData
+                data: templateData,
+                replace,
+            },
+            headers: {
+                'Content-Type': contentType
+            },
+            responseType: type
+        });
+    }
+    async pdf2html(data) {
+        const { output_html = false, input_path, input_pdf, output_path, output_file_name, replace, } = data;
+        const type = output_html ? 'arraybuffer' : 'json';
+        const contentType = output_html ? 'text/html' : 'application/json';
+        return this.request('POST', `media/pdf/pdf2html`, {
+            data: {
+                output_html,
+                input_path,
+                output_path,
+                input_pdf,
+                output_file_name,
+                replace,
             },
             headers: {
                 'Content-Type': contentType
@@ -1075,20 +1334,20 @@ class DMS extends IntegrationsBaseClient {
             responseType: type
         });
     }
-    async createDir(lib, path) {
-        return this.request('POST', `media/library/${lib}/dir`, { data: { path } });
+    async createDir(path) {
+        return this.request('POST', `media/library/dir`, { data: { path } });
     }
-    async deleteDir(lib, path) {
-        return this.request('POST', `media/library/${lib}/delete/dir`, { data: { path } });
+    async deleteDir(path) {
+        return this.request('DELETE', `media/library/dir`, { data: { path } });
     }
-    async dirs(lib, data) {
-        return await this.request("POST", `media/library/${lib}/dirs`, { data });
+    async dirs(data) {
+        return await this.request("POST", `media/library/dirs`, { data });
     }
-    async fillPdf(lib, data) {
-        const { input_path, output_path, output_pdf = false, output_type, output_file_name, form_data, forms } = data;
+    async fillPdf(data) {
+        const { input_path, output_path, output_pdf = false, output_type, output_file_name, replace, form_data, forms } = data;
         const responseType = output_pdf ? 'arraybuffer' : 'json';
         const contentType = output_pdf ? 'application/pdf' : 'application/json';
-        return this.request('POST', `media/library/${lib}/pdf/fill`, {
+        return this.request('POST', `media/pdf/fill`, {
             data: {
                 input_path,
                 output_path,
@@ -1096,6 +1355,7 @@ class DMS extends IntegrationsBaseClient {
                 output_type,
                 output_file_name,
                 form_data,
+                replace,
                 forms
             },
             headers: {
@@ -1173,7 +1433,7 @@ class DMS extends IntegrationsBaseClient {
      * // excelResult.data is a Blob
      * ```
      */
-    async convertData(lib, data, params) {
+    async convertData(data, params) {
         const { from, to, sheet_name, include_header, include_footer, header_as_comment, footer_as_comment, separator_rows, field_order, } = params;
         const queryParams = { from, to };
         // Add optional parameters if provided
@@ -1200,7 +1460,7 @@ class DMS extends IntegrationsBaseClient {
         else if (to === 'excel' || to === 'xlsx') {
             responseType = 'blob';
         }
-        return this.request('POST', `media/library/${lib}/convert/data`, {
+        return this.request('POST', `media/convert/data`, {
             data,
             params: queryParams,
             responseType,
@@ -1240,9 +1500,9 @@ class DMS extends IntegrationsBaseClient {
      * // }
      * ```
      */
-    async getDataInfo(lib, data, params) {
+    async getDataInfo(data, params) {
         const { format } = params;
-        return this.request('POST', `media/library/${lib}/convert/info`, {
+        return this.request('POST', `media/convert/info`, {
             data,
             params: { format },
             headers: {
@@ -1284,9 +1544,9 @@ class DMS extends IntegrationsBaseClient {
      * }
      * ```
      */
-    async validateData(lib, data, params) {
+    async validateData(data, params) {
         const { format } = params;
-        return this.request('POST', `media/library/${lib}/convert/validate`, {
+        return this.request('POST', `media/convert/validate`, {
             data,
             params: { format },
             headers: {
@@ -1332,12 +1592,12 @@ class DMS extends IntegrationsBaseClient {
      * // Auto-detects header, items, and footer sections
      * ```
      */
-    async jsonToCsv(lib, jsonData, options) {
+    async jsonToCsv(jsonData, options) {
         let params = {};
         if (options === null || options === void 0 ? void 0 : options.field_order) {
             params.field_order = options.field_order.join(',');
         }
-        return this.request('POST', `media/library/${lib}/convert/json-to-csv`, {
+        return this.request('POST', `media/convert/json-to-csv`, {
             params,
             data: jsonData,
             responseType: 'text',
@@ -1391,7 +1651,7 @@ class DMS extends IntegrationsBaseClient {
      * link.click();
      * ```
      */
-    async jsonToExcel(lib, jsonData, options) {
+    async jsonToExcel(jsonData, options) {
         const params = {};
         if (options === null || options === void 0 ? void 0 : options.sheet_name) {
             params.sheet_name = options.sheet_name;
@@ -1399,7 +1659,7 @@ class DMS extends IntegrationsBaseClient {
         if (options === null || options === void 0 ? void 0 : options.field_order) {
             params.field_order = options.field_order.join(',');
         }
-        return this.request('POST', `media/library/${lib}/convert/json-to-excel`, {
+        return this.request('POST', `media/convert/json-to-excel`, {
             data: jsonData,
             params,
             responseType: 'blob',
@@ -1430,8 +1690,8 @@ class DMS extends IntegrationsBaseClient {
      * // ]
      * ```
      */
-    async csvToJson(lib, csvData) {
-        return this.request('POST', `media/library/${lib}/convert/csv-to-json`, {
+    async csvToJson(csvData) {
+        return this.request('POST', `media/convert/csv-to-json`, {
             data: csvData,
             responseType: 'json',
             headers: {
@@ -1463,12 +1723,12 @@ class DMS extends IntegrationsBaseClient {
      * // Use url for download or further processing
      * ```
      */
-    async csvToExcel(lib, csvData, options) {
+    async csvToExcel(csvData, options) {
         const params = {};
         if (options === null || options === void 0 ? void 0 : options.sheet_name) {
             params.sheet_name = options.sheet_name;
         }
-        return this.request('POST', `media/library/${lib}/convert/csv-to-excel`, {
+        return this.request('POST', `media/convert/csv-to-excel`, {
             data: csvData,
             params,
             responseType: 'blob',
@@ -1503,12 +1763,12 @@ class DMS extends IntegrationsBaseClient {
      * const jsonFromBuffer = await dms.excelToJson(libraryRef, arrayBuffer);
      * ```
      */
-    async excelToJson(lib, excelData, options) {
+    async excelToJson(excelData, options) {
         const params = {};
         if (options === null || options === void 0 ? void 0 : options.sheet_name) {
             params.sheet_name = options.sheet_name;
         }
-        return this.request('POST', `media/library/${lib}/convert/excel-to-json`, {
+        return this.request('POST', `media/convert/excel-to-json`, {
             data: excelData,
             params,
             responseType: 'json',
@@ -1547,12 +1807,12 @@ class DMS extends IntegrationsBaseClient {
      * link.click();
      * ```
      */
-    async excelToCsv(lib, excelData, options) {
+    async excelToCsv(excelData, options) {
         const params = {};
         if (options === null || options === void 0 ? void 0 : options.sheet_name) {
             params.sheet_name = options.sheet_name;
         }
-        return this.request('POST', `media/library/${lib}/convert/excel-to-csv`, {
+        return this.request('POST', `media/convert/excel-to-csv`, {
             data: excelData,
             params,
             responseType: 'text',
@@ -1564,7 +1824,7 @@ class DMS extends IntegrationsBaseClient {
     async request(method, endpoint, params) {
         return await this.client.request({
             method: method,
-            url: `/v2/dms/${endpoint}`,
+            url: `/v3/dms/${endpoint}`,
             ...params
         });
     }