@ptkl/sdk 0.10.1 → 1.0.0

package/dist/v0.10/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.10/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.10/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.10/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.10/types/component.d.ts

@@ -0,0 +1,110 @@
+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 = {
+    force_update_protected_fields: 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, };

package/dist/{types → v0.10}/types/integrations.d.ts

@@ -52,7 +52,7 @@ export type PDFFillOptions = {
     forms?: PDFFormStructure[] | any;
 };
 export type HTML2PDFOptions = {
-    input_html?: boolean;
+    input_html?: string;
     input_path?: string;
     output_path?: string;
     output_pdf?: boolean;
@@ -206,3 +206,116 @@ export type MediaUploadBase64Payload = {
     /** 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/v0.10/users.d.ts

@@ -0,0 +1,69 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { UserClaims, UserModel, Role, CreateRoleRequest, EditRoleRequest, RoleModel, Permission } from "./types/users";
+import { AxiosResponse } from "axios";
+export default class Users extends PlatformBaseClient {
+    auth(username: string, password: string, project: string): Promise<AxiosResponse<any>>;
+    /**
+     * Resend confirmation email
+     * @param email User email
+     */
+    resendConfirmationEmail(email: string): Promise<AxiosResponse<any>>;
+    /**
+     * Request password reset email
+     * This only sends an email with a reset link, does not expose or change passwords
+     * @param email User email
+     */
+    requestPasswordReset(email: string): Promise<AxiosResponse<any>>;
+    /**
+     * Get current user's model
+     */
+    getUser(): Promise<AxiosResponse<UserModel>>;
+    /**
+     * Get current user's claims
+     */
+    getClaims(): Promise<AxiosResponse<UserClaims>>;
+    /**
+     * Edit user profile
+     * @param data Profile update data
+     */
+    editProfile(data: any): Promise<AxiosResponse<any>>;
+    /**
+     * Get user permissions
+     */
+    getPermissions(): Promise<AxiosResponse<Permission[]>>;
+    /**
+     * Get list of available permissions
+     */
+    listPermissions(): Promise<AxiosResponse<Permission[]>>;
+    /**
+     * Create a new role
+     * @param role Role data including name, permissions, workspaces, and level
+     */
+    createRole(role: CreateRoleRequest): Promise<AxiosResponse<Role>>;
+    /**
+     * Delete a role
+     * @param uuid Role UUID
+     */
+    deleteRole(uuid: string): Promise<AxiosResponse<{
+        status: boolean;
+    }>>;
+    /**
+     * List all roles
+     */
+    listRoles(): Promise<AxiosResponse<Role[]>>;
+    /**
+     * Get role details by UUID
+     * @param uuid Role UUID
+     */
+    getRoleModel(uuid: string): Promise<AxiosResponse<RoleModel>>;
+    /**
+     * Edit a role
+     * @param uuid Role UUID
+     * @param data Role update data including permissions, workspaces, and level
+     */
+    editRole(uuid: string, data: EditRoleRequest): Promise<AxiosResponse<Role>>;
+    /**
+     * @deprecated Use getPermissions() instead
+     */
+    permissions(): Promise<AxiosResponse<any>>;
+}

package/dist/v0.10/workflow.d.ts

@@ -0,0 +1,5 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Workflow extends PlatformBaseClient {
+    trigger(id: string, event: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    publish(event: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/api/apiUser.d.ts

@@ -0,0 +1,9 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class APIUser extends PlatformBaseClient {
+    auth(username: string, password: string, project: string): Promise<import("axios").AxiosResponse<any, any>>;
+    newSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    revokeSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    edit(uuid: string, roles: string[]): Promise<import("axios").AxiosResponse<any, any>>;
+    list(): Promise<any>;
+    get(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/api/apps.d.ts

@@ -0,0 +1,8 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Apps extends PlatformBaseClient {
+    private appType;
+    constructor(appType?: string);
+    updateSettings(updateValues: any, ref: string): Promise<any>;
+    download(ref: string, version: string): Promise<any>;
+    upload(formData: FormData): Promise<any>;
+}

package/dist/v0.9/api/baseClient.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from "axios";
+export default class BaseClient {
+    client: AxiosInstance;
+    constructor(client: AxiosInstance);
+    setClient(client: AxiosInstance): this;
+}