@ductape/sdk 0.0.4-v6 → 0.0.4-v60

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

@@ -36,17 +36,20 @@ 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 secrets_1 = require("../../secrets");
 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 objects_utils_2 = require("../../apps/utils/objects.utils");
 const webhooksApi_service_1 = require("../../api/services/webhooksApi.service");
 class ProductsBuilderService {
-    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client, queues, access_key }) {
+        this.workspace_private_key = null;
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
         this.token = token;
+        this.access_key = access_key || null;
         this.userApi = new userApi_service_1.UserApiService(env_type, redis_client);
         this.productApi = new productsApi_service_1.ProductsApiService(env_type, redis_client);
         this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type, redis_client);
@@ -54,6 +57,150 @@ class ProductsBuilderService {
         this.appApi = new appApi_service_1.AppApiService(env_type, redis_client);
         this.inputsService = new inputs_service_1.default();
         this.thirdPartyApps = [];
+        if (redis_client) {
+            this.redisClient = redis_client;
+            // Start healthcheck workers automatically
+            //this.startHealthcheckWorkers();
+        }
+        if (queues) {
+            this.queues = queues;
+        }
+    }
+    fetchPrivateKey() {
+        return this.product.private_key;
+    }
+    fetchWorkspaceId() {
+        return this.product.workspace_id;
+    }
+    fetchProductId() {
+        return this.product._id;
+    }
+    async createHealthcheck(data) {
+        try {
+            await validators_1.CreateProductHealthcheckSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const exists = await this.fetchHealthcheck(data.app, data.tag);
+            if (!exists) {
+                const { app: access_tag, event: action } = data;
+                const app = await this.fetchThirdPartyAppByAccessTag(access_tag);
+                const version = app.versions.find((data) => data.tag === app.version);
+                if (!version) {
+                    throw new Error(`Version ${app.version} not found`);
+                }
+                const event = version.actions.find((act) => act.tag === action);
+                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`);
+                    }
+                    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);
+                    return env;
+                }));
+                const envs = await this.fetchEnvs();
+                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);
+                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,
+                        action: data.event,
+                        input: env.input,
+                        env: env.slug,
+                        product: this.product.tag,
+                        retries: data.retries,
+                    };
+                    const jobId = `healthcheck-${data.tag}`;
+                    const job = await this.queues.health.getJob(jobId);
+                    if (job) {
+                        await job.remove();
+                    }
+                    await this.queues.health.add(jobId, payload, { jobId, repeat: { every: data.interval } });
+                });
+            }
+        }
+        catch (e) {
+            console.log(e);
+            throw e;
+        }
+    }
+    async updateHealthcheck(tag, data) {
+        try {
+            // 1. Fetch the existing healthcheck
+            const healthcheck = await this.fetchHealthcheck(data.app, tag);
+            if (!healthcheck) {
+                throw new Error(`Healthcheck with tag: ${tag} not found`);
+            }
+            // 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))) {
+                throw new Error(`Healthcheck with tag ${data.tag} already exists`);
+            }
+            // 4. Validate and process envs
+            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`);
+                    }
+                    // Validate input if present
+                    if (env.input) {
+                        const app = await this.fetchThirdPartyAppByAccessTag(data.app);
+                        const version = app.versions.find((v) => v.tag === app.version);
+                        if (!version) {
+                            throw new Error(`Version ${app.version} not found`);
+                        }
+                        const event = version.actions.find((act) => act.tag === data.event);
+                        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);
+                    }
+                    return env;
+                }));
+            }
+            // 5. Ensure all product envs are covered
+            const envs = await this.fetchEnvs();
+            envs.map((env) => {
+                var _a;
+                const exists = (_a = data.envs) === null || _a === void 0 ? void 0 : _a.findIndex((dbEnv) => dbEnv.slug === env.slug);
+                if (exists === -1) {
+                    throw new Error(`Product env ${env.slug} is not defined, please provide details`);
+                }
+            });
+            // 6. Update the healthcheck
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, healthcheck), data), { tag, component: enums_1.ProductComponents.HEALTHCHECK, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchHealthcheck(access_tag, tag, throwError = false) {
+        const healthchecks = await this.productApi.fetchProductComponents(this.product_id, 'healthcheck', this.getUserAccess());
+        const health = healthchecks.find((data) => data.tag === tag && data.app === access_tag);
+        if (!health && throwError)
+            throw new Error(`Healthcheck ${tag} not found`);
+        return health || null;
+    }
+    async fetchHealthchecks(access_tag, throwError = false) {
+        const healthchecks = await this.productApi.fetchProductComponents(this.product_id, 'healthcheck', this.getUserAccess());
+        const health = healthchecks.filter((data) => data.app === access_tag);
+        if (!health && throwError)
+            throw new Error(`Access tag ${access_tag} not found`);
+        return health;
+    }
+    async fetchProductHealthchecks() {
+        const healthchecks = await this.productApi.fetchProductComponents(this.product_id, 'healthcheck', this.getUserAccess());
+        return healthchecks;
     }
     async updateDataValidation(selector, update) {
         if (!selector.startsWith('$Data{') && !selector.startsWith('$Filter')) {
@@ -68,26 +215,27 @@ class ProductsBuilderService {
         if (stages.length < 3) {
             throw new Error(`Invalid selector ${selector}`);
         }
-        const tag = stages[0];
-        const type = stages[1];
+        const tag = String(stages[0]);
+        const type = String(stages[1]);
         let size = 2;
         let data;
         switch (type) {
             case productsBuilder_types_1.FeatureEventTypes.DB_ACTION:
-                const action = this.fetchDatabaseAction(tag);
+                const action = await this.fetchDatabaseAction(tag);
                 if (!action)
                     throw new Error(`DB Action ${tag} not found`);
                 data = useData ? action.data : action.filterData;
                 break;
             case productsBuilder_types_1.FeatureEventTypes.NOTIFICATION:
                 size = 3;
-                if (!stages[3] || (stages[3] !== 'push' && stages[3] !== 'callback' && stages[3] !== 'email')) {
-                    throw new Error(`Invalid value ${stages[3]} in ${selector}, expected to be "push", "callback" or "email" in notification`);
+                const stage3Str = String(stages[3]);
+                if (!stages[3] || (stage3Str !== 'push' && stage3Str !== 'callback' && stage3Str !== 'email')) {
+                    throw new Error(`Invalid value ${stage3Str} in ${selector}, expected to be "push", "callback" or "email" in notification`);
                 }
-                const notification = this.fetchNotificationMessage(tag);
+                const notification = await this.fetchNotificationMessage(tag);
                 if (!notification)
                     throw new Error(`Notification ${tag} not found`);
-                if (stages[3] === 'push') {
+                if (stage3Str === 'push') {
                     data = notification.push_notification_data;
                 }
                 if (stages[3] === 'callback') {
@@ -129,11 +277,11 @@ class ProductsBuilderService {
             await validators_1.CreateProductBuilderSchema.validateAsync(data);
             const exists = await this.checkIfProductExists(data.name);
             if (exists && (exists === null || exists === void 0 ? void 0 : exists._id)) {
-                await this.initializeProduct(exists === null || exists === void 0 ? void 0 : exists._id);
+                // await this.initializeProduct(exists?._id);
             }
             else {
                 const product = await this.createNewProduct(data);
-                await this.initializeProduct(product._id);
+                // await this.initializeProduct(product._id);
             }
         }
         catch (e) {
@@ -144,10 +292,26 @@ class ProductsBuilderService {
         if (!this.workspace) {
             this.workspace = await this.workspaceApi.fetchWorkspaceById(this.getUserAccess(), subCheck);
         }
+        // Fetch workspace private key using the dedicated endpoint for secrets encryption
+        if (!this.workspace_private_key && this.access_key) {
+            try {
+                this.workspace_private_key = await this.workspaceApi.fetchPrivateKey(this.getUserAccess(), this.access_key);
+            }
+            catch (e) {
+                console.warn('[ProductsBuilderService] Failed to fetch workspace private key:', e);
+            }
+        }
+    }
+    /**
+     * Get the workspace private key for secrets encryption
+     * @returns The workspace private key or null if not available
+     */
+    getWorkspacePrivateKey() {
+        return this.workspace_private_key;
     }
     async initializeProduct(product_id) {
         try {
-            this.product = await this.productApi.fetchProduct(product_id, this.getUserAccess());
+            this.product = (await this.productApi.initProduct(product_id, this.getUserAccess()));
             this.product_id = product_id;
         }
         catch (e) {
@@ -156,20 +320,64 @@ class ProductsBuilderService {
     }
     async initializeProductByTag(tag) {
         try {
-            this.product = await this.productApi.fetchProductByTag(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`);
+            }
             this.product_id = this.product._id;
         }
         catch (e) {
             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)
                 throw new Error('Product not initialized');
             await validators_1.CreateProductBuilderSchema.validateAsync(data);
             await this.productApi.updateProduct(this.product_id, Object.assign({}, data), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
@@ -186,11 +394,11 @@ class ProductsBuilderService {
             return false;
         }
     }
-    fetchProduct() {
+    async fetchProduct() {
         if (!this.product) {
             throw new Error('Product not yet initiated');
         }
-        return this.product;
+        return await this.productApi.fetchProductByTag(this.product.tag, this.getUserAccess());
     }
     async createSession(data, throwErrorIfExists = false) {
         try {
@@ -198,10 +406,10 @@ class ProductsBuilderService {
             if (!data.tag) {
                 throw new Error('tag field is required');
             }
-            const exists = this.fetchSession(data.tag);
+            const exists = await this.fetchSession(data.tag);
             if (!exists) {
-                if (!data.selector.startsWith('$Schema{')) {
-                    throw new Error('Selector should be in the format $Schema{...}{key}');
+                if (!data.selector.startsWith('$Session{')) {
+                    throw new Error('Selector should be in the format $Session{...}{key}');
                 }
                 const stages = (0, string_utils_1.extractStages)(data.selector);
                 let current = data.schema;
@@ -213,20 +421,16 @@ 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;
-                delete data.tag;
                 const payload = Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE });
-                await this.appApi.updateApp(this.app_id, payload, this.getUserAccess());
-                await this.initializeProduct(this.product_id);
+                await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
             }
             else {
                 if (throwErrorIfExists)
@@ -239,7 +443,7 @@ class ProductsBuilderService {
     }
     async updateSession(tag, data) {
         try {
-            const session = this.fetchSession(tag);
+            const session = await this.fetchSession(tag);
             if (!session) {
                 throw new Error(`Session with tag: ${tag} not found`);
             }
@@ -272,25 +476,39 @@ 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());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchSession(tag) {
-        var _a;
-        return (_a = this.product.sessions) === null || _a === void 0 ? void 0 : _a.find((auth) => auth.tag === tag);
+    async fetchSessions(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'session', this.getUserAccess());
+        return components;
+    }
+    async fetchSession(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'session', tag, this.getUserAccess());
+        return component;
     }
-    fetchSessions() {
-        return this.product.sessions;
+    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 {
@@ -304,16 +522,17 @@ class ProductsBuilderService {
             if (data.sample)
                 data.sample = JSON.stringify(data.sample);
             await create_productMessageBrokerTopic_validator_1.default.validateAsync(data);
-            const exists = this.fetchMessageBrokerTopic(data.tag);
-            const broker = this.fetchMessageBroker(messageBrokerTag);
-            (0, functions_utils_1.validateAWSSQSQueueUrl)(broker.envs, data.queueUrls);
+            const exists = await this.fetchMessageBrokerTopic(data.tag);
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (broker) {
+                (0, functions_utils_1.validateAWSSQSQueueUrl)(broker.envs, data.queueUrls);
+            }
             data.tag = tag;
             if (!exists) {
                 if (data.sample) {
                     data.data = (await (0, string_utils_1.extractPlaceholders)(data.sample));
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_TOPIC, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -336,12 +555,12 @@ class ProductsBuilderService {
             if (!messageBrokerTag || !tag) {
                 throw new Error(`tag is expected to be defined as "messageBrokr_tag:topic_tag"`);
             }
-            const exists = this.fetchMessageBrokerTopic(data.tag);
+            const exists = await this.fetchMessageBrokerTopic(data.tag);
             if (!exists) {
                 throw new Error(`Topic ${data.tag} not found`);
             }
-            const broker = this.fetchMessageBroker(messageBrokerTag);
-            if (data.queueUrls) {
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (data.queueUrls && broker) {
                 (0, functions_utils_1.validateAWSSQSQueueUrl)(broker.envs, data.queueUrls);
             }
             data.tag = tag;
@@ -350,7 +569,6 @@ class ProductsBuilderService {
                     data.data = (await (0, string_utils_1.extractPlaceholders)(data.sample));
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_TOPIC, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 throw new Error(`Message Broker Topic ${data.tag} not found`);
@@ -360,7 +578,7 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchMessageBrokerTopic(tag, throwErrorIfExists = false) {
+    async fetchMessageBrokerTopic(tag, throwErrorIfExists = false) {
         const [messageBrokerTag, topicTag] = tag.split(':');
         if (!messageBrokerTag || !topicTag) {
             throw new Error(`tag is expected to be defined as "messageBroker_tag:topic_tag"`);
@@ -373,12 +591,140 @@ class ProductsBuilderService {
             throw new Error(`MessageBroker topic ${tag} not found`);
         return topic;
     }
-    fetchMessageBrokerTopics(messageBrokerTag) {
+    async fetchMessageBrokerTopics(messageBrokerTag) {
         const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
         if (!messageBroker)
             throw new Error(`Message Broker ${messageBrokerTag} not found`);
         return messageBroker.topics;
     }
+    // ==================== MESSAGE BROKER PRODUCERS ====================
+    async createMessageBrokerProducer(data) {
+        var _a, _b;
+        try {
+            const [messageBrokerTag, topicTag] = data.topic.split(':');
+            if (!messageBrokerTag || !topicTag) {
+                throw new Error(`topic is expected to be defined as "messageBroker_tag:topic_tag"`);
+            }
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${messageBrokerTag} not found`);
+            }
+            // Check if topic exists
+            const topic = (_a = broker.topics) === null || _a === void 0 ? void 0 : _a.find((t) => t.tag === topicTag);
+            if (!topic) {
+                throw new Error(`Topic ${topicTag} not found in broker ${messageBrokerTag}`);
+            }
+            // Check if producer already exists
+            const existingProducer = (_b = broker.producers) === null || _b === void 0 ? void 0 : _b.find((p) => p.tag === data.tag);
+            if (existingProducer) {
+                throw new Error(`Producer ${data.tag} already exists in broker ${messageBrokerTag}`);
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_PRODUCER, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateMessageBrokerProducer(data) {
+        var _a;
+        try {
+            const [messageBrokerTag, topicTag] = data.topic.split(':');
+            if (!messageBrokerTag || !topicTag) {
+                throw new Error(`topic is expected to be defined as "messageBroker_tag:topic_tag"`);
+            }
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${messageBrokerTag} not found`);
+            }
+            // Check if producer exists
+            const existingProducer = (_a = broker.producers) === null || _a === void 0 ? void 0 : _a.find((p) => p.tag === data.tag);
+            if (!existingProducer) {
+                throw new Error(`Producer ${data.tag} not found in broker ${messageBrokerTag}`);
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_PRODUCER, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchMessageBrokerProducer(brokerTag, tag) {
+        var _a;
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === brokerTag);
+        if (!messageBroker)
+            throw new Error(`MessageBroker ${brokerTag} not found`);
+        const producer = (_a = messageBroker.producers) === null || _a === void 0 ? void 0 : _a.find((p) => p.tag === tag);
+        return producer || null;
+    }
+    async fetchMessageBrokerProducers(messageBrokerTag) {
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
+        if (!messageBroker)
+            throw new Error(`Message Broker ${messageBrokerTag} not found`);
+        return messageBroker.producers || [];
+    }
+    // ==================== MESSAGE BROKER CONSUMERS ====================
+    async createMessageBrokerConsumer(data) {
+        var _a, _b;
+        try {
+            const [messageBrokerTag, topicTag] = data.topic.split(':');
+            if (!messageBrokerTag || !topicTag) {
+                throw new Error(`topic is expected to be defined as "messageBroker_tag:topic_tag"`);
+            }
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${messageBrokerTag} not found`);
+            }
+            // Check if topic exists
+            const topic = (_a = broker.topics) === null || _a === void 0 ? void 0 : _a.find((t) => t.tag === topicTag);
+            if (!topic) {
+                throw new Error(`Topic ${topicTag} not found in broker ${messageBrokerTag}`);
+            }
+            // Check if consumer already exists
+            const existingConsumer = (_b = broker.consumers) === null || _b === void 0 ? void 0 : _b.find((c) => c.tag === data.tag);
+            if (existingConsumer) {
+                throw new Error(`Consumer ${data.tag} already exists in broker ${messageBrokerTag}`);
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_CONSUMER, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateMessageBrokerConsumer(data) {
+        var _a;
+        try {
+            const [messageBrokerTag, topicTag] = data.topic.split(':');
+            if (!messageBrokerTag || !topicTag) {
+                throw new Error(`topic is expected to be defined as "messageBroker_tag:topic_tag"`);
+            }
+            const broker = await this.fetchMessageBroker(messageBrokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${messageBrokerTag} not found`);
+            }
+            // Check if consumer exists
+            const existingConsumer = (_a = broker.consumers) === null || _a === void 0 ? void 0 : _a.find((c) => c.tag === data.tag);
+            if (!existingConsumer) {
+                throw new Error(`Consumer ${data.tag} not found in broker ${messageBrokerTag}`);
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { messageBrokerTag, component: enums_1.ProductComponents.MESSAGEBROKER_CONSUMER, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchMessageBrokerConsumer(brokerTag, tag) {
+        var _a;
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === brokerTag);
+        if (!messageBroker)
+            throw new Error(`MessageBroker ${brokerTag} not found`);
+        const consumer = (_a = messageBroker.consumers) === null || _a === void 0 ? void 0 : _a.find((c) => c.tag === tag);
+        return consumer || null;
+    }
+    async fetchMessageBrokerConsumers(messageBrokerTag) {
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
+        if (!messageBroker)
+            throw new Error(`Message Broker ${messageBrokerTag} not found`);
+        return messageBroker.consumers || [];
+    }
     async validateQuotaFallbackInputAndOutput(data, type) {
         const input = data.input;
         await Promise.all(data.options.map(async (d, index) => {
@@ -411,7 +757,7 @@ class ProductsBuilderService {
             this.checkActionQuotaFallbackInput(action.body, option.input.body, input, 'body');
         }
         else {
-            const feature = this.fetchFeature(option.event);
+            const feature = await this.fetchFeature(option.event);
             if (!feature) {
                 throw new Error(`Feature ${option.event} not found`);
             }
@@ -501,7 +847,7 @@ class ProductsBuilderService {
         }
         else {
             // fetch feature
-            const feature = this.fetchFeature(option.event);
+            const feature = await this.fetchFeature(option.event);
             if (!feature) {
                 throw new Error(`Feature ${option.event} not found`);
             }
@@ -569,7 +915,7 @@ class ProductsBuilderService {
             if (!data.tag) {
                 throw new Error('tag field is required');
             }
-            if (!this.fetchQuota(data.tag)) {
+            if (!(await this.fetchQuota(data.tag))) {
                 await validators_1.CreateProductQuotaSchema.validateAsync(data);
                 await this.validateQuotaFallbackInputAndOutput(data, 'quota');
                 data.total_quota = 0;
@@ -594,7 +940,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');
                             }
                         }
@@ -612,7 +961,7 @@ class ProductsBuilderService {
     }
     async updateQuota(tag, data) {
         try {
-            const quota = this.fetchQuota(tag);
+            const quota = await this.fetchQuota(tag);
             if (quota) {
                 await validators_1.UpdateProductQuotaSchema.validateAsync(data);
                 if (data.options) {
@@ -640,7 +989,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');
                                 }
                             }
@@ -660,18 +1012,36 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchQuota(tag) {
-        return this.fetchQuotas().find((data) => data.tag === tag);
+    async fetchQuotas(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'quota', this.getUserAccess());
+        return components;
     }
-    fetchQuotas() {
-        return this.product.quota;
+    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) {
                 throw new Error('tag field is required');
             }
-            if (!this.fetchFallback(data.tag)) {
+            if (!(await this.fetchFallback(data.tag))) {
                 await validators_1.CreateProductFallbackSchema.validateAsync(data);
                 await this.validateQuotaFallbackInputAndOutput(data, 'fallback');
                 await Promise.all(data.options.map(async (d) => {
@@ -693,7 +1063,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');
                             }
                         }
@@ -711,7 +1084,7 @@ class ProductsBuilderService {
     }
     async updateFallback(tag, data) {
         try {
-            const fallback = this.fetchFallback(tag);
+            const fallback = await this.fetchFallback(tag);
             if (fallback) {
                 await validators_1.UpdateProductFallbackSchema.validateAsync(data);
                 if (data.options) {
@@ -736,7 +1109,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');
                                 }
                             }
@@ -756,19 +1132,36 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchFallback(tag) {
-        return this.fetchFallbacks().find((data) => data.tag === tag);
+    async fetchFallbacks(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'fallback', this.getUserAccess());
+        return components;
+    }
+    async fetchFallback(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'fallback', tag, this.getUserAccess());
+        return component;
     }
-    fetchFallbacks() {
-        return this.product.fallback;
+    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
-            if (!this.fetchEnv(data.slug)) {
+            if (!(await this.fetchEnv(data.slug))) {
                 await validators_1.CreateProductEnvSchema.validateAsync(data);
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.ENV, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -781,137 +1174,221 @@ class ProductsBuilderService {
     }
     async updateEnv(slug, data) {
         try {
-            const env = this.fetchEnv(slug, true);
+            const env = await this.fetchEnv(slug);
             if (!env) {
                 throw new Error(`Env ${slug} not found`);
             }
             const { _id } = env;
             await validators_1.UpdateProductEnvSchema.validateAsync(data); // Change to update;
-            if (data.slug && this.fetchEnv(data.slug)) {
+            if (data.slug && (await this.fetchEnv(data.slug))) {
                 throw new Error(`slug ${slug} is in use`); // TODO: also check on the backend
             }
             if (!data.slug) {
                 data.slug = slug;
             }
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, env), data)), { component: enums_1.ProductComponents.ENV, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchEnvs() {
-        return this.product.envs;
+    async fetchEnvs(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'env', this.getUserAccess());
+        return components;
     }
-    fetchEnv(slug, throwErrorIfExists = false) {
-        const env = this.product.envs.find((data) => data.slug === slug);
-        if (!env && throwErrorIfExists)
-            throw new Error(`Env ${slug} not found`);
-        return env;
+    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 (!this.fetchMessageBroker(data.tag, false)) {
+        var _a;
+        const logPrefix = '[MessageBroker:Create]';
+        console.log(`${logPrefix} Starting creation for broker: ${data.tag}`);
+        console.log(`${logPrefix} Broker name: ${data.name}`);
+        console.log(`${logPrefix} Broker description: ${data.description || 'N/A'}`);
+        console.log(`${logPrefix} Number of environments: ${((_a = data.envs) === null || _a === void 0 ? void 0 : _a.length) || 0}`);
+        const existingBroker = await this.fetchMessageBroker(data.tag);
+        if (!existingBroker) {
+            console.log(`${logPrefix} Broker ${data.tag} does not exist, proceeding with creation`);
+            console.log(`${logPrefix} Validating schema...`);
             await validators_1.CreateMessageBrokerSchema.validateAsync(data);
-            data.envs = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            console.log(`${logPrefix} Schema validation passed`);
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                console.log(`${logPrefix} Processing env: ${env.slug} (type: ${env.type})`);
+                const exists = await this.fetchEnv(env.slug);
                 if (!exists) {
+                    console.error(`${logPrefix} Env ${env.slug} does not exist`);
                     throw new Error(`Env ${env.slug} does not exist`);
                 }
-                env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
-                return env;
-            });
-            const envs = this.fetchEnvs();
-            envs.map((env) => {
+                console.log(`${logPrefix} Env ${env.slug} exists, verified`);
+                // Store sensitive credentials as secrets
+                console.log(`${logPrefix} Processing secrets for env: ${env.slug}...`);
+                env.config = await this.processMessageBrokerConfigSecrets(env.config, env.type, data.tag, env.slug);
+                console.log(`${logPrefix} Secrets processed for env: ${env.slug}`);
+                console.log(`${logPrefix} Encrypting config for env: ${env.slug}...`);
+                env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
+                console.log(`${logPrefix} Config encrypted for env: ${env.slug}`);
+                processedEnvs.push(env);
+            }
+            data.envs = processedEnvs;
+            console.log(`${logPrefix} All environments processed: ${processedEnvs.length}`);
+            const envs = await this.fetchEnvs();
+            console.log(`${logPrefix} Product has ${envs.length} environments defined`);
+            for (const env of envs) {
                 const exists = data.envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
                 if (exists === -1) {
+                    console.error(`${logPrefix} Product env ${env.slug} is not defined in broker config`);
                     throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
                 }
-            });
+            }
+            console.log(`${logPrefix} All product environments have broker configs`);
+            console.log(`${logPrefix} Sending create request to API...`);
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.MESSAGEBROKER, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
+            console.log(`${logPrefix} Message broker ${data.tag} created successfully`);
         }
         else {
+            console.log(`${logPrefix} Broker ${data.tag} already exists`);
             if (throwErrorIfExists)
                 throw new Error(`Message Broker ${data.tag} already exists`);
         }
     }
     async updateMessageBroker(tag, data) {
+        var _a, _b;
+        const logPrefix = '[MessageBroker:Update]';
+        console.log(`${logPrefix} Starting update for broker: ${tag}`);
+        console.log(`${logPrefix} New tag (if changed): ${data.tag || 'unchanged'}`);
+        console.log(`${logPrefix} New name: ${data.name || 'unchanged'}`);
+        console.log(`${logPrefix} Number of environments in update: ${((_a = data.envs) === null || _a === void 0 ? void 0 : _a.length) || 0}`);
         try {
-            const messageBroker = this.fetchMessageBroker(tag);
+            console.log(`${logPrefix} Fetching existing broker: ${tag}`);
+            const messageBroker = await this.fetchMessageBroker(tag);
             if (!messageBroker) {
+                console.error(`${logPrefix} Broker ${tag} not found`);
                 throw new Error(`Broker ${tag} not found`);
             }
+            console.log(`${logPrefix} Existing broker found with ${((_b = messageBroker.envs) === null || _b === void 0 ? void 0 : _b.length) || 0} environments`);
             const { _id, envs } = messageBroker;
-            await validators_1.UpdateMessageBrokerSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchMessageBroker(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            console.log('2', data.envs);
-            data.envs = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            console.log(`${logPrefix} Broker ID: ${_id}`);
+            console.log(`${logPrefix} Validating update schema...`);
+            await validators_1.UpdateMessageBrokerSchema.validateAsync(data);
+            console.log(`${logPrefix} Schema validation passed`);
+            if (data.tag && (await this.fetchMessageBroker(data.tag))) {
+                console.error(`${logPrefix} Tag ${data.tag} is already in use`);
+                throw new Error(`tag ${tag} is in use`);
+            }
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                console.log(`${logPrefix} Processing env: ${env.slug} (type: ${env.type})`);
+                const exists = await this.fetchEnv(env.slug);
                 if (!exists) {
+                    console.error(`${logPrefix} Env ${env.slug} does not exist`);
                     throw new Error(`Env ${env.slug} does not exist`);
                 }
-                if (env.config)
-                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
-                return env;
-            });
+                console.log(`${logPrefix} Env ${env.slug} exists, verified`);
+                if (env.config) {
+                    // Store sensitive credentials as secrets
+                    console.log(`${logPrefix} Processing secrets for env: ${env.slug}...`);
+                    env.config = await this.processMessageBrokerConfigSecrets(env.config, env.type, data.tag || tag, env.slug);
+                    console.log(`${logPrefix} Secrets processed for env: ${env.slug}`);
+                    console.log(`${logPrefix} Encrypting config for env: ${env.slug}...`);
+                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
+                    console.log(`${logPrefix} Config encrypted for env: ${env.slug}`);
+                }
+                else {
+                    console.log(`${logPrefix} No config provided for env: ${env.slug}, skipping secrets processing`);
+                }
+                processedEnvs.push(env);
+            }
+            data.envs = processedEnvs;
+            console.log(`${logPrefix} All environments processed: ${processedEnvs.length}`);
             const overwrite = [];
             const newEnvs = [];
-            data.envs.map((dataEnv) => {
+            for (const dataEnv of data.envs) {
                 const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
-                if (!this.fetchEnv(dataEnv.slug)) {
+                if (!(await this.fetchEnv(dataEnv.slug))) {
+                    console.error(`${logPrefix} Product Environment ${dataEnv.slug} doesn't exist`);
                     throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
                 }
                 if (exists === -1) {
+                    console.log(`${logPrefix} Env ${dataEnv.slug} is a NEW environment`);
                     if (!dataEnv.config) {
+                        console.error(`${logPrefix} Config is required for new env ${dataEnv.slug}`);
                         throw new Error(`config is required for new env ${data.envs[exists].slug}`);
                     }
                     newEnvs.push(dataEnv);
                 }
                 else {
+                    console.log(`${logPrefix} Env ${dataEnv.slug} will OVERWRITE existing config`);
                     if (envs[exists].config) {
-                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.fetchProduct().private_key);
+                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.product.private_key);
                     }
                     overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
                 }
-            });
+            }
             const unchanged = [];
-            envs.map((env) => {
+            for (const env of envs) {
                 const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
                 const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
                 if (!newEnv && !overwriteEnv) {
+                    console.log(`${logPrefix} Env ${env.slug} is UNCHANGED`);
                     if (env.config) {
-                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
+                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
                     }
                     unchanged.push(env);
                 }
-            });
+            }
             data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            console.log(`${logPrefix} Final env breakdown - Unchanged: ${unchanged.length}, Overwrite: ${overwrite.length}, New: ${newEnvs.length}`);
+            console.log(`${logPrefix} Sending update request to API...`);
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, messageBroker), data), { component: enums_1.ProductComponents.MESSAGEBROKER, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
+            console.log(`${logPrefix} Message broker ${tag} updated successfully`);
         }
         catch (e) {
+            console.error(`${logPrefix} Update failed:`, e);
             throw e;
         }
     }
-    fetchMessageBroker(tag, throwErrorIfExists = false) {
-        const messageBroker = this.product.messageBrokers.find((data) => data.tag === tag);
-        if (!messageBroker && throwErrorIfExists)
-            throw new Error(`Message Broker ${tag} not found`);
-        if (messageBroker) {
-            messageBroker.envs.map((broker) => {
-                if (typeof broker.config === 'string') {
-                    broker.config = JSON.parse((0, processor_utils_1.decrypt)(String(broker.config), this.fetchProduct().private_key));
-                }
-            });
-        }
-        return messageBroker;
+    async fetchMessageBrokers(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'message_broker', this.getUserAccess());
+        return components;
     }
-    fetchMessageBrokers() {
-        return this.product.messageBrokers.map((broker) => {
-            return this.fetchMessageBroker(broker.tag);
-        });
+    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;
+        }
     }
     async fetchStorageFiles(filter) {
         try {
@@ -927,14 +1404,31 @@ class ProductsBuilderService {
             });
         }
         catch (e) {
-            throw (e);
+            throw e;
+        }
+    }
+    async fetchSessionUsers(filter) {
+        try {
+            const result = await this.productApi.fetchProductSessionUsers(Object.assign(Object.assign({}, filter), { product: this.product.tag }), this.getUserAccess());
+            if (!result)
+                return [];
+            return result.map((res) => {
+                delete res._id;
+                delete res.workspace_id;
+                delete res.__v;
+                return res;
+            });
+        }
+        catch (e) {
+            throw e;
         }
     }
     async createStorage(data, throwErrorIfExists = false) {
-        if (!this.fetchStorage(data.tag, false)) {
+        if (!(await this.fetchStorage(data.tag))) {
             await create_productStorage_validator_1.CreateProductStorageSchema.validateAsync(data);
-            data.envs = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            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`);
                 }
@@ -942,18 +1436,20 @@ class ProductsBuilderService {
                     // @ts-ignore
                     //env.config.config.private_key = gcpPKCSConvert(env.config.config.private_key)
                 }
-                env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
-                return env;
-            });
-            const envs = this.fetchEnvs();
-            envs.map((env) => {
+                // Store sensitive credentials as secrets
+                env.config = await this.processStorageConfigSecrets(env.config, env.type, data.tag, env.slug);
+                env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), 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((dbEnv) => dbEnv.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.STORAGE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         else {
             if (throwErrorIfExists)
@@ -962,7 +1458,7 @@ class ProductsBuilderService {
     }
     async updateStorage(tag, data) {
         try {
-            const storage = this.fetchStorage(tag);
+            const storage = await this.fetchStorage(tag);
             if (!storage) {
                 throw new Error(`Storage ${tag} not found`);
             }
@@ -971,8 +1467,8 @@ class ProductsBuilderService {
             if (data.tag && this.fetchStorage(data.tag)) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
-            data.envs = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            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`);
                 }
@@ -980,10 +1476,13 @@ class ProductsBuilderService {
                     // @ts-ignore
                     //env.config.config.private_key = gcpPKCSConvert(env.config.config.private_key)
                 }
-                if (env.config)
-                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
+                if (env.config) {
+                    // Store sensitive credentials as secrets
+                    env.config = await this.processStorageConfigSecrets(env.config, env.type, data.tag || tag, env.slug);
+                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
+                }
                 return env;
-            });
+            }));
             const overwrite = [];
             const newEnvs = [];
             data.envs.map((dataEnv) => {
@@ -999,7 +1498,7 @@ class ProductsBuilderService {
                 }
                 else {
                     if (envs[exists].config) {
-                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.fetchProduct().private_key);
+                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.product.private_key);
                     }
                     overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
                 }
@@ -1010,60 +1509,531 @@ class ProductsBuilderService {
                 const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
                 if (!newEnv && !overwriteEnv) {
                     if (env.config) {
-                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
+                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
                     }
                     unchanged.push(env);
                 }
             });
             data.envs = [...unchanged, ...overwrite, ...newEnvs];
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, storage), data), { component: enums_1.ProductComponents.STORAGE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchStorage(tag, throwErrorIfExists = false) {
-        const storage = this.product.storage.find((data) => data.tag === tag);
-        if (!storage && throwErrorIfExists)
-            throw new Error(`Storage ${tag} not found`);
-        if (storage) {
-            storage.envs.map((store) => {
-                if (typeof store.config === 'string') {
-                    store.config = JSON.parse((0, processor_utils_1.decrypt)(String(store.config), this.fetchProduct().private_key));
-                }
-            });
-        }
-        return storage;
-    }
-    fetchStorages() {
-        return this.product.storage.map((storage) => {
-            return this.fetchStorage(storage.tag);
-        });
+    async fetchStorages(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'storage', this.getUserAccess());
+        return components;
     }
-    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());
+        }
+        catch (e) {
+            throw e;
         }
     }
-    validateVariablesValues(variables, appVariables) {
-        if (appVariables && appVariables.length) {
-            appVariables.map((data) => {
+    // ==================== 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) {
+        var _a, _b, _c, _d;
+        console.log('[ProductsService.createVector] Starting vector creation:', {
+            tag: data.tag,
+            name: data.name,
+            type: data.type,
+            envsCount: (_a = data.envs) === null || _a === void 0 ? void 0 : _a.length,
+            productTag: (_b = this.product) === null || _b === void 0 ? void 0 : _b.tag,
+        });
+        if (!(await this.fetchVector(data.tag))) {
+            await validators_1.CreateProductVectorSchema.validateAsync(data);
+            const processedEnvs = [];
+            for (const env of data.envs) {
+                console.log('[ProductsService.createVector] Processing env:', {
+                    slug: env.slug,
+                    hasApiKey: !!env.apiKey,
+                    hasEndpoint: !!env.endpoint,
+                });
+                const exists = await this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                // Store API key as secret and encrypt
+                if (env.apiKey) {
+                    console.log('[ProductsService.createVector] Converting API key to secret for env:', env.slug);
+                    const originalApiKey = env.apiKey;
+                    env.apiKey = await this.storeVectorApiKeyAsSecret(env.apiKey, data.tag, env.slug);
+                    console.log('[ProductsService.createVector] API key after secret conversion:', {
+                        wasConverted: originalApiKey !== env.apiKey,
+                        isSecretRef: (_c = env.apiKey) === null || _c === void 0 ? void 0 : _c.startsWith('$Secret{'),
+                    });
+                    env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                    console.log('[ProductsService.createVector] API key encrypted');
+                }
+                // Store endpoint as secret and encrypt
+                if (env.endpoint) {
+                    console.log('[ProductsService.createVector] Converting endpoint to secret for env:', env.slug);
+                    const originalEndpoint = env.endpoint;
+                    env.endpoint = await this.storeVectorEndpointAsSecret(env.endpoint, data.tag, env.slug);
+                    console.log('[ProductsService.createVector] Endpoint after secret conversion:', {
+                        wasConverted: originalEndpoint !== env.endpoint,
+                        isSecretRef: (_d = env.endpoint) === null || _d === void 0 ? void 0 : _d.startsWith('$Secret{'),
+                    });
+                    env.endpoint = (0, processor_utils_1.encrypt)(env.endpoint, this.product.private_key);
+                    console.log('[ProductsService.createVector] Endpoint encrypted');
+                }
+                processedEnvs.push(env);
+                console.log('[ProductsService.createVector] Env processed successfully:', env.slug);
+            }
+            data.envs = processedEnvs;
+            console.log('[ProductsService.createVector] All envs processed, total:', processedEnvs.length);
+            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`);
+        }
+    }
+    /**
+     * Update an existing vector database configuration
+     * @param tag Vector config tag
+     * @param data Updated vector configuration
+     */
+    async updateVector(tag, data) {
+        var _a, _b;
+        console.log('[ProductsService.updateVector] Starting vector update:', {
+            tag,
+            newTag: data.tag,
+            name: data.name,
+            envsCount: (_a = data.envs) === null || _a === void 0 ? void 0 : _a.length,
+            productTag: (_b = this.product) === null || _b === void 0 ? void 0 : _b.tag,
+        });
+        try {
+            const vector = await this.fetchVector(tag);
+            if (!vector) {
+                throw new Error(`Vector ${tag} not found`);
+            }
+            const { _id, envs } = vector;
+            console.log('[ProductsService.updateVector] Found existing vector:', {
+                _id,
+                existingEnvsCount: envs === null || envs === void 0 ? void 0 : envs.length,
+            });
+            await validators_1.UpdateProductVectorSchema.validateAsync(data);
+            if (data.tag && (await this.fetchVector(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            if (data.envs) {
+                console.log('[ProductsService.updateVector] Processing envs update');
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    var _a, _b;
+                    console.log('[ProductsService.updateVector] Processing env:', {
+                        slug: env.slug,
+                        hasApiKey: !!env.apiKey,
+                        hasEndpoint: !!env.endpoint,
+                    });
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    // Store API key as secret and encrypt
+                    if (env.apiKey) {
+                        console.log('[ProductsService.updateVector] Converting API key to secret for env:', env.slug);
+                        const originalApiKey = env.apiKey;
+                        env.apiKey = await this.storeVectorApiKeyAsSecret(env.apiKey, data.tag || tag, env.slug);
+                        console.log('[ProductsService.updateVector] API key after secret conversion:', {
+                            wasConverted: originalApiKey !== env.apiKey,
+                            isSecretRef: (_a = env.apiKey) === null || _a === void 0 ? void 0 : _a.startsWith('$Secret{'),
+                        });
+                        env.apiKey = (0, processor_utils_1.encrypt)(env.apiKey, this.product.private_key);
+                        console.log('[ProductsService.updateVector] API key encrypted');
+                    }
+                    // Store endpoint as secret and encrypt
+                    if (env.endpoint) {
+                        console.log('[ProductsService.updateVector] Converting endpoint to secret for env:', env.slug);
+                        const originalEndpoint = env.endpoint;
+                        env.endpoint = await this.storeVectorEndpointAsSecret(env.endpoint, data.tag || tag, env.slug);
+                        console.log('[ProductsService.updateVector] Endpoint after secret conversion:', {
+                            wasConverted: originalEndpoint !== env.endpoint,
+                            isSecretRef: (_b = env.endpoint) === null || _b === void 0 ? void 0 : _b.startsWith('$Secret{'),
+                        });
+                        env.endpoint = (0, processor_utils_1.encrypt)(env.endpoint, this.product.private_key);
+                        console.log('[ProductsService.updateVector] Endpoint encrypted');
+                    }
+                    console.log('[ProductsService.updateVector] Env processed successfully:', env.slug);
+                    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 }, vector), data), { component: enums_1.ProductComponents.VECTOR, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * 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());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    // ==================== 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 {
+            if (throwErrorIfExists)
+                throw new Error(`Agent ${data.tag} already exists`);
+        }
+    }
+    /**
+     * 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`);
+                }
+                // Store API key as secret and encrypt
+                if (env.apiKey) {
+                    env.apiKey = await this.storeModelApiKeyAsSecret(env.apiKey, data.tag, env.slug);
+                    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`);
+                    }
+                    // Store API key as secret and encrypt
+                    if (env.apiKey) {
+                        env.apiKey = await this.storeModelApiKeyAsSecret(env.apiKey, data.tag || tag, env.slug);
+                        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) {
@@ -1078,7 +2048,7 @@ class ProductsBuilderService {
         const { envs: appEnvs } = version;
         return envs.map((env) => {
             const { auth } = env;
-            this.fetchEnv(env.product_env_slug, true);
+            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`);
@@ -1168,10 +2138,10 @@ class ProductsBuilderService {
             });
             (0, inputs_utils_create_1.validateInputSchema)(queryValues, querySchema);
         }
-        const updateData = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.fetchProduct().private_key);
+        const updateData = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.product.private_key);
         let updateValues = null;
         if (exists.setup_type === enums_1.AuthTypes.TOKEN) {
-            updateValues = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.fetchProduct().private_key);
+            updateValues = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.product.private_key);
         }
         return { data: updateData, values: updateValues };
     }
@@ -1204,8 +2174,10 @@ class ProductsBuilderService {
                     throw new Error(`App ${app.access_tag} not found`);
                 }
                 const cleanedAppData = await this.validateAppData(appData, app);
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, cleanedAppData), { component: enums_1.ProductComponents.APP, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
+                if (!cleanedAppData.pricing_tag) {
+                    cleanedAppData.pricing_tag = `${appData.tag}:${productsBuilder_types_1.PricingTag.FREE}`;
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, cleanedAppData), { app_tag: appData.tag, component: enums_1.ProductComponents.APP, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
             }
             else {
                 if (throwErrorIfExists)
@@ -1236,7 +2208,7 @@ class ProductsBuilderService {
     }
     async updateApp(access_tag, data) {
         try {
-            const app = this.fetchApp(access_tag);
+            const app = await this.fetchApp(access_tag);
             if (!app) {
                 throw new Error(`App ${access_tag} not found`);
             }
@@ -1252,28 +2224,43 @@ class ProductsBuilderService {
                       throw new Error(`access_tag ${access_tag} is in use`); // TODO: also check on the backend
                   }*/
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { access_tag, component: enums_1.ProductComponents.APP, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchApps() {
+    async fetchApps() {
         return this.product.apps;
     }
-    fetchApp(tag, throwErrorIfExists = false) {
-        const app = this.product.apps.find((data) => data.access_tag === tag);
+    async fetchApp(tag, throwErrorIfExists = false) {
+        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
-            if (!this.fetchFunction(data.tag)) {
+            if (!(await this.fetchFunction(data.tag))) {
                 await validators_1.CreateProductFunctionSchema.validateAsync(data);
                 data.envs.map((env) => {
-                    env.auth = (0, processor_utils_1.encrypt)(JSON.stringify(env.auth), this.fetchProduct().private_key);
+                    env.auth = (0, processor_utils_1.encrypt)(JSON.stringify(env.auth), this.product.private_key);
                 });
                 data.sample_data = (await this.inputsService.parseJson({
                     data: data.sample,
@@ -1286,7 +2273,6 @@ class ProductsBuilderService {
                     category: enums_1.Categories.DATA,
                 }));
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FUNCTION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -1299,37 +2285,51 @@ class ProductsBuilderService {
     }
     async updateFunction(tag, data) {
         try {
-            const func = this.fetchFunction(tag);
+            const func = await this.fetchFunction(tag);
             if (!func) {
                 throw new Error(`Function ${tag} not found`);
             }
             const { _id } = func;
             await validators_1.UpdateProductFunctionSchema.validateAsync(data); // Change to update;
-            if (data.tag && 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());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchFunctions() {
-        return this.product.functions;
+    async fetchFunctions(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'function', this.getUserAccess());
+        return components;
+    }
+    async fetchFunction(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'function', tag, this.getUserAccess());
+        return component;
     }
-    fetchFunction(tag) {
-        const func = this.product.functions.find((data) => data.tag === tag);
-        // if (!func) throw new Error(`Function ${tag} not found`);
-        return func;
+    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
-            if (!this.fetchCache(data.tag)) {
+            if (!(await this.fetchCache(data.tag))) {
                 await validators_1.CreateProductCacheSchema.validateAsync(data);
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.CACHE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -1342,62 +2342,75 @@ class ProductsBuilderService {
     }
     async updateCache(tag, data) {
         try {
-            const cache = this.fetchCache(tag);
+            const cache = await this.fetchCache(tag);
             if (!cache) {
                 throw new Error(`Cache ${tag} not found`);
             }
             const { _id } = cache;
             await validators_1.UpdateProductCacheSchema.validateAsync(data); // Change to update;
-            if (data.tag && 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());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchCache(tag, throwErrorIfExists = false) {
-        const cache = this.product.caches.find((data) => data.tag === tag);
-        if (!cache && throwErrorIfExists)
-            throw new Error(`Cache ${tag} not found`);
-        return cache;
+    async fetchCaches(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'cache', this.getUserAccess());
+        return components;
+    }
+    async fetchCache(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'cache', tag, this.getUserAccess());
+        return component;
     }
-    fetchCaches() {
-        return this.product.caches;
+    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
-            if (!this.fetchNotification(data.tag)) {
+            if (!(await this.fetchNotification(data.tag))) {
                 await validators_1.CreateProductNotificationSchema.validateAsync(data);
-                const envs = this.fetchEnvs();
-                envs.map((env) => {
+                const envs = await this.fetchEnvs();
+                for (const env of envs) {
                     const exists = data.envs.findIndex((nEnv) => nEnv.slug === env.slug);
                     if (exists === -1) {
                         throw new Error(`Notification for environment ${env.slug} is not defined, please provide the environment details`);
                     }
-                });
+                }
                 for (let i = 0; i < data.envs.length; i++) {
+                    // Process secrets for each notification handler
+                    const processedEnv = await this.processNotificationEnvSecrets(data.envs[i], data.tag, data.envs[i].slug);
                     const updates = {
-                        push_notifications: data.envs[i].push_notifications
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].push_notifications), this.fetchProduct().private_key)
+                        push_notifications: processedEnv.push_notifications
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.push_notifications), this.product.private_key)
                             : undefined,
-                        emails: data.envs[i].emails
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].emails), this.fetchProduct().private_key)
+                        emails: processedEnv.emails
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.emails), this.product.private_key)
                             : undefined,
-                        callbacks: data.envs[i].callbacks
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].callbacks), this.fetchProduct().private_key)
-                            : undefined,
-                        sms: data.envs[i].sms
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.fetchProduct().private_key)
+                        callbacks: processedEnv.callbacks
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.callbacks), this.product.private_key)
                             : undefined,
+                        sms: processedEnv.sms ? (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.sms), this.product.private_key) : undefined,
                     };
                     data.envs[i] = Object.assign(Object.assign({}, data.envs[i]), updates);
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.NOTIFICATION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -1418,7 +2431,7 @@ class ProductsBuilderService {
             if (!notificationTag || !tag) {
                 throw new Error(`tag is expected to be defined as "notification_tag:message_tag"`);
             }
-            const exists = this.fetchNotificationMessage(data.tag);
+            const exists = await this.fetchNotificationMessage(data.tag);
             data.tag = tag;
             if (!exists) {
                 if (!data.email && !data.push_notification && !data.callback) {
@@ -1455,7 +2468,6 @@ class ProductsBuilderService {
                     data.sms_data = (0, string_utils_1.extractPlaceholders)(data.sms, '');
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { notificationTag, component: enums_1.ProductComponents.NOTIFICATION_MESSAGE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -1466,12 +2478,12 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchNotificationMessage(tag, throwErrorIfExists = false) {
+    async fetchNotificationMessage(tag, throwErrorIfExists = false) {
         const [notificationTag, messageTag] = tag.split(':');
         if (!notificationTag || !messageTag) {
             throw new Error(`tag is expected to be defined as "notification_tag:message_tag"`);
         }
-        const notification = this.fetchNotification(notificationTag);
+        const notification = await this.fetchNotification(notificationTag);
         if (!notification)
             throw new Error(`Notification ${notificationTag} not found`);
         const message = notification.messages.find((data) => data.tag === messageTag);
@@ -1479,7 +2491,7 @@ class ProductsBuilderService {
             throw new Error(`Notification message ${tag} not found`);
         return message;
     }
-    fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
+    async fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
         const notification = this.product.notifications.find((data) => data.tag === notificationTag);
         if (!notification)
             throw new Error(`Notification ${notificationTag} not found`);
@@ -1487,7 +2499,7 @@ class ProductsBuilderService {
     }
     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');
@@ -1533,7 +2545,6 @@ class ProductsBuilderService {
             const payload = Object.assign(Object.assign(Object.assign({}, message), data), { notificationTag, component: enums_1.ProductComponents.NOTIFICATION_MESSAGE, action: enums_1.RequestAction.UPDATE });
             // Update product and reinitialize
             await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (error) {
             throw error;
@@ -1541,21 +2552,25 @@ class ProductsBuilderService {
     }
     async updateNotification(tag, data) {
         try {
-            const { _id, envs } = this.fetchNotification(tag);
-            if (data.tag && tag !== data.tag && this.fetchNotification(data.tag)) {
+            const notificationResult = await this.fetchNotification(tag);
+            if (!notificationResult) {
+                throw new Error(`Notification with tag ${tag} not found`);
+            }
+            const { _id, envs } = notificationResult;
+            if (data.tag && tag !== data.tag && (await this.fetchNotification(data.tag))) {
                 throw new Error(`Notification of tag ${data.tag} already exists`);
             }
             await validators_1.UpdateProductNotificationSchema.validateAsync(data); // Change to update;
-            let notification = this.fetchNotification(tag);
+            let notification = await this.fetchNotification(tag);
             if (!notification) {
                 throw new Error(`Notification with tag ${tag} not found`);
             }
             if (data.envs) {
                 const overwrite = [];
                 const newEnvs = [];
-                data.envs.map(async (dataEnv) => {
+                for (const dataEnv of data.envs) {
                     const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
-                    if (!this.fetchEnv(dataEnv.slug)) {
+                    if (!(await this.fetchEnv(dataEnv.slug))) {
                         throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
                     }
                     if (exists === -1) {
@@ -1565,70 +2580,61 @@ class ProductsBuilderService {
                     else {
                         overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
                     }
-                });
+                }
                 const unchanged = [];
-                envs.map((env) => {
+                for (const env of envs) {
                     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];
             }
             const update = Object.assign(Object.assign({}, notification), data);
-            update.envs.map((env) => {
-                if (env.emails)
-                    env.emails = (0, processor_utils_1.encrypt)(JSON.stringify(env.emails), this.fetchProduct().private_key);
-                if (env.push_notifications)
-                    env.push_notifications = (0, processor_utils_1.encrypt)(JSON.stringify(env.push_notifications), this.fetchProduct().private_key);
-                if (env.callbacks)
-                    env.callbacks = (0, processor_utils_1.encrypt)(JSON.stringify(env.callbacks), this.fetchProduct().private_key);
-                if (env.sms)
-                    env.sms = (0, processor_utils_1.encrypt)(JSON.stringify(env.sms), this.fetchProduct().private_key);
-                return env;
-            });
+            for (let i = 0; i < update.envs.length; i++) {
+                const env = update.envs[i];
+                // Process secrets for each notification handler
+                const processedEnv = await this.processNotificationEnvSecrets(env, data.tag || tag, env.slug);
+                if (processedEnv.emails)
+                    update.envs[i].emails = (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.emails), this.product.private_key);
+                if (processedEnv.push_notifications)
+                    update.envs[i].push_notifications = (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.push_notifications), this.product.private_key);
+                if (processedEnv.callbacks)
+                    update.envs[i].callbacks = (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.callbacks), this.product.private_key);
+                if (processedEnv.sms)
+                    update.envs[i].sms = (0, processor_utils_1.encrypt)(JSON.stringify(processedEnv.sms), this.product.private_key);
+            }
             const payload = Object.assign(Object.assign({ _id }, update), { component: enums_1.ProductComponents.NOTIFICATION, action: enums_1.RequestAction.UPDATE });
             await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchNotification(tag, notification_slug = '', throwErrorIfExists = false) {
-        const notification = this.product.notifications.find((data) => data.tag === tag);
-        if (notification && throwErrorIfExists)
-            throw new Error(`Notification ${tag} is in use`);
-        /*if (notification_slug) {
-          const { notifications, emails, callbacks } = notification.envs.find(
-            (data: INotificationEnv) => (data.slug = notification_slug),
-          );
-          return { notifications, emails, callbacks };
-        }*/
-        if (notification) {
-            notification.envs.map((data) => {
-                if (data.callbacks && typeof data.callbacks == 'string') {
-                    data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.fetchProduct().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.fetchProduct().private_key));
-                }
-                if (data.emails && typeof data.emails == 'string') {
-                    data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.fetchProduct().private_key));
-                }
-                if (data.sms && typeof data.sms == 'string') {
-                    data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.fetchProduct().private_key));
-                }
-                return data;
-            });
-        }
-        return notification;
+    async fetchNotifications(version) {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'notification', this.getUserAccess());
+        return components;
     }
-    fetchNotifications() {
-        return this.product.notifications.map((notification) => {
-            return this.fetchNotification(notification.tag);
-        });
+    async fetchNotification(tag, version) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'notification', tag, this.getUserAccess());
+        return component;
+    }
+    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
@@ -1728,24 +2734,27 @@ class ProductsBuilderService {
         await this.validateActionDataInput(data, action, event.input, event_index, sequence_index);
     }
     async checkAndValidateFunctionDataInput(data, sequence_index, event, event_index) {
-        const func = 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) {
         console.log('EVENTY', event.event);
-        const { filterData, data: dbData, filterTemplate, template } = this.fetchDatabaseAction(event.event);
+        const { filterData, data: dbData, filterTemplate, template } = await this.fetchDatabaseAction(event.event);
         await this.validateDBActionDataInput(data, { filterData, data: dbData, template, filter: filterTemplate }, event.input, event_index, sequence_index);
     }
     async checkAndValidateFeatureDataInput(data, sequence_index, event, event_index) {
-        const { input } = this.fetchFeature(event.event);
+        const feature = await this.fetchFeature(event.event);
+        if (!feature)
+            throw new Error(`Feature ${event.event} not found`);
+        const { input } = feature;
         await this.validateFeatureDataInput(data, input, event.input, event_index, sequence_index);
     }
     async checkAndValidateNotificationDataInput(data, sequence_index, event, event_index) {
-        const { callback_data: callback, push_notification_data: notification, email_data: email, sms_data: sms, } = this.fetchNotificationMessage(event.event);
+        const { callback_data: callback, push_notification_data: notification, email_data: email, sms_data: sms, } = await this.fetchNotificationMessage(event.event);
         await this.validateNotificationDataInput(data, { callback, notification, email, sms }, event.input, event_index, sequence_index);
     }
     async checkAndValidatePublishDataInput(data, sequence_index, event, event_index) {
-        const topic = this.fetchMessageBrokerTopic(event.event);
+        const topic = await this.fetchMessageBrokerTopic(event.event);
         if (!topic) {
             throw new Error(`Topic ${event.event} not registered`);
         }
@@ -1753,14 +2762,14 @@ class ProductsBuilderService {
         //await this.validatePublishTopicDataInput(data, { data: topicData }, event.input, event_index, sequence_index)
     }
     async checkAndValidateStorageDataInput(data, sequence_index, event, event_index) {
-        const storage = this.fetchStorage(event.event);
+        const storage = await this.fetchStorage(event.event);
         if (!storage) {
             throw new Error(`Storage ${event.event} does not exist`);
         }
         //await this.validateStorageDataInput(data, {}, event.input, event_index, sequence_index);
     }
     async checkAndValidateJobDataInput(data, sequence_index, event, event_index) {
-        const job = this.fetchJob(event.event);
+        const job = await this.fetchJob(event.event);
         if (job.type === productsBuilder_types_1.JobEventTypes.ACTION) {
             await this.checkAndValidateActionDataInput(data, sequence_index, event, event_index);
         }
@@ -1776,9 +2785,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) {
@@ -1800,7 +2806,7 @@ class ProductsBuilderService {
             await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
         }
         /*if (event.type === FeatureEventTypes.SUBSCRIBE) {
-          const topic = this.fetchMessageBrokerTopic(event.event);
+          const topic = await this.fetchMessageBrokerTopic(event.event);
     
           if(!topic) {
             throw new Error(`Topic ${event.event} not registered`);
@@ -2003,7 +3009,7 @@ class ProductsBuilderService {
         });
     }
     async validateActionInputData(data, skipSample = false, option = false, optionIndex = 0) {
-        var _a;
+        var _a, _b;
         const { obj } = data, base_data = __rest(data, ["obj"]);
         if (!data.sample && Object.keys(obj).length === 0) {
             return;
@@ -2011,8 +3017,8 @@ class ProductsBuilderService {
         if (!data.sample) {
             throw new Error('Something unexpected happened in validating action input');
         }
-        const sequence = data.feature.sequence[data.sequence_index];
-        if (obj === undefined || obj === null) {
+        const sequence = data.feature.sequence ? (_a = data.feature) === null || _a === void 0 ? void 0 : _a.sequence[data.sequence_index] : null;
+        if ((obj === undefined || obj === null) && sequence) {
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should not be ${obj}`);
             }
@@ -2020,7 +3026,7 @@ class ProductsBuilderService {
                 throw new Error(`option event index ${optionIndex}, ${data.type} should not be ${obj}`);
             }
         }
-        if (Object.values(obj).length > 0 && ((_a = data.sample.data) === null || _a === void 0 ? void 0 : _a.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`);
             }
@@ -2031,7 +3037,7 @@ class ProductsBuilderService {
         if (Object.values(obj).length === 0 && data.sample.data.length === 0 /*data.sample?.data?.length === 0*/) {
             return;
         }
-        if (Object.values(obj).length === 0 && data.sample.data.length > 0 && !skipSample) {
+        if (sequence && Object.values(obj).length === 0 && data.sample.data.length > 0 && !skipSample) {
             //console.log("validity err: ",obj, data.sample)
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should not be an empty object`);
@@ -2207,7 +3213,9 @@ class ProductsBuilderService {
             let current_input = input;
             for (let i = 0; i < stages.length; i++) {
                 let stage = stages[i];
-                const matches = stage.match(/^\[(\d+)\]$/);
+                // Convert to string for .match() call
+                const stageStr = String(stage);
+                const matches = stageStr.match(/^\[(\d+)\]$/);
                 if (matches && matches.length === 2) {
                     const number = parseInt(matches[1], 10);
                     if (!isNaN(number)) {
@@ -2263,14 +3271,16 @@ class ProductsBuilderService {
             }
             else {
                 //const envs =
-                const app = this.fetchApp(access_tag);
+                const app = await this.fetchApp(access_tag);
                 const { envs } = app;
                 await Promise.all(envs.map((env) => {
                     if (stages[0] !== env.auth.auth_tag) {
                         throw new Error(`Auth ${stages[0]} does not exist on env ${env.product_env_slug} on app ${access_tag}`);
                     }
-                    const decrypted = JSON.parse((0, processor_utils_1.decrypt)(env.auth.values, this.fetchProduct().private_key));
-                    const check = (0, objects_utils_1.findFaultyKeys)(stages.slice(1), decrypted);
+                    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 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}`);
                     }
@@ -2286,7 +3296,9 @@ class ProductsBuilderService {
                 let i = 1;
                 while (i < stages.length) {
                     let stage = stages[i];
-                    const matches = stage.match(/^\[(\d+)\]$/);
+                    // Convert to string for .match() call
+                    const stageStr = String(stage);
+                    const matches = stageStr.match(/^\[(\d+)\]$/);
                     if (matches && matches.length === 2) {
                         const number = parseInt(matches[1], 10);
                         if (!isNaN(number)) {
@@ -2360,11 +3372,15 @@ class ProductsBuilderService {
                 // let current_data;
                 if (i === 0) {
                     // find sequence by tag, see if it exists and its before current sequence
-                    this.validateSequenceInputParents(stage, meta.sequence_index, meta.feature.sequence);
-                    sequence = this.fetchPriorSequence(meta, stage);
+                    // Convert stage to string for function calls
+                    const stageStr = String(stage);
+                    this.validateSequenceInputParents(stageStr, meta.sequence_index, meta.feature.sequence);
+                    sequence = this.fetchPriorSequence(meta, stageStr);
                 }
                 if (i === 1 && sequence) {
-                    event = this.fetchSequenceEvent(sequence, stage);
+                    // Convert stage to string for function calls
+                    const stageStr = String(stage);
+                    event = this.fetchSequenceEvent(sequence, stageStr);
                     if (!event) {
                         throw new Error(`event ${stage} not found in sequence ${sequence.tag}`);
                     }
@@ -2393,7 +3409,9 @@ class ProductsBuilderService {
                 if (i > 1 && response) {
                     let parent_index = 0;
                     let increment = false;
-                    const matches = stage.match(/^\[(\d+)\]$/);
+                    // Convert to string for .match() call
+                    const stageStr = String(stage);
+                    const matches = stageStr.match(/^\[(\d+)\]$/);
                     if (matches && matches.length === 2) {
                         const number = parseInt(matches[1], 10);
                         if (!isNaN(number)) {
@@ -2451,7 +3469,7 @@ class ProductsBuilderService {
             if (stages.length > 2) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}, only two keys is required`);
             }
-            const app = this.fetchApp(stages[0]);
+            const app = await this.fetchApp(String(stages[0]));
             if (!app) {
                 throw new Error(`App ${stages[0]} not found in sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}. `);
             }
@@ -2468,8 +3486,8 @@ class ProductsBuilderService {
             if (stages.length !== 2) {
                 throw new Error(`When using constants you need to specify the constant in the format $Constant{app_tag}{key} instead of ${value}`);
             }
-            const app_tag = stages[0];
-            const key = stages[1];
+            const app_tag = String(stages[0]);
+            const key = String(stages[1]);
             const _c = await this.fetchThirdPartyAppByAccessTag(app_tag), { version } = _c, app = __rest(_c, ["version"]);
             if (!app) {
                 throw new Error(`App ${app_tag} not found in constant ${value}`);
@@ -2559,9 +3577,10 @@ class ProductsBuilderService {
         return found;
     }
     validateActionKeyPlacement(data) {
+        var _a;
         const actionData = data.sample.data;
         const { indexes } = data;
-        const sequence = data.feature.sequence[data.sequence_index];
+        const sequence = data.feature.sequence ? (_a = data.feature) === null || _a === void 0 ? void 0 : _a.sequence[data.sequence_index] : null;
         const datapoint = actionData.find((item) => {
             return (item.parent_key === indexes.parent_key && item.key === data.key && item.level === indexes.level //&&
             //indexes.index === item.index
@@ -2569,7 +3588,12 @@ class ProductsBuilderService {
         });
         if (!datapoint) {
             console.log('VALIDATE', data.key, data.value, actionData, indexes);
-            throw new Error(`Key ${data.key} not found for ${data.type} for sequence ${sequence.tag} event ${sequence.events[data.event_index].event}`);
+            if (sequence) {
+                throw new Error(`Key ${data.key} not found for ${data.type} for sequence ${sequence.tag} event ${sequence.events[data.event_index].event}`);
+            }
+            else {
+                throw new Error(`Key ${data.key} not found`);
+            }
         }
         return datapoint;
     }
@@ -2600,12 +3624,11 @@ class ProductsBuilderService {
     }
     async createFeature(data, throwErrorIfExists = false) {
         try {
-            if (!this.fetchFeature(data.tag, false)) {
+            if (!(await this.fetchFeature(data.tag))) {
                 await validators_1.CreateProductFeatureSchema.validateAsync(data);
                 try {
                     await this.validateFeatureData(data);
                     await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                    await this.initializeProduct(this.product_id);
                 }
                 catch (e) {
                     throw e;
@@ -2622,7 +3645,7 @@ class ProductsBuilderService {
     }
     async updateFeature(tag, data) {
         try {
-            const feature = this.fetchFeature(tag);
+            const feature = await this.fetchFeature(tag);
             if (!feature) {
                 throw new Error(`Feature ${tag} not found`);
             }
@@ -2634,43 +3657,58 @@ class ProductsBuilderService {
             }
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id,
                 tag }, data), { component: enums_1.ProductComponents.FEATURE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchFeature(tag, throwErrorIfExists = true) {
-        const feature = this.product.features.find((data) => data.tag === tag);
-        if (!feature && throwErrorIfExists)
-            throw new Error(`Feature ${tag} not found`);
-        return feature;
+    async fetchFeatures() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'feature', this.getUserAccess());
+        return components;
     }
-    fetchFeatures() {
-        return this.product.features;
+    async fetchFeature(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'feature', tag, this.getUserAccess());
+        return component;
     }
-    async createDatabase(data, throwErrorIfExists = false) {
+    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
-            if (!this.fetchDatabase(data.tag, false)) {
+            if (!(await this.fetchDatabase(data.tag))) {
                 await validators_1.CreateProductDatabaseSchema.validateAsync(data);
-                data.envs = data.envs.map((env) => {
-                    const exists = this.fetchEnv(env.slug);
+                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`);
                     }
-                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.fetchProduct().private_key);
-                    return env;
-                });
-                const envs = this.fetchEnvs();
-                envs.map((env) => {
+                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, 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((dbEnv) => dbEnv.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.DATABASE, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -2683,7 +3721,7 @@ class ProductsBuilderService {
     }
     async updateDatabase(tag, data) {
         try {
-            const db = this.fetchDatabase(tag);
+            const db = await this.fetchDatabase(tag);
             if (!db) {
                 throw new Error(`Database  ${tag} not found`);
             }
@@ -2692,15 +3730,16 @@ class ProductsBuilderService {
             if (data.tag && this.fetchDatabase(data.tag)) {
                 throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
             }
-            data.envs = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            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.fetchProduct().private_key);
+                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) => {
@@ -2729,23 +3768,333 @@ class ProductsBuilderService {
             data.envs = [...unchanged, ...overwrite, ...newEnvs];
             //console.log("UPDATED!!!", JSON.stringify(data.envs))
             await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({ _id }, data), { tag, component: enums_1.ProductComponents.DATABASE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchDatabase(tag, throwErrorIfExists = false) {
-        const database = this.product.databases.find((data) => data.tag === tag);
-        database.envs.map((env) => {
-            env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.fetchProduct().private_key);
+    async fetchDatabases() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'database', this.getUserAccess());
+        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 decryptedComponents;
+    }
+    async fetchDatabase(tag) {
+        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;
+    }
+    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) {
+        var _a, _b, _c;
+        console.log('[ProductsService.createGraph] Starting graph creation:', {
+            tag: data.tag,
+            name: data.name,
+            type: data.type,
+            envsCount: (_a = data.envs) === null || _a === void 0 ? void 0 : _a.length,
+            productTag: (_b = this.product) === null || _b === void 0 ? void 0 : _b.tag,
         });
-        if (!database && throwErrorIfExists)
-            throw new Error(`Database ${tag} not found`);
-        return database;
+        try {
+            if (!(await this.fetchGraph(data.tag))) {
+                await validators_1.CreateProductGraphSchema.validateAsync(data);
+                const processedEnvs = [];
+                for (const env of data.envs) {
+                    console.log('[ProductsService.createGraph] Processing env:', {
+                        slug: env.slug,
+                        hasConnectionUrl: !!env.connection_url,
+                        hasUsername: !!env.username,
+                        hasPassword: !!env.password,
+                    });
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    // Store connection URL as secret
+                    console.log('[ProductsService.createGraph] Converting connection URL to secret for env:', env.slug);
+                    const originalUrl = env.connection_url;
+                    env.connection_url = await this.storeGraphConnectionUrlAsSecret(env.connection_url, data.tag, env.slug);
+                    console.log('[ProductsService.createGraph] Connection URL after secret conversion:', {
+                        wasConverted: originalUrl !== env.connection_url,
+                        isSecretRef: (_c = env.connection_url) === null || _c === void 0 ? void 0 : _c.startsWith('$Secret{'),
+                    });
+                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                    console.log('[ProductsService.createGraph] Connection URL encrypted');
+                    // Encrypt username and password if provided
+                    if (env.username) {
+                        console.log('[ProductsService.createGraph] Encrypting username for env:', env.slug);
+                        env.username = (0, processor_utils_1.encrypt)(env.username, this.product.private_key);
+                    }
+                    if (env.password) {
+                        console.log('[ProductsService.createGraph] Encrypting password for env:', env.slug);
+                        env.password = (0, processor_utils_1.encrypt)(env.password, this.product.private_key);
+                    }
+                    processedEnvs.push(env);
+                    console.log('[ProductsService.createGraph] Env processed successfully:', env.slug);
+                }
+                data.envs = processedEnvs;
+                console.log('[ProductsService.createGraph] All envs processed, total:', processedEnvs.length);
+                const envs = await this.fetchEnvs();
+                for (const env of envs) {
+                    const exists = data.envs.findIndex((graphEnv) => graphEnv.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.GRAPH, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Graph ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateGraph(tag, data) {
+        var _a, _b;
+        console.log('[ProductsService.updateGraph] Starting graph update:', {
+            tag,
+            newTag: data.tag,
+            name: data.name,
+            type: data.type,
+            envsCount: (_a = data.envs) === null || _a === void 0 ? void 0 : _a.length,
+            productTag: (_b = this.product) === null || _b === void 0 ? void 0 : _b.tag,
+        });
+        try {
+            const graph = await this.fetchGraph(tag);
+            if (!graph) {
+                throw new Error(`Graph ${tag} not found`);
+            }
+            const { _id, envs } = graph;
+            console.log('[ProductsService.updateGraph] Found existing graph:', {
+                _id,
+                existingEnvsCount: envs === null || envs === void 0 ? void 0 : envs.length,
+            });
+            await validators_1.UpdateProductGraphSchema.validateAsync(data);
+            if (data.tag && this.fetchGraph(data.tag)) {
+                throw new Error(`tag ${tag} is in use`);
+            }
+            console.log('[ProductsService.updateGraph] Processing envs update');
+            data.envs = await Promise.all(data.envs.map(async (env) => {
+                var _a;
+                console.log('[ProductsService.updateGraph] Processing env:', {
+                    slug: env.slug,
+                    hasConnectionUrl: !!env.connection_url,
+                    hasUsername: !!env.username,
+                    hasPassword: !!env.password,
+                });
+                const exists = await this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                if (env.connection_url) {
+                    // Store connection URL as secret
+                    console.log('[ProductsService.updateGraph] Converting connection URL to secret for env:', env.slug);
+                    const originalUrl = env.connection_url;
+                    env.connection_url = await this.storeGraphConnectionUrlAsSecret(env.connection_url, data.tag || tag, env.slug);
+                    console.log('[ProductsService.updateGraph] Connection URL after secret conversion:', {
+                        wasConverted: originalUrl !== env.connection_url,
+                        isSecretRef: (_a = env.connection_url) === null || _a === void 0 ? void 0 : _a.startsWith('$Secret{'),
+                    });
+                    env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                    console.log('[ProductsService.updateGraph] Connection URL encrypted');
+                }
+                // Encrypt username and password if provided
+                if (env.username) {
+                    console.log('[ProductsService.updateGraph] Encrypting username for env:', env.slug);
+                    env.username = (0, processor_utils_1.encrypt)(env.username, this.product.private_key);
+                }
+                if (env.password) {
+                    console.log('[ProductsService.updateGraph] Encrypting password for env:', env.slug);
+                    env.password = (0, processor_utils_1.encrypt)(env.password, this.product.private_key);
+                }
+                console.log('[ProductsService.updateGraph] Env processed successfully:', env.slug);
+                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}`);
+                    }
+                    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) {
+            throw e;
+        }
+    }
+    async fetchGraphs() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'graph', this.getUserAccess());
+        return components;
     }
-    fetchDatabases() {
-        return this.product.databases;
+    async fetchGraph(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'graph', tag, this.getUserAccess());
+        return component;
+    }
+    async deleteGraph(tag) {
+        try {
+            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 with tag: ${graphTag} not found`);
+            }
+            // Initialize actions array if it doesn't exist
+            if (!graph.actions) {
+                graph.actions = [];
+            }
+            // Check if action already exists
+            const existingAction = graph.actions.find((a) => a.tag === data.tag);
+            if (existingAction) {
+                throw new Error(`Action with tag: ${data.tag} already exists`);
+            }
+            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 (e) {
+            throw e;
+        }
+    }
+    async updateGraphAction(graphTag, actionTag, data) {
+        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[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 (e) {
+            throw e;
+        }
+    }
+    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) {
+        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;
+        }
     }
     async createDatabaseAction(data, throwErrorIfExists = false) {
         try {
@@ -2756,10 +4105,10 @@ class ProductsBuilderService {
             if (!databaseTag || !tag) {
                 throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
             }
-            const exists = this.fetchDatabaseAction(data.tag);
+            const exists = await this.fetchDatabaseAction(data.tag);
             data.tag = tag;
             if (!exists) {
-                const database = this.fetchDatabase(databaseTag);
+                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);
@@ -2783,7 +4132,6 @@ class ProductsBuilderService {
                 }
                 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());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -2794,7 +4142,7 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchDatabaseAction(tag, throwErrorIfExists = false) {
+    async fetchDatabaseAction(tag, throwErrorIfExists = false) {
         const [databaseTag, actionTag] = tag.split(':');
         if (!databaseTag || !actionTag) {
             throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
@@ -2821,7 +4169,7 @@ class ProductsBuilderService {
                 throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
             }
             // Fetch required data
-            const database = await this.fetchDatabase(databaseTag, true);
+            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 });
@@ -2849,13 +4197,12 @@ class ProductsBuilderService {
             }
             // Update product and reinitialize
             await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (error) {
             throw error;
         }
     }
-    fetchDatabaseActions(databaseTag) {
+    async fetchDatabaseActions(databaseTag) {
         const database = this.product.databases.find((data) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
@@ -2867,6 +4214,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');
@@ -2875,22 +4243,48 @@ 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 = this.fetchDatabase(databaseTag, true);
+            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());
-            await this.initializeProduct(this.product_id);
+            // 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) {
             throw new Error('tag field is required');
@@ -2899,16 +4293,23 @@ 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());
-        await this.initializeProduct(this.product_id);
+        // 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());
     }
-    fetchDatabaseMigration(tag, throwError = false) {
+    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"`);
@@ -2921,13 +4322,126 @@ class ProductsBuilderService {
             throw new Error(`Database migration ${tag} not found`);
         return migration;
     }
-    fetchDatabaseMigrations(databaseTag) {
+    async fetchDatabaseMigrations(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) {
@@ -2942,31 +4456,25 @@ class ProductsBuilderService {
             }
         }
         if (type === productsBuilder_types_1.JobEventTypes.DATABASE_ACTION) {
-            const found = this.fetchDatabaseAction(event);
+            const found = await this.fetchDatabaseAction(event);
             if (!found) {
                 throw new Error(`Database action ${event} not found`);
             }
         }
-        if (type === productsBuilder_types_1.JobEventTypes.FUNCTION) {
-            const found = this.fetchFunction(event);
-            if (!found) {
-                throw new Error(`Cloud function ${event} not found`);
-            }
-        }
         if (type === productsBuilder_types_1.JobEventTypes.STORAGE) {
-            const found = this.fetchStorage(event);
+            const found = await this.fetchStorage(event);
             if (!found) {
                 throw new Error(`Storage ${event} not found`);
             }
         }
         if (type === productsBuilder_types_1.JobEventTypes.NOTIFICATION) {
-            const found = this.fetchNotification(event);
+            const found = await this.fetchNotification(event);
             if (!found) {
                 throw new Error(`Notification ${event} not found`);
             }
         }
         if (type === productsBuilder_types_1.JobEventTypes.PUBLISH) {
-            const found = this.fetchMessageBroker(event);
+            const found = await this.fetchMessageBroker(event);
             if (!found) {
                 throw new Error(`Message Broker ${event} not found`);
             }
@@ -2975,7 +4483,7 @@ class ProductsBuilderService {
     async createJob(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchJob(data.tag)) {
+            if (!(await this.fetchJob(data.tag))) {
                 await validators_1.CreateProductJobSchema.validateAsync(data);
                 await this.validateJobEvent(data);
                 if (data.type === productsBuilder_types_1.JobEventTypes.ACTION) {
@@ -2997,7 +4505,6 @@ class ProductsBuilderService {
                     const dbAction = await this.fetchDatabaseAction(data.event);
                 }
                 await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.JOB, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -3020,20 +4527,111 @@ class ProductsBuilderService {
                 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({}, job), data), { component: enums_1.ProductComponents.JOB, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchJob(tag, throwError = false) {
-        const job = this.product.jobs.find((data) => data.tag === tag);
-        if (!job && throwError)
-            throw new Error(`Job ${tag} not found`);
-        return job;
+    async fetchJobs() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'job', this.getUserAccess());
+        return components;
+    }
+    async fetchJob(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'job', tag, this.getUserAccess());
+        return component;
     }
-    fetchJobs() {
-        return this.product.jobs;
+    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 {
@@ -3041,7 +4639,598 @@ class ProductsBuilderService {
             workspace_id: this.workspace_id,
             token: this.token,
             public_key: this.public_key,
+            access_key: this.access_key,
+        };
+    }
+    async fetchSessionUser(ductape_user_id) {
+        return await this.productApi.fetchProductSessionUser(ductape_user_id, this.getUserAccess());
+    }
+    /**
+     * Process storage config to store sensitive credentials as secrets
+     * Format: STORAGE_{PRODUCT}_{STORAGE_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Storage tag: replace "-" with "_"
+     */
+    async processStorageConfigSecrets(config, providerType, storageTag, envSlug) {
+        console.log(`[Storage Secrets] Processing secrets for storage: ${storageTag}, env: ${envSlug}, provider: ${providerType}`);
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            console.log(`[Storage Secrets] No secrets service available, skipping secret storage`);
+            return config;
+        }
+        const generateSecretKey = (keyName) => {
+            const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+            const productParts = this.product.tag.split(':');
+            const productKey = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+            const storageKey = storageTag.replace(/-/g, '_');
+            const key = `STORAGE_${sanitize(productKey)}_${sanitize(storageKey)}_${sanitize(envSlug)}_${sanitize(keyName)}`;
+            console.log(`[Storage Secrets] Generated secret key: ${key}`);
+            return key;
         };
+        const storeAsSecret = async (value, keyName) => {
+            const secretCheck = (0, secrets_1.isSecretReference)(value);
+            if (secretCheck.isSecret) {
+                console.log(`[Storage Secrets] ${keyName} is already a secret reference, skipping`);
+                return value; // Already a secret reference
+            }
+            const secretKey = generateSecretKey(keyName);
+            try {
+                const exists = await secretsService.exists(secretKey);
+                if (exists) {
+                    console.log(`[Storage Secrets] Updating existing secret: ${secretKey}`);
+                    await secretsService.update(secretKey, { value });
+                }
+                else {
+                    console.log(`[Storage Secrets] Creating new secret: ${secretKey}`);
+                    await secretsService.create({
+                        key: secretKey,
+                        value,
+                        description: `Storage ${keyName} for ${storageTag} in ${envSlug}`,
+                        scope: [this.product.tag, storageTag],
+                        envs: [envSlug],
+                    });
+                }
+                console.log(`[Storage Secrets] Successfully stored ${keyName} as secret: $Secret{${secretKey}}`);
+                return `$Secret{${secretKey}}`;
+            }
+            catch (error) {
+                console.warn(`[Storage Secrets] Failed to store storage credential as secret: ${error}`);
+                return value;
+            }
+        };
+        if (providerType === productsBuilder_types_1.StorageProviders.AWS) {
+            console.log(`[Storage Secrets] Processing AWS S3 credentials`);
+            const awsConfig = config;
+            const result = Object.assign(Object.assign({}, awsConfig), { accessKeyId: await storeAsSecret(awsConfig.accessKeyId, 'ACCESS_KEY_ID'), secretAccessKey: await storeAsSecret(awsConfig.secretAccessKey, 'SECRET_ACCESS_KEY') });
+            console.log(`[Storage Secrets] AWS S3 config processed successfully`);
+            return result;
+        }
+        else if (providerType === productsBuilder_types_1.StorageProviders.GCP) {
+            console.log(`[Storage Secrets] Processing GCP credentials`);
+            const gcpConfig = config;
+            if (gcpConfig.config) {
+                const processedConfig = Object.assign({}, gcpConfig.config);
+                // Store private_key_id as secret
+                if (processedConfig.private_key_id) {
+                    processedConfig.private_key_id = await storeAsSecret(processedConfig.private_key_id, 'PRIVATE_KEY_ID');
+                }
+                // Store private_key as secret
+                if (processedConfig.private_key) {
+                    processedConfig.private_key = await storeAsSecret(processedConfig.private_key, 'PRIVATE_KEY');
+                }
+                // Store client_email as secret
+                if (processedConfig.client_email) {
+                    processedConfig.client_email = await storeAsSecret(processedConfig.client_email, 'CLIENT_EMAIL');
+                }
+                // Store client_id as secret
+                if (processedConfig.client_id) {
+                    processedConfig.client_id = await storeAsSecret(processedConfig.client_id, 'CLIENT_ID');
+                }
+                const result = Object.assign(Object.assign({}, gcpConfig), { config: processedConfig });
+                console.log(`[Storage Secrets] GCP config processed successfully`);
+                console.log(`[Storage Secrets] Converted GCP config:`, JSON.stringify(result, null, 2));
+                return result;
+            }
+            console.log(`[Storage Secrets] GCP config has no nested config, skipping`);
+            return gcpConfig;
+        }
+        else if (providerType === productsBuilder_types_1.StorageProviders.AZURE) {
+            console.log(`[Storage Secrets] Processing Azure Blob credentials`);
+            const azureConfig = config;
+            const result = Object.assign(Object.assign({}, azureConfig), { connectionString: await storeAsSecret(azureConfig.connectionString, 'CONNECTION_STRING') });
+            console.log(`[Storage Secrets] Azure Blob config processed successfully`);
+            return result;
+        }
+        console.log(`[Storage Secrets] Unknown provider type: ${providerType}, returning config as-is`);
+        return config;
+    }
+    /**
+     * Process message broker config to store sensitive credentials as secrets
+     * Format: BROKER_{PRODUCT}_{BROKER_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Broker tag: replace "-" with "_"
+     */
+    async processMessageBrokerConfigSecrets(config, brokerType, brokerTag, envSlug) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const logPrefix = '[MessageBroker:Secrets]';
+        console.log(`${logPrefix} Processing secrets for broker: ${brokerTag}, env: ${envSlug}, type: ${brokerType}`);
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            console.log(`${logPrefix} No secrets service available, skipping secret storage`);
+            return config;
+        }
+        console.log(`${logPrefix} Secrets service available`);
+        const generateSecretKey = (keyName) => {
+            const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+            const productParts = this.product.tag.split(':');
+            const productKey = productParts[1] || productParts[0];
+            const brokerKey = brokerTag.replace(/-/g, '_');
+            const key = `BROKER_${sanitize(productKey)}_${sanitize(brokerKey)}_${sanitize(envSlug)}_${sanitize(keyName)}`;
+            console.log(`${logPrefix} Generated secret key: ${key}`);
+            return key;
+        };
+        const storeAsSecret = async (value, keyName) => {
+            console.log(`${logPrefix} Processing field: ${keyName}`);
+            if (!value) {
+                console.log(`${logPrefix} Field ${keyName} is empty, skipping`);
+                return value;
+            }
+            const secretCheck = (0, secrets_1.isSecretReference)(value);
+            if (secretCheck.isSecret) {
+                console.log(`${logPrefix} Field ${keyName} is already a secret reference: ${value}`);
+                return value;
+            }
+            const secretKey = generateSecretKey(keyName);
+            console.log(`${logPrefix} Storing ${keyName} as secret with key: ${secretKey}`);
+            try {
+                const exists = await secretsService.exists(secretKey);
+                console.log(`${logPrefix} Secret ${secretKey} exists: ${exists}`);
+                if (exists) {
+                    console.log(`${logPrefix} Updating existing secret: ${secretKey}`);
+                    await secretsService.update(secretKey, { value });
+                    console.log(`${logPrefix} Secret ${secretKey} updated successfully`);
+                }
+                else {
+                    console.log(`${logPrefix} Creating new secret: ${secretKey}`);
+                    await secretsService.create({
+                        key: secretKey,
+                        value,
+                        description: `Message broker ${keyName} for ${brokerTag} in ${envSlug}`,
+                        scope: [this.product.tag, brokerTag],
+                        envs: [envSlug],
+                    });
+                    console.log(`${logPrefix} Secret ${secretKey} created successfully`);
+                }
+                const secretRef = `$Secret{${secretKey}}`;
+                console.log(`${logPrefix} Field ${keyName} converted to secret reference: ${secretRef}`);
+                return secretRef;
+            }
+            catch (error) {
+                console.error(`${logPrefix} Failed to store ${keyName} as secret:`, error);
+                console.warn(`${logPrefix} Returning original value for ${keyName}`);
+                return value;
+            }
+        };
+        // Handle different broker types - config is passed directly without wrapper
+        console.log(`${logPrefix} Processing broker type: ${brokerType}`);
+        if (brokerType === productsBuilder_types_1.MessageBrokerTypes.REDIS) {
+            console.log(`${logPrefix} Redis config detected`);
+            console.log(`${logPrefix} Redis fields - host: ${config.host}, port: ${config.port}, password: ${config.password ? '[SET]' : '[NOT SET]'}`);
+            if (config.password) {
+                config.password = await storeAsSecret(config.password, 'PASSWORD');
+            }
+        }
+        else if (brokerType === productsBuilder_types_1.MessageBrokerTypes.RABBITMQ) {
+            console.log(`${logPrefix} RabbitMQ config detected`);
+            console.log(`${logPrefix} RabbitMQ fields - url: ${config.url ? '[SET]' : '[NOT SET]'}`);
+            if (config.url) {
+                config.url = await storeAsSecret(config.url, 'URL');
+            }
+        }
+        else if (brokerType === productsBuilder_types_1.MessageBrokerTypes.KAFKA) {
+            console.log(`${logPrefix} Kafka config detected`);
+            console.log(`${logPrefix} Kafka fields - brokers: ${(_a = config.brokers) === null || _a === void 0 ? void 0 : _a.join(', ')}, clientId: ${config.clientId}, ssl: ${config.ssl}`);
+            console.log(`${logPrefix} Kafka SASL - mechanism: ${((_b = config.sasl) === null || _b === void 0 ? void 0 : _b.mechanism) || 'N/A'}, username: ${((_c = config.sasl) === null || _c === void 0 ? void 0 : _c.username) ? '[SET]' : '[NOT SET]'}, password: ${((_d = config.sasl) === null || _d === void 0 ? void 0 : _d.password) ? '[SET]' : '[NOT SET]'}`);
+            if ((_e = config.sasl) === null || _e === void 0 ? void 0 : _e.username) {
+                config.sasl.username = await storeAsSecret(config.sasl.username, 'SASL_USERNAME');
+            }
+            if ((_f = config.sasl) === null || _f === void 0 ? void 0 : _f.password) {
+                config.sasl.password = await storeAsSecret(config.sasl.password, 'SASL_PASSWORD');
+            }
+        }
+        else if (brokerType === productsBuilder_types_1.MessageBrokerTypes.AWS_SQS) {
+            console.log(`${logPrefix} AWS SQS config detected`);
+            console.log(`${logPrefix} AWS SQS fields - region: ${config.region}, accessKeyId: ${config.accessKeyId ? '[SET]' : '[NOT SET]'}, secretAccessKey: ${config.secretAccessKey ? '[SET]' : '[NOT SET]'}`);
+            if (config.accessKeyId) {
+                config.accessKeyId = await storeAsSecret(config.accessKeyId, 'ACCESS_KEY_ID');
+            }
+            if (config.secretAccessKey) {
+                config.secretAccessKey = await storeAsSecret(config.secretAccessKey, 'SECRET_ACCESS_KEY');
+            }
+        }
+        else if (brokerType === productsBuilder_types_1.MessageBrokerTypes.NATS) {
+            console.log(`${logPrefix} NATS config detected`);
+            console.log(`${logPrefix} NATS fields - servers: ${(_g = config.servers) === null || _g === void 0 ? void 0 : _g.join(', ')}, token: ${config.token ? '[SET]' : '[NOT SET]'}, user: ${config.user ? '[SET]' : '[NOT SET]'}, pass: ${config.pass ? '[SET]' : '[NOT SET]'}, tls: ${config.tls}`);
+            if (config.token) {
+                config.token = await storeAsSecret(config.token, 'TOKEN');
+            }
+            if (config.user) {
+                config.user = await storeAsSecret(config.user, 'USER');
+            }
+            if (config.pass) {
+                config.pass = await storeAsSecret(config.pass, 'PASSWORD');
+            }
+        }
+        else if (brokerType === productsBuilder_types_1.MessageBrokerTypes.GOOGLE_PUBSUB) {
+            console.log(`${logPrefix} Google Pub/Sub config detected`);
+            console.log(`${logPrefix} Google Pub/Sub fields - projectId: ${config.projectId}, credentials: ${config.credentials ? '[SET]' : '[NOT SET]'}`);
+            if (config.credentials) {
+                console.log(`${logPrefix} Google Pub/Sub credentials - type: ${config.credentials.type}, project_id: ${config.credentials.project_id}`);
+                console.log(`${logPrefix} Google Pub/Sub credentials - private_key_id: ${config.credentials.private_key_id ? '[SET]' : '[NOT SET]'}, private_key: ${config.credentials.private_key ? '[SET]' : '[NOT SET]'}`);
+                console.log(`${logPrefix} Google Pub/Sub credentials - client_email: ${config.credentials.client_email ? '[SET]' : '[NOT SET]'}, client_id: ${config.credentials.client_id ? '[SET]' : '[NOT SET]'}`);
+                if (config.credentials.private_key_id) {
+                    config.credentials.private_key_id = await storeAsSecret(config.credentials.private_key_id, 'PRIVATE_KEY_ID');
+                }
+                if (config.credentials.private_key) {
+                    config.credentials.private_key = await storeAsSecret(config.credentials.private_key, 'PRIVATE_KEY');
+                }
+                if (config.credentials.client_email) {
+                    config.credentials.client_email = await storeAsSecret(config.credentials.client_email, 'CLIENT_EMAIL');
+                }
+                if (config.credentials.client_id) {
+                    config.credentials.client_id = await storeAsSecret(config.credentials.client_id, 'CLIENT_ID');
+                }
+            }
+        }
+        else {
+            console.log(`${logPrefix} Unknown broker type: ${brokerType}, no secrets processing`);
+        }
+        console.log(`${logPrefix} Secrets processing completed for ${brokerTag}:${envSlug}`);
+        return config;
+    }
+    /**
+     * Process notification environment config to store sensitive credentials as secrets
+     * Format: NOTIFIER_{PRODUCT}_{NOTIFIER_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Notifier tag: replace "-" with "_"
+     */
+    async processNotificationEnvSecrets(env, notifierTag, envSlug) {
+        var _a, _b;
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            return env;
+        }
+        const generateSecretKey = (keyName) => {
+            const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+            const productParts = this.product.tag.split(':');
+            const productKey = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+            const notifierKey = notifierTag.replace(/-/g, '_');
+            return `NOTIFIER_${sanitize(productKey)}_${sanitize(notifierKey)}_${sanitize(envSlug)}_${sanitize(keyName)}`;
+        };
+        const storeAsSecret = async (value, keyName) => {
+            if (!value)
+                return value;
+            const secretCheck = (0, secrets_1.isSecretReference)(value);
+            if (secretCheck.isSecret) {
+                return value; // Already a secret reference
+            }
+            const secretKey = generateSecretKey(keyName);
+            try {
+                const exists = await secretsService.exists(secretKey);
+                if (exists) {
+                    await secretsService.update(secretKey, { value });
+                }
+                else {
+                    await secretsService.create({
+                        key: secretKey,
+                        value,
+                        description: `Notification ${keyName} for ${notifierTag} in ${envSlug}`,
+                        scope: [this.product.tag, notifierTag],
+                        envs: [envSlug],
+                    });
+                }
+                return `$Secret{${secretKey}}`;
+            }
+            catch (error) {
+                console.warn(`Failed to store notification credential as secret: ${error}`);
+                return value;
+            }
+        };
+        const result = Object.assign({}, env);
+        // Process email handler
+        if ((_a = result.emails) === null || _a === void 0 ? void 0 : _a.auth) {
+            result.emails = Object.assign(Object.assign({}, result.emails), { auth: Object.assign(Object.assign({}, result.emails.auth), { pass: await storeAsSecret(result.emails.auth.pass, 'EMAIL_PASSWORD') }) });
+        }
+        // Process SMS handler
+        if (result.sms) {
+            const smsUpdates = {};
+            if (result.sms.authToken) {
+                smsUpdates.authToken = await storeAsSecret(result.sms.authToken, 'SMS_AUTH_TOKEN');
+            }
+            if (result.sms.apiSecret) {
+                smsUpdates.apiSecret = await storeAsSecret(result.sms.apiSecret, 'SMS_API_SECRET');
+            }
+            if (result.sms.apiKey) {
+                smsUpdates.apiKey = await storeAsSecret(result.sms.apiKey, 'SMS_API_KEY');
+            }
+            if (result.sms.accountSid) {
+                smsUpdates.accountSid = await storeAsSecret(result.sms.accountSid, 'SMS_ACCOUNT_SID');
+            }
+            result.sms = Object.assign(Object.assign({}, result.sms), smsUpdates);
+        }
+        // Process push notifications handler (Firebase credentials)
+        if ((_b = result.push_notifications) === null || _b === void 0 ? void 0 : _b.credentials) {
+            const creds = result.push_notifications.credentials;
+            if (creds.private_key) {
+                result.push_notifications = Object.assign(Object.assign({}, result.push_notifications), { credentials: Object.assign(Object.assign({}, creds), { private_key: await storeAsSecret(creds.private_key, 'PUSH_PRIVATE_KEY') }) });
+            }
+        }
+        return result;
+    }
+    /**
+     * Store graph connection URL as a secret
+     * Format: GRAPH_{PRODUCT}_{GRAPH_TAG}_{ENV}_URL
+     */
+    async storeGraphConnectionUrlAsSecret(connectionUrl, graphTag, envSlug) {
+        var _a;
+        console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Starting secret conversion:', {
+            graphTag,
+            envSlug,
+            hasConnectionUrl: !!connectionUrl,
+            connectionUrlLength: connectionUrl === null || connectionUrl === void 0 ? void 0 : connectionUrl.length,
+            productTag: (_a = this.product) === null || _a === void 0 ? void 0 : _a.tag,
+        });
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            console.log('[ProductsService.storeGraphConnectionUrlAsSecret] No secrets service available, returning original value');
+            return connectionUrl;
+        }
+        console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Secrets service is available');
+        const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
+        console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Secret reference check:', {
+            isSecret: secretCheck.isSecret,
+            secretKey: secretCheck.isSecret ? secretCheck.key : null,
+        });
+        if (secretCheck.isSecret) {
+            console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Value is already a secret reference, returning as-is');
+            return connectionUrl;
+        }
+        const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        const productParts = this.product.tag.split(':');
+        const productKey = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const graphKey = graphTag.replace(/-/g, '_');
+        const secretKey = `GRAPH_${sanitize(productKey)}_${sanitize(graphKey)}_${sanitize(envSlug)}_URL`;
+        console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Generated secret key:', {
+            secretKey,
+            productParts,
+            productKey,
+            graphKey,
+        });
+        try {
+            const exists = await secretsService.exists(secretKey);
+            console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Secret exists check:', { secretKey, exists });
+            if (exists) {
+                console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Updating existing secret:', secretKey);
+                await secretsService.update(secretKey, { value: connectionUrl });
+                console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Secret updated successfully');
+            }
+            else {
+                console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Creating new secret:', {
+                    secretKey,
+                    description: `Graph connection URL for ${graphTag} in ${envSlug}`,
+                    scope: [this.product.tag, graphTag],
+                    envs: [envSlug],
+                });
+                await secretsService.create({
+                    key: secretKey,
+                    value: connectionUrl,
+                    description: `Graph connection URL for ${graphTag} in ${envSlug}`,
+                    scope: [this.product.tag, graphTag],
+                    envs: [envSlug],
+                });
+                console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Secret created successfully');
+            }
+            const secretRef = `$Secret{${secretKey}}`;
+            console.log('[ProductsService.storeGraphConnectionUrlAsSecret] Returning secret reference:', secretRef);
+            return secretRef;
+        }
+        catch (error) {
+            console.error('[ProductsService.storeGraphConnectionUrlAsSecret] Failed to store secret:', {
+                secretKey,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return connectionUrl;
+        }
+    }
+    /**
+     * Generate a secret key for vector configuration field
+     * Format: VECTOR_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if vectorTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    generateVectorSecretKey(vectorTag, envSlug, field) {
+        var _a;
+        console.log('[ProductsService.generateVectorSecretKey] Generating secret key:', {
+            vectorTag,
+            envSlug,
+            field,
+            productTag: (_a = this.product) === null || _a === void 0 ? void 0 : _a.tag,
+        });
+        const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        // Support both ':' and '.' delimiters for product tags (e.g., 'ductape:rematch' or 'ductape.rematch')
+        const productParts = this.product.tag.includes(':')
+            ? this.product.tag.split(':')
+            : this.product.tag.split('.');
+        const product = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const workspace = productParts[0];
+        console.log('[ProductsService.generateVectorSecretKey] Product parsing:', {
+            productParts,
+            product,
+            workspace,
+        });
+        // Support both ':' and '.' delimiters for vector tags
+        const vectorParts = vectorTag.includes(':') ? vectorTag.split(':') : vectorTag.split('.');
+        let assetTag;
+        if (vectorParts.length > 1 && vectorParts[0] === workspace) {
+            // Same workspace prefix, use second part
+            assetTag = vectorParts[1];
+            console.log('[ProductsService.generateVectorSecretKey] Using second part of vectorTag:', assetTag);
+        }
+        else {
+            // Different or no prefix, use full tag
+            assetTag = vectorTag;
+            console.log('[ProductsService.generateVectorSecretKey] Using full vectorTag:', assetTag);
+        }
+        const secretKey = `VECTOR_${sanitize(product)}_${sanitize(assetTag)}_${sanitize(envSlug)}_${sanitize(field)}`;
+        console.log('[ProductsService.generateVectorSecretKey] Generated secret key:', secretKey);
+        return secretKey;
+    }
+    /**
+     * Store a vector field value as a secret if it exists and is not already a secret reference
+     * @returns The secret reference if stored, or the original value
+     */
+    async storeVectorFieldAsSecret(value, vectorTag, envSlug, fieldName, description) {
+        var _a;
+        console.log('[ProductsService.storeVectorFieldAsSecret] Starting secret conversion:', {
+            vectorTag,
+            envSlug,
+            fieldName,
+            hasValue: !!value,
+            valueLength: value === null || value === void 0 ? void 0 : value.length,
+            productTag: (_a = this.product) === null || _a === void 0 ? void 0 : _a.tag,
+        });
+        if (!value) {
+            console.log('[ProductsService.storeVectorFieldAsSecret] No value provided, returning undefined');
+            return undefined;
+        }
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            console.log('[ProductsService.storeVectorFieldAsSecret] No secrets service available, returning original value');
+            return value;
+        }
+        console.log('[ProductsService.storeVectorFieldAsSecret] Secrets service is available');
+        const secretCheck = (0, secrets_1.isSecretReference)(value);
+        console.log('[ProductsService.storeVectorFieldAsSecret] Secret reference check:', {
+            isSecret: secretCheck.isSecret,
+            secretKey: secretCheck.isSecret ? secretCheck.key : null,
+        });
+        if (secretCheck.isSecret) {
+            console.log('[ProductsService.storeVectorFieldAsSecret] Value is already a secret reference, returning as-is');
+            return value;
+        }
+        const secretKey = this.generateVectorSecretKey(vectorTag, envSlug, fieldName);
+        console.log('[ProductsService.storeVectorFieldAsSecret] Generated secret key:', secretKey);
+        try {
+            const exists = await secretsService.exists(secretKey);
+            console.log('[ProductsService.storeVectorFieldAsSecret] Secret exists check:', { secretKey, exists });
+            if (exists) {
+                console.log('[ProductsService.storeVectorFieldAsSecret] Updating existing secret:', secretKey);
+                await secretsService.update(secretKey, { value });
+                console.log('[ProductsService.storeVectorFieldAsSecret] Secret updated successfully');
+            }
+            else {
+                console.log('[ProductsService.storeVectorFieldAsSecret] Creating new secret:', {
+                    secretKey,
+                    description,
+                    scope: [this.product.tag, vectorTag],
+                    envs: [envSlug],
+                });
+                await secretsService.create({
+                    key: secretKey,
+                    value,
+                    description,
+                    scope: [this.product.tag, vectorTag],
+                    envs: [envSlug],
+                });
+                console.log('[ProductsService.storeVectorFieldAsSecret] Secret created successfully');
+            }
+            const secretRef = `$Secret{${secretKey}}`;
+            console.log('[ProductsService.storeVectorFieldAsSecret] Returning secret reference:', secretRef);
+            return secretRef;
+        }
+        catch (error) {
+            console.error('[ProductsService.storeVectorFieldAsSecret] Failed to store secret:', {
+                secretKey,
+                fieldName,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return value;
+        }
+    }
+    async storeVectorApiKeyAsSecret(apiKey, vectorTag, envSlug) {
+        console.log('[ProductsService.storeVectorApiKeyAsSecret] Storing API key as secret:', {
+            vectorTag,
+            envSlug,
+            hasApiKey: !!apiKey,
+            apiKeyLength: apiKey === null || apiKey === void 0 ? void 0 : apiKey.length,
+        });
+        const result = await this.storeVectorFieldAsSecret(apiKey, vectorTag, envSlug, 'API_KEY', `Vector API key for ${vectorTag} in ${envSlug}`);
+        console.log('[ProductsService.storeVectorApiKeyAsSecret] Result:', {
+            hasResult: !!result,
+            isSecretRef: result === null || result === void 0 ? void 0 : result.startsWith('$Secret{'),
+        });
+        return result || apiKey;
+    }
+    async storeVectorEndpointAsSecret(endpoint, vectorTag, envSlug) {
+        console.log('[ProductsService.storeVectorEndpointAsSecret] Storing endpoint as secret:', {
+            vectorTag,
+            envSlug,
+            hasEndpoint: !!endpoint,
+            endpointLength: endpoint === null || endpoint === void 0 ? void 0 : endpoint.length,
+        });
+        const result = await this.storeVectorFieldAsSecret(endpoint, vectorTag, envSlug, 'ENDPOINT', `Vector endpoint for ${vectorTag} in ${envSlug}`);
+        console.log('[ProductsService.storeVectorEndpointAsSecret] Result:', {
+            hasResult: !!result,
+            isSecretRef: result === null || result === void 0 ? void 0 : result.startsWith('$Secret{'),
+        });
+        return result || endpoint;
+    }
+    /**
+     * Store LLM model API key as a secret
+     * Format: MODEL_{PRODUCT}_{MODEL_TAG}_{ENV}_API_KEY
+     */
+    async storeModelApiKeyAsSecret(apiKey, modelTag, envSlug) {
+        const secretsService = (0, secrets_1.getSecretsService)();
+        if (!secretsService) {
+            return apiKey;
+        }
+        const secretCheck = (0, secrets_1.isSecretReference)(apiKey);
+        if (secretCheck.isSecret) {
+            return apiKey;
+        }
+        const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        const productParts = this.product.tag.split(':');
+        const productKey = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const modelKey = modelTag.replace(/-/g, '_');
+        const secretKey = `MODEL_${sanitize(productKey)}_${sanitize(modelKey)}_${sanitize(envSlug)}_API_KEY`;
+        try {
+            const exists = await secretsService.exists(secretKey);
+            if (exists) {
+                await secretsService.update(secretKey, { value: apiKey });
+            }
+            else {
+                await secretsService.create({
+                    key: secretKey,
+                    value: apiKey,
+                    description: `LLM model API key for ${modelTag} in ${envSlug}`,
+                    scope: [this.product.tag, modelTag],
+                    envs: [envSlug],
+                });
+            }
+            return `$Secret{${secretKey}}`;
+        }
+        catch (error) {
+            console.warn(`Failed to store model API key as secret: ${error}`);
+            return apiKey;
+        }
     }
 }
 exports.default = ProductsBuilderService;