@ductape/sdk 0.0.4-v5 → 0.0.4-v51

package/dist/index.js

@@ -43,39 +43,67 @@ const app_service_1 = __importDefault(require("./apps/services/app.service"));
 const filePath = __importStar(require("path"));
 const products_service_1 = __importDefault(require("./products/services/products.service"));
 const fs_1 = require("fs");
+const database_service_1 = require("./database/database.service");
+const graph_service_1 = require("./graph/graph.service");
 const index_types_1 = require("./types/index.types");
+const enums_1 = require("./types/enums");
 const productsApi_service_1 = require("./api/services/productsApi.service");
+const workspaceSecretsApi_service_1 = require("./api/services/workspaceSecretsApi.service");
 const imports_service_1 = __importDefault(require("./imports/imports.service"));
 const processor_service_1 = __importDefault(require("./processor/services/processor.service"));
 const logs_service_1 = __importDefault(require("./logs/logs.service"));
 const utils_1 = require("./utils");
 const mime = __importStar(require("mime-types"));
+const processor_utils_1 = require("./processor/utils/processor.utils");
 class Ductape {
     async loadRedis() {
         if (typeof window !== 'undefined') {
             throw new Error("RedisService can only be used in a server environment.");
         }
-        const redis = await Promise.resolve().then(() => __importStar(require('redis')));
-        return redis;
+        return await Promise.resolve().then(() => __importStar(require('ioredis')));
     }
     constructor({ workspace_id, private_key, user_id, env_type, redis_url }) {
+        /**
+         * Product-related operations for managing products, sessions, apps, quotas, and fallbacks.
+         */
         this.product = {
+            /**
+             * Creates a new product.
+             * @param {IProduct} data - The product data.
+             * @returns {Promise<void>} Resolves when the product is created. Throws on error.
+             */
             create: async (data) => {
                 await this.initProduct();
                 return this.productBuilder.createProduct(data);
             },
+            /**
+             * Fetches a product by tag.
+             * @param {string} tag - The product tag.
+             * @returns {Promise<IProduct|null>} The fetched product, or null if not found.
+             */
             fetch: async (tag) => {
                 await this.initProduct();
                 await this.productBuilder.initializeProductByTag(tag);
                 this.productInit = false;
                 return this.productBuilder.fetchProduct();
             },
+            /**
+             * Updates a product by tag.
+             * @param {string} tag - The product tag.
+             * @param {Partial<IProduct>} data - The product data to update.
+             * @returns {Promise<void>} Resolves when the product is updated. Throws on error.
+             */
             update: async (tag, data) => {
                 await this.initProduct();
                 await this.productBuilder.initializeProductByTag(tag);
                 this.productInit = false;
                 return this.productBuilder.updateProduct(data);
             },
+            /**
+             * Initializes a product by tag.
+             * @param {string} productTag - The product tag.
+             * @returns {Promise<void>} Resolves when initialization is complete. Throws on error.
+             */
             init: async (productTag) => {
                 try {
                     console.log(`Product initialized with tag: ${productTag}`);
@@ -89,185 +117,399 @@ class Ductape {
                 }
             },
             sessions: {
-                create: (payload) => {
+                /**
+                 * Creates a new product session.
+                 * @param {IProductSession} payload - The session payload.
+                 * @returns {Promise<void>} Resolves when the session is created. Throws on error.
+                 */
+                create: async (payload) => {
                     this.checkProductInit();
                     return this.productBuilder.createSession(payload);
                 },
-                update: (tag, payload) => {
+                /**
+                 * Updates a product session by tag.
+                 * @param {string} tag - The session tag.
+                 * @param {Partial<IProductSession>} payload - The session data to update.
+                 * @returns {Promise<void>} Resolves when the session is updated. Throws on error.
+                 */
+                update: async (tag, payload) => {
                     this.checkProductInit();
                     return this.productBuilder.updateSession(tag, payload);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all product sessions.
+                 * @returns {IProductSession[]} The list of sessions.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchSessions();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a product session by tag.
+                 * @param {string} tag - The session tag.
+                 * @returns {IProductSession|null} The fetched session, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchSession(tag);
+                },
+                /**
+                 * Fetches users for a session.
+                 * @param {IFetchUsersPayload} data - The user fetch payload.
+                 * @returns {Promise<any[]>} The users for the session.
+                 */
+                users: (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchSessionUsers(data);
                 }
             },
             apps: {
+                /**
+                 * Connects an app to a product by app tag.
+                 * @param {string} appTag - The app tag.
+                 * @returns {Promise<IAppAccess>} The result of the connection.
+                 */
                 connect: async (appTag) => {
                     this.checkProductInit();
                     return this.productBuilder.createAppAccessTag(appTag);
                 },
+                /**
+                 * Adds an app to a product.
+                 * @param {IProductApp} app - The app data.
+                 * @returns {Promise<void>} Resolves when the app is added. Throws on error.
+                 */
                 add: async (app) => {
                     this.checkProductInit();
                     return this.productBuilder.addApp(app);
                 },
+                /**
+                 * Fetches all apps for a product.
+                 * @returns {IProductApp[]} The list of apps.
+                 */
                 fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchApps();
                 },
+                /**
+                 * Fetches an app by tag.
+                 * @param {string} tag - The app tag.
+                 * @returns {IProductApp|null} The fetched app, or null if not found.
+                 */
                 fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchApp(tag);
                 },
+                /**
+                 * Updates an app by access tag.
+                 * @param {string} accessTag - The app access tag.
+                 * @param {Partial<IProductApp>} data - The app data to update.
+                 * @returns {Promise<void>} Resolves when the app is updated. Throws on error.
+                 */
                 update: async (accessTag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateApp(accessTag, data);
                 },
                 webhooks: {
+                    /**
+                     * Fetches all webhooks for an app by access tag.
+                     * @param {string} accessTag - The app access tag.
+                     * @returns {Promise<IAppWebhook[]>} The list of webhooks.
+                     */
                     fetchAll: async (accessTag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchAppWebhooks(accessTag);
                     },
-                    enable: async (data) => {
-                        const processorService = await this.createNewProcessor();
-                        return processorService.registerWebhook(data);
-                    },
+                    /**
+                     * Generates a webhook link for an app.
+                     * @param {IGenerateWebhookLink} data - The webhook link data.
+                     * @returns {Promise<string>} The generated webhook link.
+                     */
                     generateLink: async (data) => {
                         const processorService = await this.createNewProcessor();
                         return processorService.generateWebhookLink(data);
                     },
                 },
+                health: {
+                    /**
+                     * Creates a health check for an app.
+                     * @param {Partial<IProductAppHealth>} data - The health check data.
+                     * @returns {Promise<void>} Resolves when the health check is created. Throws on error.
+                     */
+                    create: async (data) => {
+                        await this.checkProductInit();
+                        return await this.productBuilder.createHealthcheck(data);
+                    },
+                    /**
+                     * Updates a health check by tag.
+                     * @param {string} tag - The health check tag.
+                     * @param {Partial<IProductAppHealth>} data - The health check data to update.
+                     * @returns {Promise<void>} Resolves when the health check is updated. Throws on error.
+                     */
+                    update: async (tag, data) => {
+                        this.checkProductInit();
+                        return this.productBuilder.updateHealthcheck(tag, data);
+                    },
+                    /**
+                     * Fetches a health check by access tag and tag.
+                     * @param {string} access_tag - The app access tag.
+                     * @param {string} tag - The health check tag.
+                     * @returns {Promise<IProductAppHealth|null>} The fetched health check, or null if not found.
+                     */
+                    fetch: async (access_tag, tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchHealthcheck(access_tag, tag);
+                    },
+                    /**
+                     * Fetches all health checks for an app by access tag.
+                     * @param {string} access_tag - The app access tag.
+                     * @returns {Promise<IProductAppHealth[]>} The list of health checks.
+                     */
+                    fetchAll: async (access_tag) => {
+                        this.checkProductInit();
+                        return this.productBuilder.fetchHealthchecks(access_tag);
+                    },
+                }
             },
+            /**
+             * Creates a quota for a product.
+             * @param {Partial<IProductQuota>} data - The quota data.
+             * @returns {Promise<void>} Resolves when the quota is created. Throws on error.
+             */
             quota: {
                 create: async (data) => {
                     await this.initProduct();
                     return this.productBuilder.createQuota(data);
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a quota by tag.
+                 * @param {string} tag - The quota tag.
+                 * @returns {IProductQuota|null} The fetched quota, or null if not found.
+                 */
+                fetch: async (tag) => {
                     return this.productBuilder.fetchQuota(tag);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all quotas for a product.
+                 * @returns {IProductQuota[]} The list of quotas.
+                 */
+                fetchAll: async () => {
                     return this.productBuilder.fetchQuotas();
                 },
+                /**
+                 * Updates a quota by tag.
+                 * @param {string} tag - The quota tag.
+                 * @param {Partial<IProductQuota>} data - The quota data to update.
+                 * @returns {Promise<void>} Resolves when the quota is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     await this.initProduct();
                     return this.productBuilder.updateQuota(tag, data);
                 },
             },
+            /**
+             * Creates a fallback for a product.
+             * @param {Partial<IProductFallback>} data - The fallback data.
+             * @returns {Promise<void>} Resolves when the fallback is created. Throws on error.
+             */
             fallback: {
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createFallback(data);
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a fallback by tag.
+                 * @param {string} tag - The fallback tag.
+                 * @returns {IProductFallback|null} The fetched fallback, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchFallback(tag);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all fallbacks for a product.
+                 * @returns {IProductFallback[]} The list of fallbacks.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchFallbacks();
                 },
+                /**
+                 * Updates a fallback by tag.
+                 * @param {string} tag - The fallback tag.
+                 * @param {Partial<IProductFallback>} data - The fallback data to update.
+                 * @returns {Promise<void>} Resolves when the fallback is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateFallback(tag, data);
                 },
             },
+            /**
+             * Updates data validation for a product.
+             * @param {string} tag - The product tag.
+             * @param {Partial<IParsedSample>} update - The update data.
+             * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
+             */
             updateValidation: async (tag, update) => {
                 this.checkProductInit();
                 return this.productBuilder.updateDataValidation(tag, update);
             },
             environments: {
+                /**
+                 * Creates an environment for a product.
+                 * @param {IProductEnv} data - The environment data.
+                 * @returns {Promise<void>} Resolves when the environment is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createEnv(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all environments for a product.
+                 * @returns {IAppEnv[]} The list of environments.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchEnvs();
                 },
-                fetch: (slug) => {
+                /**
+                 * Fetches an environment by slug.
+                 * @param {string} slug - The environment slug.
+                 * @returns {IAppEnv|null} The fetched environment, or null if not found.
+                 */
+                fetch: async (slug) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchEnv(slug);
                 },
+                /**
+                 * Updates an environment by slug.
+                 * @param {string} slug - The environment slug.
+                 * @param {Partial<IProductEnv>} data - The environment data to update.
+                 * @returns {Promise<void>} Resolves when the environment is updated. Throws on error.
+                 */
                 update: async (slug, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateEnv(slug, data);
                 },
             },
             storage: {
+                /**
+                 * Creates a storage for a product.
+                 * @param {IProductStorage} data - The storage data.
+                 * @returns {Promise<void>} Resolves when the storage is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createStorage(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all storages for a product.
+                 * @returns {IProductStorage[]} The list of storages.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchStorages();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a storage by tag.
+                 * @param {string} tag - The storage tag.
+                 * @returns {IProductStorage|null} The fetched storage, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchStorage(tag);
                 },
+                /**
+                 * Updates a storage by tag.
+                 * @param {string} tag - The storage tag.
+                 * @param {Partial<IProductStorage>} data - The storage data to update.
+                 * @returns {Promise<void>} Resolves when the storage is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateStorage(tag, data);
                 },
+                /**
+                 * Fetches storage files for a product.
+                 * @param {IFetchFilesPayload} data - The fetch files payload.
+                 * @returns {Promise<void>} Resolves when the storage files are fetched. Throws on error.
+                 */
                 files: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchStorageFiles(data);
                 }
             },
-            /*cloudFunctions: {
-              create: async (data: IProductFunction) => {
-                this.checkProductInit();
-                return this.productBuilder.createFunction(data);
-              },
-              fetchAll: () => {
-                this.checkProductInit();
-                return this.productBuilder.fetchFunctions();
-              },
-              fetch: (tag: string) => {
-                this.checkProductInit();
-                return this.productBuilder.fetchFunction(tag);
-              },
-              update: async (tag: string, data: Partial<IProductFunction>) => {
-                this.checkProductInit();
-                return this.productBuilder.updateFunction(tag, data);
-              },
-            },*/
             messageBrokers: {
+                /**
+                 * Creates a message broker for a product.
+                 * @param {Partial<IProductMessageBroker>} data - The message broker data.
+                 * @returns {Promise<void>} Resolves when the message broker is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createMessageBroker(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all message brokers for a product.
+                 * @returns {IProductMessageBroker[]} The list of message brokers.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchMessageBrokers();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a message broker by tag.
+                 * @param {string} tag - The message broker tag.
+                 * @returns {IProductMessageBroker|null} The fetched message broker, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchMessageBroker(tag);
                 },
+                /**
+                 * Updates a message broker by tag.
+                 * @param {string} tag - The message broker tag.
+                 * @param {Partial<IProductMessageBroker>} data - The message broker data to update.
+                 * @returns {Promise<void>} Resolves when the message broker is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateMessageBroker(tag, data);
                 },
                 topics: {
+                    /**
+                     * Creates a message broker topic for a product.
+                     * @param {IProductMessageBrokerTopic} data - The message broker topic data.
+                     * @returns {Promise<void>} Resolves when the message broker topic is created. Throws on error.
+                     */
                     create: async (data) => {
                         this.checkProductInit();
                         return this.productBuilder.createMessageBrokerTopic(data);
                     },
-                    fetchAll: (messageBrokerTag) => {
+                    /**
+                     * Fetches all message broker topics for a message broker by tag.
+                     * @param {string} messageBrokerTag - The message broker tag.
+                     * @returns {IProductMessageBrokerTopic[]} The list of message broker topics.
+                     */
+                    fetchAll: async (messageBrokerTag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchMessageBrokerTopics(messageBrokerTag);
                     },
-                    fetch: (tag) => {
+                    /**
+                     * Fetches a message broker topic by tag.
+                     * @param {string} tag - The message broker topic tag.
+                     * @returns {IProductMessageBrokerTopic|null} The fetched message broker topic, or null if not found.
+                     */
+                    fetch: async (tag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchMessageBrokerTopic(tag);
                     },
+                    /**
+                     * Updates a message broker topic by tag.
+                     * @param {string} tag - The message broker topic tag.
+                     * @param {Partial<IProductMessageBrokerTopic>} data - The message broker topic data to update.
+                     * @returns {Promise<void>} Resolves when the message broker topic is updated. Throws on error.
+                     */
                     update: (tag, data) => {
                         this.checkProductInit();
                         return this.productBuilder.updateMessageBrokerTopic(Object.assign(Object.assign({}, data), { tag }));
@@ -275,35 +517,76 @@ class Ductape {
                 },
             },
             notifications: {
+                /**
+                 * Creates a notification for a product.
+                 * @param {IProductNotification} data - The notification data.
+                 * @returns {Promise<void>} Resolves when the notification is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createNotification(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all notifications for a product.
+                 * @returns {IProductNotification[]} The list of notifications.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchNotifications();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a notification by tag.
+                 * @param {string} tag - The notification tag.
+                 * @returns {IProductNotification|null} The fetched notification, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchNotification(tag);
                 },
+                /**
+                 * Updates a notification by tag.
+                 * @param {string} tag - The notification tag.
+                 * @param {Partial<IProductNotification>} data - The notification data to update.
+                 * @returns {Promise<void>} Resolves when the notification is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateNotification(tag, data);
                 },
                 messages: {
+                    /**
+                     * Creates a notification message for a product.
+                     * @param {IProductNotificationTemplate} data - The notification message data.
+                     * @returns {Promise<void>} Resolves when the notification message is created. Throws on error.
+                     */
                     create: async (data) => {
                         this.checkProductInit();
                         return this.productBuilder.createNotificationMessage(data);
                     },
-                    fetchAll: (notificationTag) => {
+                    /**
+                     * Fetches all notification messages for a notification by tag.
+                     * @param {string} notificationTag - The notification tag.
+                     * @returns {IProductNotificationTemplate[]} The list of notification messages.
+                     */
+                    fetchAll: async (notificationTag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchNotificationMessages(notificationTag);
                     },
-                    fetch: (tag) => {
+                    /**
+                     * Fetches a notification message by tag.
+                     * @param {string} tag - The notification message tag.
+                     * @returns {IProductNotificationTemplate|null} The fetched notification message, or null if not found.
+                     */
+                    fetch: async (tag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchNotificationMessage(tag);
                     },
+                    /**
+                     * Updates a notification message by tag.
+                     * @param {string} tag - The notification message tag.
+                     * @param {Partial<IProductNotificationTemplate>} data - The notification message data to update.
+                     * @returns {Promise<void>} Resolves when the notification message is updated. Throws on error.
+                     */
                     update: async (tag, data) => {
                         this.checkProductInit();
                         return this.productBuilder.updateNotificationMessage(Object.assign(Object.assign({}, data), { tag }));
@@ -311,90 +594,230 @@ class Ductape {
                 },
             },
             databases: {
+                /**
+                 * Creates a database for a product.
+                 * @param {IProductDatabase} data - The database data.
+                 * @returns {Promise<void>} Resolves when the database is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createDatabase(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all databases for a product.
+                 * @returns {IProductDatabase[]} The list of databases.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchDatabases();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a database by tag.
+                 * @param {string} tag - The database tag.
+                 * @returns {IProductDatabase|null} The fetched database, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchDatabase(tag);
                 },
+                /**
+                 * Updates a database by tag.
+                 * @param {string} tag - The database tag.
+                 * @param {Partial<IProductDatabase>} data - The database data to update.
+                 * @returns {Promise<void>} Resolves when the database is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateDatabase(tag, data);
                 },
                 actions: {
+                    /**
+                     * Creates a database action for a product.
+                     * @param {IProductDatabaseAction} data - The database action data.
+                     * @returns {Promise<void>} Resolves when the database action is created. Throws on error.
+                     */
                     create: async (data) => {
                         this.checkProductInit();
                         return this.productBuilder.createDatabaseAction(data);
                     },
-                    fetchAll: (databaseTag) => {
+                    /**
+                     * Fetches all database actions for a product.
+                     * @param {string} databaseTag - The database tag.
+                     * @returns {IProductDatabaseAction[]} The list of database actions.
+                     */
+                    fetchAll: async (databaseTag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchDatabaseActions(databaseTag);
                     },
-                    fetch: (tag) => {
+                    /**
+                     * Fetches a database action by tag.
+                     * @param {string} tag - The database action tag.
+                     * @returns {IProductDatabaseAction|null} The fetched database action, or null if not found.
+                     */
+                    fetch: async (tag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchDatabaseAction(tag);
                     },
+                    /**
+                     * Updates a database action by tag.
+                     * @param {string} tag - The database action tag.
+                     * @param {Partial<IProductDatabaseAction>} data - The database action data to update.
+                     * @returns {Promise<void>} Resolves when the database action is updated. Throws on error.
+                     */
                     update: async (tag, data) => {
                         this.checkProductInit();
                         return this.productBuilder.updateDatabaseAction(Object.assign(Object.assign({}, data), { tag }));
                     },
                 },
                 migrations: {
+                    /**
+                     * Creates a database migration for a product.
+                     * @param {IProductDatabaseMigration} data - The database migration data.
+                     * @returns {void} Resolves when the database migration is created. Throws on error.
+                     */
                     create: (data) => {
                         this.checkProductInit();
                         return this.productBuilder.createDatabaseMigration(data);
                     },
-                    fetchAll: (databaseTag) => {
+                    /**
+                     * Fetches all database migrations for a product.
+                     * @param {string} databaseTag - The database tag.
+                     * @returns {IProductDatabaseMigration[]} The list of database migrations.
+                     */
+                    fetchAll: async (databaseTag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchDatabaseMigrations(databaseTag);
                     },
-                    fetch: (tag) => {
+                    /**
+                     * Fetches a database migration by tag.
+                     * @param {string} tag - The database migration tag.
+                     * @returns {IProductDatabaseMigration|null} The fetched database migration, or null if not found.
+                     */
+                    fetch: async (tag) => {
                         this.checkProductInit();
                         return this.productBuilder.fetchDatabaseMigration(tag);
                     },
+                    /**
+                     * Updates a database migration by tag.
+                     * @param {string} tag - The database migration tag.
+                     * @param {Partial<IProductDatabaseMigration>} data - The database migration data to update.
+                     * @returns {void} Resolves when the database migration is updated. Throws on error.
+                     */
                     update: (tag, data) => {
                         this.checkProductInit();
                         return this.productBuilder.updateDatabaseMigration(Object.assign(Object.assign({}, data), { tag }));
                     },
                 },
             },
+            graphs: {
+                /**
+                 * Creates a graph database for a product.
+                 * @param {IProductGraph} data - The graph database data.
+                 * @returns {Promise<void>} Resolves when the graph database is created. Throws on error.
+                 */
+                create: async (data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.createGraph(data);
+                },
+                /**
+                 * Fetches all graph databases for a product.
+                 * @returns {IProductGraph[]} The list of graph databases.
+                 */
+                fetchAll: async () => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchGraphs();
+                },
+                /**
+                 * Fetches a graph database by tag.
+                 * @param {string} tag - The graph database tag.
+                 * @returns {IProductGraph|null} The fetched graph database, or null if not found.
+                 */
+                fetch: async (tag) => {
+                    this.checkProductInit();
+                    return this.productBuilder.fetchGraph(tag);
+                },
+                /**
+                 * Updates a graph database by tag.
+                 * @param {string} tag - The graph database tag.
+                 * @param {Partial<IProductGraph>} data - The graph database data to update.
+                 * @returns {Promise<void>} Resolves when the graph database is updated. Throws on error.
+                 */
+                update: async (tag, data) => {
+                    this.checkProductInit();
+                    return this.productBuilder.updateGraph(tag, data);
+                },
+            },
             jobs: {
+                /**
+                 * Creates a job for a product.
+                 * @param {Partial<IProductJobs>} data - The job data.
+                 * @returns {Promise<void>} Resolves when the job is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createJob(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all jobs for a product.
+                 * @returns {IProductJobs[]} The list of jobs.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchJobs();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a job by tag.
+                 * @param {string} tag - The job tag.
+                 * @returns {IProductJobs|null} The fetched job, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchJob(tag);
                 },
+                /**
+                 * Updates a job by tag.
+                 * @param {string} tag - The job tag.
+                 * @param {Partial<IProductJobs>} data - The job data to update.
+                 * @returns {Promise<void>} Resolves when the job is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateJob(tag, data);
                 },
             },
             caches: {
+                /**
+                 * Creates a cache for a product.
+                 * @param {IProductCache} data - The cache data.
+                 * @returns {Promise<void>} Resolves when the cache is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createCache(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all caches for a product.
+                 * @returns {IProductCache[]} The list of caches.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchCaches();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a cache by tag.
+                 * @param {string} tag - The cache tag.
+                 * @returns {IProductCache|null} The fetched cache, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchCache(tag);
                 },
+                /**
+                 * Updates a cache by tag.
+                 * @param {string} tag - The cache tag.
+                 * @param {Partial<IProductCache>} data - The cache data to update.
+                 * @returns {Promise<void>} Resolves when the cache is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateCache(tag, data);
@@ -405,41 +828,85 @@ class Ductape {
                 },
             },
             features: {
+                /**
+                 * Creates a feature for a product.
+                 * @param {Partial<IProductFeature>} data - The feature data.
+                 * @returns {Promise<void>} Resolves when the feature is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkProductInit();
                     return this.productBuilder.createFeature(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all features for a product.
+                 * @returns {IProductFeature[]} The list of features.
+                 */
+                fetchAll: async () => {
                     this.checkProductInit();
                     return this.productBuilder.fetchFeatures();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a feature by tag.
+                 * @param {string} tag - The feature tag.
+                 * @returns {IProductFeature|null} The fetched feature, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkProductInit();
                     return this.productBuilder.fetchFeature(tag);
                 },
+                /**
+                 * Updates a feature by tag.
+                 * @param {string} tag - The feature tag.
+                 * @param {Partial<IProductCache>} data - The feature data to update.
+                 * @returns {Promise<void>} Resolves when the feature is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkProductInit();
                     return this.productBuilder.updateFeature(tag, data);
                 },
             },
         };
+        /**
+         * App-related operations for managing apps, variables, constants, actions, auths, webhooks, environments, and validation.
+         */
         this.app = {
+            /**
+             * Creates a new app.
+             * @param {ICreateAppBuilder} data - The app data.
+             * @returns {Promise<{ app_id: string }>} The ID of the created app.
+             */
             create: async (data) => {
                 await this.initApp();
                 return this.appBuilder.createApp(data);
             },
+            /**
+             * Fetches an app by tag.
+             * @param {string} tag - The app tag.
+             * @returns {Promise<IApp|null>} The fetched app, or null if not found.
+             */
             fetch: async (tag) => {
                 await this.initApp();
                 await this.appBuilder.initializeAppByTag(tag);
                 this.appInit = false;
                 return this.appBuilder.fetchApp();
             },
+            /**
+             * Updates an app by tag.
+             * @param {string} tag - The app tag.
+             * @param {Partial<IApp>} data - The app data to update.
+             * @returns {Promise<void>} Resolves when the app is updated. Throws on error.
+             */
             update: async (tag, data) => {
                 await this.initApp();
                 await this.appBuilder.initializeAppByTag(tag);
                 this.appInit = false;
                 return this.appBuilder.updateApp(data);
             },
+            /**
+             * Initializes an app by tag.
+             * @param {string} appTag - The app tag.
+             * @returns {Promise<void>} Resolves when initialization is complete. Throws on error.
+             */
             init: async (appTag) => {
                 console.log(`App initialized with tag: ${appTag}`);
                 await this.initApp();
@@ -447,43 +914,93 @@ class Ductape {
                 this.appInit = true;
             },
             variables: {
+                /**
+                 * Creates a variable for an app.
+                 * @param {IAppVariables} data - The variable data.
+                 * @returns {Promise<void>} Resolves when the variable is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkAppInit();
                     return this.appBuilder.createVariable(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all variables for an app.
+                 * @returns {IAppVariables[]} The list of variables.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchVariables();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a variable by tag.
+                 * @param {string} tag - The variable tag.
+                 * @returns {IAppVariables|null} The fetched variable, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchVariable(tag);
                 },
+                /**
+                 * Updates a variable by tag.
+                 * @param {string} tag - The variable tag.
+                 * @param {Partial<IAppVariables>} data - The variable data to update.
+                 * @returns {Promise<void>} Resolves when the variable is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateVariable(tag, data);
                 },
             },
             constants: {
+                /**
+                 * Creates a constant for an app.
+                 * @param {IAppConstants} data - The constant data.
+                 * @returns {Promise<void>} Resolves when the constant is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkAppInit();
                     return this.appBuilder.createConstant(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all constants for an app.
+                 * @returns {IAppConstants[]} The list of constants.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchConstants();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a constant by tag.
+                 * @param {string} tag - The constant tag.
+                 * @returns {IAppConstants|null} The fetched constant, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchConstant(tag);
                 },
+                /**
+                 * Updates a constant by tag.
+                 * @param {string} tag - The constant tag.
+                 * @param {Partial<IAppVariables>} data - The constant data to update.
+                 * @returns {Promise<void>} Resolves when the constant is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateConstant(tag, data);
                 },
             },
             actions: {
-                import: async ({ file, type, version, appTag, updateIfExists, }) => {
+                /**
+                 * Imports actions for an app from a file.
+                 * @param {Object} params - The import parameters.
+                 * @param {Buffer} params.file - The file buffer.
+                 * @param {ImportDocsTypes} params.type - The import type.
+                 * @param {string} params.version - The version.
+                 * @param {string} [params.appTag] - The app tag (optional).
+                 * @param {boolean} [params.updateIfExists] - Whether to update if actions exist (optional).
+                 * @returns {Promise<void>} Resolves when the import is complete. Throws on error.
+                 */
+                import: async ({ file, type, version, appTag, updateIfExists, isAdminImport, }) => {
                     var _a;
                     if (!this.token)
                         await this.initUserAuth();
@@ -503,69 +1020,167 @@ class Ductape {
                         }
                         app_id = app._id;
                     }
-                    return this.importService.importApp(file, type, version, updateIfExists, app_id);
-                },
+                    return this.importService.importApp(file, type, version, updateIfExists, app_id, isAdminImport);
+                },
+                /**
+                 * Updates an action by tag.
+                 * @param {string} tag - The action tag.
+                 * @param {Partial<IActionUpdate>} data - The action data to update.
+                 * @returns {Promise<void>} Resolves when the action is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateAction(tag, data);
                 },
-                fetchAll: () => {
+                /**
+                 * Updates multiple actions at once with shared variables (query params or headers).
+                 * @param {string[]} tags - Array of action tags to update.
+                 * @param {Object} data - The shared variable data.
+                 * @param {'query' | 'headers'} data.category - The variable type (query params or headers).
+                 * @param {string} data.key - The variable key.
+                 * @param {string} data.value - The variable value.
+                 * @returns {Promise<void>} Resolves when all actions are updated. Throws on error.
+                 */
+                updateMany: async (tags, data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.updateManyActions(tags, data);
+                },
+                /**
+                 * Creates an action.
+                 * @param {Partial<IActionUpdate> & { tag: string; name: string; resource: string; method: string }} data - The action data to create.
+                 * @returns {Promise<void>} Resolves when the action is created. Throws on error.
+                 */
+                create: async (data) => {
+                    this.checkAppInit();
+                    return this.appBuilder.createAction(data);
+                },
+                /**
+                 * Fetches all actions for an app.
+                 * @returns {IAppAction[]} The list of actions.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchActions();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches an action by tag.
+                 * @param {string} tag - The action tag.
+                 * @returns {IAppAction|null} The fetched action, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchAction(tag);
                 },
             },
             auths: {
+                /**
+                 * Creates an auth for an app.
+                 * @param {IAppAuth} data - The auth data.
+                 * @returns {Promise<void>} Resolves when the auth is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkAppInit();
                     return this.appBuilder.createAuth(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all auths for an app.
+                 * @returns {IAppAuth[]} The list of auths.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchAuths();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches an auth by tag.
+                 * @param {string} tag - The auth tag.
+                 * @returns {IAppAuth|null} The fetched auth, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchAuth(tag);
                 },
+                /**
+                 * Updates an auth by tag.
+                 * @param {string} tag - The auth tag.
+                 * @param {Partial<IAppAuth>} data - The auth data to update.
+                 * @returns {Promise<void>} Resolves when the auth is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateAuth(tag, data);
                 },
             },
             webhooks: {
+                /**
+                 * Creates a webhook for an app.
+                 * @param {Partial<IAppWebhook>} data - The webhook data.
+                 * @returns {Promise<void>} Resolves when the webhook is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkAppInit();
                     return this.appBuilder.createWebhook(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all webhooks for an app.
+                 * @returns {IAppWebhook[]} The list of webhooks.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchWebhooks();
                 },
-                fetch: (tag) => {
+                /**
+                 * Fetches a webhook by tag.
+                 * @param {string} tag - The webhook tag.
+                 * @returns {IAppWebhook|null} The fetched webhook, or null if not found.
+                 */
+                fetch: async (tag) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchWebhook(tag);
                 },
+                /**
+                 * Updates a webhook by tag.
+                 * @param {string} tag - The webhook tag.
+                 * @param {Partial<IAppWebhook>} data - The webhook data to update.
+                 * @returns {Promise<void>} Resolves when the webhook is updated. Throws on error.
+                 */
                 update: async (tag, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateWebhook(tag, data);
                 },
                 events: {
+                    /**
+                     * Creates a webhook event for an app.
+                     * @param {IAppWebhookEvent} data - The webhook event data.
+                     * @returns {Promise<void>} Resolves when the webhook event is created. Throws on error.
+                     */
                     create: async (data) => {
                         this.checkAppInit();
                         return this.appBuilder.createWebhookEvent(data);
                     },
-                    fetchAll: (webhookTag) => {
+                    /**
+                     * Fetches all webhook events for a webhook by tag.
+                     * @param {string} webhookTag - The webhook tag.
+                     * @returns {IAppWebhookEvent[]} The list of webhook events.
+                     */
+                    fetchAll: async (webhookTag) => {
                         this.checkAppInit();
                         return this.appBuilder.fetchWebhookEvents(webhookTag);
                     },
-                    fetch: (tag) => {
+                    /**
+                     * Fetches a webhook event by tag.
+                     * @param {string} tag - The webhook event tag.
+                     * @returns {IAppWebhookEvent|null} The fetched webhook event, or null if not found.
+                     */
+                    fetch: async (tag) => {
                         this.checkAppInit();
                         return this.appBuilder.fetchWebhookEvent(tag);
                     },
+                    /**
+                     * Updates a webhook event by tag.
+                     * @param {string} tag - The webhook event tag.
+                     * @param {Partial<IAppWebhookEvent>} data - The webhook event data to update.
+                     * @returns {Promise<void>} Resolves when the webhook event is updated. Throws on error.
+                     */
                     update: async (tag, data) => {
                         this.checkAppInit();
                         return this.appBuilder.updateWebhookEvent(Object.assign(Object.assign({}, data), { tag }));
@@ -573,136 +1188,303 @@ class Ductape {
                 },
             },
             environments: {
+                /**
+                 * Creates an environment for an app.
+                 * @param {IAppEnv} data - The environment data.
+                 * @returns {Promise<void>} Resolves when the environment is created. Throws on error.
+                 */
                 create: async (data) => {
                     this.checkAppInit();
                     return this.appBuilder.createEnv(data);
                 },
-                fetchAll: () => {
+                /**
+                 * Fetches all environments for an app.
+                 * @returns {IAppEnv[]} The list of environments.
+                 */
+                fetchAll: async () => {
                     this.checkAppInit();
                     return this.appBuilder.fetchEnvs();
                 },
-                fetch: (slug) => {
+                /**
+                 * Fetches an environment by slug.
+                 * @param {string} slug - The environment slug.
+                 * @returns {IAppEnv|null} The fetched environment, or null if not found.
+                 */
+                fetch: async (slug) => {
                     this.checkAppInit();
                     return this.appBuilder.fetchEnv(slug);
                 },
+                /**
+                 * Updates an environment by slug.
+                 * @param {string} slug - The environment slug.
+                 * @param {Partial<IAppEnv>} data - The environment data to update.
+                 * @returns {Promise<void>} Resolves when the environment is updated. Throws on error.
+                 */
                 update: async (slug, data) => {
                     this.checkAppInit();
                     return this.appBuilder.updateEnv(slug, data);
                 },
             },
+            /**
+             * Updates data validation for an app.
+             * @param {string} selector - The selector for the data validation.
+             * @param {Partial<IParsedSample>} update - The update data.
+             * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
+             */
             validation: (selector, update) => {
                 this.checkAppInit();
                 return this.appBuilder.updateDataValidation(selector, update);
             },
         };
-        this.processor = {
-            job: {
-                schedule: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    //return processorService.processJob()
-                },
+        /**
+         * Job-related operations for scheduling jobs.
+         */
+        this.job = {
+            /**
+             * Schedules a job for a product.
+             * @param {IProduct} data - The product data.
+             * @returns {Promise<any>} The result of the job scheduling.
+             */
+            schedule: async (data) => {
+                const processorService = await this.createNewProcessor();
+                //return processorService.processJob()
             },
-            action: {
-                run: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processAction(data);
-                },
+        };
+        /**
+         * Action-related operations for running actions.
+         */
+        this.action = {
+            /**
+             * Runs an action processor.
+             * @param {IActionProcessorInput} data - The action processor input.
+             * @returns {Promise<any>} The result of the action processing.
+             */
+            run: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processAction(data);
+            },
+        };
+        /**
+         * Session-related operations for creating, validating, and refreshing sessions.
+         */
+        this.sessions = {
+            /**
+             * Starts a new session.
+             * @param {ISessionInput} data - The session input data.
+             * @returns {Promise<any>} The result of the session generation.
+             */
+            create: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.generateSession(data);
+            },
+            /**
+             * Decrypts a session.
+             * @param {ISessionPayload} data - The session payload.
+             * @returns {Promise<any>} The decrypted session.
+             */
+            validate: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.decryptSession(data);
+            },
+            /**
+             * Refreshes a session.
+             * @param {ISessionRefreshPayload} data - The session refresh payload.
+             * @returns {Promise<any>} The refreshed session.
+             */
+            refresh: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.refreshSession(data);
+            }
+        };
+        /**
+         * Feature-related operations for running, replaying, and resuming features.
+         */
+        this.feature = {
+            /**
+             * Runs a feature processor.
+             * @param {IProcessorInput} data - The feature processor input.
+             * @returns {Promise<any>} The result of the feature processing.
+             */
+            run: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return await processorService.processFeature(data);
+            },
+            /**
+             * Generates output for a process by ID.
+             * @param {string} process_id - The process ID.
+             * @returns {Promise<any>} The generated output.
+             */
+            output: async (process_id) => {
+                const processorService = await this.createNewProcessor();
+                return await processorService.generateOutput(process_id);
+            },
+            /**
+             * Replays a process by ID.
+             * @param {string} process_id - The process ID.
+             * @returns {Promise<any>} The result of the replay.
+             */
+            replay: async (process_id) => {
+                const processorService = await this.createNewProcessor();
+                return await processorService.replayProcess(process_id);
+            },
+            /**
+             * Resumes a process by ID.
+             * @param {string} process_id - The process ID.
+             * @returns {Promise<any>} The result of the resume.
+             */
+            resume: async (process_id) => {
+                const processorService = await this.createNewProcessor();
+                return await processorService.resumeProcess(process_id);
+            },
+        };
+        /**
+         * Quota-related operations for running quota processors.
+         */
+        this.quota = {
+            /**
+             * Runs a quota processor.
+             * @param {IProcessorInput} data - The quota processor input.
+             * @returns {Promise<any>} The result of the quota processing.
+             */
+            run: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processQuota(data);
+            },
+        };
+        /**
+         * Fallback-related operations for running fallback processors.
+         */
+        this.fallback = {
+            /**
+             * Runs a fallback processor.
+             * @param {IProcessorInput} data - The fallback processor input.
+             * @returns {Promise<any>} The result of the fallback processing.
+             */
+            run: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processFallback(data);
             },
+        };
+        /**
+         * Notification-related operations for sending notifications.
+         */
+        this.notification = {
+            /**
+             * Sends a notification using the notification processor.
+             * @param {INotificationProcessorInput} data - The notification processor input.
+             * @returns {Promise<any>} The result of the notification processing.
+             */
+            send: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processNotification(data);
+            },
+        };
+        /**
+         * Storage-related operations for reading and saving files.
+         */
+        this.storage = {
+            /**
+             * Reads a file from storage.
+             * @param {string} path - The file path.
+             * @returns {Promise<IFileReadResult>} The file read result.
+             */
+            read: async (path) => {
+                try {
+                    const buffer = await fs_1.promises.readFile(path);
+                    const mimeType = mime.lookup(path) || ''; // Get MIME type or fallback to empty string
+                    return { buffer: buffer.toString('base64'), fileName: filePath.basename(path), mimeType };
+                }
+                catch (error) {
+                    console.error('Error reading file:', error);
+                    throw error;
+                }
+            },
+            /**
+             * Saves data to storage using the storage processor.
+             * @param {IStorageProcessorInput} data - The storage processor input.
+             * @returns {Promise<any>} The result of the storage processing.
+             */
+            save: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processStorage(data);
+            },
+        };
+        /**
+         * Message broker-related operations for publishing and subscribing to topics.
+         */
+        this.broker = {
+            /**
+             * Publishes a message using the message broker processor.
+             * @param {IMessageBrokerPublishInput} data - The publish input.
+             * @returns {Promise<any>} The result of the publish operation.
+             */
+            publish: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processMessageBrokerPublish(data);
+            },
+            /**
+             * Subscribes to a message broker topic.
+             * @param {IMessageBrokerSubscribeInput} data - The subscribe input.
+             * @returns {Promise<any>} The result of the subscribe operation.
+             */
+            subcribe: async (data) => {
+                const processorService = await this.createNewProcessor();
+                return processorService.processMessageBrokerSubscribe(data);
+            },
+        };
+        /**
+         * Processor-related operations for database actions only.
+         */
+        this.processor = {
             db: {
+                /**
+                 * Executes a database action processor.
+                 * @param {IDBActionProcessorInput} data - The database action processor input.
+                 * @returns {Promise<any>} The result of the database action processing.
+                 */
                 execute: async (data) => {
                     const processorService = await this.createNewProcessor();
                     return processorService.processDBAction(data);
                 },
                 migration: {
+                    /**
+                     * Runs a database migration.
+                     * @param {Object} params - The migration parameters.
+                     * @param {string} params.migration - The migration name.
+                     * @param {string} params.env - The environment.
+                     * @param {string} params.product - The product name.
+                     * @returns {Promise<any>} The result of the migration.
+                     */
                     run: async ({ migration, env, product }) => {
-                        //this.checkProductInit();
                         const processorService = await this.createNewProcessor();
                         return processorService.runMigration(product, migration, env, 'up');
                     },
+                    /**
+                     * Rolls back a database migration.
+                     * @param {Object} params - The migration parameters.
+                     * @param {string} params.migration - The migration name.
+                     * @param {string} params.env - The environment.
+                     * @param {string} params.product - The product name.
+                     * @returns {Promise<any>} The result of the rollback.
+                     */
                     rollback: async ({ migration, env, product }) => {
-                        //this.checkProductInit();
                         const processorService = await this.createNewProcessor();
                         return processorService.runMigration(product, migration, env, 'down');
                     },
                 },
             },
-            sessions: {
-                generate: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.generateSession(data);
-                }
-            },
-            feature: {
-                run: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return await processorService.processFeature(data);
-                },
-                output: async (process_id) => {
-                    const processorService = await this.createNewProcessor();
-                    return await processorService.generateOutput(process_id);
-                },
-                replay: async (process_id) => {
-                    const processorService = await this.createNewProcessor();
-                    return await processorService.replayProcess(process_id);
-                },
-                resume: async (process_id) => {
-                    const processorService = await this.createNewProcessor();
-                    return await processorService.resumeProcess(process_id);
-                },
-            },
-            quota: {
-                run: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processQuota(data);
-                },
-            },
-            fallback: {
-                run: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processFallback(data);
-                },
-            },
-            notification: {
-                send: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processNotification(data);
-                },
-            },
-            storage: {
-                readFile: async (path) => {
-                    try {
-                        const buffer = await fs_1.promises.readFile(path);
-                        const mimeType = mime.lookup(path) || ''; // Get MIME type or fallback to empty string
-                        return { buffer: buffer.toString('base64'), fileName: filePath.basename(path), mimeType };
-                    }
-                    catch (error) {
-                        console.error('Error reading file:', error);
-                        throw error;
-                    }
-                },
-                save: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processStorage(data);
-                },
-            },
-            /*cloudFunction: {
-              invoke: async (data: IFunctionProcessorInput) => {
-                const processorService = this.createNewProcessor();
-                return processorService.processFunction(data);
-              },
-            },*/
-            messageBroker: {
-                publish: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processMessageBrokerPublish(data);
-                },
-                subcribe: async (data) => {
-                    const processorService = await this.createNewProcessor();
-                    return processorService.processMessageBrokerSubscribe(data);
-                },
-            },
         };
+        /**
+         * Logs-related operations for initializing and fetching logs.
+         */
         this.logs = {
+            /**
+             * Initializes the logger service for a product or app.
+             * @param {string} [productTag] - The product tag (optional).
+             * @param {string} [appTag] - The app tag (optional).
+             * @throws {Error} If neither productTag nor appTag is provided.
+             * @returns {Promise<void>} Resolves when logger is initialized.
+             */
             init: async (productTag, appTag) => {
                 if (!productTag && !appTag) {
                     throw new Error('At least one of productTag or appTag must be provided');
@@ -717,52 +1499,13 @@ class Ductape {
                     await this.appBuilder.initializeAppByTag(appTag);
                     this.appInit = true;
                 }
-                this.loggerService = this.createNewLogger(productTag ? this.productBuilder.fetchProduct()._id : null, appTag ? this.appBuilder.fetchApp()._id : null);
+                this.loggerService = this.createNewLogger(productTag ? this.productBuilder.fetchProductId() : null, appTag ? this.appBuilder.fetchApp()._id : null);
             },
             add: async () => { },
             /**
-             * 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'
-             * });
+             * Fetches logs based on provided query parameters.
+             * @param {LogQueryParams} params - The log query parameters.
+             * @returns {Promise<any>} The fetched log data.
              */
             fetch: async (params) => {
                 if (!this.loggerService) {
@@ -778,6 +1521,153 @@ class Ductape {
             },
             publish: async () => { },
         };
+        /**
+         * Workspace secrets operations for securely storing encrypted key-value pairs.
+         * Values are encrypted client-side using the workspace's private key.
+         */
+        this.secrets = {
+            /**
+             * Cached workspace private key for encryption/decryption.
+             * Fetched once and reused for the session.
+             */
+            _privateKey: null,
+            /**
+             * Fetches and caches the workspace private key.
+             * @returns {Promise<string>} The decrypted workspace private key.
+             */
+            fetchPrivateKey: async () => {
+                if (!this.token)
+                    await this.initUserAuth();
+                if (this.secrets._privateKey) {
+                    return this.secrets._privateKey;
+                }
+                const privateKey = await this.secretsApi.getPrivateKey({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                });
+                this.secrets._privateKey = privateKey;
+                return privateKey;
+            },
+            /**
+             * Creates a new workspace secret.
+             * The value is encrypted client-side before being sent to the server.
+             * @param {Object} data - The secret data.
+             * @param {string} data.key - The unique key for the secret (alphanumeric + underscores).
+             * @param {string} data.value - The plaintext value to encrypt and store.
+             * @param {string} [data.description] - Optional description.
+             * @param {string} [data.token_type] - Optional token type ('api' or 'access').
+             * @param {string[]} [data.scope] - Optional array of scopes.
+             * @param {string[]} [data.envs] - Optional array of environment slugs.
+             * @param {number|null} [data.expires_at] - Optional expiry timestamp in seconds (Unix epoch).
+             * @returns {Promise<IWorkspaceSecret>} The created secret (without encrypted value).
+             */
+            create: async (data) => {
+                if (!this.token)
+                    await this.initUserAuth();
+                // Get the workspace private key for encryption
+                const workspacePrivateKey = await this.secrets.fetchPrivateKey();
+                // Encrypt the value client-side
+                const encrypted_value = (0, processor_utils_1.encrypt)(data.value, workspacePrivateKey);
+                const payload = {
+                    key: data.key,
+                    encrypted_value,
+                    description: data.description,
+                    token_type: data.token_type,
+                    scope: data.scope,
+                    envs: data.envs,
+                    expires_at: data.expires_at,
+                };
+                return this.secretsApi.createSecret({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                }, payload);
+            },
+            /**
+             * Lists all workspace secrets.
+             * Returns metadata only, not the encrypted values.
+             * @returns {Promise<IWorkspaceSecret[]>} List of secrets.
+             */
+            fetchAll: async () => {
+                if (!this.token)
+                    await this.initUserAuth();
+                return this.secretsApi.listSecrets({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                });
+            },
+            /**
+             * Fetches a single secret by key and decrypts its value.
+             * @param {string} key - The secret key.
+             * @returns {Promise<IWorkspaceSecret & { value: string }>} The secret with decrypted value.
+             */
+            fetch: async (key) => {
+                if (!this.token)
+                    await this.initUserAuth();
+                // Get the workspace private key for decryption
+                const workspacePrivateKey = await this.secrets.fetchPrivateKey();
+                const secret = await this.secretsApi.getSecret({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                }, key);
+                // Decrypt the value client-side
+                const decryptedValue = secret.encrypted_value
+                    ? (0, processor_utils_1.decrypt)(secret.encrypted_value, workspacePrivateKey)
+                    : '';
+                return Object.assign(Object.assign({}, secret), { value: decryptedValue });
+            },
+            /**
+             * Updates a workspace secret.
+             * If a new value is provided, it will be encrypted client-side.
+             * @param {string} key - The secret key to update.
+             * @param {Object} data - The update data.
+             * @param {string} [data.value] - New plaintext value to encrypt.
+             * @param {string} [data.description] - New description.
+             * @param {number|null} [data.expires_at] - New expiry timestamp.
+             * @returns {Promise<IWorkspaceSecret>} The updated secret.
+             */
+            update: async (key, data) => {
+                if (!this.token)
+                    await this.initUserAuth();
+                const payload = {
+                    description: data.description,
+                    expires_at: data.expires_at,
+                };
+                // If a new value is provided, encrypt it
+                if (data.value !== undefined) {
+                    const workspacePrivateKey = await this.secrets.fetchPrivateKey();
+                    payload.encrypted_value = (0, processor_utils_1.encrypt)(data.value, workspacePrivateKey);
+                }
+                return this.secretsApi.updateSecret({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                }, key, payload);
+            },
+            /**
+             * Deletes a workspace secret.
+             * @param {string} key - The secret key to delete.
+             * @returns {Promise<boolean>} True if deleted successfully.
+             */
+            delete: async (key) => {
+                if (!this.token)
+                    await this.initUserAuth();
+                return this.secretsApi.deleteSecret({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                }, key);
+            },
+        };
         this.workspace_id = workspace_id;
         this.private_key = private_key;
         this.user_id = user_id;
@@ -786,10 +1676,27 @@ class Ductape {
         this.appApi = new appApi_service_1.AppApiService(this.environment);
         this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(this.environment);
         this.productsApi = new productsApi_service_1.ProductsApiService(this.environment);
+        this.secretsApi = new workspaceSecretsApi_service_1.WorkspaceSecretsApiService(this.environment);
         this.redis_url = redis_url;
         return (0, utils_1.createDeepProxy)(this, this.environment);
     }
-    async connectRedis() {
+    async loadBullMQ() {
+        if (typeof window !== 'undefined') {
+            throw new Error("Bullmq can only be used in a server environment.");
+        }
+        const bull = await Promise.resolve().then(() => __importStar(require('bullmq')));
+        return {
+            Queue: bull.Queue,
+            Worker: bull.Worker,
+            Job: bull.Job,
+        };
+    }
+    /**
+     * Connects to Redis and initializes job and health check queues and workers.
+     * @throws {Error} If called in a browser environment or if Redis URL is missing.
+     * @returns {Promise<void>} Resolves when Redis and queues are initialized.
+     */
+    async monitor() {
         if (typeof window !== 'undefined') {
             throw new Error("RedisService can only be used in a server environment.");
         }
@@ -797,16 +1704,162 @@ class Ductape {
             throw new Error("Redis URL is not provided.");
         }
         if (this.redisClient) {
-            // Already connected — reuse existing client
+            // Already connected
+            return;
+        }
+        // TODO: remove this requirement
+        if (!this.redisClient) {
             return;
         }
-        const { createClient } = await this.loadRedis();
-        this.redisClient = createClient({ url: this.redis_url });
-        await this.redisClient.connect();
+        if (!this.public_key) {
+            await this.initUserAuth(false);
+        }
+        const Redis = await this.loadRedis();
+        const { Queue, Worker: BullWorker } = await this.loadBullMQ();
+        // Create Redis client with required options for BullMQ
+        this.redisClient = new Redis.default(this.redis_url, {
+            maxRetriesPerRequest: null, // Required by BullMQ
+        });
+        // Initialize job queues
+        this.jobsQueue = new Queue('ductape_jobs', {
+            connection: this.redisClient,
+        });
+        this.healthCheckQueue = new Queue('ductape_healthchecks', {
+            connection: this.redisClient,
+        });
+        this.healthCheckUpdaterQueue = new Queue('healthchecks-updater', {
+            connection: this.redisClient
+        });
+        // Schedule healthcheck jobs for all products/environments
+        await this.scheduleAllHealthcheckJobs();
+        // Initialize job worker
+        this.jobsWorker = new BullWorker('ductape_jobs', async (job) => {
+            console.log(`Processing job ${job.id} of type ${job.name}`, job.data);
+            const processor = await this.createNewProcessor();
+            await processor.runJobs(job);
+        }, {
+            connection: this.redisClient,
+        });
+        // Initialize health check worker
+        this.healthCheckWorker = new BullWorker('ductape_healthchecks', async (job) => {
+            console.log(`Running health check job ${job.id}`, job.data);
+            const processor = await this.createNewProcessor();
+            console.log("FIND JOB!!!!", job.data);
+            if (job && job.data && Object.keys(job.data).length) {
+                // Call processAction with job.data
+                const result = await processor.processAction(job.data);
+                // Write result to Redis cache
+                await processor.writeHealthcheckResultToCache(job.data, Object.assign({ status: (result === null || result === void 0 ? void 0 : result.status) || 'unknown', lastChecked: Date.now() }, result));
+                // Re-enqueue the job for continuous healthchecks
+                //await this.scheduleHealthcheckJob(job.data);
+            }
+        }, {
+            connection: this.redisClient,
+        });
+        // Add a repeatable job to update DB every 10 minutes
+        await this.healthCheckUpdaterQueue.add('healthchecks-updater', {}, {
+            jobId: 'healthchecks-updater',
+            repeat: { every: 5 * 60 * 1000 }
+        });
+        // Healthcheck updater worker
+        this.healthCheckUpdaterWorker = new BullWorker('healthchecks-updater', async (job) => {
+            console.log('Init Processor for healthcheck Updater');
+            if (job.name !== 'healthchecks-updater')
+                return;
+            // Gather all healthcheck results from Redis
+            const keys = await this.redisClient.keys('healthcheck:*');
+            console.log("Found Keys for healthcheck updater", JSON.stringify(keys));
+            const envResults = {};
+            for (const key of keys) {
+                const [_, productTag, tag, envSlug] = key.split(':');
+                console.log(`${productTag} , ${tag}, ${envSlug}`);
+                const data = JSON.parse(await this.redisClient.get(key));
+                if (!envResults[productTag])
+                    envResults[productTag] = {};
+                if (!envResults[productTag][tag])
+                    envResults[productTag][tag] = {};
+                envResults[productTag][tag][envSlug] = data;
+            }
+            for (const productTag in envResults) {
+                const tagsData = Object.entries(envResults[productTag]).map(([tag, envs]) => ({
+                    tag,
+                    environments: Object.entries(envs).map(([slug, data]) => (Object.assign({ slug }, data))),
+                }));
+                console.log();
+                const processor = await this.createNewProcessor();
+                console.log('PROCESSING ENV RESULT', productTag, tagsData);
+                await processor.updateHealthcheckOnProcessor(productTag, tagsData);
+            }
+        }, {
+            connection: this.redisClient,
+        });
+        // Attach error listeners
+        this.jobsWorker.on('failed', (job, err) => {
+            console.error(`Job ${job === null || job === void 0 ? void 0 : job.id} failed:`, err);
+        });
+        this.healthCheckWorker.on('failed', (job, err) => {
+            console.error(`Health check ${job === null || job === void 0 ? void 0 : job.id} failed:`, err);
+        });
+    }
+    /**
+     * Schedules all healthcheck jobs for all products and environments.
+     */
+    async scheduleAllHealthcheckJobs() {
+        // Fetch all products (or use this.products if already loaded)
+        const products = this.products || await this.productsApi.fetchWorkspaceProducts(enums_1.PublicStates.ALL, {
+            token: this.token,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            workspace_id: this.workspace_id,
+        });
+        for (const product of products) {
+            const healthchecks = product.healthchecks || [];
+            const privateKey = product.private_key;
+            for (const healthcheck of healthchecks) {
+                for (const env of healthcheck.envs) {
+                    let decryptedInput = env.input;
+                    if (typeof decryptedInput === 'string') {
+                        decryptedInput = JSON.parse((0, processor_utils_1.decrypt)(decryptedInput, privateKey));
+                    }
+                    const jobData = {
+                        healthcheck: healthcheck.tag,
+                        env: env.slug,
+                        product: product.tag,
+                        app: healthcheck.app,
+                        input: decryptedInput,
+                        event: healthcheck.event,
+                        retries: healthcheck.retries || 0,
+                    };
+                    const jobId = `healthcheck-exec-${healthcheck.tag}-${env.slug}`;
+                    await this.scheduleHealthcheckJob(jobId, jobData, healthcheck.interval);
+                }
+            }
+        }
+    }
+    /**
+     * Schedules a single healthcheck job with the given interval (ms).
+     * If interval is not provided, defaults to 60s.
+     */
+    async scheduleHealthcheckJob(jobId, jobData, interval) {
+        console.log("JOBBERMAN", { jobId, jobData, interval });
+        const job = await this.healthCheckQueue.getJob(jobId);
+        if (job) {
+            await job.remove();
+        }
+        const repeat = interval ? { every: interval } : { every: 60000 };
+        await this.healthCheckQueue.add('healthchecks-updater', jobData, { repeat, jobId });
     }
+    /**
+     * Sets the authentication token for API requests.
+     * @param {string} token - The authentication token.
+     */
     setToken(token) {
         this.token = token;
     }
+    /**
+     * Sets the public key for API requests.
+     * @param {string} public_key - The public key.
+     */
     setPublicKey(public_key) {
         this.public_key = public_key;
     }
@@ -832,6 +1885,26 @@ class Ductape {
             throw new Error(`app init required`);
         }
     }
+    /**
+     * Database operations for querying, inserting, updating, and managing databases.
+     * Provides unified interface for SQL and NoSQL databases.
+     */
+    get database() {
+        if (!this.databaseService) {
+            this.databaseService = this.createNewDatabaseService();
+        }
+        return this.databaseService;
+    }
+    /**
+     * Graph database operations for Neo4j, AWS Neptune, ArangoDB, and Memgraph.
+     * Provides unified interface for graph database CRUD, traversals, and path finding.
+     */
+    get graph() {
+        if (!this.graphService) {
+            this.graphService = this.createNewGraphService();
+        }
+        return this.graphService;
+    }
     async initUserAuth(subCheck = true) {
         this.token = null;
         this.public_key = null;
@@ -860,6 +1933,24 @@ class Ductape {
             app_id,
         });
     }
+    createNewDatabaseService() {
+        return new database_service_1.DatabaseService({
+            workspace_id: this.workspace_id,
+            user_id: this.user_id,
+            public_key: this.public_key,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
+    createNewGraphService() {
+        return new graph_service_1.GraphService({
+            workspace_id: this.workspace_id,
+            user_id: this.user_id,
+            public_key: this.public_key,
+            token: this.token,
+            env_type: this.environment,
+        });
+    }
     createNewProductBuilder() {
         return new products_service_1.default({
             workspace_id: this.workspace_id,
@@ -878,6 +1969,8 @@ class Ductape {
             user_id: this.user_id,
             token: this.token,
             env_type: this.environment,
+            redis_client: this.redisClient,
+            queues: { health: this.healthCheckQueue, jobs: this.jobsQueue }
         });
     }
     createNewImporter() {
@@ -996,6 +2089,13 @@ class Ductape {
             throw error;
         }
     }
+    /**
+     * Fetches the latest healthcheck status for a product/env from Redis cache via processor service.
+     */
+    async getHealthcheckStatus(productTag, envSlug) {
+        const processor = await this.createNewProcessor();
+        return processor.getHealthcheckStatusFromCache(productTag, envSlug);
+    }
 }
 exports.default = Ductape;
 //# sourceMappingURL=index.js.map