@ptkl/sdk 0.10.2 → 1.0.0

package/dist/v0.9/ratchet.d.ts

@@ -0,0 +1,196 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+import { RatchetQueryResponse, RatchetConnection, CreateRatchetConnectionRequest, InspectQueryRequest } from "./types/ratchet";
+export default 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
+     * ```
+     */
+    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/v0.9/sandbox.d.ts

@@ -0,0 +1,14 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Sandbox extends PlatformBaseClient {
+    /**
+     * Call the sandbox service to execute a serverless function
+     *
+     * @param name
+     * @param data
+     * @returns
+     *
+     * @example
+     * const result = await platform.sandbox().spark("myFunction", { foo: "bar" })
+     */
+    spark(name: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/system.d.ts

@@ -0,0 +1,4 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class System extends PlatformBaseClient {
+    resourceResolver(ref: string, resourceName: string, format?: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/thunder.d.ts

@@ -0,0 +1,13 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Thunder extends PlatformBaseClient {
+    read(type: string, filters: any, flag: string, options?: any): Promise<import("axios").AxiosResponse<any, any>>;
+    write(type: string, filters: any, d: any, flag: any): Promise<import("axios").AxiosResponse<any, any>>;
+    operation(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    find(name: string, filters: any): Promise<import("axios").AxiosResponse<any, any>>;
+    findOne(name: string, filters: any): Promise<import("axios").AxiosResponse<any, any>>;
+    paginate(name: string, filters: any, options?: any): Promise<import("axios").AxiosResponse<any, any>>;
+    upsert(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    insertOne(name: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    updateOne(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    delete(name: string, filters: any): Promise<import("axios").AxiosResponse<any, any>>;
+}

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

@@ -0,0 +1,116 @@
+type FindParams = {
+    currentPage?: number;
+    perPage?: number;
+    sortBy?: string;
+    sortDesc?: boolean;
+    filterOn?: string[];
+    filter?: any;
+    disabled?: any;
+    dateFrom?: string;
+    dateTo?: string;
+    dateField?: string;
+    $adv?: FindAdvancedParams;
+    $aggregate?: FindAggregateParams[];
+};
+type FindOptions = {
+    cache?: boolean;
+    buildttl?: number;
+    locale?: string;
+    unmaskPasswords?: boolean;
+};
+type FindResponse = {
+    items: Model[];
+    total: number;
+    page: number;
+    pages: number;
+};
+/**
+ * Callback function for processing each document in a stream
+ * @param document - A single model document from the stream
+ */
+type StreamCallback = (document: Model) => void | Promise<void>;
+/**
+ * Streaming response handler
+ */
+type StreamHandler = {
+    onData: StreamCallback;
+    onError?: (error: Error) => void;
+    onEnd?: () => void;
+};
+/**
+ * Chainable aggregate result that supports both buffered and streaming modes
+ */
+type AggregateChainable = {
+    onData: (callback: StreamCallback) => AggregateChainable;
+    onError: (callback: (error: Error) => void) => AggregateChainable;
+    onEnd: (callback: () => void) => AggregateChainable;
+    then: <T>(resolve?: (value: any) => T, reject?: (error: any) => any) => Promise<T>;
+    catch: (reject: (error: any) => any) => Promise<any>;
+};
+type FindAdvancedParams = {
+    [key: string]: any;
+};
+type FindAggregateParams = {
+    [key: string]: any;
+};
+type Model = {
+    uuid: string;
+    __version__: number;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    updated_by: string;
+    deleted_at: string;
+    deleted_by: string;
+    [key: string]: any;
+};
+type UpdateOptions = {
+    forceUpdateProtectedFields: boolean;
+};
+type UpdateManyOptions = UpdateOptions & {
+    rollbackOnError: boolean;
+};
+type CreateManyOptions = {
+    rollbackOnError: boolean;
+};
+type ModifyOptions = {
+    upsert: boolean;
+};
+type ComponentOptions = {
+    version?: string;
+};
+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, ComponentOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, StreamCallback, StreamHandler, AggregateChainable, UpdateManyOptions, CreateManyOptions, };

package/dist/v0.9/types/config.d.ts

@@ -0,0 +1,11 @@
+export interface UserConfig {
+    uuid?: string;
+    user_uuid: string;
+    data: Record<string, any>;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ConfigUpdateRequest {
+    data: Record<string, any>;
+    path: string;
+}

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

@@ -0,0 +1,321 @@
+export type PaymentProvider = 'monri';
+export type GetPaymentLinkOptions = {
+    totalAmount: number;
+    description: string;
+    redirectUrl?: string | null;
+};
+export type PDFFormTextField = {
+    name: string;
+    value: string;
+    locked?: boolean;
+};
+export type PDFFormDateField = {
+    name: string;
+    value: string;
+    locked?: boolean;
+};
+export type PDFFormCheckboxField = {
+    name: string;
+    value: boolean;
+};
+export type PDFFormRadioButtonGroup = {
+    name: string;
+    value: string;
+    locked?: boolean;
+};
+export type PDFFormListBox = {
+    name: string;
+    values: string[];
+    locked?: boolean;
+};
+export type PDFFormComboBox = {
+    name: string;
+    value: string;
+};
+export type PDFFormStructure = {
+    textfield?: PDFFormTextField[];
+    datefield?: PDFFormDateField[];
+    checkbox?: PDFFormCheckboxField[];
+    radiobuttongroup?: PDFFormRadioButtonGroup[];
+    listbox?: PDFFormListBox[];
+    combobox?: PDFFormComboBox[];
+};
+export type PDFOutputType = 'pdf' | 'base64' | 'file';
+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>;
+    forms?: PDFFormStructure[] | any;
+};
+export type HTML2PDFOptions = {
+    input_html?: string;
+    input_path?: string;
+    output_path?: string;
+    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>;
+};
+/**
+ * Supported data formats for conversion operations
+ */
+export type DataFormat = 'json' | 'csv' | 'excel' | 'xlsx';
+/**
+ * Parameters for data conversion between formats
+ */
+export type DataConversionParams = {
+    /** Source format */
+    from: DataFormat;
+    /** Target format */
+    to: DataFormat;
+    /** Optional Excel sheet name (defaults to "Sheet1") */
+    sheet_name?: string;
+    /** Include header section in output (default: true) */
+    include_header?: boolean;
+    /** Include footer section in output (default: true) */
+    include_footer?: boolean;
+    /** Render header as comments in CSV (default: false) */
+    header_as_comment?: boolean;
+    /** Render footer as comments in CSV (default: false) */
+    footer_as_comment?: boolean;
+    /** Empty rows between sections (default: 1) */
+    separator_rows?: number;
+    /** Specify order of fields/columns */
+    field_order?: string[];
+};
+/**
+ * Parameters for data format validation
+ */
+export type DataValidationParams = {
+    /** Format to validate against */
+    format: DataFormat;
+};
+/**
+ * Parameters for data analysis and information extraction
+ */
+export type DataInfoParams = {
+    /** Format of the data to analyze */
+    format: DataFormat;
+};
+/**
+ * Information about analyzed data structure and content
+ */
+export type DataInfo = {
+    /** Detected or specified format */
+    format: string;
+    /** Size of data in bytes */
+    size_bytes: number;
+    /** Number of records/rows */
+    record_count: number;
+    /** Number of fields/columns */
+    field_count: number;
+    /** Array of field/column names */
+    fields: string[];
+    /** Library reference UUID */
+    library_ref: string;
+};
+/**
+ * Result of data format validation
+ */
+export type DataValidationResult = {
+    /** Whether the data is valid for the specified format */
+    valid: boolean;
+    /** Validation message (success or error details) */
+    message: string;
+    /** Library reference UUID */
+    library_ref: string;
+};
+/**
+ * Optional parameters for data conversion operations
+ */
+export type ConversionOptions = {
+    /** Excel sheet name for read/write operations (defaults to "Sheet1") */
+    sheet_name?: string; /** Specify order of fields/columns */
+    field_order?: string[];
+};
+export type NbsIpsQrCode = {
+    TransactionType: string;
+    Version: string;
+    CharacterSet: string;
+    RecipientAccountNumber: string;
+    RecipientName: string;
+    AmountInLocalCurrency: string;
+    PayerInformation: string;
+    PaymentPurposeCode: string;
+    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;
+};