@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/products/services/products.service.js

@@ -22,13 +22,13 @@ const inputs_utils_create_1 = require("../../inputs/utils/inputs.utils.create");
 const enums_1 = require("../../types/enums");
 const productsBuilder_types_1 = require("../../types/productsBuilder.types");
 const validators_1 = require("../validators");
-const objects_utils_1 = require("./utils/objects.utils");
+const objects_utils_1 = require("../utils/objects.utils");
 const processor_utils_1 = require("../../processor/utils/processor.utils");
-const create_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productDatabaseAction.validator"));
-const update_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productDatabaseAction.validator"));
+const create_productDatabaseAction_validator_1 = require("../validators/joi-validators/create.productDatabaseAction.validator");
+const update_productDatabaseAction_validator_1 = require("../validators/joi-validators/update.productDatabaseAction.validator");
 const create_productStorage_validator_1 = require("../validators/joi-validators/create.productStorage.validator");
 const inputs_types_1 = require("../../types/inputs.types");
-const string_utils_1 = require("./utils/string.utils");
+const string_utils_1 = require("../utils/string.utils");
 const workspaceApi_service_1 = require("../../api/services/workspaceApi.service");
 const string_utils_2 = require("../../apps/utils/string.utils");
 const create_productDatabaseMigration_validator_1 = __importDefault(require("../validators/joi-validators/create.productDatabaseMigration.validator"));
@@ -36,11 +36,9 @@ const update_productDatabaseMigration_validator_1 = __importDefault(require("../
 const create_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/create.productNotificationMessage.validator"));
 const create_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/create.productMessageBrokerTopic.validator"));
 const update_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/update.productMessageBrokerTopic.validator"));
-const create_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productGraphAction.validator"));
-const update_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productGraphAction.validator"));
 const update_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/update.productNotificationMessage.validator"));
 const create_productNotification_validator_1 = require("../validators/joi-validators/create.productNotification.validator");
-const functions_utils_1 = require("./utils/functions.utils");
+const functions_utils_1 = require("../utils/functions.utils");
 const objects_utils_2 = require("../../apps/utils/objects.utils");
 const webhooksApi_service_1 = require("../../api/services/webhooksApi.service");
 class ProductsBuilderService {
@@ -96,24 +94,24 @@ class ProductsBuilderService {
                     }
                     await this.validateActionDataInput({ input: env.input }, event, env.input, 0, 0);
                     env.input = (0, processor_utils_1.encrypt)(JSON.stringify(env.input), this.product.private_key);
-                    console.log("INPUT", env);
+                    console.log('INPUT', env);
                     return env;
                 }));
                 const envs = await this.fetchEnvs();
-                console.log("ENVS ===>>>>", envs);
-                console.log("DBENVS ====>>>>", data.envs);
+                console.log('ENVS ===>>>>', envs);
+                console.log('DBENVS ====>>>>', data.envs);
                 envs.map((env) => {
                     const exists = data.envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
                     if (exists === -1) {
                         throw new Error(`Product env ${env.slug} is not defined, please provide details`);
                     }
                 });
-                console.log("UPDATING VALUE", data);
+                console.log('UPDATING VALUE', data);
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.ProductComponents.HEALTHCHECK }), this.getUserAccess());
                 data.envs.map(async (env) => {
                     const payload = {
                         app: data.app,
-                        event: data.event,
+                        action: data.event,
                         input: env.input,
                         env: env.slug,
                         product: this.product.tag,
@@ -143,7 +141,7 @@ class ProductsBuilderService {
             // 2. Validate the incoming data
             await validators_1.CreateProductHealthcheckSchema.validateAsync(data); // No Update schema, use Create
             // 3. Check for tag conflicts
-            if (data.tag && data.tag !== tag && await this.fetchHealthcheck(data.app, data.tag)) {
+            if (data.tag && data.tag !== tag && (await this.fetchHealthcheck(data.app, data.tag))) {
                 throw new Error(`Healthcheck with tag ${data.tag} already exists`);
             }
             // 4. Validate and process envs
@@ -294,7 +292,7 @@ class ProductsBuilderService {
     }
     async initializeProduct(product_id) {
         try {
-            this.product = await this.productApi.initProduct(product_id, this.getUserAccess());
+            this.product = (await this.productApi.initProduct(product_id, this.getUserAccess()));
             this.product_id = product_id;
         }
         catch (e) {
@@ -303,7 +301,7 @@ class ProductsBuilderService {
     }
     async initializeProductByTag(tag) {
         try {
-            this.product = await this.productApi.initProduct(tag, this.getUserAccess());
+            this.product = (await this.productApi.initProduct(tag, this.getUserAccess()));
             if (!this.product) {
                 throw new Error(`Product with tag "${tag}" not found or failed to fetch`);
             }
@@ -313,6 +311,48 @@ class ProductsBuilderService {
             throw e;
         }
     }
+    /**
+     * Bootstrap action - ultra-lightweight API call to fetch action data needed for processAction
+     * Replaces 5+ separate API calls: initializeProduct, fetchApp, fetchThirdPartyApp, fetchEnv, initializePricing
+     * Returns only the minimal action data needed to execute
+     */
+    async bootstrapAction(params) {
+        try {
+            const result = await this.productApi.bootstrapAction(params, this.getUserAccess());
+            // Initialize minimal product data
+            if (result.product_id) {
+                this.product_id = result.product_id;
+            }
+            return result;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async bootstrapNotification(params) {
+        try {
+            const result = await this.productApi.bootstrapNotification(params, this.getUserAccess());
+            if (result.product_id) {
+                this.product_id = result.product_id;
+            }
+            return result;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async bootstrapStorage(params) {
+        try {
+            const result = await this.productApi.bootstrapStorage(params, this.getUserAccess());
+            if (result.product_id) {
+                this.product_id = result.product_id;
+            }
+            return result;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async updateProduct(data) {
         try {
             if (!this.app_id)
@@ -362,15 +402,13 @@ class ProductsBuilderService {
                         throw new Error(`${data.selector} not found in event sample`);
                     }
                 }
-                if (current === null ||
-                    typeof current === "undefined" ||
-                    typeof current === "object") {
-                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
+                if (current === null || typeof current === 'undefined' || typeof current === 'object') {
+                    throw new Error('Selector value is not allowed to be an object|array|null|undefined');
                 }
-                data.schema_data = await this.inputsService.parseJson({
+                data.schema_data = (await this.inputsService.parseJson({
                     data: data.schema,
-                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE
-                });
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
+                }));
                 data.selectorValue = current;
                 const payload = Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE });
                 await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
@@ -419,10 +457,8 @@ class ProductsBuilderService {
                         throw new Error(`${data.selector} not found in event sample`);
                     }
                 }
-                if (current === null ||
-                    typeof current === "undefined" ||
-                    typeof current === "object") {
-                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
+                if (current === null || typeof current === 'undefined' || typeof current === 'object') {
+                    throw new Error('Selector value is not allowed to be an object|array|null|undefined');
                 }
             }
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, session), data)), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
@@ -431,7 +467,7 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchSessions() {
+    async fetchSessions(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'session', this.getUserAccess());
         return components;
     }
@@ -439,6 +475,22 @@ class ProductsBuilderService {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'session', tag, this.getUserAccess());
         return component;
     }
+    async deleteSession(tag) {
+        try {
+            const session = await this.fetchSession(tag);
+            if (!session) {
+                throw new Error(`Session with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.SESSION,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createMessageBrokerTopic(data, throwErrorIfExists = false) {
         try {
             if (!data.tag) {
@@ -512,7 +564,7 @@ class ProductsBuilderService {
         if (!messageBrokerTag || !topicTag) {
             throw new Error(`tag is expected to be defined as "messageBroker_tag:topic_tag"`);
         }
-        const messageBroker = await this.fetchMessageBroker(messageBrokerTag);
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
         if (!messageBroker)
             throw new Error(`MessageBroker ${messageBrokerTag} not found`);
         const topic = messageBroker.topics.find((data) => data.tag === topicTag);
@@ -521,7 +573,7 @@ class ProductsBuilderService {
         return topic;
     }
     async fetchMessageBrokerTopics(messageBrokerTag) {
-        const messageBroker = await this.fetchMessageBroker(messageBrokerTag);
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
         if (!messageBroker)
             throw new Error(`Message Broker ${messageBrokerTag} not found`);
         return messageBroker.topics;
@@ -741,7 +793,10 @@ class ProductsBuilderService {
                             if (!action) {
                                 throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
                             }
-                            if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                            if (action.headers.data.length > 0 ||
+                                action.body.data.length > 0 ||
+                                action.params.data.length > 0 ||
+                                action.query.data.length > 0) {
                                 throw new Error('Healthcheck action is expected to have no headers, body, params or query');
                             }
                         }
@@ -787,7 +842,10 @@ class ProductsBuilderService {
                                 if (!action) {
                                     throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
                                 }
-                                if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                if (action.headers.data.length > 0 ||
+                                    action.body.data.length > 0 ||
+                                    action.params.data.length > 0 ||
+                                    action.query.data.length > 0) {
                                     throw new Error('Healthcheck action is expected to have no headers, body, params or query');
                                 }
                             }
@@ -807,14 +865,30 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchQuotas() {
+    async fetchQuotas(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'quota', this.getUserAccess());
         return components;
     }
-    async fetchQuota(tag) {
+    async fetchQuota(tag, version) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'quota', tag, this.getUserAccess());
         return component;
     }
+    async deleteQuota(tag) {
+        try {
+            const quota = await this.fetchQuota(tag);
+            if (!quota) {
+                throw new Error(`Quota with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.QUOTA,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createFallback(data) {
         try {
             if (!data.tag) {
@@ -842,7 +916,10 @@ class ProductsBuilderService {
                             if (!action) {
                                 throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
                             }
-                            if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                            if (action.headers.data.length > 0 ||
+                                action.body.data.length > 0 ||
+                                action.params.data.length > 0 ||
+                                action.query.data.length > 0) {
                                 throw new Error('Healthcheck action is expected to have no headers, body, params or query');
                             }
                         }
@@ -885,7 +962,10 @@ class ProductsBuilderService {
                                 if (!action) {
                                     throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
                                 }
-                                if (action.headers.data.length > 0 || action.body.data.length > 0 || action.params.data.length > 0 || action.query.data.length > 0) {
+                                if (action.headers.data.length > 0 ||
+                                    action.body.data.length > 0 ||
+                                    action.params.data.length > 0 ||
+                                    action.query.data.length > 0) {
                                     throw new Error('Healthcheck action is expected to have no headers, body, params or query');
                                 }
                             }
@@ -905,14 +985,30 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchFallbacks() {
+    async fetchFallbacks(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'fallback', this.getUserAccess());
         return components;
     }
-    async fetchFallback(tag) {
+    async fetchFallback(tag, version) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'fallback', tag, this.getUserAccess());
         return component;
     }
+    async deleteFallback(tag) {
+        try {
+            const fallback = await this.fetchFallback(tag);
+            if (!fallback) {
+                throw new Error(`Fallback with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.FALLBACK,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createEnv(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
@@ -949,14 +1045,31 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchEnvs() {
+    async fetchEnvs(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'env', this.getUserAccess());
         return components;
     }
     async fetchEnv(slug) {
+        console.log;
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'env', slug, this.getUserAccess());
         return component;
     }
+    async deleteEnv(slug) {
+        try {
+            const env = await this.fetchEnv(slug);
+            if (!env) {
+                throw new Error(`Environment with slug: ${slug} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                slug,
+                component: enums_1.ProductComponents.ENV,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createMessageBroker(data, throwErrorIfExists = false) {
         if (!(await this.fetchMessageBroker(data.tag))) {
             await validators_1.CreateMessageBrokerSchema.validateAsync(data);
@@ -1045,27 +1158,29 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchMessageBrokers() {
+    async fetchMessageBrokers(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'message_broker', this.getUserAccess());
-        components.map((broker) => {
-            return broker.envs.map((env) => {
-                if (typeof env.config === 'string') {
-                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
-                }
-            });
-        });
         return components;
     }
-    async fetchMessageBroker(tag) {
-        const messageBroker = await this.productApi.fetchProductComponentByTag(this.product_id, 'message_broker', tag, this.getUserAccess());
-        if (messageBroker) {
-            messageBroker.envs.map((env) => {
-                if (typeof env.config === 'string') {
-                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
-                }
-            });
+    async fetchMessageBroker(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'message_broker', tag, this.getUserAccess());
+        return component;
+    }
+    async deleteMessageBroker(tag) {
+        try {
+            const messageBroker = await this.fetchMessageBroker(tag);
+            if (!messageBroker) {
+                throw new Error(`Message broker with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.MESSAGEBROKER,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
         }
-        return messageBroker;
     }
     async fetchStorageFiles(filter) {
         try {
@@ -1081,7 +1196,7 @@ class ProductsBuilderService {
             });
         }
         catch (e) {
-            throw (e);
+            throw e;
         }
     }
     async fetchSessionUsers(filter) {
@@ -1097,7 +1212,7 @@ class ProductsBuilderService {
             });
         }
         catch (e) {
-            throw (e);
+            throw e;
         }
     }
     async createStorage(data, throwErrorIfExists = false) {
@@ -1193,133 +1308,521 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchStorages() {
+    async fetchStorages(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'storage', this.getUserAccess());
-        components.map((storage) => {
-            storage.envs.map((env) => {
-                if (typeof env.config === 'string') {
-                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
-                }
-            });
-        });
         return components;
     }
-    async fetchStorage(tag) {
-        const storage = await this.productApi.fetchProductComponentByTag(this.product_id, 'storage', tag, this.getUserAccess());
-        if (storage) {
-            storage.envs.map((store) => {
-                if (typeof store.config === 'string') {
-                    store.config = JSON.parse((0, processor_utils_1.decrypt)(String(store.config), this.product.private_key));
-                }
-            });
-        }
-        return storage;
-    }
-    async validateAppData(appData, app) {
-        // TODO:
-        const { envs } = app;
-        // const { envs: appEnvs, auths: appAuths } = appData
-        const version = appData.versions.find((data) => (data.latest = true));
-        app.envs = this.validateAppEnvs(envs, version);
-        // await this.validateAppAuth(auth, appData);
-        return app;
+    async fetchStorage(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'storage', tag, this.getUserAccess());
+        return component;
     }
-    validateVariablesSchema(variables, appVariables) {
-        if (variables && variables.length) {
-            variables.map((data) => {
-                const appVar = appVariables.find((value) => value.key === data.key);
-                if (!appVar) {
-                    throw new Error(`variable key: ${data.key} not found`);
-                }
-                // if()
-            });
+    async deleteStorage(tag) {
+        try {
+            const storage = await this.fetchStorage(tag);
+            if (!storage) {
+                throw new Error(`Storage with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.STORAGE,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
         }
-    }
-    validateVariablesValues(variables, appVariables) {
-        if (!variables) {
-            variables = [];
+        catch (e) {
+            throw e;
         }
-        if (appVariables && appVariables.length) {
-            appVariables.map((data) => {
-                const find = variables.find((value) => value.key === data.key);
-                if (data.required) {
-                    if (!find) {
-                        throw new Error(`variable key: ${data.key} is required`);
-                    }
+    }
+    // ==================== VECTOR DATABASE METHODS ====================
+    /**
+     * Create a new vector database configuration
+     * @param data Vector database configuration
+     * @param throwErrorIfExists Whether to throw error if vector config already exists
+     */
+    async createVector(data, throwErrorIfExists = false) {
+        if (!(await this.fetchVector(data.tag))) {
+            await validators_1.CreateProductVectorSchema.validateAsync(data);
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                const exists = await this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
                 }
-                this.inputsService.validateFeatureInputData(find, data);
-            });
+                // Encrypt API key if provided
+                if (env.apiKey) {
+                    env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                }
+                processedEnvs.push(env);
+            }
+            data.envs = processedEnvs;
+            const envs = await this.fetchEnvs();
+            for (const env of envs) {
+                const exists = data.envs.findIndex((vecEnv) => vecEnv.slug === env.slug);
+                if (exists === -1) {
+                    throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
+                }
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.VECTOR, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+        }
+        else {
+            if (throwErrorIfExists)
+                throw new Error(`Vector ${data.tag} already exists`);
         }
     }
-    validateAppEnvs(envs, version) {
-        const { envs: appEnvs } = version;
-        return envs.map((env) => {
-            const { auth } = env;
-            this.fetchEnv(env.product_env_slug);
-            const appEnv = appEnvs.find((appEnv) => appEnv.slug === env.app_env_slug);
-            if (!appEnv) {
-                throw new Error(`app_slug ${env.app_env_slug} not found`);
+    /**
+     * Update an existing vector database configuration
+     * @param tag Vector config tag
+     * @param data Updated vector configuration
+     */
+    async updateVector(tag, data) {
+        try {
+            const vector = await this.fetchVector(tag);
+            if (!vector) {
+                throw new Error(`Vector ${tag} not found`);
             }
-            const updates = this.validateAppAuth(auth, version);
-            this.validateVariablesSchema(env.variables, version.variables);
-            this.validateVariablesValues(env.variables, version.variables);
-            if (updates && updates.data) {
-                env.auth.data = updates.data;
+            const { _id, envs } = vector;
+            await validators_1.UpdateProductVectorSchema.validateAsync(data);
+            if (data.tag && (await this.fetchVector(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
             }
-            if (updates && updates.values) {
-                env.auth.values = updates.values;
+            if (data.envs) {
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    // Encrypt API key if provided
+                    if (env.apiKey) {
+                        env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                    }
+                    return env;
+                }));
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.forEach((dataEnv) => {
+                    const existsIdx = envs.findIndex((env) => env.slug === dataEnv.slug);
+                    if (existsIdx === -1) {
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[existsIdx]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs.forEach((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...unchanged, ...overwrite, ...newEnvs];
             }
-            return env;
-        });
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, vector), data), { component: enums_1.ProductComponents.VECTOR, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
     }
-    validateAppAuth(auth, version) {
-        const { auths: appAuth, actions } = version;
-        const exists = appAuth.find((appAuth) => appAuth.tag === auth.auth_tag);
-        if (!exists) {
-            throw new Error(`app_auth ${auth.auth_tag} not found`);
+    /**
+     * Fetch all vector database configurations
+     * @param version Optional version
+     */
+    async fetchVectors(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'vector', this.getUserAccess());
+        return components;
+    }
+    /**
+     * Fetch a specific vector database configuration by tag
+     * @param tag Vector config tag
+     * @param version Optional version
+     */
+    async fetchVector(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'vector', tag, this.getUserAccess());
+        return component;
+    }
+    /**
+     * Delete a vector database configuration
+     * @param tag Vector config tag
+     */
+    async deleteVector(tag) {
+        try {
+            const vector = await this.fetchVector(tag);
+            if (!vector) {
+                throw new Error(`Vector with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.VECTOR,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
         }
-        const { data } = auth;
-        let bodySchema;
-        let headerSchema;
-        let paramsSchema;
-        let querySchema;
-        let schema;
-        if (exists.action_tag) {
-            const action = actions.find((action) => action.tag === exists.action_tag);
-            if (!action)
-                throw new Error(`Auth action tag ${exists.action_tag} not found`);
-            schema = action;
+        catch (e) {
+            throw e;
         }
-        else if (exists.tokens) {
-            schema = exists.tokens;
+    }
+    // ==================== AGENT METHODS ====================
+    /**
+     * Create a new agent configuration
+     * @param data Agent configuration data
+     * @param throwErrorIfExists Whether to throw an error if agent already exists
+     */
+    async createAgent(data, throwErrorIfExists = false) {
+        if (!(await this.fetchAgent(data.tag))) {
+            await validators_1.CreateProductAgentSchema.validateAsync(data);
+            // Validate envs if provided
+            if (data.envs) {
+                for (const env of data.envs) {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                }
+            }
+            // Validate that all product envs are configured
+            const envs = await this.fetchEnvs();
+            if (data.envs) {
+                for (const env of envs) {
+                    const exists = data.envs.findIndex((agentEnv) => agentEnv.slug === env.slug);
+                    if (exists === -1) {
+                        // Auto-add missing envs with default config
+                        data.envs.push({ slug: env.slug, active: true });
+                    }
+                }
+            }
+            else {
+                // Initialize envs with all product envs
+                data.envs = envs.map((env) => ({ slug: env.slug, active: true }));
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.AGENT, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
         }
         else {
-            throw new Error('Invalid auth, create and use another');
-        }
-        bodySchema = schema.body;
-        headerSchema = schema.headers;
-        paramsSchema = schema.params;
-        querySchema = schema.query;
-        const { body, headers, params, query } = data;
-        if (!body)
-            throw new Error(`Auth body not allowed to be undefined. If empty set as {}`);
-        if (!headers)
-            throw new Error(`Auth headers not allowed to be undefined. If empty set as {}`);
-        if (!params)
-            throw new Error(`Auth params not allowed to be undefined. If empty set as {}`);
-        if (!query)
-            throw new Error(`Auth query not allowed to be undefined. If empty set as {}`);
-        if (bodySchema && bodySchema.data) {
-            const bodyValues = this.inputsService.parseData({
-                data: body,
-                category: enums_1.Categories.SETUP,
-                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-                type: enums_1.InputsTypes.JSON,
-            });
-            (0, inputs_utils_create_1.validateInputSchema)(bodyValues, bodySchema);
+            if (throwErrorIfExists)
+                throw new Error(`Agent ${data.tag} already exists`);
         }
-        if (headerSchema && headerSchema.data) {
-            const headerValues = this.inputsService.parseData({
+    }
+    /**
+     * Update an existing agent configuration
+     * @param tag Agent tag
+     * @param data Updated agent configuration
+     */
+    async updateAgent(tag, data) {
+        try {
+            const agent = await this.fetchAgent(tag);
+            if (!agent) {
+                throw new Error(`Agent ${tag} not found`);
+            }
+            const { _id, envs } = agent;
+            await validators_1.UpdateProductAgentSchema.validateAsync(data);
+            if (data.tag && data.tag !== tag && (await this.fetchAgent(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            if (data.envs) {
+                // Validate that all provided envs exist
+                for (const env of data.envs) {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                }
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.forEach((dataEnv) => {
+                    var _a;
+                    const existsIdx = (_a = envs === null || envs === void 0 ? void 0 : envs.findIndex((env) => env.slug === dataEnv.slug)) !== null && _a !== void 0 ? _a : -1;
+                    if (existsIdx === -1) {
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[existsIdx]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs === null || envs === void 0 ? void 0 : envs.forEach((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, agent), data), { component: enums_1.ProductComponents.AGENT, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * Fetch all agent configurations
+     * @param version Optional version
+     */
+    async fetchAgents(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'agent', this.getUserAccess());
+        return components;
+    }
+    /**
+     * Fetch a specific agent configuration by tag
+     * @param tag Agent tag
+     * @param version Optional version
+     */
+    async fetchAgent(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'agent', tag, this.getUserAccess());
+        return component;
+    }
+    /**
+     * Delete an agent configuration
+     * @param tag Agent tag
+     */
+    async deleteAgent(tag) {
+        try {
+            const agent = await this.fetchAgent(tag);
+            if (!agent) {
+                throw new Error(`Agent with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.AGENT,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // ==================== LLM MODEL METHODS ====================
+    /**
+     * Create a new LLM model configuration
+     * API keys are automatically encrypted using the product's private key
+     * @param data LLM model configuration
+     * @param throwErrorIfExists Whether to throw error if model already exists
+     */
+    async createModel(data, throwErrorIfExists = false) {
+        if (!(await this.fetchModel(data.tag))) {
+            await validators_1.CreateProductModelSchema.validateAsync(data);
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                const exists = await this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                // Encrypt API key if provided
+                if (env.apiKey) {
+                    env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                }
+                processedEnvs.push(env);
+            }
+            data.envs = processedEnvs;
+            const envs = await this.fetchEnvs();
+            for (const env of envs) {
+                const exists = data.envs.findIndex((modelEnv) => modelEnv.slug === env.slug);
+                if (exists === -1) {
+                    throw new Error(`Product env ${env.slug} is not defined, please provide API key configuration`);
+                }
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.MODEL, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+        }
+        else {
+            if (throwErrorIfExists)
+                throw new Error(`Model ${data.tag} already exists`);
+        }
+    }
+    /**
+     * Update an existing LLM model configuration
+     * @param tag Model tag
+     * @param data Updated model configuration
+     */
+    async updateModel(tag, data) {
+        try {
+            const model = await this.fetchModel(tag);
+            if (!model) {
+                throw new Error(`Model ${tag} not found`);
+            }
+            const { _id, envs } = model;
+            await validators_1.UpdateProductModelSchema.validateAsync(data);
+            if (data.tag && (await this.fetchModel(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            if (data.envs) {
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    // Encrypt API key if provided
+                    if (env.apiKey) {
+                        env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                    }
+                    return env;
+                }));
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.forEach((dataEnv) => {
+                    const existsIdx = envs.findIndex((env) => env.slug === dataEnv.slug);
+                    if (existsIdx === -1) {
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[existsIdx]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs.forEach((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, model), data), { component: enums_1.ProductComponents.MODEL, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * Fetch all LLM model configurations
+     * @param version Optional version
+     */
+    async fetchModels(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'model', this.getUserAccess());
+        return components;
+    }
+    /**
+     * Fetch a specific LLM model configuration by tag
+     * @param tag Model tag
+     * @param version Optional version
+     */
+    async fetchModel(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'model', tag, this.getUserAccess());
+        return component;
+    }
+    /**
+     * Delete an LLM model configuration
+     * @param tag Model tag
+     */
+    async deleteModel(tag) {
+        try {
+            const model = await this.fetchModel(tag);
+            if (!model) {
+                throw new Error(`Model with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.MODEL,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async validateAppData(appData, app) {
+        // TODO:
+        const { envs } = app;
+        // const { envs: appEnvs, auths: appAuths } = appData
+        const version = appData.versions.find((data) => (data.latest = true));
+        app.envs = this.validateAppEnvs(envs, version);
+        // await this.validateAppAuth(auth, appData);
+        return app;
+    }
+    validateVariablesSchema(variables, appVariables) {
+        if (variables && variables.length) {
+            variables.map((data) => {
+                const appVar = appVariables.find((value) => value.key === data.key);
+                if (!appVar) {
+                    throw new Error(`variable key: ${data.key} not found`);
+                }
+                // if()
+            });
+        }
+    }
+    validateVariablesValues(variables, appVariables) {
+        if (!variables) {
+            variables = [];
+        }
+        if (appVariables && appVariables.length) {
+            appVariables.map((data) => {
+                const find = variables.find((value) => value.key === data.key);
+                if (data.required) {
+                    if (!find) {
+                        throw new Error(`variable key: ${data.key} is required`);
+                    }
+                }
+                this.inputsService.validateFeatureInputData(find, data);
+            });
+        }
+    }
+    validateAppEnvs(envs, version) {
+        const { envs: appEnvs } = version;
+        return envs.map((env) => {
+            const { auth } = env;
+            this.fetchEnv(env.product_env_slug);
+            const appEnv = appEnvs.find((appEnv) => appEnv.slug === env.app_env_slug);
+            if (!appEnv) {
+                throw new Error(`app_slug ${env.app_env_slug} not found`);
+            }
+            const updates = this.validateAppAuth(auth, version);
+            this.validateVariablesSchema(env.variables, version.variables);
+            this.validateVariablesValues(env.variables, version.variables);
+            if (updates && updates.data) {
+                env.auth.data = updates.data;
+            }
+            if (updates && updates.values) {
+                env.auth.values = updates.values;
+            }
+            return env;
+        });
+    }
+    validateAppAuth(auth, version) {
+        const { auths: appAuth, actions } = version;
+        const exists = appAuth.find((appAuth) => appAuth.tag === auth.auth_tag);
+        if (!exists) {
+            throw new Error(`app_auth ${auth.auth_tag} not found`);
+        }
+        const { data } = auth;
+        let bodySchema;
+        let headerSchema;
+        let paramsSchema;
+        let querySchema;
+        let schema;
+        if (exists.action_tag) {
+            const action = actions.find((action) => action.tag === exists.action_tag);
+            if (!action)
+                throw new Error(`Auth action tag ${exists.action_tag} not found`);
+            schema = action;
+        }
+        else if (exists.tokens) {
+            schema = exists.tokens;
+        }
+        else {
+            throw new Error('Invalid auth, create and use another');
+        }
+        bodySchema = schema.body;
+        headerSchema = schema.headers;
+        paramsSchema = schema.params;
+        querySchema = schema.query;
+        const { body, headers, params, query } = data;
+        if (!body)
+            throw new Error(`Auth body not allowed to be undefined. If empty set as {}`);
+        if (!headers)
+            throw new Error(`Auth headers not allowed to be undefined. If empty set as {}`);
+        if (!params)
+            throw new Error(`Auth params not allowed to be undefined. If empty set as {}`);
+        if (!query)
+            throw new Error(`Auth query not allowed to be undefined. If empty set as {}`);
+        if (bodySchema && bodySchema.data) {
+            const bodyValues = this.inputsService.parseData({
+                data: body,
+                category: enums_1.Categories.SETUP,
+                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
+                type: enums_1.InputsTypes.JSON,
+            });
+            (0, inputs_utils_create_1.validateInputSchema)(bodyValues, bodySchema);
+        }
+        if (headerSchema && headerSchema.data) {
+            const headerValues = this.inputsService.parseData({
                 data: headers,
                 category: enums_1.Categories.SETUP,
                 expected: inputs_types_1.ExpectedValues.PARSEINPUT,
@@ -1437,16 +1940,30 @@ class ProductsBuilderService {
         }
     }
     async fetchApps() {
-        const app = await this.productApi.fetchProductComponents(this.product_id, 'app', this.getUserAccess());
-        return app;
+        return this.product.apps;
     }
     async fetchApp(tag, throwErrorIfExists = false) {
-        const apps = await this.fetchApps();
-        const app = apps.find((data) => data.app_tag === tag || data.access_tag === tag);
+        const app = this.product.apps.find((data) => data.app_tag === tag || data.access_tag === tag);
         if (!app && throwErrorIfExists)
             throw new Error(`App ${tag} not found`);
         return app;
     }
+    async deleteApp(tag) {
+        try {
+            const app = await this.fetchApp(tag, true);
+            if (!app) {
+                throw new Error(`App with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag: app.access_tag,
+                component: enums_1.ProductComponents.APP,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createFunction(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
@@ -1484,7 +2001,7 @@ class ProductsBuilderService {
             }
             const { _id } = func;
             await validators_1.UpdateProductFunctionSchema.validateAsync(data); // Change to update;
-            if (data.tag && await this.fetchFunction(data.tag)) {
+            if (data.tag && (await this.fetchFunction(data.tag))) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, func), data), { component: enums_1.ProductComponents.FUNCTION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
@@ -1493,14 +2010,30 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchFunctions() {
+    async fetchFunctions(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'function', this.getUserAccess());
         return components;
     }
-    async fetchFunction(tag) {
+    async fetchFunction(tag, version) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'function', tag, this.getUserAccess());
         return component;
     }
+    async deleteFunction(tag) {
+        try {
+            const func = await this.fetchFunction(tag);
+            if (!func) {
+                throw new Error(`Function with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.FUNCTION,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createCache(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
@@ -1525,7 +2058,7 @@ class ProductsBuilderService {
             }
             const { _id } = cache;
             await validators_1.UpdateProductCacheSchema.validateAsync(data); // Change to update;
-            if (data.tag && await this.fetchCache(data.tag)) {
+            if (data.tag && (await this.fetchCache(data.tag))) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.ProductComponents.CACHE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
@@ -1534,14 +2067,30 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchCaches() {
+    async fetchCaches(version) {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'cache', this.getUserAccess());
         return components;
     }
-    async fetchCache(tag) {
+    async fetchCache(tag, version) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'cache', tag, this.getUserAccess());
         return component;
     }
+    async deleteCache(tag) {
+        try {
+            const cache = await this.fetchCache(tag);
+            if (!cache) {
+                throw new Error(`Cache with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.CACHE,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createNotification(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
@@ -1565,9 +2114,7 @@ class ProductsBuilderService {
                         callbacks: data.envs[i].callbacks
                             ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].callbacks), this.product.private_key)
                             : undefined,
-                        sms: data.envs[i].sms
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.product.private_key)
-                            : undefined,
+                        sms: data.envs[i].sms ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.product.private_key) : undefined,
                     };
                     data.envs[i] = Object.assign(Object.assign({}, data.envs[i]), updates);
                 }
@@ -1653,14 +2200,14 @@ class ProductsBuilderService {
         return message;
     }
     async fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
-        const notification = await this.fetchNotification(notificationTag); //this.product.notifications.find((data: IProductNotification) => data.tag === notificationTag);
+        const notification = this.product.notifications.find((data) => data.tag === notificationTag);
         if (!notification)
             throw new Error(`Notification ${notificationTag} not found`);
         return notification.messages;
     }
     async updateNotificationMessage(data) {
         try {
-            console.log("NOTIFICATION DATA!!", data);
+            console.log('NOTIFICATION DATA!!', data);
             await update_productNotificationMessage_validator_1.default.validateAsync(data);
             if (!data.tag) {
                 throw new Error('tag field is required');
@@ -1770,48 +2317,32 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    async fetchNotifications() {
-        let components = await this.productApi.fetchProductComponents(this.product_id, 'notification', this.getUserAccess());
-        const notifications = components.map((notification) => {
-            return notification.envs.map((data) => {
-                if (data.callbacks && typeof data.callbacks == 'string') {
-                    data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.product.private_key));
-                }
-                if (data.push_notifications && typeof data.push_notifications == 'string') {
-                    data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.product.private_key));
-                }
-                if (data.emails && typeof data.emails == 'string') {
-                    data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.product.private_key));
-                }
-                if (data.sms && typeof data.sms == 'string') {
-                    data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.product.private_key));
-                }
-                return data;
-            });
-        });
-        return notifications;
+    async fetchNotifications(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'notification', this.getUserAccess());
+        return components;
     }
-    async fetchNotification(tag) {
+    async fetchNotification(tag, version) {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'notification', tag, this.getUserAccess());
-        component.envs.map((data) => {
-            if (data.callbacks && typeof data.callbacks == 'string') {
-                data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.product.private_key));
-            }
-            if (data.push_notifications && typeof data.push_notifications == 'string') {
-                data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.product.private_key));
-            }
-            if (data.emails && typeof data.emails == 'string') {
-                data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.product.private_key));
-            }
-            if (data.sms && typeof data.sms == 'string') {
-                data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.product.private_key));
-            }
-            return data;
-        });
         return component;
     }
-    validateFeatureSequence(array) {
-        // Validate uniqueness of sequence_tag
+    async deleteNotification(tag) {
+        try {
+            const notification = await this.fetchNotification(tag);
+            if (!notification) {
+                throw new Error(`Notification with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.NOTIFICATION,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    validateFeatureSequence(array) {
+        // Validate uniqueness of sequence_tag
         const uniqueTags = new Set();
         for (const item of array) {
             if (uniqueTags.has(item.tag)) {
@@ -1908,7 +2439,7 @@ class ProductsBuilderService {
         await this.validateActionDataInput(data, action, event.input, event_index, sequence_index);
     }
     async checkAndValidateFunctionDataInput(data, sequence_index, event, event_index) {
-        const func = await this.fetchFunction(event.event);
+        const func = (await this.fetchFunction(event.event));
         await this.validateActionDataInput(data, func, event.input, event_index, sequence_index);
     }
     async checkAndValidateDBActionDataInput(data, sequence_index, event, event_index) {
@@ -1959,9 +2490,6 @@ class ProductsBuilderService {
         if (job.type === productsBuilder_types_1.JobEventTypes.PUBLISH) {
             await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
         }
-        if (job.type === productsBuilder_types_1.JobEventTypes.FUNCTION) {
-            await this.checkAndValidateFunctionDataInput(data, sequence_index, event, event_index);
-        }
     }
     async checkAndValidateFallbackDataInput(data, sequence_index, event, event_index) { }
     async validateEvent(data, sequence_index, event, event_index) {
@@ -2203,7 +2731,7 @@ class ProductsBuilderService {
                 throw new Error(`option event index ${optionIndex}, ${data.type} should not be ${obj}`);
             }
         }
-        if (sequence && (Object.values(obj).length > 0 && ((_b = data.sample.data) === null || _b === void 0 ? void 0 : _b.length) === 0)) {
+        if (sequence && Object.values(obj).length > 0 && ((_b = data.sample.data) === null || _b === void 0 ? void 0 : _b.length) === 0) {
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should be an empty object`);
             }
@@ -2456,7 +2984,7 @@ class ProductsBuilderService {
                     }
                     const decrypted = JSON.parse((0, processor_utils_1.decrypt)(env.auth.values, this.product.private_key));
                     // Convert stages to string[] for findFaultyKeys
-                    const stringStages = stages.slice(1).map(stage => String(stage));
+                    const stringStages = stages.slice(1).map((stage) => String(stage));
                     const check = (0, objects_utils_1.findFaultyKeys)(stringStages, decrypted);
                     if (check.faultyKeys) {
                         throw new Error(`Auth Key(s) ${check.faultyKeys.join(', ')} is/are invalid, they do not exist in authorization for ${env.product_env_slug} on app ${access_tag}`);
@@ -2847,6 +3375,22 @@ class ProductsBuilderService {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'feature', tag, this.getUserAccess());
         return component;
     }
+    async deleteFeature(tag) {
+        try {
+            const feature = await this.fetchFeature(tag);
+            if (!feature) {
+                throw new Error(`Feature with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.FEATURE,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createDatabase(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
@@ -2936,21 +3480,42 @@ class ProductsBuilderService {
     }
     async fetchDatabases() {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'database', this.getUserAccess());
-        components.map((database) => {
-            database.envs.map((env) => {
-                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+        const decryptedComponents = components.map((component) => {
+            const dbComponent = component;
+            const decryptedEnvs = dbComponent.envs.map((env) => {
+                return Object.assign(Object.assign({}, env), { connection_url: (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key) });
             });
+            return Object.assign(Object.assign({}, dbComponent), { envs: decryptedEnvs });
         });
-        return components;
+        return decryptedComponents;
     }
     async fetchDatabase(tag) {
-        const database = await this.productApi.fetchProductComponentByTag(this.product_id, 'database', tag, this.getUserAccess());
-        database.envs.map((env) => {
-            env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
-        });
-        return database;
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'database', tag, this.getUserAccess());
+        if (component) {
+            const decryptedEnvs = component.envs.map((env) => {
+                return Object.assign(Object.assign({}, env), { connection_url: (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key) });
+            });
+            return Object.assign(Object.assign({}, component), { envs: decryptedEnvs });
+        }
+        return component;
     }
-    // ==================== GRAPH DATABASE METHODS ====================
+    async deleteDatabase(tag) {
+        try {
+            const database = await this.fetchDatabase(tag);
+            if (!database) {
+                throw new Error(`Database with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.DATABASE,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // GRAPH CRUD METHODS
     async createGraph(data, throwErrorIfExists = false) {
         try {
             if (!(await this.fetchGraph(data.tag))) {
@@ -2991,47 +3556,45 @@ class ProductsBuilderService {
             }
             const { _id, envs } = graph;
             await validators_1.UpdateProductGraphSchema.validateAsync(data);
-            if (data.tag && (await this.fetchGraph(data.tag))) {
-                throw new Error(`tag ${data.tag} is in use`);
+            if (data.tag && this.fetchGraph(data.tag)) {
+                throw new Error(`tag ${tag} is in use`);
             }
-            if (data.envs) {
-                data.envs = await Promise.all(data.envs.map(async (env) => {
-                    const exists = await this.fetchEnv(env.slug);
-                    if (!exists) {
-                        throw new Error(`Env ${env.slug} does not exist`);
-                    }
-                    if (env.connection_url) {
-                        env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
-                    }
-                    return env;
-                }));
-                const overwrite = [];
-                const newEnvs = [];
-                data.envs.map((dataEnv) => {
-                    const existsIndex = envs.findIndex((env) => env.slug === dataEnv.slug);
-                    if (!(this.fetchEnv(dataEnv.slug))) {
-                        throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
-                    }
-                    if (existsIndex === -1) {
-                        if (!dataEnv.connection_url) {
-                            throw new Error(`connection_url is required for new env ${dataEnv.slug}`);
-                        }
-                        newEnvs.push(dataEnv);
-                    }
-                    else {
-                        overwrite.push(Object.assign(Object.assign({}, envs[existsIndex]), dataEnv));
-                    }
-                });
-                const unchanged = [];
-                envs.map((env) => {
-                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
-                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
-                    if (!newEnv && !overwriteEnv) {
-                        unchanged.push(env);
+            data.envs = await Promise.all(data.envs.map(async (env) => {
+                const exists = await this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                if (env.connection_url) {
+                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                }
+                return env;
+            }));
+            const overwrite = [];
+            const newEnvs = [];
+            data.envs.map((dataEnv) => {
+                const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
+                if (!this.fetchEnv(dataEnv.slug)) {
+                    throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                }
+                if (exists === -1) {
+                    if (!dataEnv.connection_url) {
+                        throw new Error(`connection_url is required for new env ${data.envs[exists].slug}`);
                     }
-                });
-                data.envs = [...unchanged, ...overwrite, ...newEnvs];
-            }
+                    newEnvs.push(dataEnv);
+                }
+                else {
+                    overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
+                }
+            });
+            const unchanged = [];
+            envs.map((env) => {
+                const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                if (!newEnv && !overwriteEnv) {
+                    unchanged.push(env);
+                }
+            });
+            data.envs = [...unchanged, ...overwrite, ...newEnvs];
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.GRAPH, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
         }
         catch (e) {
@@ -3040,126 +3603,129 @@ class ProductsBuilderService {
     }
     async fetchGraphs() {
         const components = await this.productApi.fetchProductComponents(this.product_id, 'graph', this.getUserAccess());
-        components.map((graph) => {
-            graph.envs.map((env) => {
-                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
-            });
-        });
         return components;
     }
     async fetchGraph(tag) {
-        const graph = await this.productApi.fetchProductComponentByTag(this.product_id, 'graph', tag, this.getUserAccess());
-        if (graph && graph.envs) {
-            graph.envs.map((env) => {
-                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
-            });
-        }
-        return graph;
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'graph', tag, this.getUserAccess());
+        return component;
     }
-    // ==================== GRAPH ACTION METHODS ====================
-    async createGraphAction(data, throwErrorIfExists = false) {
-        var _a;
+    async deleteGraph(tag) {
         try {
-            if (!data.tag) {
-                throw new Error('tag field is required');
-            }
-            const [graphTag, tag] = data.tag.split(':');
-            if (!graphTag || !tag) {
-                throw new Error('tag should be formatted as graph_tag:action_tag');
+            const graph = await this.fetchGraph(tag);
+            if (!graph) {
+                throw new Error(`Graph with tag: ${tag} not found`);
             }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.GRAPH,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // ==================== GRAPH ACTIONS ====================
+    async createGraphAction(graphTag, data) {
+        try {
             const graph = await this.fetchGraph(graphTag);
             if (!graph) {
-                throw new Error(`Graph ${graphTag} not found`);
+                throw new Error(`Graph with tag: ${graphTag} not found`);
+            }
+            // Initialize actions array if it doesn't exist
+            if (!graph.actions) {
+                graph.actions = [];
             }
-            const existingAction = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.find((action) => action.tag === tag);
+            // Check if action already exists
+            const existingAction = graph.actions.find((a) => a.tag === data.tag);
             if (existingAction) {
-                if (throwErrorIfExists) {
-                    throw new Error(`Graph action ${data.tag} already exists`);
-                }
-                return;
+                throw new Error(`Action with tag: ${data.tag} already exists`);
             }
-            // Validate the action data
-            const validationData = Object.assign(Object.assign({}, data), { tag });
-            await create_productGraphAction_validator_1.default.validateAsync(validationData);
-            // Extract placeholders from template
-            const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-            const template = JSON.stringify(data.template);
-            // Process filter template if provided
-            let filterData, filterTemplate;
-            if (data.filterTemplate) {
-                filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                filterTemplate = JSON.stringify(data.filterTemplate);
-            }
-            const actionData = Object.assign(Object.assign({}, data), { tag, data: values, template,
-                filterData,
-                filterTemplate });
-            graph.actions = graph.actions || [];
-            graph.actions.push(actionData);
-            await this.updateGraph(graphTag, { actions: graph.actions });
+            graph.actions.push(data);
+            await this.productApi.updateProduct(this.product_id, {
+                tag: graphTag,
+                actions: graph.actions,
+                component: enums_1.ProductComponents.GRAPH,
+                action: enums_1.RequestAction.UPDATE,
+            }, this.getUserAccess());
         }
-        catch (error) {
-            throw new Error(`Failed to create graph action: ${error.message}`);
+        catch (e) {
+            throw e;
         }
     }
-    async updateGraphAction(data) {
-        var _a;
+    async updateGraphAction(graphTag, actionTag, data) {
         try {
-            if (!data.tag) {
-                throw new Error('tag field is required');
-            }
-            const [graphTag, tag] = data.tag.split(':');
-            if (!graphTag || !tag) {
-                throw new Error('tag should be formatted as graph_tag:action_tag');
-            }
             const graph = await this.fetchGraph(graphTag);
             if (!graph) {
-                throw new Error(`Graph ${graphTag} not found`);
+                throw new Error(`Graph with tag: ${graphTag} not found`);
             }
-            const actionIndex = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.findIndex((action) => action.tag === tag);
-            if (actionIndex === undefined || actionIndex === -1) {
-                throw new Error(`Graph action ${data.tag} not found`);
-            }
-            // Validate the update data
-            const validationData = Object.assign(Object.assign({}, data), { tag });
-            await update_productGraphAction_validator_1.default.validateAsync(validationData);
-            // Process template if provided
-            const updateData = Object.assign(Object.assign({}, data), { tag });
-            if (data.template) {
-                updateData.data = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                updateData.template = JSON.stringify(data.template);
+            if (!graph.actions) {
+                throw new Error(`Action with tag: ${actionTag} not found`);
             }
-            // Process filter template if provided
-            if (data.filterTemplate) {
-                updateData.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                updateData.filterTemplate = JSON.stringify(data.filterTemplate);
+            const actionIndex = graph.actions.findIndex((a) => a.tag === actionTag);
+            if (actionIndex === -1) {
+                throw new Error(`Action with tag: ${actionTag} not found`);
             }
-            graph.actions[actionIndex] = Object.assign(Object.assign({}, graph.actions[actionIndex]), updateData);
-            await this.updateGraph(graphTag, { actions: graph.actions });
+            graph.actions[actionIndex] = Object.assign(Object.assign({}, graph.actions[actionIndex]), data);
+            await this.productApi.updateProduct(this.product_id, {
+                tag: graphTag,
+                actions: graph.actions,
+                component: enums_1.ProductComponents.GRAPH,
+                action: enums_1.RequestAction.UPDATE,
+            }, this.getUserAccess());
         }
-        catch (error) {
-            throw new Error(`Failed to update graph action: ${error.message}`);
+        catch (e) {
+            throw e;
         }
     }
-    async fetchGraphAction(tag, throwErrorIfNotExists = false) {
-        var _a, _b;
-        const [graphTag, actionTag] = tag.split(':');
-        if (!graphTag || !actionTag) {
-            throw new Error('tag is expected to be defined as "graph_tag:action_tag"');
-        }
-        const graph = (_a = this.product.graphs) === null || _a === void 0 ? void 0 : _a.find((data) => data.tag === graphTag);
-        if (!graph)
-            throw new Error(`Graph ${graphTag} not found`);
-        const action = (_b = graph.actions) === null || _b === void 0 ? void 0 : _b.find((data) => data.tag === actionTag);
-        if (!action && throwErrorIfNotExists)
-            throw new Error(`Graph action ${tag} not found`);
-        return action || null;
+    async fetchGraphAction(graphTag, actionTag) {
+        try {
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph || !graph.actions) {
+                return null;
+            }
+            return graph.actions.find((a) => a.tag === actionTag) || null;
+        }
+        catch (e) {
+            throw e;
+        }
     }
     async fetchGraphActions(graphTag) {
-        const graph = await this.fetchGraph(graphTag);
-        if (!graph) {
-            throw new Error(`Graph ${graphTag} not found`);
+        try {
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph with tag: ${graphTag} not found`);
+            }
+            return graph.actions || [];
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async deleteGraphAction(graphTag, actionTag) {
+        try {
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph with tag: ${graphTag} not found`);
+            }
+            if (!graph.actions) {
+                throw new Error(`Action with tag: ${actionTag} not found`);
+            }
+            const actionIndex = graph.actions.findIndex((a) => a.tag === actionTag);
+            if (actionIndex === -1) {
+                throw new Error(`Action with tag: ${actionTag} not found`);
+            }
+            graph.actions.splice(actionIndex, 1);
+            await this.productApi.updateProduct(this.product_id, {
+                tag: graphTag,
+                actions: graph.actions,
+                component: enums_1.ProductComponents.GRAPH,
+                action: enums_1.RequestAction.UPDATE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
         }
-        return graph.actions || [];
     }
     async createDatabaseAction(data, throwErrorIfExists = false) {
         try {
@@ -3173,18 +3739,27 @@ class ProductsBuilderService {
             const exists = await this.fetchDatabaseAction(data.tag);
             data.tag = tag;
             if (!exists) {
-                // Verify database exists
-                await this.fetchDatabase(databaseTag);
-                // Validate the action data using the unified schema
-                const validationData = Object.assign(Object.assign({}, data), { tag });
-                await create_productDatabaseAction_validator_1.default.validateAsync(validationData);
-                // Extract placeholders from the structured template
-                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                const template = JSON.stringify(data.template);
-                // Process filter template if provided (for UPDATE/DELETE actions)
-                if (data.filterTemplate) {
-                    data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                    data.filterTemplate = JSON.stringify(data.filterTemplate);
+                const database = await this.fetchDatabase(databaseTag);
+                let values, template;
+                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
+                    await create_productDatabaseAction_validator_1.NOSQLDatabaseActionsSchema.validateAsync(data);
+                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                    template = JSON.stringify(data.template);
+                    if (data.type === productsBuilder_types_1.DatabaseActionTypes.UPDATE && !data.filterTemplate) {
+                        throw new Error(`filterTemplate is required for ${productsBuilder_types_1.DatabaseActionTypes.UPDATE} actions in ${productsBuilder_types_1.DatabaseTypes.MONGODB}`);
+                    }
+                    if (data.filterTemplate) {
+                        data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                        data.filterTemplate = JSON.stringify(data.filterTemplate);
+                    }
+                }
+                else {
+                    create_productDatabaseAction_validator_1.SQLDatabaseActionSchema.validateAsync(data);
+                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
+                    template = data.template;
+                    if (data.filterTemplate) {
+                        data.filterData = (0, string_utils_1.extractPlaceholders)(String(data.filterTemplate));
+                    }
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { data: values, template,
                     databaseTag, component: enums_1.ProductComponents.DATABASE_ACTION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
@@ -3224,27 +3799,32 @@ class ProductsBuilderService {
             if (!databaseTag || !tag) {
                 throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
             }
-            // Fetch required data (also verifies database exists)
-            await this.fetchDatabase(databaseTag);
+            // Fetch required data
+            const database = await this.fetchDatabase(databaseTag);
             const action = await this.fetchDatabaseAction(data.tag, true);
             // Construct payload
             const payload = Object.assign(Object.assign(Object.assign({}, action), data), { databaseTag, component: enums_1.ProductComponents.DATABASE_ACTION, action: enums_1.RequestAction.UPDATE });
             // Validate and process the template
             data.tag = tag;
-            // Validate using the unified schema
-            const validationData = Object.assign(Object.assign({}, data), { tag });
-            await update_productDatabaseAction_validator_1.default.validateAsync(validationData);
             if (data.template) {
-                // Extract placeholders from the structured template
-                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                const template = JSON.stringify(data.template);
+                let values, template;
+                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
+                    await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
+                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                    template = JSON.stringify(data.template);
+                }
+                else {
+                    await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
+                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
+                    template = data.template;
+                }
                 Object.assign(payload, { data: values, template });
             }
-            // Process filter template if provided
-            if (data.filterTemplate) {
-                const filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                const filterTemplate = JSON.stringify(data.filterTemplate);
-                Object.assign(payload, { filterData, filterTemplate });
+            else if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
+                await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
+            }
+            else {
+                await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
             }
             // Update product and reinitialize
             await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
@@ -3254,7 +3834,7 @@ class ProductsBuilderService {
         }
     }
     async fetchDatabaseActions(databaseTag) {
-        const database = await this.fetchDatabase(databaseTag);
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const actions = database.actions;
@@ -3265,6 +3845,27 @@ class ProductsBuilderService {
         }
         return actions;
     }
+    async deleteDatabaseAction(tag) {
+        try {
+            const [databaseTag, actionTag] = tag.split(':');
+            if (!databaseTag || !actionTag) {
+                throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
+            }
+            const action = await this.fetchDatabaseAction(tag, true);
+            if (!action) {
+                throw new Error(`Database action with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag: actionTag,
+                databaseTag,
+                component: enums_1.ProductComponents.DATABASE_ACTION,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async createDatabaseMigration(data, throwErrorIfExists) {
         if (!data.tag) {
             throw new Error('tag field is required');
@@ -3273,20 +3874,47 @@ class ProductsBuilderService {
         if (!databaseTag || !tag) {
             throw new Error(`tag is expected to be defined as "database_tag:migration_tag"`);
         }
-        const exists = this.fetchDatabaseMigration(data.tag);
+        const exists = await this.fetchDatabaseMigration(data.tag);
         data.tag = tag;
-        await create_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag })); // Change to update;
+        await create_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag }));
         if (!exists) {
             const database = await this.fetchDatabase(databaseTag);
             if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
                 throw new Error(`${database.type} does not support migrations`);
             }
-            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { databaseTag, component: enums_1.ProductComponents.DATABASE_MIGRATION }), this.getUserAccess());
+            // Process migration value - supports both simple strings and rich operations
+            let processedValue = data.value;
+            if (data.value) {
+                processedValue = {
+                    up: this.processMigrationOperations(data.value.up),
+                    down: this.processMigrationOperations(data.value.down),
+                };
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { value: processedValue, databaseTag, component: enums_1.ProductComponents.DATABASE_MIGRATION }), this.getUserAccess());
         }
         else {
             if (throwErrorIfExists)
-                throw new Error(`Database Action ${data.tag} already exists`);
-        }
+                throw new Error(`Database Migration ${data.tag} already exists`);
+        }
+    }
+    /**
+     * Process migration operations - handles both string and object formats
+     * Strings are passed through as-is (raw SQL/CQL)
+     * Objects are serialized for storage and executed by the migration engine
+     */
+    processMigrationOperations(operations) {
+        if (!operations || !Array.isArray(operations))
+            return [];
+        return operations.map((op) => {
+            if (typeof op === 'string') {
+                return op; // Raw SQL/CQL string
+            }
+            // Rich operation object - validate it has required 'type' field
+            if (typeof op === 'object' && op !== null && 'type' in op) {
+                return op;
+            }
+            throw new Error(`Invalid migration operation format. Expected string or object with 'type' field.`);
+        });
     }
     async updateDatabaseMigration(data) {
         if (!data.tag) {
@@ -3296,20 +3924,28 @@ class ProductsBuilderService {
         if (!databaseTag || !tag) {
             throw new Error(`tag is expected to be defined as "database_tag:migration_tag"`);
         }
-        await update_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag })); // Change to update;
-        const action = this.fetchDatabaseMigration(data.tag);
-        if (!action) {
+        await update_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag }));
+        const existing = await this.fetchDatabaseMigration(data.tag);
+        if (!existing) {
             throw new Error(`Migration ${data.tag} not found`);
         }
         data.tag = tag;
-        await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, action), Object.assign(Object.assign({}, data), { databaseTag })), { component: enums_1.ProductComponents.DATABASE_MIGRATION }), this.getUserAccess());
+        // Process migration value if provided - supports both simple strings and rich operations
+        let processedValue = data.value;
+        if (data.value) {
+            processedValue = {
+                up: this.processMigrationOperations(data.value.up),
+                down: this.processMigrationOperations(data.value.down),
+            };
+        }
+        await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, existing), data), { value: processedValue || existing.value, databaseTag, component: enums_1.ProductComponents.DATABASE_MIGRATION }), this.getUserAccess());
     }
     async fetchDatabaseMigration(tag, throwError = false) {
         const [databaseTag, migrationTag] = tag.split(':');
         if (!databaseTag || !migrationTag) {
             throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
         }
-        const database = await this.fetchDatabase(databaseTag); //this.product.databases.find((data: IProductDatabase) => data.tag === databaseTag);
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const migration = database.migrations.find((data) => data.tag === migrationTag);
@@ -3318,12 +3954,125 @@ class ProductsBuilderService {
         return migration;
     }
     async fetchDatabaseMigrations(databaseTag) {
-        const database = await this.fetchDatabase(databaseTag); //this.product.databases.find((data: IProductDatabase) => data.tag === databaseTag);
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const migrations = database.migrations;
         return migrations;
     }
+    async deleteDatabaseMigration(tag) {
+        try {
+            const [databaseTag, migrationTag] = tag.split(':');
+            if (!databaseTag || !migrationTag) {
+                throw new Error(`tag is expected to be defined as "database_tag:migration_tag"`);
+            }
+            const migration = await this.fetchDatabaseMigration(tag, true);
+            if (!migration) {
+                throw new Error(`Database migration with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag: migrationTag,
+                databaseTag,
+                component: enums_1.ProductComponents.DATABASE_MIGRATION,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // ==================== DATABASE TRIGGER CRUD ====================
+    async createDatabaseTrigger(data, throwErrorIfExists = false) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [databaseTag, triggerTag] = data.tag.split(':');
+            if (!databaseTag || !triggerTag) {
+                throw new Error(`tag is expected to be defined as "database_tag:trigger_tag"`);
+            }
+            const exists = await this.fetchDatabaseTrigger(data.tag);
+            if (exists) {
+                if (throwErrorIfExists) {
+                    throw new Error(`Database trigger with tag: ${data.tag} already exists`);
+                }
+                return;
+            }
+            const database = await this.fetchDatabase(databaseTag);
+            if (!database) {
+                throw new Error(`Database ${databaseTag} not found`);
+            }
+            // Initialize triggers array if not present
+            if (!database.triggers) {
+                database.triggers = [];
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { tag: triggerTag, databaseTag, component: enums_1.ProductComponents.DATABASE_TRIGGER, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateDatabaseTrigger(data) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [databaseTag, triggerTag] = data.tag.split(':');
+            if (!databaseTag || !triggerTag) {
+                throw new Error(`tag is expected to be defined as "database_tag:trigger_tag"`);
+            }
+            const exists = await this.fetchDatabaseTrigger(data.tag, true);
+            if (!exists) {
+                throw new Error(`Database trigger with tag: ${data.tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { tag: triggerTag, databaseTag, component: enums_1.ProductComponents.DATABASE_TRIGGER, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchDatabaseTrigger(tag, throwError = false) {
+        const [databaseTag, triggerTag] = tag.split(':');
+        if (!databaseTag || !triggerTag) {
+            throw new Error(`tag is expected to be defined as "database_tag:trigger_tag"`);
+        }
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const triggers = database.triggers || [];
+        const trigger = triggers.find((data) => data.tag === triggerTag);
+        if (!trigger && throwError)
+            throw new Error(`Database trigger ${tag} not found`);
+        return trigger || null;
+    }
+    async fetchDatabaseTriggers(databaseTag) {
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const triggers = database.triggers || [];
+        return triggers;
+    }
+    async deleteDatabaseTrigger(tag) {
+        try {
+            const [databaseTag, triggerTag] = tag.split(':');
+            if (!databaseTag || !triggerTag) {
+                throw new Error(`tag is expected to be defined as "database_tag:trigger_tag"`);
+            }
+            const trigger = await this.fetchDatabaseTrigger(tag, true);
+            if (!trigger) {
+                throw new Error(`Database trigger with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag: triggerTag,
+                databaseTag,
+                component: enums_1.ProductComponents.DATABASE_TRIGGER,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     async validateJobEvent(data) {
         const { type, app, event } = data;
         if (type === productsBuilder_types_1.JobEventTypes.ACTION) {
@@ -3343,12 +4092,6 @@ class ProductsBuilderService {
                 throw new Error(`Database action ${event} not found`);
             }
         }
-        if (type === productsBuilder_types_1.JobEventTypes.FUNCTION) {
-            const found = await this.fetchFunction(event);
-            if (!found) {
-                throw new Error(`Cloud function ${event} not found`);
-            }
-        }
         if (type === productsBuilder_types_1.JobEventTypes.STORAGE) {
             const found = await this.fetchStorage(event);
             if (!found) {
@@ -3405,7 +4148,7 @@ class ProductsBuilderService {
     }
     async updateJob(tag, data) {
         try {
-            const job = await this.fetchJob(tag);
+            const job = this.fetchJob(tag);
             if (!job) {
                 throw new Error(`Job ${tag} not found`);
             }
@@ -3428,6 +4171,99 @@ class ProductsBuilderService {
         const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'job', tag, this.getUserAccess());
         return component;
     }
+    async deleteJob(tag) {
+        try {
+            const job = await this.fetchJob(tag);
+            if (!job) {
+                throw new Error(`Job with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.JOB,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // ==================== WORKFLOW CRUD METHODS ====================
+    async createWorkflow(data, throwErrorIfExists = false) {
+        try {
+            if (!(await this.fetchWorkflow(data.tag))) {
+                // Validate required fields
+                if (!data.name || !data.tag) {
+                    throw new Error('Workflow requires name and tag');
+                }
+                // Validate envs if provided
+                if (data.envs && data.envs.length > 0) {
+                    for (const env of data.envs) {
+                        const exists = await this.fetchEnv(env.slug);
+                        if (!exists) {
+                            throw new Error(`Env ${env.slug} does not exist`);
+                        }
+                    }
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.WORKFLOW, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Workflow ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateWorkflow(tag, data) {
+        try {
+            const workflow = await this.fetchWorkflow(tag);
+            if (!workflow) {
+                throw new Error(`Workflow ${tag} not found`);
+            }
+            const { _id } = workflow;
+            if (data.tag && data.tag !== tag && (await this.fetchWorkflow(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            // Validate envs if provided
+            if (data.envs && data.envs.length > 0) {
+                for (const env of data.envs) {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                }
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.WORKFLOW, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchWorkflows() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'workflow', this.getUserAccess());
+        return components;
+    }
+    async fetchWorkflow(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'workflow', tag, this.getUserAccess());
+        return component;
+    }
+    async deleteWorkflow(tag) {
+        try {
+            const workflow = await this.fetchWorkflow(tag);
+            if (!workflow) {
+                throw new Error(`Workflow with tag: ${tag} not found`);
+            }
+            await this.productApi.updateProduct(this.product_id, {
+                tag,
+                component: enums_1.ProductComponents.WORKFLOW,
+                action: enums_1.RequestAction.DELETE,
+            }, this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
     getUserAccess() {
         return {
             user_id: this.user_id,