@ptkl/sdk 0.10.0 → 0.10.2

package/dist/types/api/ratchet.d.ts

@@ -1,4 +1,196 @@
 import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+import { RatchetQueryResponse, RatchetConnection, CreateRatchetConnectionRequest, InspectQueryRequest } from "../types/ratchet";
 export default class Ratchet extends PlatformBaseClient {
-    query(name: string, params: any): Promise<import("axios").AxiosResponse<any, any>>;
+    /**
+     * 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
+     * ```
+     */
+    getConnections(): Promise<AxiosResponse<RatchetConnection[]>>;
+    /**
+     * 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
+     * ```
+     */
+    getConnection(id: string): Promise<AxiosResponse<RatchetConnection>>;
+    /**
+     * 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'
+     *   }
+     * });
+     * ```
+     */
+    createConnection(connection: CreateRatchetConnectionRequest): Promise<AxiosResponse<RatchetConnection>>;
+    /**
+     * 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' }
+     *   ]
+     * });
+     * ```
+     */
+    updateConnection(connection: RatchetConnection): Promise<AxiosResponse<{
+        status: boolean;
+    }>>;
+    /**
+     * Delete a database connection
+     *
+     * @param id - Connection ID to delete
+     * @returns Success status
+     *
+     * @example
+     * ```typescript
+     * const ratchet = new Ratchet();
+     * await ratchet.deleteConnection('users_db');
+     * ```
+     */
+    deleteConnection(id: string): Promise<AxiosResponse<{
+        status: boolean;
+    }>>;
+    /**
+     * 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'
+     *   }
+     * });
+     * ```
+     */
+    testConnection(connection: RatchetConnection): Promise<AxiosResponse<{
+        status: boolean;
+    }>>;
+    /**
+     * 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', []);
+     * ```
+     */
+    query<T = any>(name: string, params: any[] | Record<string, any>): Promise<AxiosResponse<RatchetQueryResponse<T>>>;
+    /**
+     * 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']
+     * });
+     * ```
+     */
+    inspectQuery<T = any>(request: InspectQueryRequest): Promise<AxiosResponse<RatchetQueryResponse<T>>>;
 }

package/dist/types/index.d.ts

@@ -25,4 +25,5 @@ export type * from './types/integrations';
 export type * from './types/users';
 export type * from './types/project';
 export type * from './types/config';
+export type * from './types/ratchet';
 export default Platform;

package/dist/types/types/component.d.ts

@@ -47,4 +47,38 @@ type UpdateOptions = {
 type ModifyOptions = {
     upsert: boolean;
 };
-export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, };
+type ComponentLabel = {
+    locales: Record<string, string>;
+};
+type ComponentWorkspace = {
+    uuid: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    DeletedAt: string | null;
+    workspace_uuid: string;
+    component_uuid: string;
+};
+type ComponentListItem = {
+    uuid: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    DeletedAt: string | null;
+    name: string;
+    label: ComponentLabel;
+    tag: string;
+    icon: string | null;
+    is_active: boolean;
+    is_public: boolean;
+    visible: boolean;
+    project_uuid: string;
+    scope: string;
+    sort: number;
+    public_version: string;
+    dev_version: string;
+    versions: string[] | null;
+    dependencies: string[];
+    workspaces: ComponentWorkspace[];
+    storage_size: number;
+};
+type ComponentListResponse = ComponentListItem[];
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, };

package/dist/types/types/integrations.d.ts

@@ -45,6 +45,7 @@ export type PDFFillOptions = {
     input_path?: string;
     output_path?: string;
     output_pdf?: boolean;
+    replace?: boolean;
     output_type?: PDFOutputType;
     output_file_name?: string;
     form_data?: Record<string, any>;
@@ -57,6 +58,16 @@ export type HTML2PDFOptions = {
     output_pdf?: boolean;
     output_type?: PDFOutputType;
     output_file_name?: string;
+    replace?: boolean;
+    data?: Record<string, any>;
+};
+export type PDF2HTMLOptions = {
+    input_path?: string;
+    input_pdf?: string;
+    output_path?: string;
+    output_html?: string;
+    output_file_name?: string;
+    replace?: boolean;
     data?: Record<string, any>;
 };
 /**
@@ -148,3 +159,163 @@ export type NbsIpsQrCode = {
     PurposeOfPayment: string;
     PaymentOrderNumber: string;
 };
+/**
+ * Payload for multipart form upload
+ */
+export type MediaUploadPayload = {
+    /** Array of files to upload */
+    files: File[];
+    /** Directory path where files should be uploaded */
+    uploadDir: string;
+    /** Whether files should be publicly accessible */
+    public?: boolean;
+    /** If true, replace files if they already exist */
+    replace?: boolean;
+    /** Expiration timestamp in ISO 8601 format (RFC3339) */
+    expiresAt?: string;
+    /** Additional metadata as key-value pairs */
+    metadata?: Record<string, string>;
+};
+/**
+ * File structure for base64 upload
+ */
+export type MediaUploadBase64File = {
+    /** Name of the file including extension */
+    name: string;
+    /** MIME type of the file (e.g., 'image/png', 'application/pdf') */
+    content_type: string;
+    /** Base64-encoded file content */
+    data: string;
+};
+/**
+ * Payload for base64/JSON upload
+ */
+export type MediaUploadBase64Payload = {
+    /** Reference identifier for the upload operation */
+    ref?: string;
+    /** Directory path where files should be uploaded */
+    path: string;
+    /** Whether files should be publicly accessible */
+    is_public?: boolean;
+    /** If true, replace files if they already exist */
+    replace?: boolean;
+    /** Expiration timestamp (Date object or ISO 8601 string) */
+    expires_at?: Date | string;
+    /** Additional metadata as key-value pairs */
+    metadata?: Record<string, string>;
+    /** Array of files with base64-encoded content */
+    files: MediaUploadBase64File[];
+};
+/**
+ * Filters for document listing endpoints
+ */
+export type DocumentListParams = {
+    /** Optional text to search within documents */
+    searchText?: string;
+    /** Whether to search recursively through directories */
+    recursive?: boolean;
+};
+export type DocumentSourceType = "component" | string;
+export type DocumentSource = {
+    type: DocumentSourceType;
+    value: string;
+    label: string;
+    tag: string;
+};
+export type DocumentFieldDataMapping = {
+    sourceField?: string;
+};
+export type DocumentFieldSource = "text" | "options" | "datepicker" | DocumentSource["tag"];
+export type DocumentField = {
+    field: string;
+    label?: string | null;
+    source: DocumentFieldSource;
+    value?: string | number | null;
+    format?: string;
+    data?: DocumentFieldDataMapping;
+};
+export type DocumentAuditEntry = {
+    time: string;
+    name?: string;
+    uuid?: string;
+};
+export type DocumentVariant = {
+    name: string;
+    version: number;
+    content: string;
+    sources?: DocumentSource[];
+    fields?: DocumentField[];
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentResponse = {
+    name: string;
+    variants: DocumentVariant[];
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentListItem = {
+    name: string;
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentListResponse = DocumentListItem[];
+/**
+ * Payload for creating a document
+ */
+export type DocumentCreatePayload = {
+    /** Document path (including directory and filename) */
+    path: string;
+    /** Document content (plain text or structured) */
+    content?: string;
+    /** Document variant identifier */
+    variant?: string;
+    /** Optional document sources metadata */
+    sources?: DocumentSource[];
+    /** Optional custom fields metadata */
+    fields?: DocumentField[];
+};
+/**
+ * Payload for updating an existing document
+ */
+export type DocumentUpdatePayload = {
+    /** Document path (including directory and filename) */
+    path: string;
+    /** Variant to update */
+    variant?: string;
+    /** Current version used for optimistic locking */
+    version?: number;
+    /** Updated content */
+    content?: string;
+    /** Updated sources metadata */
+    sources?: DocumentSource[];
+    /** Updated fields metadata */
+    fields?: DocumentField[];
+};
+/**
+ * Payload for restoring a deleted document
+ */
+export type DocumentRestorePayload = {
+    /** Path of the deleted document */
+    path: string;
+    /** Optional new path to restore to */
+    newPath?: string;
+};
+/**
+ * Payload for creating a document comment
+ */
+export type DocumentCommentPayload = {
+    /** Target document path */
+    path: string;
+    /** Comment body */
+    content: string;
+    /** Variant the comment belongs to */
+    variant?: string;
+    /** Comment start position */
+    from?: number;
+    /** Comment end position */
+    to?: number;
+};

package/dist/types/types/ratchet.d.ts

@@ -0,0 +1,38 @@
+export interface RatchetQueryRequest {
+    name: string;
+    params: any[];
+}
+export interface RatchetQueryResponse<T = any> {
+    data: T;
+    status: boolean;
+}
+export interface RatchetCredentials {
+    type: string;
+    dsn?: string;
+    user?: string;
+    password?: string;
+    host?: string;
+    dbname?: string;
+    service_account_json?: string;
+    project_id?: string;
+}
+export interface RatchetQuery {
+    id: string;
+    expression: string;
+}
+export interface RatchetConnection {
+    id: string;
+    type: string;
+    credentials: RatchetCredentials;
+    queries?: RatchetQuery[];
+}
+export interface CreateRatchetConnectionRequest {
+    id: string;
+    type: string;
+    credentials: RatchetCredentials;
+}
+export interface InspectQueryRequest {
+    name: string;
+    query: RatchetQuery;
+    params: any[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ptkl/sdk",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "scripts": {
     "build": "rollup -c",
     "build:monaco": "npm run build && node scripts/generate-monaco-types.cjs",