@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -22,13 +22,13 @@ const inputs_utils_create_1 = require("../../inputs/utils/inputs.utils.create");
 const enums_1 = require("../../types/enums");
 const productsBuilder_types_1 = require("../../types/productsBuilder.types");
 const validators_1 = require("../validators");
-const objects_utils_1 = require("../utils/objects.utils");
+const objects_utils_1 = require("./utils/objects.utils");
 const processor_utils_1 = require("../../processor/utils/processor.utils");
-const create_productDatabaseAction_validator_1 = require("../validators/joi-validators/create.productDatabaseAction.validator");
-const update_productDatabaseAction_validator_1 = require("../validators/joi-validators/update.productDatabaseAction.validator");
+const create_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productDatabaseAction.validator"));
+const update_productDatabaseAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productDatabaseAction.validator"));
 const create_productStorage_validator_1 = require("../validators/joi-validators/create.productStorage.validator");
 const inputs_types_1 = require("../../types/inputs.types");
-const string_utils_1 = require("../utils/string.utils");
+const string_utils_1 = require("./utils/string.utils");
 const workspaceApi_service_1 = require("../../api/services/workspaceApi.service");
 const string_utils_2 = require("../../apps/utils/string.utils");
 const create_productDatabaseMigration_validator_1 = __importDefault(require("../validators/joi-validators/create.productDatabaseMigration.validator"));
@@ -36,13 +36,15 @@ const update_productDatabaseMigration_validator_1 = __importDefault(require("../
 const create_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/create.productNotificationMessage.validator"));
 const create_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/create.productMessageBrokerTopic.validator"));
 const update_productMessageBrokerTopic_validator_1 = __importDefault(require("../validators/joi-validators/update.productMessageBrokerTopic.validator"));
+const create_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/create.productGraphAction.validator"));
+const update_productGraphAction_validator_1 = __importDefault(require("../validators/joi-validators/update.productGraphAction.validator"));
 const update_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/update.productNotificationMessage.validator"));
 const create_productNotification_validator_1 = require("../validators/joi-validators/create.productNotification.validator");
-const functions_utils_1 = require("../utils/functions.utils");
+const functions_utils_1 = require("./utils/functions.utils");
 const objects_utils_2 = require("../../apps/utils/objects.utils");
 const webhooksApi_service_1 = require("../../api/services/webhooksApi.service");
 class ProductsBuilderService {
-    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 }) {
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
@@ -54,6 +56,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,
+                        event: 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 +214,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 +276,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) {
@@ -147,7 +294,7 @@ class ProductsBuilderService {
     }
     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,7 +303,10 @@ 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) {
@@ -169,7 +319,6 @@ class ProductsBuilderService {
                 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,24 +335,49 @@ 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) {
+    async createSession(data, throwErrorIfExists = false) {
         try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchSession(data.tag)) {
-                await validators_1.CreateProductSessionSchema.validateAsync(data);
-                data.schema_data = (await this.inputsService.parseJson({
+            await validators_1.CreateProductSessionSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const exists = await this.fetchSession(data.tag);
+            if (!exists) {
+                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;
+                for (const stage of stages) {
+                    if (current && typeof current === 'object' && stage in current) {
+                        current = current[stage];
+                    }
+                    else {
+                        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");
+                }
+                data.schema_data = await this.inputsService.parseJson({
                     data: data.schema,
-                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-                    category: enums_1.Categories.DATA,
-                }));
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeProduct(this.product_id);
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE
+                });
+                data.selectorValue = current;
+                const payload = Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE });
+                await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Session ${data.tag} already exists`);
             }
         }
         catch (e) {
@@ -212,13 +386,13 @@ class ProductsBuilderService {
     }
     async updateSession(tag, data) {
         try {
-            const auth = this.fetchSession(tag);
-            if (!auth) {
-                throw new Error(`Session ${tag} not found`);
+            const session = await this.fetchSession(tag);
+            if (!session) {
+                throw new Error(`Session with tag: ${tag} not found`);
             }
             //const { _id } = auth;
             await validators_1.UpdateProductSessionSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchEnv(data.tag) && data.tag !== tag) {
+            if (data.tag && this.fetchSession(data.tag) && data.tag !== tag) {
                 throw new Error(`tag ${data.tag} is in use`); // TODO: also check on the backend
             }
             if (!data.tag) {
@@ -230,20 +404,40 @@ class ProductsBuilderService {
                     expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
                     category: enums_1.Categories.DATA,
                 }));
+                if (!data.selector) {
+                    throw new Error('Selector is expected when updating schema');
+                }
             }
-            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, auth), data)), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
+            if (data.selector) {
+                const stages = (0, string_utils_1.extractStages)(data.selector);
+                let current = data.schema;
+                for (const stage of stages) {
+                    if (current && typeof current === 'object' && stage in current) {
+                        current = current[stage];
+                    }
+                    else {
+                        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");
+                }
+            }
+            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());
         }
         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() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'session', this.getUserAccess());
+        return components;
     }
-    fetchSessions() {
-        return this.product.sessions;
+    async fetchSession(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'session', tag, this.getUserAccess());
+        return component;
     }
     async createMessageBrokerTopic(data, throwErrorIfExists = false) {
         try {
@@ -257,16 +451,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)
@@ -289,12 +484,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;
@@ -303,7 +498,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`);
@@ -313,12 +507,12 @@ 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"`);
         }
-        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
+        const messageBroker = await this.fetchMessageBroker(messageBrokerTag);
         if (!messageBroker)
             throw new Error(`MessageBroker ${messageBrokerTag} not found`);
         const topic = messageBroker.topics.find((data) => data.tag === topicTag);
@@ -326,8 +520,8 @@ class ProductsBuilderService {
             throw new Error(`MessageBroker topic ${tag} not found`);
         return topic;
     }
-    fetchMessageBrokerTopics(messageBrokerTag) {
-        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
+    async fetchMessageBrokerTopics(messageBrokerTag) {
+        const messageBroker = await this.fetchMessageBroker(messageBrokerTag);
         if (!messageBroker)
             throw new Error(`Message Broker ${messageBrokerTag} not found`);
         return messageBroker.topics;
@@ -364,7 +558,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`);
             }
@@ -454,7 +648,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`);
             }
@@ -522,7 +716,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;
@@ -565,7 +759,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) {
@@ -613,18 +807,20 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchQuota(tag) {
-        return this.fetchQuotas().find((data) => data.tag === tag);
+    async fetchQuotas() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'quota', this.getUserAccess());
+        return components;
     }
-    fetchQuotas() {
-        return this.product.quota;
+    async fetchQuota(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'quota', tag, this.getUserAccess());
+        return component;
     }
     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) => {
@@ -664,7 +860,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) {
@@ -709,19 +905,20 @@ class ProductsBuilderService {
             throw e;
         }
     }
-    fetchFallback(tag) {
-        return this.fetchFallbacks().find((data) => data.tag === tag);
+    async fetchFallbacks() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'fallback', this.getUserAccess());
+        return components;
     }
-    fetchFallbacks() {
-        return this.product.fallback;
+    async fetchFallback(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'fallback', tag, this.getUserAccess());
+        return component;
     }
     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)
@@ -734,54 +931,53 @@ 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() {
+        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) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'env', slug, this.getUserAccess());
+        return component;
     }
     async createMessageBroker(data, throwErrorIfExists = false) {
-        if (!this.fetchMessageBroker(data.tag, false)) {
+        if (!(await this.fetchMessageBroker(data.tag))) {
             await validators_1.CreateMessageBrokerSchema.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.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
-                return env;
-            });
-            const envs = this.fetchEnvs();
-            envs.map((env) => {
+                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.MESSAGEBROKER, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         else {
             if (throwErrorIfExists)
@@ -790,30 +986,32 @@ class ProductsBuilderService {
     }
     async updateMessageBroker(tag, data) {
         try {
-            const messageBroker = this.fetchMessageBroker(tag);
+            const messageBroker = await this.fetchMessageBroker(tag);
             if (!messageBroker) {
                 throw new Error(`Broker ${tag} not found`);
             }
             const { _id, envs } = messageBroker;
             await validators_1.UpdateMessageBrokerSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchMessageBroker(data.tag)) {
+            if (data.tag && (await 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);
+            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`);
                 }
                 if (env.config)
-                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
-                return env;
-            });
+                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.product.private_key);
+                processedEnvs.push(env);
+            }
+            data.envs = processedEnvs;
             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))) {
                     throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
                 }
                 if (exists === -1) {
@@ -824,48 +1022,51 @@ 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));
                 }
-            });
+            }
             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) {
                     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 }, messageBroker), data), { component: enums_1.ProductComponents.MESSAGEBROKER, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeProduct(this.product_id);
         }
         catch (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`);
+    async fetchMessageBrokers() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'message_broker', this.getUserAccess());
+        components.map((broker) => {
+            return broker.envs.map((env) => {
+                if (typeof env.config === 'string') {
+                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
+                }
+            });
+        });
+        return components;
+    }
+    async fetchMessageBroker(tag) {
+        const messageBroker = await this.productApi.fetchProductComponentByTag(this.product_id, 'message_broker', tag, this.getUserAccess());
         if (messageBroker) {
-            messageBroker.envs.map((broker) => {
-                if (typeof broker.config === 'string') {
-                    broker.config = JSON.parse((0, processor_utils_1.decrypt)(String(broker.config), this.fetchProduct().private_key));
+            messageBroker.envs.map((env) => {
+                if (typeof env.config === 'string') {
+                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
                 }
             });
         }
         return messageBroker;
     }
-    fetchMessageBrokers() {
-        return this.product.messageBrokers.map((broker) => {
-            return this.fetchMessageBroker(broker.tag);
-        });
-    }
     async fetchStorageFiles(filter) {
         try {
             const result = await this.productApi.fetchProductStorageFiles(Object.assign(Object.assign({}, filter), { product: this.product.tag }), this.getUserAccess());
@@ -883,11 +1084,28 @@ class ProductsBuilderService {
             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`);
                 }
@@ -895,18 +1113,18 @@ 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) => {
+                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)
@@ -915,7 +1133,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`);
             }
@@ -924,8 +1142,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`);
                 }
@@ -934,9 +1152,9 @@ class ProductsBuilderService {
                     //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);
+                    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) => {
@@ -952,7 +1170,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));
                 }
@@ -963,37 +1181,40 @@ 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`);
+    async fetchStorages() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'storage', this.getUserAccess());
+        components.map((storage) => {
+            storage.envs.map((env) => {
+                if (typeof env.config === 'string') {
+                    env.config = JSON.parse((0, processor_utils_1.decrypt)(String(env.config), this.product.private_key));
+                }
+            });
+        });
+        return components;
+    }
+    async fetchStorage(tag) {
+        const storage = await this.productApi.fetchProductComponentByTag(this.product_id, 'storage', tag, this.getUserAccess());
         if (storage) {
             storage.envs.map((store) => {
                 if (typeof store.config === 'string') {
-                    store.config = JSON.parse((0, processor_utils_1.decrypt)(String(store.config), this.fetchProduct().private_key));
+                    store.config = JSON.parse((0, processor_utils_1.decrypt)(String(store.config), this.product.private_key));
                 }
             });
         }
         return storage;
     }
-    fetchStorages() {
-        return this.product.storage.map((storage) => {
-            return this.fetchStorage(storage.tag);
-        });
-    }
     async validateAppData(appData, app) {
         // TODO:
         const { envs } = app;
@@ -1015,6 +1236,9 @@ class ProductsBuilderService {
         }
     }
     validateVariablesValues(variables, appVariables) {
+        if (!variables) {
+            variables = [];
+        }
         if (appVariables && appVariables.length) {
             appVariables.map((data) => {
                 const find = variables.find((value) => value.key === data.key);
@@ -1031,7 +1255,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`);
@@ -1121,10 +1345,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 };
     }
@@ -1157,8 +1381,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)
@@ -1189,7 +1415,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`);
             }
@@ -1205,17 +1431,18 @@ 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() {
-        return this.product.apps;
+    async fetchApps() {
+        const app = await this.productApi.fetchProductComponents(this.product_id, 'app', this.getUserAccess());
+        return app;
     }
-    fetchApp(tag, throwErrorIfExists = false) {
-        const app = this.product.apps.find((data) => data.access_tag === tag);
+    async fetchApp(tag, throwErrorIfExists = false) {
+        const apps = await this.fetchApps();
+        const app = apps.find((data) => data.app_tag === tag || data.access_tag === tag);
         if (!app && throwErrorIfExists)
             throw new Error(`App ${tag} not found`);
         return app;
@@ -1223,10 +1450,10 @@ class ProductsBuilderService {
     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,
@@ -1239,7 +1466,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)
@@ -1252,37 +1478,35 @@ 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() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'function', this.getUserAccess());
+        return components;
     }
-    fetchFunction(tag) {
-        const func = this.product.functions.find((data) => data.tag === tag);
-        // if (!func) throw new Error(`Function ${tag} not found`);
-        return func;
+    async fetchFunction(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'function', tag, this.getUserAccess());
+        return component;
     }
     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)
@@ -1295,62 +1519,59 @@ 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() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'cache', this.getUserAccess());
+        return components;
     }
-    fetchCaches() {
-        return this.product.caches;
+    async fetchCache(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'cache', tag, this.getUserAccess());
+        return component;
     }
     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++) {
                     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)
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].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)
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].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)
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].callbacks), this.product.private_key)
                             : undefined,
                         sms: data.envs[i].sms
-                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.fetchProduct().private_key)
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.product.private_key)
                             : undefined,
                     };
                     data.envs[i] = Object.assign(Object.assign({}, data.envs[i]), updates);
                 }
                 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)
@@ -1371,7 +1592,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) {
@@ -1408,7 +1629,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)
@@ -1419,12 +1639,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);
@@ -1432,8 +1652,8 @@ class ProductsBuilderService {
             throw new Error(`Notification message ${tag} not found`);
         return message;
     }
-    fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
-        const notification = this.product.notifications.find((data) => data.tag === notificationTag);
+    async fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
+        const notification = await this.fetchNotification(notificationTag); //this.product.notifications.find((data: IProductNotification) => data.tag === notificationTag);
         if (!notification)
             throw new Error(`Notification ${notificationTag} not found`);
         return notification.messages;
@@ -1486,7 +1706,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;
@@ -1494,21 +1713,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) {
@@ -1518,70 +1741,74 @@ 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) => {
+            for (const env of update.envs) {
                 if (env.emails)
-                    env.emails = (0, processor_utils_1.encrypt)(JSON.stringify(env.emails), this.fetchProduct().private_key);
+                    env.emails = (0, processor_utils_1.encrypt)(JSON.stringify(env.emails), this.product.private_key);
                 if (env.push_notifications)
-                    env.push_notifications = (0, processor_utils_1.encrypt)(JSON.stringify(env.push_notifications), this.fetchProduct().private_key);
+                    env.push_notifications = (0, processor_utils_1.encrypt)(JSON.stringify(env.push_notifications), this.product.private_key);
                 if (env.callbacks)
-                    env.callbacks = (0, processor_utils_1.encrypt)(JSON.stringify(env.callbacks), this.fetchProduct().private_key);
+                    env.callbacks = (0, processor_utils_1.encrypt)(JSON.stringify(env.callbacks), this.product.private_key);
                 if (env.sms)
-                    env.sms = (0, processor_utils_1.encrypt)(JSON.stringify(env.sms), this.fetchProduct().private_key);
-                return env;
-            });
+                    env.sms = (0, processor_utils_1.encrypt)(JSON.stringify(env.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) => {
+    async fetchNotifications() {
+        let components = await this.productApi.fetchProductComponents(this.product_id, 'notification', this.getUserAccess());
+        const notifications = components.map((notification) => {
+            return notification.envs.map((data) => {
                 if (data.callbacks && typeof data.callbacks == 'string') {
-                    data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.fetchProduct().private_key));
+                    data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.product.private_key));
                 }
                 if (data.push_notifications && typeof data.push_notifications == 'string') {
-                    data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.fetchProduct().private_key));
+                    data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.product.private_key));
                 }
                 if (data.emails && typeof data.emails == 'string') {
-                    data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.fetchProduct().private_key));
+                    data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.product.private_key));
                 }
                 if (data.sms && typeof data.sms == 'string') {
-                    data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.fetchProduct().private_key));
+                    data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.product.private_key));
                 }
                 return data;
             });
-        }
-        return notification;
+        });
+        return notifications;
     }
-    fetchNotifications() {
-        return this.product.notifications.map((notification) => {
-            return this.fetchNotification(notification.tag);
+    async fetchNotification(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'notification', tag, this.getUserAccess());
+        component.envs.map((data) => {
+            if (data.callbacks && typeof data.callbacks == 'string') {
+                data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.product.private_key));
+            }
+            if (data.push_notifications && typeof data.push_notifications == 'string') {
+                data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.product.private_key));
+            }
+            if (data.emails && typeof data.emails == 'string') {
+                data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.product.private_key));
+            }
+            if (data.sms && typeof data.sms == 'string') {
+                data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.product.private_key));
+            }
+            return data;
         });
+        return component;
     }
     validateFeatureSequence(array) {
         // Validate uniqueness of sequence_tag
@@ -1681,24 +1908,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`);
         }
@@ -1706,14 +1936,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);
         }
@@ -1753,7 +1983,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`);
@@ -1956,7 +2186,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;
@@ -1964,8 +2194,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}`);
             }
@@ -1973,7 +2203,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`);
             }
@@ -1984,7 +2214,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`);
@@ -2160,7 +2390,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)) {
@@ -2216,14 +2448,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}`);
                     }
@@ -2239,7 +2473,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)) {
@@ -2313,11 +2549,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}`);
                     }
@@ -2346,7 +2586,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)) {
@@ -2404,7 +2646,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}. `);
             }
@@ -2421,8 +2663,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}`);
@@ -2512,9 +2754,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
@@ -2522,7 +2765,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;
     }
@@ -2553,12 +2801,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;
@@ -2575,7 +2822,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`);
             }
@@ -2587,43 +2834,42 @@ 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) {
         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)
@@ -2636,7 +2882,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`);
             }
@@ -2645,15 +2891,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) => {
@@ -2682,23 +2929,237 @@ 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);
+    async fetchDatabases() {
+        const components = await this.productApi.fetchProductComponents(this.product_id, 'database', this.getUserAccess());
+        components.map((database) => {
+            database.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+            });
+        });
+        return components;
+    }
+    async fetchDatabase(tag) {
+        const database = await this.productApi.fetchProductComponentByTag(this.product_id, 'database', tag, this.getUserAccess());
         database.envs.map((env) => {
-            env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.fetchProduct().private_key);
+            env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
         });
-        if (!database && throwErrorIfExists)
-            throw new Error(`Database ${tag} not found`);
         return database;
     }
-    fetchDatabases() {
-        return this.product.databases;
+    // ==================== GRAPH DATABASE METHODS ====================
+    async createGraph(data, throwErrorIfExists = false) {
+        try {
+            if (!(await this.fetchGraph(data.tag))) {
+                await validators_1.CreateProductGraphSchema.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`);
+                    }
+                    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((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) {
+        try {
+            const graph = await this.fetchGraph(tag);
+            if (!graph) {
+                throw new Error(`Graph ${tag} not found`);
+            }
+            const { _id, envs } = graph;
+            await validators_1.UpdateProductGraphSchema.validateAsync(data);
+            if (data.tag && (await this.fetchGraph(data.tag))) {
+                throw new Error(`tag ${data.tag} is in use`);
+            }
+            if (data.envs) {
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = await this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    if (env.connection_url) {
+                        env.connection_url = (0, processor_utils_1.encrypt)(env.connection_url, this.product.private_key);
+                    }
+                    return env;
+                }));
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.map((dataEnv) => {
+                    const existsIndex = envs.findIndex((env) => env.slug === dataEnv.slug);
+                    if (!(this.fetchEnv(dataEnv.slug))) {
+                        throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                    }
+                    if (existsIndex === -1) {
+                        if (!dataEnv.connection_url) {
+                            throw new Error(`connection_url is required for new env ${dataEnv.slug}`);
+                        }
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[existsIndex]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs.map((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...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());
+        components.map((graph) => {
+            graph.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+            });
+        });
+        return components;
+    }
+    async fetchGraph(tag) {
+        const graph = await this.productApi.fetchProductComponentByTag(this.product_id, 'graph', tag, this.getUserAccess());
+        if (graph && graph.envs) {
+            graph.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.product.private_key);
+            });
+        }
+        return graph;
+    }
+    // ==================== GRAPH ACTION METHODS ====================
+    async createGraphAction(data, throwErrorIfExists = false) {
+        var _a;
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [graphTag, tag] = data.tag.split(':');
+            if (!graphTag || !tag) {
+                throw new Error('tag should be formatted as graph_tag:action_tag');
+            }
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph ${graphTag} not found`);
+            }
+            const existingAction = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.find((action) => action.tag === tag);
+            if (existingAction) {
+                if (throwErrorIfExists) {
+                    throw new Error(`Graph action ${data.tag} already exists`);
+                }
+                return;
+            }
+            // Validate the action data
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await create_productGraphAction_validator_1.default.validateAsync(validationData);
+            // Extract placeholders from template
+            const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+            const template = JSON.stringify(data.template);
+            // Process filter template if provided
+            let filterData, filterTemplate;
+            if (data.filterTemplate) {
+                filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                filterTemplate = JSON.stringify(data.filterTemplate);
+            }
+            const actionData = Object.assign(Object.assign({}, data), { tag, data: values, template,
+                filterData,
+                filterTemplate });
+            graph.actions = graph.actions || [];
+            graph.actions.push(actionData);
+            await this.updateGraph(graphTag, { actions: graph.actions });
+        }
+        catch (error) {
+            throw new Error(`Failed to create graph action: ${error.message}`);
+        }
+    }
+    async updateGraphAction(data) {
+        var _a;
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [graphTag, tag] = data.tag.split(':');
+            if (!graphTag || !tag) {
+                throw new Error('tag should be formatted as graph_tag:action_tag');
+            }
+            const graph = await this.fetchGraph(graphTag);
+            if (!graph) {
+                throw new Error(`Graph ${graphTag} not found`);
+            }
+            const actionIndex = (_a = graph.actions) === null || _a === void 0 ? void 0 : _a.findIndex((action) => action.tag === tag);
+            if (actionIndex === undefined || actionIndex === -1) {
+                throw new Error(`Graph action ${data.tag} not found`);
+            }
+            // Validate the update data
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await update_productGraphAction_validator_1.default.validateAsync(validationData);
+            // Process template if provided
+            const updateData = Object.assign(Object.assign({}, data), { tag });
+            if (data.template) {
+                updateData.data = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                updateData.template = JSON.stringify(data.template);
+            }
+            // Process filter template if provided
+            if (data.filterTemplate) {
+                updateData.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                updateData.filterTemplate = JSON.stringify(data.filterTemplate);
+            }
+            graph.actions[actionIndex] = Object.assign(Object.assign({}, graph.actions[actionIndex]), updateData);
+            await this.updateGraph(graphTag, { actions: graph.actions });
+        }
+        catch (error) {
+            throw new Error(`Failed to update graph action: ${error.message}`);
+        }
+    }
+    async fetchGraphAction(tag, throwErrorIfNotExists = false) {
+        var _a, _b;
+        const [graphTag, actionTag] = tag.split(':');
+        if (!graphTag || !actionTag) {
+            throw new Error('tag is expected to be defined as "graph_tag:action_tag"');
+        }
+        const graph = (_a = this.product.graphs) === null || _a === void 0 ? void 0 : _a.find((data) => data.tag === graphTag);
+        if (!graph)
+            throw new Error(`Graph ${graphTag} not found`);
+        const action = (_b = graph.actions) === null || _b === void 0 ? void 0 : _b.find((data) => data.tag === actionTag);
+        if (!action && throwErrorIfNotExists)
+            throw new Error(`Graph action ${tag} not found`);
+        return action || null;
+    }
+    async fetchGraphActions(graphTag) {
+        const graph = await this.fetchGraph(graphTag);
+        if (!graph) {
+            throw new Error(`Graph ${graphTag} not found`);
+        }
+        return graph.actions || [];
     }
     async createDatabaseAction(data, throwErrorIfExists = false) {
         try {
@@ -2709,34 +3170,24 @@ 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);
-                let values, template;
-                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                    await create_productDatabaseAction_validator_1.NOSQLDatabaseActionsSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                    template = JSON.stringify(data.template);
-                    if (data.type === productsBuilder_types_1.DatabaseActionTypes.UPDATE && !data.filterTemplate) {
-                        throw new Error(`filterTemplate is required for ${productsBuilder_types_1.DatabaseActionTypes.UPDATE} actions in ${productsBuilder_types_1.DatabaseTypes.MONGODB}`);
-                    }
-                    if (data.filterTemplate) {
-                        data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
-                        data.filterTemplate = JSON.stringify(data.filterTemplate);
-                    }
-                }
-                else {
-                    create_productDatabaseAction_validator_1.SQLDatabaseActionSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
-                    template = data.template;
-                    if (data.filterTemplate) {
-                        data.filterData = (0, string_utils_1.extractPlaceholders)(String(data.filterTemplate));
-                    }
+                // Verify database exists
+                await this.fetchDatabase(databaseTag);
+                // Validate the action data using the unified schema
+                const validationData = Object.assign(Object.assign({}, data), { tag });
+                await create_productDatabaseAction_validator_1.default.validateAsync(validationData);
+                // Extract placeholders from the structured template
+                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                const template = JSON.stringify(data.template);
+                // Process filter template if provided (for UPDATE/DELETE actions)
+                if (data.filterTemplate) {
+                    data.filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                    data.filterTemplate = JSON.stringify(data.filterTemplate);
                 }
                 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)
@@ -2747,7 +3198,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"`);
@@ -2773,43 +3224,37 @@ class ProductsBuilderService {
             if (!databaseTag || !tag) {
                 throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
             }
-            // Fetch required data
-            const database = await this.fetchDatabase(databaseTag, true);
+            // Fetch required data (also verifies database exists)
+            await this.fetchDatabase(databaseTag);
             const action = await this.fetchDatabaseAction(data.tag, true);
             // Construct payload
             const payload = Object.assign(Object.assign(Object.assign({}, action), data), { databaseTag, component: enums_1.ProductComponents.DATABASE_ACTION, action: enums_1.RequestAction.UPDATE });
             // Validate and process the template
             data.tag = tag;
+            // Validate using the unified schema
+            const validationData = Object.assign(Object.assign({}, data), { tag });
+            await update_productDatabaseAction_validator_1.default.validateAsync(validationData);
             if (data.template) {
-                let values, template;
-                if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                    await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
-                    template = JSON.stringify(data.template);
-                }
-                else {
-                    await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
-                    values = (0, string_utils_1.extractPlaceholders)(String(data.template));
-                    template = data.template;
-                }
+                // Extract placeholders from the structured template
+                const values = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.template));
+                const template = JSON.stringify(data.template);
                 Object.assign(payload, { data: values, template });
             }
-            else if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB) {
-                await update_productDatabaseAction_validator_1.UpdateNOSQLDatabaseActionsSchema.validateAsync(data);
-            }
-            else {
-                await update_productDatabaseAction_validator_1.UpdateSQLDatabaseActionSchema.validateAsync(data);
+            // Process filter template if provided
+            if (data.filterTemplate) {
+                const filterData = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.filterTemplate));
+                const filterTemplate = JSON.stringify(data.filterTemplate);
+                Object.assign(payload, { filterData, filterTemplate });
             }
             // 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) {
-        const database = this.product.databases.find((data) => data.tag === databaseTag);
+    async fetchDatabaseActions(databaseTag) {
+        const database = await this.fetchDatabase(databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const actions = database.actions;
@@ -2832,12 +3277,11 @@ class ProductsBuilderService {
         data.tag = tag;
         await create_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag })); // Change to update;
         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);
         }
         else {
             if (throwErrorIfExists)
@@ -2859,14 +3303,13 @@ class ProductsBuilderService {
         }
         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);
     }
-    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"`);
         }
-        const database = this.product.databases.find((data) => data.tag === databaseTag);
+        const database = await this.fetchDatabase(databaseTag); //this.product.databases.find((data: IProductDatabase) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const migration = database.migrations.find((data) => data.tag === migrationTag);
@@ -2874,8 +3317,8 @@ class ProductsBuilderService {
             throw new Error(`Database migration ${tag} not found`);
         return migration;
     }
-    fetchDatabaseMigrations(databaseTag) {
-        const database = this.product.databases.find((data) => data.tag === databaseTag);
+    async fetchDatabaseMigrations(databaseTag) {
+        const database = await this.fetchDatabase(databaseTag); //this.product.databases.find((data: IProductDatabase) => data.tag === databaseTag);
         if (!database)
             throw new Error(`Database ${databaseTag} not found`);
         const migrations = database.migrations;
@@ -2895,31 +3338,31 @@ 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);
+            const found = await this.fetchFunction(event);
             if (!found) {
                 throw new Error(`Cloud function ${event} not found`);
             }
         }
         if (type === productsBuilder_types_1.JobEventTypes.STORAGE) {
-            const found = 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`);
             }
@@ -2928,7 +3371,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) {
@@ -2950,7 +3393,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)
@@ -2963,7 +3405,7 @@ class ProductsBuilderService {
     }
     async updateJob(tag, data) {
         try {
-            const job = this.fetchJob(tag);
+            const job = await this.fetchJob(tag);
             if (!job) {
                 throw new Error(`Job ${tag} not found`);
             }
@@ -2973,20 +3415,18 @@ 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;
     }
-    fetchJobs() {
-        return this.product.jobs;
+    async fetchJob(tag) {
+        const component = await this.productApi.fetchProductComponentByTag(this.product_id, 'job', tag, this.getUserAccess());
+        return component;
     }
     getUserAccess() {
         return {
@@ -2996,6 +3436,9 @@ class ProductsBuilderService {
             public_key: this.public_key,
         };
     }
+    async fetchSessionUser(ductape_user_id) {
+        return await this.productApi.fetchProductSessionUser(ductape_user_id, this.getUserAccess());
+    }
 }
 exports.default = ProductsBuilderService;
 //# sourceMappingURL=products.service.js.map