@ductape/sdk 0.0.1

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

@@ -0,0 +1,2762 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const appApi_service_1 = require("../../api/services/appApi.service");
+const productsApi_service_1 = require("../../api/services/productsApi.service");
+const userApi_service_1 = require("../../api/services/userApi.service");
+const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"));
+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 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_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 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"));
+const update_productDatabaseMigration_validator_1 = __importDefault(require("../validators/joi-validators/update.productDatabaseMigration.validator"));
+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 update_productNotificationMessage_validator_1 = __importDefault(require("../validators/joi-validators/update.productNotificationMessage.validator"));
+const create_productNotification_validator_1 = require("../validators/joi-validators/create.productNotification.validator");
+const functions_utils_1 = require("../utils/functions.utils");
+const objects_utils_2 = require("../../apps/utils/objects.utils");
+class ProductsBuilderService {
+    constructor({ workspace_id, public_key, user_id, token, env_type }) {
+        this.workspace_id = workspace_id;
+        this.public_key = public_key;
+        this.user_id = user_id;
+        this.token = token;
+        this.userApi = new userApi_service_1.UserApiService(env_type);
+        this.productApi = new productsApi_service_1.ProductsApiService(env_type);
+        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type);
+        this.appApi = new appApi_service_1.AppApiService(env_type);
+        this.inputsService = new inputs_service_1.default();
+        this.thirdPartyApps = [];
+    }
+    async updateDataValidation(selector, update) {
+        if (!selector.startsWith('$Data{') && !selector.startsWith('$Filter')) {
+            throw new Error(`selector ${selector} is expected to start with $Data or $Filter`);
+        }
+        let useData = true;
+        if (selector.startsWith('$Filter')) {
+            useData = false;
+        }
+        await validators_1.UpdateParsedSampleSchema.validateAsync(update);
+        const stages = this.extractStages(selector);
+        if (stages.length < 3) {
+            throw new Error(`Invalid selector ${selector}`);
+        }
+        const tag = stages[0];
+        const type = stages[1];
+        let size = 2;
+        let data;
+        switch (type) {
+            case productsBuilder_types_1.FeatureEventTypes.DB_ACTION:
+                const action = 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 notification = this.fetchNotificationMessage(tag);
+                if (!notification)
+                    throw new Error(`Notification ${tag} not found`);
+                if (stages[3] === 'push') {
+                    data = notification.push_notification_data;
+                }
+                if (stages[3] === 'callback') {
+                    data = notification.callback_data;
+                }
+                if (stages[3] === 'email') {
+                    data = notification.email_data;
+                }
+                break;
+            default:
+                throw new Error(`Type ${type} not handled`);
+        }
+        if (selector.startsWith('$Filter') && type !== productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
+            throw new Error(`Filter cannot be used for ${type} in ${selector} only usable in ${productsBuilder_types_1.FeatureEventTypes.DB_ACTION}`);
+        }
+        const selectorArray = stages.slice(size);
+        let parent_key = '';
+        let exists;
+        for (let i = 0; i < selectorArray.length; i++) {
+            if (i > 0) {
+                exists = data.findIndex((d) => {
+                    return d.key === selectorArray[i] && d.parent_key === parent_key;
+                });
+            }
+            if (i === 0) {
+                exists = data.findIndex((d) => {
+                    return d.key === selectorArray[i] && (d.parent_key === parent_key || !d.parent_key);
+                });
+            }
+            if (exists === -1) {
+                throw new Error(`Invalid value ${selectorArray[i]} in selector ${selector}`);
+            }
+        }
+        const newValue = Object.assign(Object.assign({}, data[exists]), update);
+        return false;
+    }
+    async createProduct(data) {
+        try {
+            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);
+            }
+            else {
+                const product = await this.createNewProduct(data);
+                await this.initializeProduct(product._id);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async initializeWorkspace(subCheck = true) {
+        if (!this.workspace) {
+            this.workspace = await this.workspaceApi.fetchWorkspaceById(this.getUserAccess(), subCheck);
+        }
+    }
+    async initializeProduct(product_id) {
+        try {
+            this.product = await this.productApi.fetchProduct(product_id, this.getUserAccess());
+            this.product_id = product_id;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async initializeProductByTag(tag) {
+        try {
+            this.product = await this.productApi.fetchProductByTag(tag, this.getUserAccess());
+            this.product_id = this.product._id;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateProduct(data) {
+        try {
+            if (!this.app_id)
+                throw new Error('Product not initialized');
+            await validators_1.CreateProductBuilderSchema.validateAsync(data);
+            await this.productApi.updateProduct(this.product_id, Object.assign({}, data), this.getUserAccess());
+            await this.initializeProduct(this.product_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async createNewProduct(data) {
+        return this.productApi.createProduct(Object.assign({}, data), this.getUserAccess());
+    }
+    async checkIfProductExists(name) {
+        try {
+            return await this.productApi.checkProductNameExists(name, this.getUserAccess());
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    fetchProduct() {
+        if (!this.product) {
+            throw new Error('Product not yet initiated');
+        }
+        return this.product;
+    }
+    async createMessageBrokerTopic(data, throwErrorIfExists = false) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [messageBrokerTag, tag] = data.tag.split(':');
+            if (!messageBrokerTag || !tag) {
+                throw new Error(`tag is expected to be defined as "messageBroker_tag:topic_tag"`);
+            }
+            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);
+            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)
+                    throw new Error(`Message Broker Topic ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateMessageBrokerTopic(data) {
+        try {
+            if (data.sample)
+                data.sample = JSON.stringify(data.sample);
+            await update_productMessageBrokerTopic_validator_1.default.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [messageBrokerTag, tag] = data.tag.split(':');
+            if (!messageBrokerTag || !tag) {
+                throw new Error(`tag is expected to be defined as "messageBrokr_tag:topic_tag"`);
+            }
+            const exists = this.fetchMessageBrokerTopic(data.tag);
+            if (!exists) {
+                throw new Error(`Topic ${data.tag} not found`);
+            }
+            const broker = this.fetchMessageBroker(messageBrokerTag);
+            if (data.queueUrls) {
+                (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.UPDATE }), this.getUserAccess());
+                await this.initializeProduct(this.product_id);
+            }
+            else {
+                throw new Error(`Message Broker Topic ${data.tag} not found`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    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);
+        if (!messageBroker)
+            throw new Error(`MessageBroker ${messageBrokerTag} not found`);
+        const topic = messageBroker.topics.find((data) => data.tag === topicTag);
+        if (!topic && throwErrorIfExists)
+            throw new Error(`MessageBroker topic ${tag} not found`);
+        return topic;
+    }
+    fetchMessageBrokerTopics(messageBrokerTag) {
+        const messageBroker = this.product.messageBrokers.find((data) => data.tag === messageBrokerTag);
+        if (!messageBroker)
+            throw new Error(`Message Broker ${messageBrokerTag} not found`);
+        return messageBroker.topics;
+    }
+    async validateQuotaFallbackInputAndOutput(data) {
+        const input = data.input;
+        await Promise.all(data.options.map(async (d, index) => {
+            await this.validateQuotaFallbackInput(d, input);
+            const pastOutput = index > 0 ? data.options[index - 1].output : null;
+            await this.validateQuotaFallbackOutput(d, pastOutput, input);
+        }));
+    }
+    async validateQuotaFallbackInput(option, input) {
+        if (option.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+            const _a = await this.fetchThirdPartyAppByAccessTag(option.app), { version } = _a, appData = __rest(_a, ["version"]);
+            if (!appData) {
+                throw new Error(`App ${option.app} not found`);
+            }
+            this.isQuotaFallbackInput = true;
+            const { actions } = appData.versions.find((data) => data.tag === version);
+            const action = actions.find((data) => data.tag === option.event);
+            if (!appData) {
+                throw new Error(`Action ${option.event} not found in ${option.app} version ${version}`);
+            }
+            await this.validateActionDataInput({ input }, action, option.input, 0, 0);
+        }
+        else {
+            const feature = this.fetchFeature(option.event);
+            if (!feature) {
+                throw new Error(`Feature ${option.event} not found`);
+            }
+            (0, objects_utils_2.validateObjectKeys)(feature.input, option.input);
+            const keyValues = (0, objects_utils_1.traverseObject)(option.input);
+            for (let keyValue of keyValues) {
+                const { key, value } = keyValue;
+                if (!value.startsWith('$Input{')) {
+                    //throw new Error(`Feature input ${value} is invalid, all feature Inputs are expected to start with $Input{}`);
+                }
+            }
+        }
+        this.isQuotaFallbackInput = false;
+    }
+    async validateQuotaFallbackOutput(
+    /*app: string,
+    event: string,
+    response: Record<string, unknown>,
+    input: Record<string, IFeatureInput>,*/
+    option, pastResponse, input) {
+        /*const { version, ...appData } = await this.fetchThirdPartyAppByAccessTag(option.app);
+    
+        if (!appData) {
+          throw new Error(`App ${option.app} not found`);
+        }
+    
+        const { actions } = appData.versions.find((data) => data.tag === version);
+    
+        const action = actions.find((data) => data.tag === option.event);
+    
+        if (!appData) {
+          throw new Error(`Action ${event} not found in ${option.app} version ${version}`);
+        }
+        if (pastResponse) {
+          validateObjectKeys(response, pastResponse);
+        }
+    
+        const res = action.responses.find((item) => item.success === true);
+        // fetch success result
+    
+        if (!res) {
+          throw new Error(`event ${event} does not have a success response`);
+        }
+    
+        await this.validateActionResponse(response, res)*/
+    }
+    async createQuota(data) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            if (!this.fetchQuota(data.tag)) {
+                await validators_1.CreateProductQuotaSchema.validateAsync(data);
+                await this.validateQuotaFallbackInputAndOutput(data);
+                data.total_quota = 0;
+                data.total_init = 0;
+                await Promise.all(data.options.map(async (d) => {
+                    data.total_quota += d.quota;
+                    const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                    if (!app) {
+                        throw new Error(`App with access tag ${d.app} not found`);
+                    }
+                    const version = app.versions.find((version) => version.tag === app.version);
+                    const action = version.actions.find((action) => action.tag === d.event);
+                    if (!action) {
+                        throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                    }
+                    if (d.healthcheck) {
+                        const action = version.actions.find((action) => action.tag === d.healthcheck);
+                        if (!d.check_interval) {
+                            d.check_interval = 10000;
+                        }
+                        if (!action) {
+                            throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                        }
+                    }
+                    d.last_checked = new Date();
+                    d.provider_status = productsBuilder_types_1.ProviderStatus.AVAILABLE;
+                    d.last_available = true;
+                }));
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.QUOTA, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+            }
+            else {
+                throw new Error(`Quota with tag ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateQuota(tag, data) { }
+    fetchQuota(tag) {
+        return this.fetchQuotas().find((data) => data.tag === tag);
+    }
+    fetchQuotas() {
+        return this.product.quota;
+    }
+    async createFallback(data) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            if (!this.fetchQuota(data.tag)) {
+                await validators_1.CreateProductFallbackSchema.validateAsync(data);
+                await this.validateQuotaFallbackInputAndOutput(data);
+                await Promise.all(data.options.map(async (d) => {
+                    const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+                    if (!app) {
+                        throw new Error(`App with access tag ${d.app} not found`);
+                    }
+                    const version = app.versions.find((version) => version.tag === app.version);
+                    const action = version.actions.find((action) => action.tag === d.event);
+                    if (!action) {
+                        throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`);
+                    }
+                    if (d.healthcheck) {
+                        const action = version.actions.find((action) => action.tag === d.healthcheck);
+                        if (!d.check_interval) {
+                            d.check_interval = 10000;
+                        }
+                        if (!action) {
+                            throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`);
+                        }
+                    }
+                    d.last_checked = new Date();
+                    d.provider_status = productsBuilder_types_1.ProviderStatus.AVAILABLE;
+                    d.last_available = true;
+                }));
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.FALLBACK, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+            }
+            else {
+                throw new Error(`Quota with tag ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateFallback(tag, data) {
+        /*try {
+    
+          if (!data.tag) {
+            throw new Error('tag field is required');
+          }
+    
+          if (this.fetchQuota(tag)) {
+    
+            if(data.tag && tag !== data.tag && this.fetchFallback(data.tag)) {
+              throw new Error(`Fallback with new tag ${data.tag} already exists`)
+            }
+    
+            if(!data.tag) {
+              data.tag = tag;
+            }
+    
+            await UpdateProductFallbackSchema.validateAsync(data);
+    
+            await this.validateQuotaFallbackInputAndOutput(data);
+    
+            await Promise.all(data.options.map(async (d) => {
+    
+              const app = await this.fetchThirdPartyAppByAccessTag(d.app);
+    
+              if (!app) {
+                throw new Error(`App with access tag ${d.app} not found`)
+              }
+    
+              const version = app.versions.find((version) => version.tag === app.version);
+              const action = version.actions.find((action) => action.tag === d.event)
+    
+              if (!action) {
+                throw new Error(`Cannot find action ${d.event} on app ${app.tag} version ${app.version}`)
+              }
+    
+              if (d.healthcheck) {
+                const action = version.actions.find((action) => action.tag === d.healthcheck)
+    
+                if (!d.check_interval) {
+                  d.check_interval = 10000;
+                }
+    
+                if (!action) {
+                  throw new Error(`Cannot find healthcheck action ${d.healthcheck} on app ${app.tag} version ${app.version}`)
+                }
+              }
+    
+              d.last_checked = new Date();
+              d.provider_status = ProviderStatus.AVAILABLE;
+              d.last_available = true;
+            }))
+    
+            await this.productApi.updateProduct(
+              this.product_id,
+              {
+                ...data,
+                component: ProductComponents.FALLBACK,
+              },
+              this.getUserAccess(),
+            );
+    
+          } else {
+            throw new Error(`Quota with tag ${data.tag} already exists`)
+          }
+    
+        } catch (e) {
+          throw e;
+        }*/
+    }
+    fetchFallback(tag) {
+        return this.fetchFallbacks().find((data) => data.tag === tag);
+    }
+    fetchFallbacks() {
+        return this.product.fallback;
+    }
+    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)) {
+                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)
+                    throw new Error(`Environment ${data.slug} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateEnv(slug, data) {
+        try {
+            const env = this.fetchEnv(slug, true);
+            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)) {
+                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;
+    }
+    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 createMessageBroker(data, throwErrorIfExists = false) {
+        if (!this.fetchMessageBroker(data.tag, false)) {
+            await validators_1.CreateMessageBrokerSchema.validateAsync(data);
+            data.envs = data.envs.map((env) => {
+                const exists = 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) => {
+                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)
+                throw new Error(`Message Broker ${data.tag} already exists`);
+        }
+    }
+    async updateMessageBroker(tag, data) {
+        try {
+            const messageBroker = 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)) {
+                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);
+                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;
+            });
+            const overwrite = [];
+            const newEnvs = [];
+            data.envs.map((dataEnv) => {
+                const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
+                if (!this.fetchEnv(dataEnv.slug)) {
+                    throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                }
+                if (exists === -1) {
+                    if (!dataEnv.config) {
+                        throw new Error(`config is required for new env ${data.envs[exists].slug}`);
+                    }
+                    newEnvs.push(dataEnv);
+                }
+                else {
+                    if (envs[exists].config) {
+                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.fetchProduct().private_key);
+                    }
+                    overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
+                }
+            });
+            const unchanged = [];
+            envs.map((env) => {
+                const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                if (!newEnv && !overwriteEnv) {
+                    if (env.config) {
+                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().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`);
+        if (messageBroker) {
+            messageBroker.envs.map((broker) => {
+                if (typeof broker.config === 'string') {
+                    broker.config = JSON.parse((0, processor_utils_1.decrypt)(String(broker.config), this.fetchProduct().private_key));
+                }
+            });
+        }
+        return messageBroker;
+    }
+    fetchMessageBrokers() {
+        return this.product.messageBrokers.map((broker) => {
+            return this.fetchMessageBroker(broker.tag);
+        });
+    }
+    async createStorage(data, throwErrorIfExists = false) {
+        if (!this.fetchStorage(data.tag, false)) {
+            await create_productStorage_validator_1.CreateProductStorageSchema.validateAsync(data);
+            data.envs = data.envs.map((env) => {
+                const exists = this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                if (env.type === productsBuilder_types_1.StorageProviders.GCP) {
+                    // @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) => {
+                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)
+                throw new Error(`Database ${data.tag} already exists`);
+        }
+    }
+    async updateStorage(tag, data) {
+        try {
+            const storage = this.fetchStorage(tag);
+            if (!storage) {
+                throw new Error(`Storage ${tag} not found`);
+            }
+            const { _id, envs } = storage;
+            await create_productStorage_validator_1.UpdateProductStorageSchema.validateAsync(data); // Change to update;
+            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);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                if (env.type === productsBuilder_types_1.StorageProviders.GCP) {
+                    // @ts-ignore
+                    //env.config.config.private_key = gcpPKCSConvert(env.config.config.private_key)
+                }
+                if (env.config)
+                    env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
+                return env;
+            });
+            const overwrite = [];
+            const newEnvs = [];
+            data.envs.map((dataEnv) => {
+                const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
+                if (!this.fetchEnv(dataEnv.slug)) {
+                    throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                }
+                if (exists === -1) {
+                    if (!dataEnv.config) {
+                        throw new Error(`config is required for new env ${data.envs[exists].slug}`);
+                    }
+                    newEnvs.push(dataEnv);
+                }
+                else {
+                    if (envs[exists].config) {
+                        envs[exists].config = (0, processor_utils_1.encrypt)(JSON.stringify(envs[exists].config), this.fetchProduct().private_key);
+                    }
+                    overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
+                }
+            });
+            const unchanged = [];
+            envs.map((env) => {
+                const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                if (!newEnv && !overwriteEnv) {
+                    if (env.config) {
+                        env.config = (0, processor_utils_1.encrypt)(JSON.stringify(env.config), this.fetchProduct().private_key);
+                    }
+                    unchanged.push(env);
+                }
+            });
+            data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({ _id }, storage), data), { component: enums_1.ProductComponents.STORAGE, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeProduct(this.product_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchStorage(tag, throwErrorIfExists = false) {
+        const storage = this.product.storage.find((data) => data.tag === tag);
+        if (!storage && throwErrorIfExists)
+            throw new Error(`Storage ${tag} not found`);
+        if (storage) {
+            storage.envs.map((store) => {
+                if (typeof store.config === 'string') {
+                    store.config = JSON.parse((0, processor_utils_1.decrypt)(String(store.config), this.fetchProduct().private_key));
+                }
+            });
+        }
+        return storage;
+    }
+    fetchStorages() {
+        return this.product.storage.map((storage) => {
+            return this.fetchStorage(storage.tag);
+        });
+    }
+    async validateAppData(appData, app) {
+        // TODO:
+        const { envs } = app;
+        // const { envs: appEnvs, auths: appAuths } = appData
+        const version = appData.versions.find((data) => (data.latest = true));
+        app.envs = this.validateAppEnvs(envs, version);
+        // await this.validateAppAuth(auth, appData);
+        return app;
+    }
+    validateVariablesSchema(variables, appVariables) {
+        if (variables && variables.length) {
+            variables.map((data) => {
+                const appVar = appVariables.find((value) => value.key === data.key);
+                if (!appVar) {
+                    throw new Error(`variable key: ${data.key} not found`);
+                }
+                // if()
+            });
+        }
+    }
+    validateVariablesValues(variables, appVariables) {
+        if (appVariables && appVariables.length) {
+            appVariables.map((data) => {
+                const find = variables.find((value) => value.key === data.key);
+                if (data.required) {
+                    if (!find) {
+                        throw new Error(`variable key: ${data.key} is required`);
+                    }
+                }
+                this.inputsService.validateFeatureInputData(find, data);
+            });
+        }
+    }
+    validateAppEnvs(envs, version) {
+        const { envs: appEnvs } = version;
+        return envs.map((env) => {
+            const { auth } = env;
+            this.fetchEnv(env.product_env_slug, true);
+            const appEnv = appEnvs.find((appEnv) => appEnv.slug === env.app_env_slug);
+            if (!appEnv) {
+                throw new Error(`app_slug ${env.app_env_slug} not found`);
+            }
+            const updates = this.validateAppAuth(auth, version);
+            this.validateVariablesSchema(env.variables, version.variables);
+            this.validateVariablesValues(env.variables, version.variables);
+            if (updates && updates.data) {
+                env.auth.data = updates.data;
+            }
+            if (updates && updates.values) {
+                env.auth.values = updates.values;
+            }
+            return env;
+        });
+    }
+    validateAppAuth(auth, version) {
+        const { auths: appAuth, actions } = version;
+        const exists = appAuth.find((appAuth) => appAuth.tag === auth.auth_tag);
+        if (!exists) {
+            throw new Error(`app_auth ${auth.auth_tag} not found`);
+        }
+        const { data } = auth;
+        let bodySchema;
+        let headerSchema;
+        let paramsSchema;
+        let querySchema;
+        let schema;
+        if (exists.action_tag) {
+            const action = actions.find((action) => action.tag === exists.action_tag);
+            if (!action)
+                throw new Error(`Auth action tag ${exists.action_tag} not found`);
+            schema = action;
+        }
+        else if (exists.tokens) {
+            schema = exists.tokens;
+        }
+        else {
+            throw new Error('Invalid auth, create and use another');
+        }
+        bodySchema = schema.body;
+        headerSchema = schema.headers;
+        paramsSchema = schema.params;
+        querySchema = schema.query;
+        const { body, headers, params, query } = data;
+        if (!body)
+            throw new Error(`Auth body not allowed to be undefined. If empty set as {}`);
+        if (!headers)
+            throw new Error(`Auth headers not allowed to be undefined. If empty set as {}`);
+        if (!params)
+            throw new Error(`Auth params not allowed to be undefined. If empty set as {}`);
+        if (!query)
+            throw new Error(`Auth query not allowed to be undefined. If empty set as {}`);
+        if (bodySchema && bodySchema.data) {
+            const bodyValues = this.inputsService.parseData({
+                data: body,
+                category: enums_1.Categories.SETUP,
+                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
+                type: enums_1.InputsTypes.JSON,
+            });
+            (0, inputs_utils_create_1.validateInputSchema)(bodyValues, bodySchema);
+        }
+        if (headerSchema && headerSchema.data) {
+            const headerValues = this.inputsService.parseData({
+                data: headers,
+                category: enums_1.Categories.SETUP,
+                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
+                type: enums_1.InputsTypes.JSON,
+            });
+            (0, inputs_utils_create_1.validateInputSchema)(headerValues, headerSchema);
+        }
+        if (paramsSchema && paramsSchema.data) {
+            const paramsValues = this.inputsService.parseData({
+                data: params,
+                category: enums_1.Categories.SETUP,
+                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
+                type: enums_1.InputsTypes.JSON,
+            });
+            (0, inputs_utils_create_1.validateInputSchema)(paramsValues, paramsSchema);
+        }
+        if (querySchema && querySchema.data) {
+            const queryValues = this.inputsService.parseData({
+                data: query,
+                category: enums_1.Categories.SETUP,
+                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
+                type: enums_1.InputsTypes.JSON,
+            });
+            (0, inputs_utils_create_1.validateInputSchema)(queryValues, querySchema);
+        }
+        const updateData = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.fetchProduct().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);
+        }
+        return { data: updateData, values: updateValues };
+    }
+    async createAppAccessTag(app_tag) {
+        await this.initializeWorkspace();
+        const { name: workspace_name } = this.workspace;
+        const app = await this.appApi.fetchAppByTag(app_tag, this.getUserAccess());
+        if (!app) {
+            throw new Error(`App ${app_tag} not found`);
+        }
+        const { _id: app_id } = app;
+        const accessTag = `${app_tag}:${(0, string_utils_2.tagify)(workspace_name)}`;
+        const { access, access_tag } = await this.appApi.createAppAccess(app_id, this.product_id, accessTag, this.getUserAccess());
+        return {
+            access_tag,
+            access,
+        };
+    }
+    async addApp(app, throwErrorIfExists = false) {
+        try {
+            await validators_1.CreateProductAppSchema.validateAsync(app);
+            // TODO: figure out a way to check if this has run before, halt if it has
+            if (!this.fetchApp(app.access_tag, throwErrorIfExists)) {
+                const _a = await this.appApi.fetchAccessByTag(app.access_tag, this.getUserAccess()), { version } = _a, access = __rest(_a, ["version"]);
+                if (!access) {
+                    throw new Error(`Access to app ${app.access_tag} not found`);
+                }
+                const appData = await this.appApi.fetchApp(access.app_id, this.getUserAccess());
+                if (!appData) {
+                    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);
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`App ${app.access_tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchAppWebhooks(access_tag) {
+        try {
+            const app = await this.fetchThirdPartyAppByAccessTag(access_tag);
+            if (!app) {
+                throw new Error(`App with access tag ${access_tag} not found`);
+            }
+            const version = app.versions.find((version) => version.tag === app.version);
+            if (!version) {
+                throw new Error(`Required app version not found`);
+            }
+            return version.webhooks;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateApp(access_tag, data) {
+        try {
+            const app = this.fetchApp(access_tag);
+            if (!app) {
+                throw new Error(`App ${access_tag} not found`);
+            }
+            const { _id } = app;
+            //await UpdateProductAppSchema.validateAsync(data); // Change to update;
+            if (data.access_tag && data.access_tag !== access_tag) {
+                throw new Error(`access_tag mismatch between ${access_tag} and ${data.access_tag}`);
+            }
+            if (!this.fetchApp(access_tag)) {
+                throw new Error(`access_tag ${access_tag} not found`); // TODO: also check on the backend
+            }
+            /*if (data.access_tag && this.fetchApp(data.access_tag)) {
+                      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;
+    }
+    fetchApp(tag, throwErrorIfExists = false) {
+        const app = this.product.apps.find((data) => data.access_tag === tag);
+        if (!app && throwErrorIfExists)
+            throw new Error(`App ${tag} not found`);
+        return app;
+    }
+    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)) {
+                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);
+                });
+                data.sample_data = (await this.inputsService.parseJson({
+                    data: data.sample,
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
+                    category: enums_1.Categories.DATA,
+                }));
+                data.response_data = (await this.inputsService.parseJson({
+                    data: data.sample,
+                    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.FUNCTION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                await this.initializeProduct(this.product_id);
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Function ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateFunction(tag, data) {
+        try {
+            const func = 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)) {
+                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;
+    }
+    fetchFunction(tag) {
+        const func = this.product.functions.find((data) => data.tag === tag);
+        if (!func)
+            throw new Error(`Function ${tag} not found`);
+        return func;
+    }
+    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)) {
+                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)
+                    throw new Error(`Cache ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateCache(tag, data) {
+        try {
+            const cache = 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)) {
+                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;
+    }
+    fetchCaches() {
+        return this.product.caches;
+    }
+    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)) {
+                await validators_1.CreateProductNotificationSchema.validateAsync(data);
+                const envs = this.fetchEnvs();
+                envs.map((env) => {
+                    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)
+                            : undefined,
+                        emails: data.envs[i].emails
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].emails), this.fetchProduct().private_key)
+                            : undefined,
+                        callbacks: data.envs[i].callbacks
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].callbacks), this.fetchProduct().private_key)
+                            : undefined,
+                        sms: data.envs[i].sms
+                            ? (0, processor_utils_1.encrypt)(JSON.stringify(data.envs[i].sms), this.fetchProduct().private_key)
+                            : 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)
+                    throw new Error(`Notification ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async createNotificationMessage(data, throwErrorIfExists = false) {
+        try {
+            await create_productNotificationMessage_validator_1.default.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [notificationTag, tag] = data.tag.split(':');
+            if (!notificationTag || !tag) {
+                throw new Error(`tag is expected to be defined as "notification_tag:message_tag"`);
+            }
+            const exists = this.fetchNotificationMessage(data.tag);
+            data.tag = tag;
+            if (!exists) {
+                if (!data.email && !data.push_notification && !data.callback) {
+                    throw new Error(`atleast one of "email","push_notification" or "callback" is expected to be set`);
+                }
+                if (data.email) {
+                    const emailTemaplate = (0, string_utils_1.extractPlaceholders)(data.email.template, 'template');
+                    const subjectTemplate = (0, string_utils_1.extractPlaceholders)(data.email.subject, 'subject');
+                    data.email_data = [...emailTemaplate, ...subjectTemplate];
+                }
+                if (data.push_notification) {
+                    data.push_notification_data = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.push_notification));
+                    const titleTemplate = (0, string_utils_1.extractPlaceholders)(data.push_notification.title, 'title');
+                    const bodyTemplate = (0, string_utils_1.extractPlaceholders)(data.push_notification.body, 'body');
+                    const dataTemplate = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.push_notification.data || {}), 'data');
+                    data.push_notification_data = [...titleTemplate, ...bodyTemplate, ...dataTemplate];
+                }
+                if (data.callback) {
+                    const bodyTemplate = data.callback.body
+                        ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.body), 'body')
+                        : [];
+                    const queryTemplate = data.callback.query
+                        ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.query), 'query')
+                        : [];
+                    const paramsTemplate = data.callback.params
+                        ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.params), 'params')
+                        : [];
+                    const headerTemplate = data.callback.headers
+                        ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.headers), 'headers')
+                        : [];
+                    data.callback_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+                }
+                if (data.sms) {
+                    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)
+                    throw new Error(`Database Action ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    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.product.notifications.find((data) => data.tag === notificationTag);
+        if (!notification)
+            throw new Error(`Notification ${notificationTag} not found`);
+        const message = notification.messages.find((data) => data.tag === messageTag);
+        if (!message && throwErrorIfExists)
+            throw new Error(`Notification message ${tag} not found`);
+        return message;
+    }
+    fetchNotificationMessages(notificationTag, throwErrorIfExists = false) {
+        const notification = this.product.notifications.find((data) => data.tag === notificationTag);
+        if (!notification)
+            throw new Error(`Notification ${notificationTag} not found`);
+        return notification.messages;
+    }
+    async updateNotificationMessage(data) {
+        try {
+            await update_productNotificationMessage_validator_1.default.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [notificationTag, tag] = data.tag.split(':');
+            if (!notificationTag || !tag) {
+                throw new Error(`tag is expected to be defined as "notification_tag:message_tag"`);
+            }
+            // Fetch required data
+            //const notification = await this.fetchNotification(notificationTag);
+            const message = await this.fetchNotificationMessage(data.tag, true);
+            // Validate and process the template
+            data.tag = tag;
+            if (data.email) {
+                const emailTemaplate = (0, string_utils_1.extractPlaceholders)(data.email.template, 'template');
+                const subjectTemplate = (0, string_utils_1.extractPlaceholders)(data.email.subject, 'subject');
+                data.email_data = [...emailTemaplate, ...subjectTemplate];
+            }
+            if (data.push_notification) {
+                data.push_notification_data = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.push_notification));
+                const titleTemplate = (0, string_utils_1.extractPlaceholders)(data.push_notification.title, 'title');
+                const bodyTemplate = (0, string_utils_1.extractPlaceholders)(data.push_notification.body, 'body');
+                const dataTemplate = (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.push_notification.data || {}), 'data');
+                data.push_notification_data = [...titleTemplate, ...bodyTemplate, ...dataTemplate];
+            }
+            if (data.callback) {
+                const bodyTemplate = data.callback.body ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.body), 'body') : [];
+                const queryTemplate = data.callback.query
+                    ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.query), 'query')
+                    : [];
+                const paramsTemplate = data.callback.params
+                    ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.params), 'params')
+                    : [];
+                const headerTemplate = data.callback.headers
+                    ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(data.callback.headers), 'headers')
+                    : [];
+                data.callback_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+            }
+            if (data.sms) {
+                data.sms_data = (0, string_utils_1.extractPlaceholders)(data.sms, '');
+            }
+            // Construct payload
+            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;
+        }
+    }
+    async updateNotification(tag, data) {
+        try {
+            const { _id, envs } = this.fetchNotification(tag);
+            if (data.tag && tag !== data.tag && 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);
+            if (!notification) {
+                throw new Error(`Notification with tag ${tag} not found`);
+            }
+            if (data.envs) {
+                const overwrite = [];
+                const newEnvs = [];
+                data.envs.map(async (dataEnv) => {
+                    const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
+                    if (!this.fetchEnv(dataEnv.slug)) {
+                        throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                    }
+                    if (exists === -1) {
+                        await create_productNotification_validator_1.ProductNotificationEnvsSchema.validateAsync(dataEnv);
+                        newEnvs.push(dataEnv);
+                    }
+                    else {
+                        overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
+                    }
+                });
+                const unchanged = [];
+                envs.map((env) => {
+                    const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                    if (!newEnv && !overwriteEnv) {
+                        unchanged.push(env);
+                    }
+                });
+                data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            }
+            const update = Object.assign(Object.assign({}, notification), data);
+            update.envs.map((env) => {
+                if (env.emails)
+                    env.emails = (0, processor_utils_1.encrypt)(JSON.stringify(env.emails), this.fetchProduct().private_key);
+                if (env.push_notifications)
+                    env.push_notifications = (0, processor_utils_1.encrypt)(JSON.stringify(env.push_notifications), this.fetchProduct().private_key);
+                if (env.callbacks)
+                    env.callbacks = (0, processor_utils_1.encrypt)(JSON.stringify(env.callbacks), this.fetchProduct().private_key);
+                if (env.sms)
+                    env.sms = (0, processor_utils_1.encrypt)(JSON.stringify(env.sms), this.fetchProduct().private_key);
+                return env;
+            });
+            const payload = Object.assign(Object.assign({ _id }, update), { component: enums_1.ProductComponents.NOTIFICATION, action: enums_1.RequestAction.UPDATE });
+            await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
+            await this.initializeProduct(this.product_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchNotification(tag, notification_slug = '', throwErrorIfExists = false) {
+        const notification = this.product.notifications.find((data) => data.tag === tag);
+        if (notification && throwErrorIfExists)
+            throw new Error(`Notification ${tag} is in use`);
+        /*if (notification_slug) {
+          const { notifications, emails, callbacks } = notification.envs.find(
+            (data: INotificationEnv) => (data.slug = notification_slug),
+          );
+          return { notifications, emails, callbacks };
+        }*/
+        if (notification) {
+            notification.envs.map((data) => {
+                if (data.callbacks && typeof data.callbacks == 'string') {
+                    data.callbacks = JSON.parse((0, processor_utils_1.decrypt)(String(data.callbacks), this.fetchProduct().private_key));
+                }
+                if (data.push_notifications && typeof data.push_notifications == 'string') {
+                    data.push_notifications = JSON.parse((0, processor_utils_1.decrypt)(String(data.push_notifications), this.fetchProduct().private_key));
+                }
+                if (data.emails && typeof data.emails == 'string') {
+                    data.emails = JSON.parse((0, processor_utils_1.decrypt)(String(data.emails), this.fetchProduct().private_key));
+                }
+                if (data.sms && typeof data.sms == 'string') {
+                    data.sms = JSON.parse((0, processor_utils_1.decrypt)(String(data.sms), this.fetchProduct().private_key));
+                }
+                return data;
+            });
+        }
+        return notification;
+    }
+    fetchNotifications() {
+        return this.product.notifications.map((notification) => {
+            return this.fetchNotification(notification.tag);
+        });
+    }
+    validateFeatureSequence(array) {
+        // Validate uniqueness of sequence_tag
+        const uniqueTags = new Set();
+        for (const item of array) {
+            if (uniqueTags.has(item.tag)) {
+                throw new Error(`Duplicate sequence_tag found: ${item.tag}`);
+            }
+            uniqueTags.add(item.tag);
+        }
+        // Validate levels are in order starting from 0
+        /*let expectedLevel = 0;
+            for (const item of array) {
+                if (item.level !== expectedLevel) {
+                    throw new Error(`Invalid level found: expected ${expectedLevel}, found ${item.level}`);
+                }
+                expectedLevel++;
+            }*/
+    }
+    validateUniqueEventTags(data) {
+        // TODO: this might not be necessary o
+        const eventTagsSet = new Set(); // TODO: this might have to be moved to line 658
+        data.sequence.forEach((sequence) => {
+            sequence.events.forEach((data) => {
+                const { event } = data;
+                if (eventTagsSet.has(event)) {
+                    throw new Error(`Duplicate event_tag found: ${event}`);
+                }
+                eventTagsSet.add(event);
+            });
+        });
+    }
+    async validateFeatureData(data) {
+        const { sequence } = data;
+        this.validateUniqueEventTags(data); // TODO: this might be unnecessary
+        this.validateFeatureSequence(sequence);
+        const promises = sequence.map((obj, sequence_index) => {
+            const { events, parents } = obj;
+            if (parents && parents.length) {
+                this.validateSequenceParents(parents, sequence_index, sequence);
+            }
+            return Promise.all(events.map((event, event_index) => this.validateEvent(data, sequence_index, event, event_index)));
+        });
+        const results = await Promise.allSettled(promises.flat());
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            //throw new Error(`Validation errors: ${errors.join(', ')}`);
+            errors.map((error) => {
+                //console.log(error);
+                throw error;
+            });
+        }
+    }
+    validateSequenceParents(parents, sequence_index, sequence) {
+        const map = new Map();
+        for (let i = 0; i < sequence_index; i++) {
+            map.set(sequence[i].tag, i);
+        }
+        for (let i = 0; i < parents.length; i++) {
+            if (map.get(parents[i]) === undefined) {
+                throw new Error(`Invalid parent ${parents[i]} in sequence ${sequence[sequence_index].tag}, parents have to be declared before their children`);
+            }
+        }
+    }
+    validateSequenceInputParents(parent, sequence_index, sequence) {
+        let found = false;
+        const parents = sequence[sequence_index].parents;
+        if (!parents || parents.length === 0)
+            throw new Error(`Parents array cannot be empty or null when there is a $Sequence value in sequence ${sequence[sequence_index].tag}`);
+        for (let i = 0; i < sequence_index; i++) {
+            if (sequence[i].tag === parent)
+                found = true;
+        }
+        if (!found)
+            throw new Error(`Parents array needs to contain parent sequence ${parent} in ${sequence[sequence_index].tag}`);
+    }
+    async checkAndValidateActionDataInput(data, sequence_index, event, event_index) {
+        /*const application = this.fetchThirdPartyAppByAccessTag(event.a)
+    
+        if (!application) {
+          throw new Error(`App ${event.app} does not exist`);
+        }
+    
+        const { version, ...app } = application;
+        const { access_tag } = app;*/
+        // validate action_tag
+        const app = await this.fetchThirdPartyAppByAccessTag(event.app);
+        const { versions, version } = app;
+        const versionExists = versions.find((data) => data.tag === version);
+        if (!versionExists) {
+            throw new Error(`Version ${version} does not exist on app ${event.app}`);
+        }
+        const { actions } = versionExists;
+        const action = this.fetchThirdPartyAppActionByTag(actions, event.event);
+        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);
+        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);
+        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);
+        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);
+        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);
+        if (!topic) {
+            throw new Error(`Topic ${event.event} not registered`);
+        }
+        const { data: topicData } = topic;
+        //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);
+        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);
+        if (job.type === productsBuilder_types_1.JobEventTypes.ACTION) {
+            await this.checkAndValidateActionDataInput(data, sequence_index, event, event_index);
+        }
+        if (job.type === productsBuilder_types_1.JobEventTypes.DATABASE_ACTION) {
+            await this.checkAndValidateDBActionDataInput(data, sequence_index, event, event_index);
+        }
+        if (job.type === productsBuilder_types_1.JobEventTypes.NOTIFICATION) {
+            await this.checkAndValidateNotificationDataInput(data, sequence_index, event, event_index);
+        }
+        if (job.type === productsBuilder_types_1.JobEventTypes.STORAGE) {
+            await this.checkAndValidateStorageDataInput(data, sequence_index, event, event_index);
+        }
+        if (job.type === productsBuilder_types_1.JobEventTypes.PUBLISH) {
+            await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
+        }
+        if (job.type === productsBuilder_types_1.JobEventTypes.FUNCTION) {
+            await this.checkAndValidateFunctionDataInput(data, sequence_index, event, event_index);
+        }
+    }
+    async checkAndValidateFallbackDataInput(data, sequence_index, event, event_index) { }
+    async validateEvent(data, sequence_index, event, event_index) {
+        this.validateConditional(event, data, sequence_index, event_index);
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+            await this.checkAndValidateActionDataInput(data, sequence_index, event, event_index);
+            // validate input
+        }
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
+            await this.checkAndValidateDBActionDataInput(data, sequence_index, event, event_index);
+        }
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.FEATURE) {
+            await this.checkAndValidateFeatureDataInput(data, sequence_index, event, event_index);
+        }
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.NOTIFICATION) {
+            await this.checkAndValidateNotificationDataInput(data, sequence_index, event, event_index);
+        }
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.PUBLISH) {
+            await this.checkAndValidatePublishDataInput(data, sequence_index, event, event_index);
+        }
+        /*if (event.type === FeatureEventTypes.SUBSCRIBE) {
+          const topic = this.fetchMessageBrokerTopic(event.event);
+    
+          if(!topic) {
+            throw new Error(`Topic ${event.event} not registered`);
+          }
+        }*/
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.STORAGE) {
+            await this.checkAndValidateStorageDataInput(data, sequence_index, event, event_index);
+        }
+        if (event.type === productsBuilder_types_1.FeatureEventTypes.JOB) {
+            await this.checkAndValidateJobDataInput(data, sequence_index, event, event_index);
+        }
+    }
+    async validateDBActionDataInput(data, action, event_input, event_index, sequence_index) {
+        // const {data: dataInput, filter: filter} = event_input;
+        const indexes = {
+            parent_key: '',
+            level: 0,
+            key: '',
+            index: 0,
+        };
+        await this.validateActionInputData({
+            obj: event_input.data,
+            sample: { type: enums_1.InputsTypes.JSON, sample: action.template, data: action.data },
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.DATA,
+            indexes: indexes,
+        }, true);
+        await this.validateActionInputData({
+            obj: event_input.filter,
+            sample: { type: enums_1.InputsTypes.JSON, sample: action.filter, data: action.filterData },
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.FILTER,
+            indexes: indexes,
+        }, true);
+    }
+    async validateFeatureDataInput(data, featureInput, input, event_index, sequence_index) {
+        (0, processor_utils_1.validateFeatureJSONInput)(input, featureInput);
+    }
+    async validateNotificationDataInput(data, action, event_input, event_index, sequence_index) {
+        // const {data: dataInput, filter: filter} = event_input;
+        const indexes = {
+            parent_key: '',
+            level: 0,
+            key: '',
+            index: 0,
+        };
+        if (event_input.callback) {
+            await this.validateActionInputData({
+                obj: event_input.callback,
+                sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.callback },
+                event_index,
+                sequence_index,
+                feature: data,
+                type: enums_1.Categories.DATA,
+                indexes: indexes,
+            }, true);
+        }
+        if (event_input.email) {
+            const indexes = {
+                parent_key: '',
+                level: 0,
+                key: '',
+                index: 0,
+            };
+            const _a = event_input.email, { recipients } = _a, email = __rest(_a, ["recipients"]);
+            await this.validateActionInputData({
+                obj: email.subject,
+                sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.email.filter((value) => value.parent_key === 'subject') },
+                event_index,
+                sequence_index,
+                feature: data,
+                type: enums_1.Categories.DATA,
+                indexes: Object.assign(Object.assign({}, indexes), { parent_key: 'subject', level: 1 }),
+            }, true);
+            await this.validateActionInputData({
+                obj: email.template,
+                sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.email.filter((value) => value.parent_key === 'template') },
+                event_index,
+                sequence_index,
+                feature: data,
+                type: enums_1.Categories.DATA,
+                indexes: Object.assign(Object.assign({}, indexes), { parent_key: 'template', level: 1 }),
+            }, true);
+        }
+        if (event_input.push_notification) {
+            const _b = event_input.push_notification, { device_tokens } = _b, push_notification = __rest(_b, ["device_tokens"]);
+            await this.validateActionInputData({
+                obj: push_notification.body,
+                sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.notification.filter((value) => value.parent_key === 'body') },
+                event_index,
+                sequence_index,
+                feature: data,
+                type: enums_1.Categories.DATA,
+                indexes: Object.assign(Object.assign({}, indexes), { parent_key: 'body', level: 1 }),
+            }, true);
+            if (push_notification.data) {
+                console.log("JUMANJI", push_notification.data);
+                await this.validateActionInputData({
+                    obj: push_notification.data,
+                    sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.notification.filter((value) => value.parent_key === 'data') },
+                    event_index,
+                    sequence_index,
+                    feature: data,
+                    type: enums_1.Categories.DATA,
+                    indexes: Object.assign(Object.assign({}, indexes), { parent_key: 'data', level: 1 }),
+                }, true);
+            }
+            if (push_notification.title)
+                await this.validateActionInputData({
+                    obj: push_notification.title,
+                    sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.notification.filter((value) => value.parent_key === 'title') },
+                    event_index,
+                    sequence_index,
+                    feature: data,
+                    type: enums_1.Categories.DATA,
+                    indexes: Object.assign(Object.assign({}, indexes), { parent_key: 'title', level: 1 }),
+                }, true);
+        }
+        if (event_input.sms) {
+            const _c = event_input.sms, { recipients } = _c, sms = __rest(_c, ["recipients"]);
+            await this.validateActionInputData({
+                obj: sms.body,
+                sample: { type: enums_1.InputsTypes.JSON, sample: '', data: action.sms },
+                event_index,
+                sequence_index,
+                feature: data,
+                type: enums_1.Categories.DATA,
+                indexes: Object.assign({}, indexes),
+            }, true);
+        }
+    }
+    async validateActionDataInput(data, action, event_input, event_index, sequence_index) {
+        const { params, query, headers, body } = event_input;
+        const { params: actionParams, query: actionQuery, headers: actionHeaders, body: actionBody } = action;
+        const indexes = {
+            parent_key: '',
+            level: 0,
+            key: '',
+            index: 0,
+        };
+        await this.validateActionInputData({
+            obj: params,
+            sample: actionParams,
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.PARAMS,
+            indexes,
+        });
+        await this.validateActionInputData({
+            obj: query,
+            sample: actionQuery,
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.QUERY,
+            indexes,
+        });
+        await this.validateActionInputData({
+            obj: headers,
+            sample: actionHeaders,
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.HEADER,
+            indexes,
+        });
+        await this.validateActionInputData({
+            obj: body,
+            sample: actionBody,
+            event_index,
+            sequence_index,
+            feature: data,
+            type: enums_1.Categories.BODY,
+            indexes,
+        });
+    }
+    async validateActionInputData(data, skipSample = false, option = false, optionIndex = 0) {
+        var _a;
+        const { obj } = data, base_data = __rest(data, ["obj"]);
+        if (!data.sample && Object.keys(obj).length === 0) {
+            return;
+        }
+        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) {
+            if (!option) {
+                throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should not be ${obj}`);
+            }
+            else {
+                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 (!option) {
+                throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should be an empty object`);
+            }
+            else {
+                throw new Error(`option event index ${optionIndex}, ${data.type} should not be an empty object`);
+            }
+        }
+        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) {
+            //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`);
+            }
+            else {
+                throw new Error(`option event index ${optionIndex}, ${data.type} should not be an empty object`);
+            }
+        }
+        let index = 0;
+        for (const key in obj) {
+            if (typeof obj[key] === 'object') {
+                // Check if the object has keys "function" and "values"
+                if ('function' in obj[key] && 'values' in obj[key]) {
+                    // Special handling for objects with keys "function" and "values"
+                    await this.parseActionEventInput(Object.assign({ key, value: obj[key] }, base_data));
+                }
+                else {
+                    // Normal recursive call for nested objects
+                    await this.validateActionInputData(Object.assign(Object.assign({}, base_data), { obj: obj[key], indexes: {
+                            key,
+                            index,
+                            parent_key: data.indexes.key,
+                            level: data.indexes.level++,
+                        } }), skipSample, option, optionIndex);
+                }
+            }
+            else if (Array.isArray(obj[key])) {
+                // If it's an array, iterate through each element
+                Object.keys(obj[key]).forEach(async (elementKey) => {
+                    const element = obj[key][elementKey];
+                    if (typeof element === 'object') {
+                        // Check if the object within array has keys "function" and "values"
+                        if ('function' in element && 'values' in element) {
+                            // Special handling for objects within array with keys "function" and "values"
+                            await this.parseActionEventInput(Object.assign({ key: elementKey, value: element }, base_data));
+                        }
+                        else {
+                            // Normal recursive call for nested objects within arrays
+                            await this.validateActionInputData(Object.assign(Object.assign({}, base_data), { obj: element, indexes: {
+                                    key: elementKey,
+                                    index,
+                                    parent_key: data.indexes.key,
+                                    level: data.indexes.level++,
+                                } }), skipSample, option, optionIndex);
+                        }
+                    }
+                    else {
+                        await this.parseActionEventInput(Object.assign({ key: elementKey, value: element }, base_data));
+                    }
+                });
+            }
+            else {
+                await this.parseActionEventInput(Object.assign({ key, value: obj[key] }, base_data));
+            }
+            index++;
+        }
+    }
+    validateConditional(event, feature, sequence_index, event_index) {
+        const sequence = feature.sequence[sequence_index];
+        const input = feature.input;
+        const { condition } = event;
+        // Define valid operators
+        // Check if condition exists
+        if (condition && condition.check) {
+            // Split the check into parts: initiator, operator, and value
+            const parts = (0, string_utils_1.extractConditionalParts)(condition.check);
+            if (!parts) {
+                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid check format. 
+          Ensure it follows the pattern: initiator operator value (e.g., $Index < 10)
+          Valid operators are: ${productsBuilder_types_1.ValidOperators.join(', ')}`);
+            }
+            const [, initiator, operator, value] = parts;
+            if (condition.type === productsBuilder_types_1.Conditions.LOOP && initiator !== '$Index') {
+                throw new Error(`invalid index ${initiator} in event ${event.event} in ${sequence.tag}, loop indexes are expected to be defined as $Index`);
+            }
+            // Validate operator
+            if (!productsBuilder_types_1.ValidOperators.includes(operator)) {
+                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid operator "${operator}" for "${condition.type}" condition
+          Valid operators are: ${productsBuilder_types_1.ValidOperators.join(', ')}`);
+            }
+            if (condition.type === productsBuilder_types_1.Conditions.LOOP && condition.iter) {
+                // check if value is an integer
+                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid loop iter "${condition.iter}" is expected to be an integer .`);
+            }
+            // check if value is an integer
+            if (condition.type === productsBuilder_types_1.Conditions.LOOP && condition.init && !Number.isInteger(condition.init)) {
+                throw new Error(`event ${event.event} in ${sequence.tag} has an invalid loop init "${condition.init}" is expected to be an integer .`);
+            }
+            // check if value is not numeric but points towards a value
+            if (condition.type === productsBuilder_types_1.Conditions.LOOP && !(0, string_utils_1.isNumeric)(value)) {
+                //console.log(1, value);
+                if (!value.startsWith('$')) {
+                    throw new Error(`event ${event.event} in ${sequence.tag} has an invalid operator "${operator}".`);
+                }
+                const payload = {
+                    datapoint: {
+                        key: 'condition-value',
+                        required: true,
+                        maxLength: 0,
+                        minLength: 0,
+                        type: enums_1.DataTypes.INTEGER, // value is expected to be a number
+                    },
+                    value,
+                    input: input,
+                    stages: this.extractStages(value),
+                };
+                const meta = { compare: true, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL };
+                this.parseInputString(payload, meta);
+            }
+            if (condition.type === productsBuilder_types_1.Conditions.CHECK) {
+                this.parseInputString({
+                    datapoint: {
+                        key: 'condition-initiator',
+                        required: true,
+                        maxLength: 0,
+                        minLength: 0,
+                        type: enums_1.DataTypes.STRING,
+                    },
+                    value: initiator,
+                    input: input,
+                    stages: this.extractStages(initiator),
+                }, { compare: false, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL });
+                //console.log(2, value);
+                if (value.startsWith('$')) {
+                    this.parseInputString({
+                        datapoint: {
+                            key: 'condition-value',
+                            required: true,
+                            maxLength: 0,
+                            minLength: 0,
+                            type: enums_1.DataTypes.STRING,
+                        },
+                        value,
+                        input: input,
+                        stages: this.extractStages(value),
+                    }, { compare: false, feature, sequence_index, event_index, type: enums_1.Categories.CONDITIONAL });
+                }
+            }
+        }
+        // Check if the condition is a CHECK and allow_fail is true
+        if (condition && condition.type === productsBuilder_types_1.Conditions.CHECK && event.allow_fail) {
+            throw new Error(`event ${event.event} cannot set allow_fail: true as it is a check conditional`);
+        }
+    }
+    async parseActionEventInput(data) {
+        const datapoint = this.validateActionKeyPlacement(data);
+        let stages, input;
+        const opFunc = (0, functions_utils_1.extractFunctionAndArgs)(data.value); // TODO: check if this works
+        if (typeof data.value === 'string' && !opFunc) {
+            stages = this.extractStages(data.value);
+            input = data.feature.input;
+            this.parseInputString({ datapoint, value: data.value, input, stages }, {
+                feature: data.feature,
+                sequence_index: data.sequence_index,
+                event_index: data.event_index,
+                type: data.type,
+                compare: true,
+            });
+        }
+    }
+    async parseInputString(payload, meta) {
+        const { datapoint, value, input, stages } = payload;
+        const sequence = meta.feature.sequence[meta.sequence_index];
+        //console.log(3, value)
+        if (!value) {
+            //console.log(payload)
+            return;
+        }
+        if ((this.isQuotaFallbackInput) && (0, string_utils_1.startsWithAny)(value, ['$Sequence{', '$Response{'])) {
+            throw new Error(`Value ${value} cannot be a $Sequence or $Response value when defining Quota & Fallback input`);
+        }
+        if (value.startsWith('$Input{')) {
+            let current_input = input;
+            for (let i = 0; i < stages.length; i++) {
+                let stage = stages[i];
+                const matches = stage.match(/^\[(\d+)\]$/);
+                if (matches && matches.length === 2) {
+                    const number = parseInt(matches[1], 10);
+                    if (!isNaN(number)) {
+                        stage = number;
+                    }
+                    else {
+                        throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
+                    }
+                }
+                if (!current_input[stage])
+                    throw new Error(`Input key ${stage} in ${value} does not exist`);
+                current_input = current_input[stage];
+            }
+            if ((0, objects_utils_1.deepEqual)(current_input, input)) {
+                throw new Error(`Error 490101: something unexpected happened`);
+            }
+            if (meta.compare)
+                this.compareInputWithExpectedInput(datapoint, current_input, value);
+        }
+        else if (value.startsWith('$Auth{')) {
+            // TODO: make sure that all auths have the same responses
+            // TODO: make sure apps have only one auth, for now
+            const { app: access_tag } = meta.feature.sequence[meta.sequence_index].events[meta.event_index];
+            const _a = await this.fetchThirdPartyAppByAccessTag(access_tag), { version } = _a, app = __rest(_a, ["version"]);
+            const { auths, actions } = app.versions.find((data) => data.tag === version);
+            const auth_tag = stages[0];
+            let auth;
+            for (let i = 0; i < auths.length; i++) {
+                if (auths[i].tag === auth_tag) {
+                    auth = auths[i];
+                }
+            }
+            if (!auth) {
+                throw new Error(`Auth in ${value} not found in app ${access_tag}`);
+            }
+            /*const { envs } = this.fetchApp(access_tag, false);
+      
+                  for(let i=0; i< envs.length; i++) {
+                      if (envs[i].auth.auth_tag ) {
+                          throw new Error(`Auth ${auth_tag} not in use in product environment ${envs[i].product_slug}, please be uniform in environment auth definition`)
+                      }
+                  }*/
+            let response;
+            let validated = false;
+            if (auth.setup_type === enums_1.AuthTypes.CREDENTIALS) {
+                const action = actions.find((item) => {
+                    return item.tag === auth.action_tag;
+                });
+                if (!action) {
+                    throw new Error(`Could not find auth action ${auth.action_tag}`);
+                }
+                response = action.responses.find((item) => item.success === true);
+            }
+            else {
+                //const envs =
+                const app = 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);
+                    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}`);
+                    }
+                    // TODO: check for valid value
+                    validated = true;
+                }));
+            }
+            if (response) {
+                let parent_index = 0;
+                let increment = false;
+                let level = 0;
+                let parent_key = '';
+                let i = 1;
+                while (i < stages.length) {
+                    let stage = stages[i];
+                    const matches = stage.match(/^\[(\d+)\]$/);
+                    if (matches && matches.length === 2) {
+                        const number = parseInt(matches[1], 10);
+                        if (!isNaN(number)) {
+                            stage = number;
+                            parent_index = number; // TODO: check whether this handles the array issue
+                            i++; // move to next stage instantly
+                            increment = true;
+                        }
+                        else {
+                            throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
+                        }
+                    }
+                    const found = response.body.data.find((item) => {
+                        if (!increment) {
+                            return item.parent_key === parent_key && item.key === stage && level === item.level;
+                        }
+                        else {
+                            return (item.parent_key === parent_key &&
+                                parent_index === stage &&
+                                stages[i] === item.key &&
+                                level === item.level);
+                        }
+                    });
+                    if (!found) {
+                        throw new Error(`Cannot find key: ${stage} in  ${value}`);
+                    }
+                    level++;
+                    parent_key = String(stages[i]);
+                    if (i === stages.length - 1 && meta.compare) {
+                        this.compareInputWithExpectedInput(datapoint, found, value);
+                    }
+                    i++;
+                }
+            }
+            else if (!validated) {
+                throw new Error(`There is no successful response sample for Action ${auth.action_tag} in app ${access_tag}`);
+            }
+        }
+        else if (value.startsWith('$Sequence{') || value.startsWith('$Response{')) {
+            let isResponse = false;
+            if (value.startsWith('$Response{')) {
+                isResponse = true;
+            }
+            //let current_input = input as unknown as Record<string, unknown>;
+            //const { feature, sequence_index, event_index} = meta;
+            let parent_key = '';
+            let level = 0;
+            let i = 0;
+            let sequence;
+            let response;
+            // handle array checks
+            const indexer = (0, string_utils_1.validateAndLocateTag)(value);
+            /*const bracketPattern = /\[(.*?)\]$/;
+          
+            // Test the string for the pattern
+            const matchBracket = value.match(bracketPattern);
+          
+            // check if matchbracket value isnt index
+            if (matchBracket) {
+          
+              if(matchBracket[1] !== "$Index") {
+                throw new Error(`Invalid sequence loop ending value: "${matchBracket[1]}". Only "$Index" is allowed.`);
+              }
+          
+              datapoint.type = DataTypes.ARRAY;
+            }*/
+            // console.log(value, stages)
+            while (i < stages.length) {
+                let stage = stages[i];
+                let event;
+                // 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);
+                }
+                if (i === 1 && sequence) {
+                    event = this.fetchSequenceEvent(sequence, stage);
+                    if (!event) {
+                        throw new Error(`event ${stage} not found in sequence ${sequence.tag}`);
+                    }
+                    let { type, app: access_tag, event: event_tag } = event;
+                    if (type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
+                        const _b = await this.fetchThirdPartyAppByAccessTag(access_tag), { version } = _b, app = __rest(_b, ["version"]);
+                        const { actions } = app.versions.find((data) => data.tag === version);
+                        const { responses } = this.fetchThirdPartyAppActionByTag(actions, event_tag);
+                        response = responses.find((item) => item.success === true);
+                        // fetch success result
+                        if (!response) {
+                            throw new Error(`event ${stage} does not have a success response`);
+                        }
+                    }
+                    if (type === productsBuilder_types_1.FeatureEventTypes.DB_ACTION) {
+                        // TODO:
+                    }
+                    if (type === productsBuilder_types_1.FeatureEventTypes.JOB) {
+                        // TODO:
+                    }
+                    if (type === productsBuilder_types_1.FeatureEventTypes.NOTIFICATION) {
+                        // TODO:
+                    }
+                    //TODO: handle other types
+                }
+                if (i > 1 && response) {
+                    let parent_index = 0;
+                    let increment = false;
+                    const matches = stage.match(/^\[(\d+)\]$/);
+                    if (matches && matches.length === 2) {
+                        const number = parseInt(matches[1], 10);
+                        if (!isNaN(number)) {
+                            stage = number;
+                            parent_index = number; // TODO: check whether this handles the array issue
+                            i++; // move to next stage instantly
+                            increment = true;
+                        }
+                        else {
+                            throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
+                        }
+                    }
+                    const found = response.body.data.find((item) => {
+                        if (!increment) {
+                            return item.parent_key === parent_key && item.key === stage && level === item.level;
+                        }
+                        else {
+                            return (item.parent_key === parent_key &&
+                                parent_index === stage &&
+                                stages[i] === item.key &&
+                                level === item.level);
+                        }
+                    });
+                    if (!found) {
+                        throw new Error(`Cannot find key: ${stage} in  ${value}`);
+                    }
+                    level++;
+                    parent_key = String(stages[i]);
+                    if (indexer && indexer === i) {
+                        // datapoint.type = DataTypes.ARRAY;
+                        // console.log({datapoint}, {found}, {value});
+                        // this.compareInputWithExpectedInput(datapoint, found as unknown as IParsedSample, value);
+                        if (found.type !== enums_1.DataTypes.ARRAY) {
+                            throw new Error(`{${stage}} in ${value} is required to be ${datapoint.type} not ${found.type}`);
+                        }
+                    }
+                    if (i === stages.length - 1 && meta.compare) {
+                        this.compareInputWithExpectedInput(datapoint, found, value);
+                    }
+                }
+                i++;
+            }
+        }
+        else if (value === '$Default') {
+            if (!datapoint.defaultValue) {
+                throw new Error(`sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, the key {${datapoint.key}: ${value}} does not have a default`);
+            }
+        }
+        else if (value.startsWith('$Variable{')) {
+            // $Variable{APP_NAME}$
+            const stages = this.extractStages(value);
+            if (stages.length < 2) {
+                throw new Error(`sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}, you have to define what variable is to be used`);
+            }
+            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]);
+            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}. `);
+            }
+            if (!app.envs[0]) {
+                throw new Error(`App ${stages[0]} has not environments defined`);
+            }
+            const { variables } = app.envs[0];
+            if (!variables.find((item) => item.key === stages[1])) {
+                throw new Error(`Variable ${stages[1]} does not exist in app ${stages[0]} in value ${value} in sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}`);
+            }
+        }
+        else if (value.startsWith('$Constant{')) {
+            const stages = this.extractStages(value);
+            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 _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}`);
+            }
+            const { constants } = app.versions.find((data) => data.tag === version);
+            const exists = constants.find((item) => item.key === key);
+            if (!exists) {
+                throw new Error(`Constant with key ${key} in ${value}, does not exist on app ${app}`);
+            }
+        }
+        else if (value.startsWith('$Length{') || value.startsWith('$Size{')) {
+            const { matchLength, matchSize } = (0, string_utils_1.checkLengthAndSizeMatches)(value);
+            let content;
+            let type;
+            if (matchLength) {
+                content = matchLength[1];
+                type = enums_1.DataTypes.ARRAY;
+            }
+            else if (matchSize) {
+                // Added safeguard for $Size match
+                content = matchSize[1];
+                type = enums_1.DataTypes.OBJECT;
+            }
+            await this.parseInputString({
+                datapoint: {
+                    key: 'value-evaluator',
+                    required: true,
+                    maxLength: 0,
+                    minLength: 0,
+                    type, // value is expected to be object or array
+                },
+                value: content,
+                input: input,
+                stages: this.extractStages(content),
+            }, Object.assign(Object.assign({}, meta), { type: enums_1.Categories.CONDITIONAL }));
+        }
+        else if (value.startsWith('$')) {
+            /*throw new Error(
+              `sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type} has invalid : {${
+                datapoint.key
+              }: ${value}}`,
+            );*/
+            (0, functions_utils_1.extractFunctionAndArgs)(value);
+        }
+    }
+    compareInputWithExpectedInput(datapoint, found_input, value) {
+        if (datapoint.maxLength !== 0 && found_input.maxLength && found_input.maxLength > datapoint.maxLength) {
+            throw new Error(`maxlength of ${value} -> ${found_input.maxLength} cannot be greater than ${datapoint.maxLength}`);
+        }
+        if (datapoint.minLength !== 0 && found_input.minLength && found_input.minLength < datapoint.minLength) {
+            throw new Error(`minlength of ${value} cannot be less than ${datapoint.minLength}`);
+        }
+        const strTypes = [
+            enums_1.DataTypes.EMAIL_STRING,
+            enums_1.DataTypes.NOSPACES_STRING,
+            enums_1.DataTypes.UUID,
+            enums_1.DataTypes.NUMBER_STRING,
+            enums_1.DataTypes.INTEGER,
+        ];
+        const dateTypes = [
+            enums_1.DataTypes.DATE,
+            enums_1.DataTypes.DATE_STRING
+        ];
+        const strException = ((datapoint.type === enums_1.DataTypes.STRING || found_input.type === enums_1.DataTypes.STRING) &&
+            (strTypes.includes(found_input.type) || strTypes.includes(datapoint.type)));
+        const dateException = ((datapoint.type === enums_1.DataTypes.INTEGER || found_input.type === enums_1.DataTypes.INTEGER) &&
+            (dateTypes.includes(found_input.type) || dateTypes.includes(datapoint.type)));
+        if (datapoint.type !== found_input.type && !strException && !dateException) {
+            //console.log("STR EXCEPTION", strException, found_input.type, datapoint.type)
+            throw new Error(`${value} is required to be ${datapoint.type} not ${found_input.type}`);
+        }
+    }
+    extractStages(input) {
+        return (0, string_utils_1.extractStages)(input);
+    }
+    fetchSequenceEvent(sequence, event) {
+        return sequence.events.find((item) => item.event === event);
+    }
+    fetchPriorSequence(meta, stage) {
+        let found;
+        for (let i = 0; i < meta.sequence_index; i++) {
+            if (meta.feature.sequence[i].tag === stage) {
+                found = meta.feature.sequence[i];
+            }
+        }
+        if (!found) {
+            const sequence = meta.feature.sequence[meta.sequence_index].tag;
+            throw `sequence ${stage} not found before ${sequence}, values can only inherit from sequences before them in the feature chain`;
+        }
+        return found;
+    }
+    validateActionKeyPlacement(data) {
+        const actionData = data.sample.data;
+        const { indexes } = data;
+        const sequence = data.feature.sequence[data.sequence_index];
+        const datapoint = actionData.find((item) => {
+            return (item.parent_key === indexes.parent_key && item.key === data.key && item.level === indexes.level //&&
+            //indexes.index === item.index
+            );
+        });
+        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}`);
+        }
+        return datapoint;
+    }
+    async fetchThirdPartyAppByAccessTag(access_tag) {
+        try {
+            const app = this.thirdPartyApps.find((item) => access_tag === item.access_tag);
+            if (app) {
+                return Object.assign(Object.assign({}, app.app), { version: app.version });
+            }
+            const access = await this.appApi.fetchAccessByTag(access_tag, this.getUserAccess());
+            if (!access) {
+                throw new Error(`Access to app ${access_tag} not found`);
+            }
+            const appData = await this.appApi.fetchApp(access.app_id, this.getUserAccess());
+            this.thirdPartyApps.push({ access_tag, app: appData, version: access.version });
+            return Object.assign(Object.assign({}, appData), { version: access.version });
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchThirdPartyAppActionByTag(actions, action_tag) {
+        const action = actions.find((action) => action.tag === action_tag);
+        if (!action) {
+            throw new Error(`Action ${action_tag} not found`);
+        }
+        return action;
+    }
+    async createFeature(data, throwErrorIfExists = false) {
+        try {
+            if (!this.fetchFeature(data.tag, false)) {
+                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;
+                }
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Feature ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateFeature(tag, data) {
+        try {
+            const feature = this.fetchFeature(tag);
+            if (!feature) {
+                throw new Error(`Feature ${tag} not found`);
+            }
+            const { _id } = feature;
+            await validators_1.UpdateProductFeatureSchema.validateAsync(data); // Change to update;
+            await this.validateFeatureData(Object.assign({ tag }, data));
+            if (data.tag && this.fetchFeature(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,
+                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;
+    }
+    fetchFeatures() {
+        return this.product.features;
+    }
+    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)) {
+                await validators_1.CreateProductDatabaseSchema.validateAsync(data);
+                data.envs = data.envs.map((env) => {
+                    const exists = 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) => {
+                    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)
+                    throw new Error(`Database ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateDatabase(tag, data) {
+        try {
+            const db = this.fetchDatabase(tag);
+            if (!db) {
+                throw new Error(`Database  ${tag} not found`);
+            }
+            const { _id, envs } = db;
+            await validators_1.UpdateProductDatabaseSchema.validateAsync(data); // Change to update;
+            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);
+                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);
+                return env;
+            });
+            const overwrite = [];
+            const newEnvs = [];
+            data.envs.map((dataEnv) => {
+                const exists = envs.findIndex((env) => env.slug === dataEnv.slug);
+                if (!this.fetchEnv(dataEnv.slug)) {
+                    throw new Error(`Product Environment ${dataEnv.slug} doesn't exist`);
+                }
+                if (exists === -1) {
+                    if (!dataEnv.connection_url) {
+                        throw new Error(`connection_url is required for new env ${data.envs[exists].slug}`);
+                    }
+                    newEnvs.push(dataEnv);
+                }
+                else {
+                    overwrite.push(Object.assign(Object.assign({}, envs[exists]), dataEnv));
+                }
+            });
+            const unchanged = [];
+            envs.map((env) => {
+                const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                if (!newEnv && !overwriteEnv) {
+                    unchanged.push(env);
+                }
+            });
+            data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            //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);
+        if (!database && throwErrorIfExists)
+            throw new Error(`Database ${tag} not found`);
+        return database;
+    }
+    fetchDatabases() {
+        return this.product.databases;
+    }
+    async createDatabaseAction(data, throwErrorIfExists = false) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [databaseTag, tag] = data.tag.split(':');
+            if (!databaseTag || !tag) {
+                throw new Error(`tag is expected to be defined as "database_tag:action_tag"`);
+            }
+            const exists = 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));
+                    }
+                }
+                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)
+                    throw new Error(`Database Action ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    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"`);
+        }
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const action = database.actions.find((data) => data.tag === actionTag);
+        if (!action && throwErrorIfExists)
+            throw new Error(`Database action ${tag} not found`);
+        if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB && action) {
+            //console.log(action.template)
+            // action.template = JSON.parse(action.template);
+        }
+        return action;
+    }
+    async updateDatabaseAction(data) {
+        try {
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [databaseTag, tag] = data.tag.split(':');
+            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);
+            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;
+            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;
+                }
+                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);
+            }
+            // 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);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const actions = database.actions;
+        if (database.type === productsBuilder_types_1.DatabaseTypes.MONGODB && actions.length) {
+            /*return actions.map((data)=>{
+              return{ ...data,template: JSON.parse(String(data.template))}
+            })*/
+        }
+        return actions;
+    }
+    async createDatabaseMigration(data, throwErrorIfExists) {
+        if (!data.tag) {
+            throw new Error('tag field is required');
+        }
+        const [databaseTag, tag] = data.tag.split(':');
+        if (!databaseTag || !tag) {
+            throw new Error(`tag is expected to be defined as "database_tag:migration_tag"`);
+        }
+        const exists = this.fetchDatabaseMigration(data.tag);
+        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);
+            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)
+                throw new Error(`Database Action ${data.tag} already exists`);
+        }
+    }
+    async updateDatabaseMigration(data) {
+        if (!data.tag) {
+            throw new Error('tag field is required');
+        }
+        const [databaseTag, tag] = data.tag.split(':');
+        if (!databaseTag || !tag) {
+            throw new Error(`tag is expected to be defined as "database_tag:migration_tag"`);
+        }
+        await update_productDatabaseMigration_validator_1.default.validateAsync(Object.assign(Object.assign({}, data), { databaseTag })); // Change to update;
+        const action = this.fetchDatabaseMigration(data.tag);
+        if (!action) {
+            throw new Error(`Migration ${data.tag} not found`);
+        }
+        data.tag = tag;
+        await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, action), Object.assign(Object.assign({}, data), { databaseTag })), { component: enums_1.ProductComponents.DATABASE_MIGRATION }), this.getUserAccess());
+        await this.initializeProduct(this.product_id);
+    }
+    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);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const migration = database.migrations.find((data) => data.tag === migrationTag);
+        if (!migration && throwError)
+            throw new Error(`Database migration ${tag} not found`);
+        return migration;
+    }
+    fetchDatabaseMigrations(databaseTag) {
+        const database = this.product.databases.find((data) => data.tag === databaseTag);
+        if (!database)
+            throw new Error(`Database ${databaseTag} not found`);
+        const migrations = database.migrations;
+        return migrations;
+    }
+    async validateJobEvent(data) {
+        const { type, app, event } = data;
+        if (type === productsBuilder_types_1.JobEventTypes.ACTION) {
+            const appl = await this.fetchThirdPartyAppByAccessTag(app);
+            if (!appl) {
+                throw new Error(`App with access tag ${app} not found`);
+            }
+            const version = appl.versions.find((version) => version.tag === appl.version);
+            const action = version.actions.find((action) => action.tag === event);
+            if (!action) {
+                throw new Error(`Cannot find action ${event} on app ${appl.tag} version ${appl.version}`);
+            }
+        }
+        if (type === productsBuilder_types_1.JobEventTypes.DATABASE_ACTION) {
+            const found = this.fetchDatabaseAction(event);
+            if (!found) {
+                throw new Error(`Database action ${event} not found`);
+            }
+        }
+        if (type === productsBuilder_types_1.JobEventTypes.FUNCTION) {
+            const found = this.fetchFunction(event);
+            if (!found) {
+                throw new Error(`Cloud function ${event} not found`);
+            }
+        }
+        if (type === productsBuilder_types_1.JobEventTypes.STORAGE) {
+            const found = this.fetchStorage(event);
+            if (!found) {
+                throw new Error(`Storage ${event} not found`);
+            }
+        }
+        if (type === productsBuilder_types_1.JobEventTypes.NOTIFICATION) {
+            const found = this.fetchNotification(event);
+            if (!found) {
+                throw new Error(`Notification ${event} not found`);
+            }
+        }
+        if (type === productsBuilder_types_1.JobEventTypes.PUBLISH) {
+            const found = this.fetchMessageBroker(event);
+            if (!found) {
+                throw new Error(`Message Broker ${event} not found`);
+            }
+        }
+    }
+    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)) {
+                await validators_1.CreateProductJobSchema.validateAsync(data);
+                await this.validateJobEvent(data);
+                if (data.type === productsBuilder_types_1.JobEventTypes.ACTION) {
+                    const app = await this.fetchThirdPartyAppByAccessTag(data.app);
+                    if (!app) {
+                        throw new Error(`Invalid app ${data.app}`);
+                    }
+                    const { version, versions } = app;
+                    const myVersion = versions.find((data) => data.tag === version);
+                    if (!myVersion) {
+                        throw new Error(`Invlaid version ${version} for app ${data.app}`);
+                    }
+                    const action = myVersion.actions.findIndex((action) => data.event === action.tag);
+                    if (!action) {
+                        throw new Error(`Invlaid event ${data.event} on version ${version} for app ${data.app}`);
+                    }
+                }
+                if (data.type === productsBuilder_types_1.JobEventTypes.DATABASE_ACTION) {
+                    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)
+                    throw new Error(`Job ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateJob(tag, data) {
+        try {
+            const job = this.fetchJob(tag);
+            if (!job) {
+                throw new Error(`Job ${tag} not found`);
+            }
+            await validators_1.UpdateProductJobSchema.validateAsync(data); // Change to update;
+            await this.validateJobEvent(data);
+            if (data.tag && this.fetchJob(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({}, 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;
+    }
+    fetchJobs() {
+        return this.product.jobs;
+    }
+    getUserAccess() {
+        return {
+            user_id: this.user_id,
+            workspace_id: this.workspace_id,
+            token: this.token,
+            public_key: this.public_key,
+        };
+    }
+}
+exports.default = ProductsBuilderService;
+//# sourceMappingURL=products.service.js.map