@ptkl/sdk 0.10.2 → 1.0.1

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,298 @@
+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[];
+type FieldRoles = {
+    see: string[];
+    edit: string[];
+};
+type Context = {
+    key: string;
+    value: any;
+};
+type FieldConstraints = {
+    required?: boolean;
+    unique?: boolean;
+    placeholder?: string;
+    default?: string;
+    length?: {
+        min?: number | null;
+        max?: number | null;
+    };
+    not_allowed_words?: string;
+    regex?: string;
+    date?: {
+        pattern?: string;
+        disable_past_dates?: boolean;
+        disable_future_dates?: boolean;
+        disabled_dates?: {
+            dates?: string[];
+            to?: string;
+            from?: string;
+            days?: number[];
+            days_of_month?: number[];
+            ranges?: Array<{
+                from: string;
+                to: string;
+            }>;
+        };
+        highlighted_dates?: {
+            dates?: string[];
+            to?: string;
+            from?: string;
+            days?: number[];
+            days_of_month?: number[];
+            ranges?: Array<{
+                from: string;
+                to: string;
+            }>;
+            include_disabled?: boolean;
+        };
+    };
+    selectables?: {
+        items?: any[];
+        multiple?: boolean;
+        range?: {
+            from: number;
+            to: number;
+        };
+        custom?: boolean;
+    };
+    table?: {
+        search?: boolean;
+        per_page?: number;
+        save_on_create?: boolean;
+        fields?: SettingsField[];
+    };
+    relation?: {
+        label?: string;
+        searchOn?: string[];
+    };
+};
+type SettingsField = {
+    name: string;
+    label: Record<string, any>;
+    key: string;
+    type: string;
+    description?: Record<string, any>;
+    module?: string;
+    group?: string;
+    sortOrder?: number;
+    visible?: boolean;
+    protected?: boolean;
+    roles?: FieldRoles;
+    context?: Context[];
+    constraints?: FieldConstraints;
+    relation?: {
+        foreign?: string;
+        key?: string[];
+        type?: string;
+        foreign_uuid?: string | null;
+    };
+    mutators?: {
+        get?: string;
+        set?: string;
+    };
+    provided_template?: boolean;
+    provided_template_component?: string;
+    component_template?: string;
+    template?: string;
+    permissions?: string[];
+};
+type Filters = {
+    filter?: string;
+    filterOn?: string[];
+    dateField?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    $adv?: Record<string, any>;
+};
+type PresetContext = {
+    filters?: Filters;
+    default?: boolean;
+    locked?: boolean;
+    expr?: string;
+};
+type Preset = {
+    name: string;
+    roles: string[];
+    context: PresetContext;
+};
+type Function = {
+    name: string;
+    expr: string;
+};
+type TemplatesDist = {
+    sdk_version: number;
+    sdk_engine: string;
+    dist: Record<string, any>;
+};
+type Settings = {
+    version?: string;
+    appearance?: {
+        list_entrypoint?: string;
+        create_entrypoint?: string;
+        edit_entrypoint?: string;
+    };
+    list?: {
+        quick_actions?: boolean;
+        perPage?: number;
+        fields?: Array<{
+            key: string;
+            label: Record<string, any>;
+            name?: string;
+            sortOrder?: number;
+            sortable?: boolean;
+            filterable?: boolean;
+            sortDirection?: string;
+            sortByFormatted?: boolean;
+            filterByFormatted?: boolean;
+            formatterEditor?: string;
+            variant?: string;
+            formatter?: string;
+            provided_template_component?: string;
+            component_template?: string;
+        }>;
+    };
+    fields?: SettingsField[];
+    model?: {
+        events?: Record<string, any>[];
+        unique_indexes_combinations?: string[][];
+    };
+    presets?: Preset[];
+    templates?: Record<string, any>[];
+    templates_dist?: TemplatesDist;
+    config?: Record<string, any>;
+    functions?: Function[];
+};
+type SetupData = {
+    name: string;
+    label?: Record<string, any>;
+    tag: string;
+    scope?: string;
+    public_version?: string;
+    dev_version?: string;
+    project_uuid?: string;
+    workspaces?: string[];
+    roles?: string[];
+    settings?: Settings;
+    env?: string;
+    is_active?: boolean;
+    is_public?: boolean;
+    icon?: string;
+    template_component_id?: string;
+    integrator?: string;
+};
+type ComponentCreateResponse = ComponentListItem;
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, ComponentOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, StreamCallback, StreamHandler, AggregateChainable, UpdateManyOptions, CreateManyOptions, Settings, SettingsField, FieldRoles, FieldConstraints, Context, Preset, PresetContext, Filters, Function, TemplatesDist, SetupData, ComponentCreateResponse, };

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;
+}