@ductape/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,325 @@
+import { ImportDocsTypes, IApp, IAppConstants, IAppEnv, IAppVariables, IAppWebhook, IAppWebhookEvent, ICreateAppBuilder, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, IProductFeature, IProductJobs, IProductStorage, IProcessorInput, IActionProcessorInput, IDBActionProcessorInput, IProductMessageBroker, IProductNotification, INotificationProcessorInput, IProductNotificationTemplate, IStorageProcessorInput, IParsedSample, IRegisterWebhook, IGenerateWebhookLink, IAppAuth, IMessageBrokerPublishInput, IMessageBrokerSubscribeInput, IProductMessageBrokerTopic, IAppAction, IProductDatabaseMigration, LogQueryParams, IProductQuota, FetchRemoteCachePayload, IFileReadResult } from './types';
+import { IDuctapeInit } from './types/index.types';
+import { PublicStates } from './types/enums';
+export interface IDuctape {
+}
+export default class Ductape implements IDuctape {
+    private user_id;
+    private workspace_id;
+    private private_key;
+    private public_key;
+    private session;
+    private token;
+    private apps;
+    private products;
+    private userApi;
+    private appApi;
+    private productsApi;
+    private workspaceApi;
+    private productBuilder;
+    private loggerService;
+    private appBuilder;
+    private importService;
+    private productInit;
+    private appInit;
+    private environment;
+    private redisClient?;
+    constructor({ workspace_id, private_key, user_id, env_type, redis_url }: IDuctapeInit);
+    setToken(token: string): void;
+    setPublicKey(public_key: string): void;
+    private initProduct;
+    private initApp;
+    private checkProductInit;
+    private checkAppInit;
+    product: {
+        create: (data: IProduct) => Promise<void>;
+        fetch: (tag: string) => Promise<IProduct>;
+        update: (tag: string, data: Partial<IProduct>) => Promise<void>;
+        init: (productTag: string) => Promise<void>;
+        apps: {
+            connect: (appTag: string) => Promise<import("./types").IAppAccess>;
+            add: (app: IProductApp) => Promise<void>;
+            fetchAll: () => Promise<IProductApp[]>;
+            fetch: (tag: string) => Promise<IProductApp>;
+            update: (accessTag: string, data: Partial<IProductApp>) => Promise<void>;
+            webhooks: {
+                fetchAll: (accessTag: string) => Promise<IAppWebhook[]>;
+                enable: (data: IRegisterWebhook) => Promise<void>;
+                generateLink: (data: IGenerateWebhookLink) => Promise<string>;
+            };
+        };
+        quota: {
+            create: (data: Partial<IProductQuota>) => Promise<void>;
+            fetch: (tag: string) => void;
+            fetchAll: () => void;
+            update: (slug: string, data: Partial<IProductQuota>) => Promise<void>;
+        };
+        updateValidation: (tag: string, update: Partial<IParsedSample>) => Promise<boolean>;
+        environments: {
+            create: (data: IProductEnv) => Promise<void>;
+            fetchAll: () => IProductEnv[];
+            fetch: (slug: string) => IProductEnv;
+            update: (slug: string, data: Partial<IProductEnv>) => Promise<void>;
+        };
+        storage: {
+            create: (data: IProductStorage) => Promise<void>;
+            fetchAll: () => IProductStorage[];
+            fetch: (tag: string) => IProductStorage;
+            update: (tag: string, data: Partial<IProductStorage>) => Promise<void>;
+        };
+        messageBrokers: {
+            create: (data: Partial<IProductMessageBroker>) => Promise<void>;
+            fetchAll: () => IProductMessageBroker[];
+            fetch: (tag: string) => IProductMessageBroker;
+            update: (tag: string, data: Partial<IProductMessageBroker>) => Promise<void>;
+            topics: {
+                create: (data: IProductMessageBrokerTopic) => Promise<void>;
+                fetchAll: (messageBrokerTag: string) => IProductMessageBrokerTopic[];
+                fetch: (tag: string) => IProductMessageBrokerTopic;
+                update: (tag: string, data: Partial<IProductMessageBrokerTopic>) => Promise<void>;
+            };
+        };
+        notifications: {
+            create: (data: IProductNotification) => Promise<void>;
+            fetchAll: () => IProductNotification[];
+            fetch: (tag: string) => IProductNotification;
+            update: (tag: string, data: Partial<IProductNotification>) => Promise<void>;
+            messages: {
+                create: (data: IProductNotificationTemplate) => Promise<void>;
+                fetchAll: (notificationTag: string) => IProductNotificationTemplate[];
+                fetch: (tag: string) => IProductNotificationTemplate;
+                update: (tag: string, data: Partial<IProductNotificationTemplate>) => Promise<void>;
+            };
+        };
+        databases: {
+            create: (data: IProductDatabase) => Promise<void>;
+            fetchAll: () => IProductDatabase[];
+            fetch: (tag: string) => IProductDatabase;
+            update: (tag: string, data: Partial<IProductDatabase>) => Promise<void>;
+            actions: {
+                create: (data: IProductDatabaseAction) => Promise<void>;
+                fetchAll: (databaseTag: string) => IProductDatabaseAction[];
+                fetch: (tag: string) => IProductDatabaseAction;
+                update: (tag: string, data: Partial<IProductDatabaseAction>) => Promise<void>;
+            };
+            migrations: {
+                create: (data: IProductDatabaseMigration) => Promise<void>;
+                fetchAll: (databaseTag: string) => IProductDatabaseMigration[];
+                fetch: (tag: string) => IProductDatabaseMigration;
+                update: (tag: string, data: Partial<IProductDatabaseMigration>) => Promise<void>;
+            };
+        };
+        jobs: {
+            create: (data: Partial<IProductJobs>) => Promise<void>;
+            fetchAll: () => IProductJobs[];
+            fetch: (tag: string) => IProductJobs;
+            update: (tag: string, data: Partial<IProductJobs>) => Promise<void>;
+        };
+        caches: {
+            create: (data: IProductCache) => Promise<void>;
+            fetchAll: () => IProductCache[];
+            fetch: (tag: string) => IProductCache;
+            update: (tag: string, data: Partial<IProductCache>) => Promise<void>;
+            values: (data: FetchRemoteCachePayload) => Promise<import("./types").IRemoteCache[]>;
+        };
+        features: {
+            create: (data: Partial<IProductFeature>) => Promise<void>;
+            fetchAll: () => IProductFeature[];
+            fetch: (tag: string) => IProductFeature;
+            update: (tag: string, data: Partial<IProductCache>) => Promise<void>;
+        };
+    };
+    app: {
+        create: (data: ICreateAppBuilder) => Promise<{
+            app_id: string;
+        }>;
+        fetch: (tag: string) => Promise<IApp>;
+        update: (tag: string, data: Partial<IApp>) => Promise<void>;
+        init: (appTag: string) => Promise<void>;
+        variables: {
+            create: (data: IAppVariables) => Promise<void>;
+            fetchAll: () => IAppVariables[];
+            fetch: (tag: string) => IAppVariables;
+            update: (tag: string, data: Partial<IAppVariables>) => Promise<void>;
+        };
+        constants: {
+            create: (data: IAppConstants) => Promise<void>;
+            fetchAll: () => IAppConstants[];
+            fetch: (tag: string) => IAppConstants;
+            update: (tag: string, data: Partial<IAppVariables>) => Promise<void>;
+        };
+        actions: {
+            import: ({ file, type, version, appTag, updateIfExists, }: {
+                file: Buffer;
+                type: ImportDocsTypes;
+                version: string;
+                appTag?: string;
+                updateIfExists?: boolean;
+            }) => Promise<void>;
+            update: (tag: string, data: Partial<IAppAction>) => Promise<void>;
+            fetchAll: () => IAppAction[];
+            fetch: (tag: string) => IAppAction;
+        };
+        auths: {
+            create: (data: IAppAuth) => Promise<void>;
+            fetchAll: () => IAppAuth[];
+            fetch: (tag: string) => IAppAuth;
+            update: (tag: string, data: Partial<IAppAuth>) => Promise<void>;
+        };
+        webhooks: {
+            create: (data: Partial<IAppWebhook>) => Promise<void>;
+            fetchAll: () => IAppWebhook[];
+            fetch: (tag: string) => IAppWebhook;
+            update: (tag: string, data: Partial<IAppWebhook>) => Promise<void>;
+            events: {
+                create: (data: IAppWebhookEvent) => Promise<void>;
+                fetchAll: (webhookTag: string) => IAppWebhookEvent[];
+                fetch: (tag: string) => IAppWebhookEvent;
+                update: (tag: string, data: Partial<IAppWebhookEvent>) => Promise<void>;
+            };
+        };
+        environments: {
+            create: (data: IAppEnv) => Promise<void>;
+            fetchAll: () => IAppEnv[];
+            fetch: (slug: string) => IAppEnv;
+            update: (slug: string, data: Partial<IAppEnv>) => Promise<void>;
+        };
+        validation: (selector: string, update: Partial<IParsedSample>) => Promise<void>;
+    };
+    processor: {
+        job: {
+            schedule: (data: IProduct) => Promise<void>;
+        };
+        action: {
+            run: (data: IActionProcessorInput) => Promise<any>;
+        };
+        db: {
+            execute: (data: IDBActionProcessorInput) => Promise<any>;
+            migration: {
+                run: ({ migration, env, product }: {
+                    migration: string;
+                    env: string;
+                    product: string;
+                }) => Promise<{
+                    process_id: string;
+                }>;
+                rollback: ({ migration, env, product }: {
+                    migration: string;
+                    env: string;
+                    product: string;
+                }) => Promise<{
+                    process_id: string;
+                }>;
+            };
+        };
+        feature: {
+            run: (data: IProcessorInput) => Promise<{
+                process_id: string;
+            }>;
+            output: (process_id: string) => Promise<{
+                process_id: string;
+                status: import("./types").LogEventStatus;
+                data: Record<string, unknown>;
+                errors?: undefined;
+            } | {
+                process_id: string;
+                status: import("./types").LogEventStatus;
+                errors: string[];
+                data?: undefined;
+            } | {
+                process_id: string;
+                status: import("./types").LogEventStatus;
+                data?: undefined;
+                errors?: undefined;
+            }>;
+            replay: (process_id: string) => Promise<{
+                process_id: string;
+            }>;
+            resume: (process_id: string) => Promise<{
+                process_id: string;
+            }>;
+        };
+        quota: {
+            run: (data: IProcessorInput) => Promise<void>;
+        };
+        notification: {
+            send: (data: INotificationProcessorInput) => Promise<{
+                process_id: string;
+            }>;
+        };
+        storage: {
+            readFile: (path: string) => Promise<IFileReadResult>;
+            save: (data: IStorageProcessorInput) => Promise<any>;
+        };
+        messageBroker: {
+            publish: (data: IMessageBrokerPublishInput) => Promise<void | {
+                process_id: string;
+            }>;
+            subcribe: (data: IMessageBrokerSubscribeInput) => Promise<void | {
+                process_id: string;
+            }>;
+        };
+    };
+    logs: {
+        init: (productTag?: string, appTag?: string) => Promise<void>;
+        add: () => Promise<void>;
+        /**
+         * Fetches logs based on provded query parameters.
+         *
+         * @param params.component - Required. Specifies the component type ('app' or 'product')
+         * @param params.type - Optional. Type of analysis ('apps', 'process', 'feature', 'integrations', etc.)
+         * @param params.groupBy - Optional. Time period for grouping ('day', 'week', 'month', 'year')
+         * @param params.search - Optional. Search term for filtering logs
+         * @param params.page - Optional. Page number for pagination (≥ 1)
+         * @param params.limit - Optional. Number of items per page (≥ 1)
+         * @param params.status - Optional. Filter by status ('success', 'processing', 'fail')
+         *
+         * For component='app':
+         * @param params.tag - Optional. Tag identifier (only valid when type='actions')
+         * @param params.env - Optional. Environment filter
+         * @param params.name - Optional. Name filter
+         * @param params.action - Optional. Specific action filter
+         *
+         * For component='product':
+         * @param params.env - Optional. Environment filter
+         * @param params.name - Optional. Name filter
+         * @param params.action - Optional. Specific action filter
+         *
+         * @throws {Error} If logger service is not initialized
+         * @throws {Error} If required parameters are missing or invalid
+         * @throws {Error} If API request fails
+         *
+         * @returns {Promise<any>} The fetched log data
+         *
+         * @example
+         * // Fetch app logs
+         * const appLogs = await logs.fetch({
+         *   component: 'app',
+         *   type: 'actions',
+         *   groupBy: 'day',
+         *   limit: 20
+         * });
+         *
+         * // Fetch product logs
+         * const productLogs = await logs.fetch({
+         *   component: 'product',
+         *   type: 'database',
+         *   status: 'success'
+         * });
+         */
+        fetch: (params: LogQueryParams) => Promise<any>;
+        publish: () => Promise<void>;
+    };
+    private initUserAuth;
+    private createNewLogger;
+    private createNewProductBuilder;
+    private createNewProcessor;
+    private createNewImporter;
+    private createNewAppBuilder;
+    private fetchSession;
+    private validateWorkspace;
+    private createNewAppBuilderSession;
+    private refreshUserAccessToken;
+    fetchWorkspaceApps(status: PublicStates): Promise<Array<IApp>>;
+    fetchWorkspaceProjects(status: PublicStates): Promise<Array<IProduct>>;
+}