@ptkl/sdk 0.10.2 → 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/{types → v0.10}/types/component.d.ts

@@ -24,6 +24,29 @@ type FindResponse = {
     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;
 };
@@ -47,6 +70,9 @@ type UpdateOptions = {
 type ModifyOptions = {
     upsert: boolean;
 };
+type ComponentOptions = {
+    version?: string;
+};
 type ComponentLabel = {
     locales: Record<string, string>;
 };
@@ -81,4 +107,4 @@ type ComponentListItem = {
     storage_size: number;
 };
 type ComponentListResponse = ComponentListItem[];
-export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, };
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, ComponentOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, StreamCallback, StreamHandler, AggregateChainable, };

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

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

@@ -0,0 +1,136 @@
+import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, StreamHandler, AggregateChainable, ComponentOptions, UpdateManyOptions, CreateManyOptions } from "../types/component";
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+export default class Component extends PlatformBaseClient {
+    private ref;
+    private version;
+    constructor(ref?: string | null, options?: ComponentOptions);
+    /**
+     * Get the base path for component API calls
+     * @private
+     */
+    private getComponentPath;
+    /**
+     * Find method to search for models
+     *
+     * @param {FindParams} filters - The filters to apply to the search
+     * @param {FindOptions} opts - The options to apply to the search
+     *
+     * @returns {Promise<FindResponse>} - The result of the search
+     *
+     * @example
+     * platform.component(name).find({
+     *     currentPage: 1,
+     *     perPage: 10,
+     * })
+     *
+     * // advanced search
+     * platform.component(name).find({
+     *     $adv: {
+     *         name: "John Doe",
+     *     }
+     * )
+     **/
+    find(filters: FindParams, opts?: FindOptions): Promise<AxiosResponse<FindResponse>>;
+    /**
+     * FindOne method to search for a single model
+     *
+     * @param {FindAdvancedParams} filter - The filters to apply to the search
+     * @param {FindOptions} opts - The options to apply to the search
+     *
+     * @returns {Promise<?Model>} - The result of the search
+     *
+     * @example
+     * platform.component(name).findOne({
+     *     name: "John Doe",
+     * })
+     **/
+    findOne(filter: FindAdvancedParams, opts: FindOptions): Promise<Model | null>;
+    /**
+     * Get model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @returns (Promise<Model>)
+     */
+    get(uuid: string): Promise<AxiosResponse<Model>>;
+    /**
+     * Update model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @param data
+     * @returns
+     */
+    update(uuid: string, data: Record<string, any>, options: UpdateOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Update many models
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    updateMany(data: Record<string, any>[], options: UpdateManyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Create many models
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    createMany(data: Record<string, any>[], options: CreateManyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Modify models by filters
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    modify(filters: Record<string, any>, data: Record<string, any>, options: ModifyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Concurrent update model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @param version number - The version of the model
+     * @param data
+     * @returns
+     */
+    concurrentUpdate(uuid: string, version: number, data: Record<string, any>, options: UpdateOptions): Promise<AxiosResponse<any, any>>;
+    create(model: Record<string, any>): Promise<AxiosResponse<any, any>>;
+    delete(uuid: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Execute aggregate pipeline with optional streaming support
+     *
+     * Returns a chainable object that allows both buffered and streaming modes.
+     * Call .onData() to enable streaming mode, or await directly for buffered mode.
+     *
+     * @param {FindAggregateParams} pipeline - MongoDB aggregation pipeline
+     *
+     * @returns {AggregateChainable} Chainable object with streaming methods and Promise interface
+     *
+     * @example
+     * ```typescript
+     * // Buffered response (default, up to 5K documents)
+     * const result = await component.aggregate([{ $match: { status: 'active' } }]);
+     * console.log(result.data); // All results at once
+     *
+     * // Streaming response (up to 25K documents)
+     * await component.aggregate([{ $match: { status: 'active' } }])
+     *   .onData((doc) => console.log('Received:', doc))
+     *   .onError((err) => console.error('Error:', err))
+     *   .onEnd(() => console.log('Stream complete'));
+     * ```
+     */
+    aggregate(pipeline: FindAggregateParams): AggregateChainable;
+    settings(): Promise<AxiosResponse<any, any>>;
+    saveSettings(settings: any, version: string): Promise<AxiosResponse<any, any>>;
+    saveTemplatesDist(version: string, sdkVersion: string, engine: string, dist: Record<string, string>): Promise<any>;
+    workflow(event: string, input: any): Promise<AxiosResponse<any, any>>;
+    function(name: string, input: any): Promise<AxiosResponse<any, any>>;
+    revisions(uuid: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Internal method to handle NDJSON streaming responses
+     *
+     * @private
+     */
+    private _streamNDJSON;
+}
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, StreamHandler, AggregateChainable, ComponentOptions, };

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

@@ -0,0 +1,7 @@
+import { AxiosResponse } from "axios";
+import { ComponentListResponse } from "../types/component";
+import PlatformBaseClient from "./platformBaseClient";
+export default class ComponentUtils extends PlatformBaseClient {
+    list(): Promise<AxiosResponse<ComponentListResponse>>;
+    create(data: any): Promise<AxiosResponse<any, any>>;
+}

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

@@ -0,0 +1,14 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+import { ConfigUpdateRequest, UserConfig } from '../types/config';
+export default class Config extends PlatformBaseClient {
+    /**
+     * Get user configuration
+     */
+    getUserConfig(): Promise<AxiosResponse<UserConfig>>;
+    /**
+     * Update user configuration
+     * @param config Configuration data
+     */
+    updateUserConfig(config: ConfigUpdateRequest): Promise<AxiosResponse<any>>;
+}

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

@@ -0,0 +1,7 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Forge extends PlatformBaseClient {
+    bundleUpload(buffer: Buffer): Promise<any>;
+    getWorkspaceApps(): Promise<any>;
+    removeVersion(ref: string, version: string): Promise<any>;
+    list(): Promise<any>;
+}

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

@@ -0,0 +1,23 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Functions extends PlatformBaseClient {
+    list(): Promise<any>;
+    get(ref: string): Promise<any>;
+    update(uuid: string, update: any): Promise<any>;
+    /**
+     * Run platform function
+     *
+     * @param id - Function ID
+     * @param input - Input data
+     * @param query - Query parameters
+     * @returns - Function result
+     *
+     * @example
+     * const result = await platform.function().run("myFunction", {input: { foo: "bar" }})
+     */
+    run(id: string, d: {
+        input?: Record<string, any>;
+        query?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+    generateSignature(ref: string, env: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

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

@@ -0,0 +1,24 @@
+export { default as Component } from './component';
+export { default as Platform } from './platform';
+export { default as Functions } from './functions';
+export { default as APIUser } from './apiUser';
+export { default as Users } from './users';
+export { default as Apps } from './apps';
+export { default as ComponentUtils } from './componentUtils';
+export { default as Thunder } from './thunder';
+export { default as Ratchet } from './ratchet';
+export { default as Sandbox } from './sandbox';
+export { default as System } from './system';
+export { default as Workflow } from './workflow';
+export { default as Forge } from './forge';
+export { default as Project } from './project';
+export { default as Config } from './config';
+export { default as Integrations } from './integrations';
+export { default as Integration } from './integrations';
+export { default as Payments } from './integrations/payments';
+export { default as Invoicing } from './integrations/invoicing';
+export { default as DMS } from './integrations/dms';
+export { default as SerbiaUtil } from './integrations/serbiaUtil';
+export { default as VPFR } from './integrations/vpfr';
+import Platfrom from './platform';
+export default Platfrom;