@ductape/sdk 0.0.1

package/dist/processor/services/processor.service.js

@@ -0,0 +1,3078 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 products_service_1 = __importDefault(require("../../products/services/products.service"));
+const types_1 = require("../../types");
+const logs_service_1 = __importDefault(require("../../logs/logs.service"));
+const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"));
+const processor_utils_1 = require("../utils/processor.utils");
+const http_client_1 = __importDefault(require("../../clients/http.client"));
+const processorApi_service_1 = require("../../api/services/processorApi.service");
+const expo_client_1 = __importDefault(require("../../clients/expo.client"));
+const handlebars_1 = require("handlebars");
+const string_utils_1 = require("../../products/utils/string.utils");
+const create_productFeature_validator_1 = require("../../products/validators/joi-validators/create.productFeature.validator");
+const validators_1 = require("../../products/validators");
+const uuid_1 = require("uuid");
+const urls_1 = require("../../api/urls");
+//import { createBrokerService } from './messagebrokers';
+const date_fns_1 = require("date-fns");
+const mongo_repo_1 = require("../repos/mongo.repo");
+const postgres_repo_1 = require("../repos/postgres.repo");
+const storage_util_1 = require("../utils/storage.util");
+const sms_repo_1 = require("../repos/sms.repo");
+async function loadBrokerService() {
+    if (typeof window === 'undefined') {
+        const { createBrokerService } = await Promise.resolve().then(() => __importStar(require('./messagebrokers')));
+        return createBrokerService;
+    }
+    return null;
+}
+class ProcessorService {
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client }) {
+        this.workspace_id = workspace_id;
+        this.public_key = public_key;
+        this.user_id = user_id;
+        this.token = token;
+        this.productBuilderService = new products_service_1.default({
+            workspace_id,
+            public_key,
+            user_id,
+            token,
+            env_type,
+        });
+        this.inputService = new inputs_service_1.default();
+        this.processingOutput = {
+            success: [],
+            failure: [],
+            waiting: [],
+            skipped: [],
+        };
+        this.apps = [];
+        this.processorApiService = new processorApi_service_1.ProcessorApiService(env_type);
+        this.environment = env_type;
+        if (redis_client) {
+            this.redisClient = redis_client;
+        }
+    }
+    async registerWebhook(data) {
+        const { product: product_tag, access_tag, webhook_tag, envs } = data;
+        await this.productBuilderService.initializeProductByTag(product_tag);
+        const product = this.productBuilderService.fetchProduct();
+        const { version, envs: appEnvs } = this.productBuilderService.fetchApp(access_tag);
+        const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
+        const { webhooks } = app.versions.find((data) => data.tag === version);
+        if (!webhooks) {
+            throw new Error(`Webhooks not found for app ${access_tag}`);
+        }
+        await validators_1.RegisterWebhookEnvSchema.validateAsync(envs);
+        const webhook = webhooks.find((data) => data.tag === webhook_tag);
+        if (!webhook) {
+            throw new Error(`Webhook tag ${webhook_tag} not found`);
+        }
+        const productEnvs = this.productBuilderService.fetchEnvs();
+        productEnvs.map((env) => {
+            const exists = envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
+            if (exists === -1) {
+                throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
+            }
+        });
+        const dataArray = await Promise.all(envs.map(async (env) => {
+            await this.validateActionDataMappingInput(env.auth, types_1.WebhookEventTypes.WEBHOOK_REGISTER);
+            const productEnvData = productEnvs.find((data) => data.slug === env.slug);
+            if (!productEnvData) {
+                throw new Error(`Error finding product env ${env.slug}`);
+            }
+            const envData = productEnvData.envs.find((productEnvMap) => productEnvMap.product_env_slug === env.slug);
+            if (!envData) {
+                throw new Error(`Error finding env data for ${env.slug}`);
+            }
+            const { app_env_slug: appEnv, product_env_slug: productEnv } = envData;
+            const envWebhookData = webhook.envs.find((webhookEnv) => webhookEnv.slug === appEnv);
+            if (!envWebhookData) {
+                throw new Error(`Error finding webhook registration sample ${webhook_tag} for  env ${env.slug}`);
+            }
+            const uuid = (0, uuid_1.v4)();
+            const url = `${urls_1.WEBHOOK_BASE_URL}/webhooks/v1/process/${uuid}`;
+            let active = false;
+            if (envWebhookData.sample) {
+                const samples = {
+                    query: envWebhookData.sample_data.filter((data) => data.parent_key === 'query'),
+                    params: envWebhookData.sample_data.filter((data) => data.parent_key === 'params'),
+                    body: envWebhookData.sample_data.filter((data) => data.parent_key === 'body'),
+                    headers: envWebhookData.sample_data.filter((data) => data.parent_key === 'headers'),
+                };
+                let payload = (await this.constructJSONDataPayloads(env.auth, {}, samples, {
+                    app: access_tag,
+                    event: '',
+                    input: env.auth,
+                    type: types_1.FeatureEventTypes.ACTION,
+                    retries: 0,
+                    allow_fail: false,
+                }));
+                const { updatedObj, replacedUrl } = (0, processor_utils_1.updateUrlsInObject)(payload, url);
+                if (replacedUrl && replacedUrl !== env.url && replacedUrl) {
+                    throw new Error(`Ductape expects the url ${replacedUrl} in request body to match inputted url ${env.url}`);
+                }
+                const exists = this.fetchEnv(env.slug, {});
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                payload = updatedObj;
+                if (!replacedUrl) {
+                    payload.body.url = url;
+                }
+                const parsedUrl = new URL(envWebhookData.registration_url);
+                await this.sendActionRequest(parsedUrl.origin, parsedUrl.pathname, payload, envWebhookData.method, env.slug);
+                active = true;
+            }
+            return {
+                appEnv,
+                productEnv,
+                uuid,
+                url: env.url,
+                method: env.method,
+                access_tag,
+                webhook_tag,
+                version,
+                sender_workspace_id: app.workspace_id,
+                receiver_workspace_id: product.workspace_id,
+                app_tag: app.tag,
+                product_tag,
+                active,
+            };
+        }));
+        await this.webhookApi.registerWebhooks(dataArray, this.getUserAccess());
+    }
+    async generateWebhookLink(data) {
+        const { product: product_tag, access_tag, webhook_tag, env: product_env, url, method } = data;
+        await this.productBuilderService.initializeProductByTag(product_tag);
+        const product = this.productBuilderService.fetchProduct();
+        const { version, envs: appEnvs } = this.productBuilderService.fetchApp(access_tag);
+        const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
+        const { webhooks } = app.versions.find((data) => data.tag === version);
+        if (!webhooks) {
+            throw new Error(`Webhooks not found for app ${access_tag}`);
+        }
+        const appEnv = appEnvs.find((env) => env.product_env_slug === product_env);
+        if (!appEnv) {
+            throw new Error(`Cannot find product env ${product_env}`);
+        }
+        const uuid = (0, uuid_1.v4)();
+        const payload = {
+            appEnv: appEnv.app_env_slug,
+            productEnv: product_env,
+            uuid,
+            url,
+            method,
+            access_tag,
+            webhook_tag,
+            version,
+            sender_workspace_id: app.workspace_id,
+            receiver_workspace_id: product.workspace_id,
+            app_tag: app.tag,
+            product_tag,
+            active: false,
+        };
+        return await this.webhookApi.generateLink(payload, this.getUserAccess());
+        //return res.link;
+    }
+    async processQuota(data) {
+        this.start = Date.now();
+        this.input = data;
+        const { product: product_tag, env, input, tag: quota_tag } = data;
+        try {
+            this.productTag = product_tag;
+            const additional_logs = {
+                name: 'Process Quota',
+                type: types_1.LogEventTypes.QUOTA,
+                parent_tag: quota_tag,
+            };
+            await this.intializeProduct(additional_logs);
+            const process_id = this.process_id || (0, processor_utils_1.generateObjectId)();
+            this.process_id = process_id;
+            this.baseLogs = {
+                product_tag: this.productTag,
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                env,
+                type: types_1.LogEventTypes.QUOTA,
+                process_id,
+                data: input,
+            };
+            this.quota = this.fetchQuota(quota_tag, additional_logs);
+            this.logService.setFeatureId(this.quota._id);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process quota initiated', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
+            this.processEnv = this.fetchEnv(env, additional_logs);
+            if (!this.processEnv.active) {
+                throw new Error(`Environment ${data.env} is not active`);
+            }
+            const { input: quotaInput, options } = this.quota;
+            // validate feature input and log failure
+            this.validateJSONFeatureInput(input, quotaInput, additional_logs);
+            // split processes
+            //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            return await this.runQuotaOptions(options, additional_logs);
+        }
+        catch (e) {
+            this.end = Date.now();
+            this.logService.publish();
+            throw e;
+        }
+    }
+    async runQuotaOptions(options, additional_logs) { }
+    async runFallbackOptions(options, additional_logs) { }
+    async processFallback(data) {
+        this.start = Date.now();
+        this.input = data;
+        const { product: product_tag, env, input, tag: fallback_tag } = data;
+        try {
+            this.productTag = product_tag;
+            const additional_logs = {
+                name: 'Process Fallback',
+                type: types_1.LogEventTypes.FALLBACK,
+                parent_tag: fallback_tag,
+            };
+            await this.intializeProduct(additional_logs);
+            const process_id = this.process_id || (0, processor_utils_1.generateObjectId)();
+            this.process_id = process_id;
+            this.baseLogs = {
+                product_tag: this.productTag,
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                env,
+                type: types_1.LogEventTypes.QUOTA,
+                process_id,
+                data: input,
+            };
+            this.fallback = this.fetchFallback(fallback_tag, additional_logs);
+            this.logService.setFeatureId(this.quota._id);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process fallback initiated', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
+            this.processEnv = this.fetchEnv(env, additional_logs);
+            if (!this.processEnv.active) {
+                throw new Error(`Environment ${data.env} is not active`);
+            }
+            const { input: fallbackInput, options } = this.fallback;
+            // validate feature input and log failure
+            this.validateJSONFeatureInput(input, fallbackInput, additional_logs);
+            // split processes
+            //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            return await this.runFallbackOptions(options, additional_logs);
+        }
+        catch (e) {
+            this.end = Date.now();
+            this.logService.publish();
+            throw e;
+        }
+    }
+    async processFeature(data) {
+        this.start = Date.now();
+        this.input = data;
+        const { product: product_tag, env, input, tag: feature_tag } = data;
+        let additional_logs;
+        let passedValidation;
+        try {
+            this.productTag = product_tag;
+            additional_logs = {
+                name: 'Process feature',
+                type: types_1.LogEventTypes.FEATURE,
+                parent_tag: feature_tag,
+            };
+            await this.intializeProduct(additional_logs);
+            this.component = types_1.LogEventTypes.FEATURE;
+            const process_id = this.process_id || (0, processor_utils_1.generateObjectId)();
+            this.process_id = process_id;
+            this.baseLogs = {
+                product_tag: this.productTag,
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                env,
+                type: types_1.LogEventTypes.FEATURE,
+                process_id,
+                data: input,
+            };
+            this.feature = this.fetchFeature(feature_tag, additional_logs);
+            this.logService.setFeatureId(this.feature._id);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process feature initiated', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
+            this.processEnv = this.fetchEnv(env, additional_logs);
+            if (!this.processEnv.active) {
+                throw new Error(`Environment ${data.env} is not active`);
+            }
+            const { input: featureInput, sequence, output } = this.feature;
+            // validate feature input and log failure
+            this.validateJSONFeatureInput(input, featureInput, additional_logs);
+            // split processes
+            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            await this.processSequenceLevels(additional_logs);
+            return { process_id };
+            //return this.generateOutput(output as unknown as Record<string, IFeatureOutput>);
+        }
+        catch (e) {
+            this.end = Date.now();
+            if (this.logService) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process feature - failed', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
+                this.logService.publish();
+                if (passedValidation) {
+                    return { process_id: this.process_id };
+                }
+                else {
+                    throw e;
+                }
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async intializeProduct(additional_logs) {
+        try {
+            if (this.productTag) {
+                await this.productBuilderService.initializeProductByTag(this.productTag); // validate product_exists
+            }
+            else {
+                await this.productBuilderService.initializeProduct(this.productId);
+            }
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+            });
+            const { _id: product_id, workspace_id } = this.productBuilderService.fetchProduct();
+            this.productId = product_id;
+            if (workspace_id !== this.workspace_id) {
+                throw new Error('Access Denied');
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Product initialize - success', data: { product_id: this.productId }, status: types_1.LogEventStatus.SUCCESS }));
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Product initialize - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    fetchFeature(tag, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch feature - initiated', data: { tag }, status: types_1.LogEventStatus.PROCESSING }));
+            const feature = this.productBuilderService.fetchFeature(tag); // validate feature exists
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch feature - success', data: { tag, feature }, status: types_1.LogEventStatus.SUCCESS }));
+            return feature;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch feature - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    fetchQuota(tag, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch quota - initiated', data: { tag }, status: types_1.LogEventStatus.PROCESSING }));
+            const quota = this.productBuilderService.fetchQuota(tag); // validate feature exists
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch quota - success', data: { tag, quota }, status: types_1.LogEventStatus.SUCCESS }));
+            return quota;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch quota - failed', data: { tag, e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    fetchFallback(tag, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch fallback - initiated', data: { tag }, status: types_1.LogEventStatus.PROCESSING }));
+            const fallback = this.productBuilderService.fetchFallback(tag); // validate feature exists
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch fallback - success', data: { tag, fallback }, status: types_1.LogEventStatus.SUCCESS }));
+            return fallback;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch fallback - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    fetchEnv(env, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch environment - initiated', data: { slug: env }, status: types_1.LogEventStatus.PROCESSING }));
+            const product_env = this.productBuilderService.fetchEnv(env); // validate env exists
+            if (!product_env) {
+                throw new Error(`Env ${env} not found`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch environment - success', data: { slug: env, env: product_env }, status: types_1.LogEventStatus.SUCCESS }));
+            return product_env;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch environment - failed', data: { slug: env, e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    validateJSONFeatureInput(input, feature_input, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Input validation - initiated', data: { input: (0, processor_utils_1.anonymizeObject)(input), feature_input }, status: types_1.LogEventStatus.PROCESSING }));
+            (0, processor_utils_1.validateFeatureJSONInput)(input, feature_input);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Input validation - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Input validation - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    splitSequenceIntoLevels(data, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Split sequence - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+            const levels = {};
+            const tagMap = new Map(data.map((seq) => [seq.tag, seq]));
+            const assignedLevels = new Map();
+            let currentLevel = 1;
+            let remainingSequences = [...data];
+            while (remainingSequences.length > 0) {
+                const currentLevelSequences = [];
+                remainingSequences = remainingSequences.filter((seq) => {
+                    var _a;
+                    const parentLevels = ((_a = seq.parents) === null || _a === void 0 ? void 0 : _a.map((parent) => { var _a; return (_a = assignedLevels.get(parent)) !== null && _a !== void 0 ? _a : -1; })) || [];
+                    const isCurrentLevel = parentLevels.length === 0 || Math.max(...parentLevels) === currentLevel - 1;
+                    if (isCurrentLevel) {
+                        currentLevelSequences.push(seq);
+                        assignedLevels.set(seq.tag, currentLevel);
+                        return false; // Remove from remainingSequences
+                    }
+                    return true;
+                });
+                if (currentLevelSequences.length > 0) {
+                    levels[currentLevel] = currentLevelSequences;
+                    currentLevel++;
+                }
+                else {
+                    break; // Prevent infinite loop if there's a cycle
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Split sequence - success', data: { levels }, status: types_1.LogEventStatus.SUCCESS }));
+            return levels;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Split sequence - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async processSequenceLevels(additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process levels - initiated', data: { levels: this.sequenceLevels }, status: types_1.LogEventStatus.PROCESSING }));
+            const levelEvents = {};
+            Object.entries(this.sequenceLevels).forEach(([level, sequences]) => {
+                levelEvents[parseInt(level)] = this.fetchLevelEvents(sequences);
+            });
+            let previousLevelComplete = true;
+            for (const level of Object.keys(levelEvents)
+                .map(Number)
+                .sort((a, b) => a - b)) {
+                if (previousLevelComplete) {
+                    previousLevelComplete = await this.processLevelEvents(levelEvents[level], additional_logs);
+                }
+                else {
+                    break;
+                }
+            }
+            if (previousLevelComplete) {
+                this.logService.publish();
+                this.end = Date.now();
+                this.writeResult(types_1.LogEventStatus.SUCCESS);
+            }
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process levels - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async processLevelEvents(events, additional_logs) {
+        const promises = events.map((event) => {
+            const dependants = this.fetchActionRequestDependents(event.input, additional_logs);
+            if (this.checkDependentsSuccess(dependants)) {
+                // TODO: comparison to see if all depending events are in success || dependants is empty
+                return this.processEvent(event);
+            }
+            else {
+                this.addToWaitingOutput(event, dependants);
+            }
+        });
+        return Promise.all(promises);
+    }
+    async processFailedEvents(additional_logs) {
+        const { failure } = this.processingOutput;
+        const promises = failure.map((failed) => {
+            if (failed.retries_left > 0 && new Date().getTime() > failed.retry_at) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Reprocess failed events - initiated', data: Object.assign({}, failed), status: types_1.LogEventStatus.PROCESSING }));
+                return this.processEvent(failed.event); // process events should also take care of this.processingOutput
+            }
+            if (failed.retries_left === 0 && !failed.allow_fail) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Reprocess failed events - failed', data: Object.assign(Object.assign({}, failed), { reason: 'Ran out of Retries' }), status: types_1.LogEventStatus.FAIL }));
+                throw new Error(`Event ${failed.event.event} failed in sequence ${failed.event.sequence_tag}, ran out of retries and the feature cannot run without it succeeding`);
+            }
+        });
+        Promise.all(promises);
+    }
+    async processWaitingEvents(additional_logs) {
+        const { waiting } = this.processingOutput;
+        const promises = waiting.map((waiting) => {
+            const { dependants } = waiting;
+            if (this.checkDependentsSuccess(dependants)) {
+                // TODO: comparison to see if all depending events are in success || dependants is empty
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Reprocess waiting events - initiated', data: Object.assign({}, waiting), status: types_1.LogEventStatus.PROCESSING }));
+                return this.processEvent(waiting.event);
+            }
+            else {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Reprocess waiting events - waiting', data: Object.assign({}, waiting), status: types_1.LogEventStatus.WAITING }));
+            }
+        });
+        return Promise.all(promises);
+    }
+    checkDependentsSuccess(dependants) {
+        let pass = true;
+        for (let i = 0; i < dependants.length; i++) {
+            if (!this.processingOutput.success.find((item) => item.event.sequence_tag === dependants[i].sequence_tag && item.event.event === dependants[i].event_tag)) {
+                pass = false;
+            }
+        }
+        return pass;
+    }
+    fetchActionRequestDependents(input, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch request dependencies - initialized', data: input, status: types_1.LogEventStatus.PROCESSING }));
+            const dependents = [];
+            if (input.query) {
+                dependents.push(...this.fetchDependents(input.query, additional_logs));
+            }
+            if (input.body) {
+                dependents.push(...this.fetchDependents(input.body, additional_logs));
+            }
+            if (input.headers) {
+                dependents.push(...this.fetchDependents(input.headers, additional_logs));
+            }
+            if (input.params) {
+                dependents.push(...this.fetchDependents(input.params, additional_logs));
+            }
+            if (input.data) {
+                dependents.push(...this.fetchDependents(input.data, additional_logs));
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch request dependencies - success', data: { input: (0, processor_utils_1.anonymizeObject)(input), dependents }, status: types_1.LogEventStatus.SUCCESS }));
+            return dependents;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch request dependents - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+        }
+    }
+    fetchDependents(obj, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch dependents - initiated', data: obj, status: types_1.LogEventStatus.PROCESSING }));
+            const dependants = [];
+            for (const key in obj) {
+                const value = obj[key];
+                if (typeof value === 'object') {
+                    if ('function' in value && 'values' in value) {
+                        const { function: func, values } = value;
+                        for (let i = 0; i < values.length; i++) {
+                            if (values[i].startsWith('$Sequence')) {
+                                const stages = this.productBuilderService.extractStages(values[i]);
+                                dependants.push({
+                                    sequence_tag: stages[0],
+                                    event_tag: stages[1],
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        dependants.push(...this.fetchDependents(value, additional_logs));
+                    }
+                }
+                else if (typeof value === 'string') {
+                    if (value.startsWith('$Sequence')) {
+                        const stages = this.productBuilderService.extractStages(value);
+                        dependants.push({ sequence_tag: stages[0], event_tag: stages[1] });
+                    }
+                }
+            }
+            return dependants;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch dependents - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async constructJSONDataPayloads(object, additional_logs, samples, event, loopIndex = 0) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Construct JSON payloads - initiated', data: { object, samples }, status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {};
+            const { body: actionBody, query: actionQuery, headers: actionHeaders, params: actionParams } = object;
+            if (actionBody) {
+                const body = await this.generatePayload(actionBody, event, additional_logs, samples.body, {}, loopIndex);
+                const validationPayload = (await this.inputService.parseJson({
+                    data: body,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                await this.inputService.validateInput(validationPayload, samples.body);
+                Object.assign(payload, {
+                    body,
+                });
+            }
+            if (actionQuery) {
+                const query = await this.generatePayload(actionQuery, event, additional_logs, samples.query, {}, loopIndex);
+                const validationPayload = (await this.inputService.parseJson({
+                    data: query,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                await this.inputService.validateInput(validationPayload, samples.query);
+                Object.assign(payload, {
+                    query,
+                });
+            }
+            if (actionHeaders) {
+                const headers = await this.generatePayload(actionHeaders, event, additional_logs, samples.headers, {}, loopIndex);
+                const validationPayload = (await this.inputService.parseJson({
+                    data: headers,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                await this.inputService.validateInput(validationPayload, samples.headers);
+                Object.assign(payload, {
+                    headers,
+                });
+            }
+            if (actionParams) {
+                const params = await this.generatePayload(actionParams, event, additional_logs, samples.params, {}, loopIndex);
+                const validationPayload = (await this.inputService.parseJson({
+                    data: params,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                await this.inputService.validateInput(validationPayload, samples.params);
+                Object.assign(payload, {
+                    params,
+                });
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Construct JSON payloads - success', data: { payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.SUCCESS }));
+            return payload;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Construct JSON payloads - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async generatePayload(obj, event, additional_logs, sample = [], index = {}, loopIndex = null) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate payload - initiated', data: { obj, event, sample }, status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {};
+            const keys = Object.keys(obj);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const value = obj[key];
+                if (typeof value === 'object') {
+                    // check if function or object
+                    if ('function' in value && 'values' in value) {
+                        // Object.assign(payload, { [key]: await this.generateFunctionResult(value.function, value.values, sample) });
+                    }
+                    else {
+                        const new_level = index.level ? index.level + 1 : 1;
+                        index = { parent_key: key, level: new_level };
+                        // TODO: how to pass sample into this
+                        Object.assign(payload, {
+                            [key]: await this.generatePayload(value, event, additional_logs, sample),
+                        });
+                    }
+                }
+                else if (typeof value === 'string') {
+                    const app = event ? event.app || event.event : null;
+                    Object.assign(payload, {
+                        [key]: await this.generateStringValues(value, app, additional_logs, sample, index, key, loopIndex),
+                    });
+                }
+                else {
+                    // allow hardcoded values that are not numbers
+                    Object.assign(payload, {
+                        [key]: value,
+                    });
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate payload - success', data: { payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.SUCCESS }));
+            return payload;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generating payload - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async generateStringValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        value = (0, processor_utils_1.removeWrappingQuotes)(value);
+        const stages = this.productBuilderService.extractStages(value);
+        const locatorFor$Index = (0, string_utils_1.validateAndLocateTag)(value);
+        if (value.startsWith('$Auth{') && value.endsWith('}')) {
+            // should only be allowed in apps
+            return await this.generateAuthValue(stages, app, sample, additional_logs);
+        }
+        else if (value.startsWith('$Sequence{') && value.endsWith('}')) {
+            return await this.generateSequenceValue(stages, locatorFor$Index, loopIndex); // pass
+        }
+        else if (value.startsWith('$Input{') && value.endsWith('}')) {
+            return await this.generateInputValue(this.input.input, stages);
+        }
+        else if (value === '$Default') {
+            return await this.generateDefaultValue(sample, Object.assign(Object.assign({}, index), { key }));
+        }
+        else if (value.startsWith('$Variable{') && value.endsWith('}')) {
+            return await this.generateVariableValue(stages);
+        }
+        else if (value.startsWith('$Constant{') && value.endsWith('}')) {
+            return await this.generateConstantValue(stages);
+        }
+        else if (value.startsWith('$Size{') || value.startsWith('$Length{')) {
+            const { matchLength, matchSize } = (0, string_utils_1.checkLengthAndSizeMatches)(value);
+            let content;
+            if (matchLength) {
+                content = matchLength[1];
+                return (await this.generateStringValues(content, app, additional_logs, sample, index, key)).length;
+            }
+            else if (matchSize) {
+                // Added safeguard for $Size match
+                content = matchSize[1];
+                return Object.keys(await this.generateStringValues(content, app, additional_logs, sample, index, key)).length;
+            }
+        }
+        else if (value === '$Now') {
+            return Date.now();
+        }
+        else if (value === '$Date') {
+            return new Date().toISOString();
+        }
+        else if (!value.startsWith('$')) {
+            // allow hardcoded values
+            return value;
+        }
+        else {
+            // should be a ductape operator
+            return await this.generateOperatorValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+    }
+    async generateOperatorValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        if (value.startsWith('$Add(') && value.endsWith(')')) {
+            return await this.sumValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Substract(') && value.endsWith(')')) {
+            return await this.sumValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Pick(') && value.endsWith(')')) {
+            return await this.pickValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Concat(') && value.endsWith(')')) {
+            return await this.concatValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Substring(') && value.endsWith(')')) {
+            return await this.substringValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Trim(') && value.endsWith(')')) {
+            return await this.trimValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Join(') && value.endsWith(')')) {
+            return await this.joinArrays(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Split(') && value.endsWith(')')) {
+            return await this.splitValues(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Uppercase(') && value.endsWith(')')) {
+            return await this.uppercaseValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Lowercase(') && value.endsWith(')')) {
+            return await this.lowercaseValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Dateformat(') && value.endsWith(')')) {
+            return await this.dateFormatValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Replace(') && value.endsWith(')')) {
+            return await this.replaceValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Filter(') && value.endsWith(')')) {
+            return await this.filterValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else if (value.startsWith('$Find(') && value.endsWith(')')) {
+            return await this.findValue(value, app, additional_logs, sample, index, key, loopIndex);
+        }
+        else {
+            throw new Error(`Invalid value input ${value}`);
+        }
+    }
+    async sumValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.sumRegex);
+        if (match && match[1]) {
+            const placeHolders = match[1].split(',').map((data) => data.trim());
+            const values = await Promise.all(placeHolders.map(async (holder) => {
+                return await this.generateStringValues(holder, app, additional_logs, sample, index, key, loopIndex);
+            }));
+            const numericValues = values.map((val, i) => {
+                const num = Number(val);
+                if (isNaN(num)) {
+                    throw new Error(`Value at index ${i} ('${placeHolders[i]}' => '${val}') is not a valid number`);
+                }
+                return num;
+            });
+            return numericValues.reduce((acc, num) => acc + num, 0);
+        }
+        else {
+            return 0;
+        }
+    }
+    async subtractValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.substringRegex);
+        if (match && match[1]) {
+            const placeHolders = match[1].split(',').map((data) => data.trim());
+            const values = await Promise.all(placeHolders.map(async (holder) => {
+                return await this.generateStringValues(holder, app, additional_logs, sample, index, key, loopIndex);
+            }));
+            const numericValues = values.map((val, i) => {
+                const num = Number(val);
+                if (isNaN(num)) {
+                    throw new Error(`Value at index ${i} ('${placeHolders[i]}' => '${val}') is not a valid number`);
+                }
+                return num;
+            });
+            // Subtract the numbers in sequence (first value minus the rest)
+            const result = numericValues.reduce((acc, num) => acc - num);
+            return result;
+        }
+        else {
+            return 0;
+        }
+    }
+    async concatValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.concatRegex);
+        if (match) {
+            const placeholdersStr = match[1];
+            const separator = match[2];
+            const placeHolders = placeholdersStr.split(',').map((data) => data.trim());
+            const values = await Promise.all(placeHolders.map(async (holder) => {
+                return await this.generateStringValues(holder, app, additional_logs, sample, index, key, loopIndex);
+            }));
+            return values.join(separator);
+        }
+        else {
+            console.log('No match found');
+        }
+    }
+    async uppercaseValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.uppercaseRegex);
+        if (match) {
+            const resolvedValue = await this.generateStringValues(match[1].trim(), app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedValue !== 'string') {
+                throw new Error(`Resolved value ('${resolvedValue}') is not a string.`);
+            }
+            return resolvedValue.toUpperCase();
+        }
+        else {
+            //console.log('No match found');
+        }
+    }
+    async lowercaseValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.lowercaseRegex);
+        if (match) {
+            const resolvedValue = await this.generateStringValues(match[1].trim(), app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedValue !== 'string') {
+                throw new Error(`Resolved value ('${resolvedValue}') is not a string.`);
+            }
+            return resolvedValue.toLowerCase();
+        }
+        else {
+            //console.log('No match found');
+        }
+    }
+    async dateFormatValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.dateFormatRegex);
+        if (match) {
+            const expression = match[1].trim();
+            const formatStr = match[3].trim();
+            const resolvedDate = await this.generateStringValues(expression, app, additional_logs, sample, index, key, loopIndex);
+            const parsedDate = typeof resolvedDate === 'string' ? (0, date_fns_1.parseISO)(resolvedDate) : new Date(resolvedDate);
+            if (isNaN(parsedDate.getTime())) {
+                throw new Error(`Resolved date ('${resolvedDate}') is invalid.`);
+            }
+            return (0, date_fns_1.format)(parsedDate, formatStr);
+        }
+        else {
+            //console.log('No match found');
+        }
+    }
+    async replaceValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.replaceRegex);
+        if (match) {
+            const [_, strPlaceholder, , searchStr, , replaceStr] = match;
+            const resolvedValue = await this.generateStringValues(strPlaceholder.trim(), app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedValue !== 'string') {
+                throw new Error(`Resolved value ('${resolvedValue}') is not a string.`);
+            }
+            return resolvedValue.split(searchStr).join(replaceStr);
+        }
+        else {
+            console.log('No match found');
+        }
+    }
+    async substringValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.substringRegex);
+        if (match) {
+            const [_, stringPlaceholder, startStr, endStr] = match;
+            const start = Number(startStr);
+            const end = Number(endStr);
+            if (isNaN(start) || isNaN(end)) {
+                throw new Error(`Start and end indexes must be valid numbers (received start: '${startStr}', end: '${endStr}').`);
+            }
+            const resolvedString = await this.generateStringValues(stringPlaceholder.trim(), app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedString !== 'string') {
+                throw new Error(`Resolved value ('${resolvedString}') is not a string.`);
+            }
+            return resolvedString.substring(start, end);
+        }
+        else {
+            console.log('No match found');
+            return '';
+        }
+    }
+    async trimValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.trimRegex);
+        if (match) {
+            const stringPlaceholder = match[1].trim();
+            const resolvedString = await this.generateStringValues(stringPlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedString !== 'string') {
+                throw new Error(`Resolved value ('${resolvedString}') is not a string.`);
+            }
+            return resolvedString.trim();
+        }
+        else {
+            console.log('No match found');
+            return '';
+        }
+    }
+    async pickValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.pickRegex);
+        if (match) {
+            const valuePlaceholder = match[1].trim();
+            const indexToPick = Number(await this.generateStringValues(match[2], app, additional_logs, sample, index, key, loopIndex));
+            if (isNaN(indexToPick)) {
+                throw new Error(`Index '${match[2]}' is not a valid number.`);
+            }
+            const resolvedValue = await this.generateStringValues(valuePlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedValue === 'string' || Array.isArray(resolvedValue)) {
+                if (indexToPick < 0 || indexToPick >= resolvedValue.length) {
+                    throw new Error(`Index ${indexToPick} is out of bounds for the provided value.`);
+                }
+                return resolvedValue[indexToPick];
+            }
+            else {
+                throw new Error(`Resolved value ('${resolvedValue}') is not a string or array.`);
+            }
+        }
+        else {
+            console.log('No match found');
+        }
+    }
+    async filterValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.filterRegex);
+        if (match) {
+            const arrayPlaceholder = match[1].trim();
+            const operator = match[2].trim();
+            const valueToCompare = match[3].trim();
+            if (!types_1.ValidOperators.includes(operator)) {
+                throw new Error(`Invalid operator: ${operator}`);
+            }
+            const resolvedArray = await this.generateStringValues(arrayPlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            const resolvedValue = await this.generateStringValues(valueToCompare, app, additional_logs, sample, index, key, loopIndex);
+            if (!Array.isArray(resolvedArray)) {
+                throw new Error(`Resolved value for array ('${resolvedArray}') is not an array.`);
+            }
+            return resolvedArray.filter((item) => (0, processor_utils_1.compareValues)(item, operator, resolvedValue));
+        }
+        console.log('No $Filter match found');
+        return [];
+    }
+    async findValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.findRegex);
+        if (match) {
+            const arrayPlaceholder = match[1].trim();
+            const operator = match[2].trim();
+            const valueToCompare = match[3].trim();
+            if (!types_1.ValidOperators.includes(operator)) {
+                throw new Error(`Invalid operator: ${operator}`);
+            }
+            const resolvedArray = await this.generateStringValues(arrayPlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            const resolvedValue = await this.generateStringValues(valueToCompare, app, additional_logs, sample, index, key, loopIndex);
+            if (!Array.isArray(resolvedArray)) {
+                throw new Error(`Resolved value for array ('${resolvedArray}') is not an array.`);
+            }
+            return resolvedArray.find((item) => (0, processor_utils_1.compareValues)(item, operator, resolvedValue));
+        }
+        console.log('No $Find match found');
+        return null;
+    }
+    async splitValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.splitRegex);
+        if (match) {
+            const stringPlaceholder = match[1].trim();
+            const separator = await this.generateStringValues(match[2], app, additional_logs, sample, index, key, loopIndex);
+            const resolvedString = await this.generateStringValues(stringPlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            if (typeof resolvedString !== 'string') {
+                throw new Error(`Resolved value ('${resolvedString}') is not a string.`);
+            }
+            return resolvedString.split(separator);
+        }
+        else {
+            console.log('No match found');
+            return [];
+        }
+    }
+    async joinArrays(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
+        const match = value.match(types_1.joinRegex);
+        if (match) {
+            const arraysPlaceholder = match[1].trim();
+            const resolvedArrays = await this.generateStringValues(arraysPlaceholder, app, additional_logs, sample, index, key, loopIndex);
+            if (!Array.isArray(resolvedArrays)) {
+                throw new Error(`Resolved value ('${JSON.stringify(resolvedArrays)}') is not an array.`);
+            }
+            const mergedArray = resolvedArrays.reduce((acc, current) => {
+                if (!Array.isArray(current)) {
+                    throw new Error(`Element '${JSON.stringify(current)}' is not an array.`);
+                }
+                return acc.concat(current);
+            }, []);
+            return mergedArray;
+        }
+        else {
+            console.log('No match found');
+        }
+    }
+    async generateInputValue(input, stages) {
+        try {
+            if (stages.length === 1) {
+                return input[stages[0]];
+            }
+            if (typeof input[stages[0]] !== 'object') {
+                throw new Error(`Nested input ${input[stages[0]]} should be an object or array`);
+            }
+            stages.shift();
+            return this.generateInputValue(input[stages[0]], stages);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async generateSequenceValue(stages, indexLocator = null, indexValue = null) {
+        try {
+            // find out put in success array using event and success tags
+            const result = this.processingOutput.success.find((item) => item.event.event === stages[1] && item.event.sequence_tag === stages[0]);
+            const cleanedStages = stages.slice(2); // remove event and sequence tags
+            let locator = indexLocator;
+            if (indexLocator) {
+                locator = indexLocator - 2; // adjust to handle cleaned stages
+            }
+            if (result && result.output) {
+                return this.fetchOutputValueAfterStrippingLocators(cleanedStages, result.output, locator, indexValue);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchOutputValueAfterStrippingLocators(stages, output, indexLocator = null, indexValue = null, stageIndex = 0) {
+        try {
+            let next;
+            if (stages.length === 0) {
+                return output;
+            }
+            //const arrayIndex = extractNumberFromArrayString(stages[0]);
+            if (indexLocator !== stageIndex) {
+                // is not an array
+                next = output[stages[0]];
+            }
+            else if (indexValue) {
+                next = output[indexValue];
+            }
+            if (!next) {
+                // throw error for when next value is not found
+            }
+            if (stages.length === 1) {
+                return next;
+            }
+            if (typeof next === 'object' && stages.length) {
+                stages.shift();
+                return this.fetchOutputValueAfterStrippingLocators(stages, next, indexLocator, indexValue, stageIndex + 1);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async generateDefaultValue(sample, index) {
+        try {
+            const value = sample.find((item) => item.key === index.key && item.level === index.level && item.parent_key === index.parent_key);
+            if (!value || !value.defaultValue) {
+                throw new Error(`Cannot find default value of ${index}`);
+            }
+            return value.defaultValue;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async generateVariableValue(stages) {
+        try {
+            const app = this.productBuilderService.fetchApp(stages[0]);
+            const env = app.envs.find((items) => items.product_env_slug === this.processEnv.slug);
+            if (!env) {
+                throw new Error(`App ${stages[0]} variables needs to have a definition for env: ${this.processEnv.slug}`);
+            }
+            const { variables } = env;
+            const found = variables.find((item) => item.key === stages[1]);
+            if (!found) {
+                throw new Error(`Variable ${stages[1]} not found declared for app ${stages[0]} in ${this.processEnv.slug}`);
+            }
+            return found.value;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async generateConstantValue(stages) {
+        try {
+            const app = await this.fetchThirdPartyApp(stages[0]);
+            const found = app.constants.find((data, index) => data.key === stages[1]);
+            if (!found) {
+                throw new Error(`Constant ${stages[1]} not found declared for app ${stages[0]} in`);
+            }
+            return found.value;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    decorateValue(value, sample) {
+        if (sample.decorator) {
+            if (sample.decoratorPosition &&
+                sample.decoratorPosition == types_1.DecoratorPostions.APPEND &&
+                !value.endsWith(sample.decorator)) {
+                return `${value} ${sample.decorator}`;
+            }
+            if (sample.decoratorPosition &&
+                sample.decoratorPosition == types_1.DecoratorPostions.PREPEND &&
+                !value.startsWith(sample.decorator)) {
+                return `${sample.decorator} ${value}`;
+            }
+        }
+        return value;
+    }
+    async generateAuthValue(stages, app, sample, additional_logs) {
+        try {
+            let auth_data = await this.fetchAuthData(app, additional_logs); //TODO: should use stages[0]
+            // take the app tag in index 0..
+            if (!auth_data) {
+                throw new Error(`Cannot fetch auth data of app ${app}`);
+            }
+            stages.shift();
+            const auth = this.fetchOutputValueAfterStrippingLocators(stages, auth_data);
+            return this.decorateValue(auth, sample[0]);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchAuthData(app_tag, additional_logs) {
+        try {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching auth data - initiated', data: { app_tag, env: this.processEnv.slug }, status: types_1.LogEventStatus.PROCESSING }));
+            const app = this.productBuilderService.fetchApp(app_tag);
+            if (!app) {
+                throw new Error(`App ${app_tag} not found in $Auth value`);
+            }
+            const env = app.envs.find((item) => item.product_env_slug === this.processEnv.slug);
+            if (!env) {
+                throw new Error(`App ${app_tag} in auth needs to have a definition for env: ${this.processEnv.slug}`);
+            }
+            if (!env.auth) {
+                throw new Error(`App ${app_tag} in auth needs to have a definition for auth in env: ${this.processEnv.slug}`);
+            }
+            let values = env.auth.values;
+            if (!values) {
+                // no auth values
+                values = await this.getAndStoreAuth(env, app_tag);
+            }
+            if (!env.auth.expiry || (env.auth.expiry && Date.now() > new Date(env.auth.expiry).getTime())) {
+                // refresh
+                values = await this.getAndStoreAuth(env, app_tag);
+            }
+            const decrypted = (0, processor_utils_1.decrypt)(values, this.productBuilderService.fetchProduct().private_key);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch auth data - success', data: { auth: (0, processor_utils_1.anonymizeValue)(decrypted) }, status: types_1.LogEventStatus.SUCCESS }));
+            return JSON.parse(decrypted);
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching auth data - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    /*async runFallback(event: IFallbackEvent) {
+  
+    }
+  
+    async runQuota(event: IQuotaEvent) {
+  
+    }*/
+    async processEvent(event) {
+        try {
+            const success = this.processingOutput.success.find((data) => data.event.sequence_tag === event.sequence_tag && data.event.event === event.event);
+            if (success) {
+                return success.output;
+            }
+            /*if(event.type === FeatureEventTypes.QUOTA) {
+              this.logService.add({
+                ...this.baseLogs,
+                child_tag: event.event,
+                data: {event},
+                message: "Processing Quota",
+                status: LogEventStatus.PROCESSING
+              })
+              return this.runQuota(event as unknown as IQuotaEvent);
+            }
+      
+            if(event.type === FeatureEventTypes.FALLBACK) {
+              this.logService.add({
+                ...this.baseLogs,
+                child_tag: event.event,
+                data: {event},
+                message: "Processing Fallback",
+                status: LogEventStatus.PROCESSING
+              })
+              return this.runFallback(event as unknown as IFallbackEvent);
+            }*/
+            if (event.type === types_1.FeatureEventTypes.ACTION) {
+                const additional_logs = {
+                    parent_tag: (0, string_utils_1.extractOriginAndTag)(event.app),
+                    child_tag: event.event,
+                    type: types_1.LogEventTypes.ACTION,
+                    name: 'Process feature action',
+                };
+                return this.runAction(event, additional_logs);
+            }
+            if (event.type === types_1.FeatureEventTypes.DB_ACTION) {
+                const [parent_tag, child_tag] = event.event.split(':');
+                const additional_logs = {
+                    parent_tag,
+                    child_tag,
+                    type: types_1.LogEventTypes.DB_ACTION,
+                    name: 'Process feature database action',
+                };
+                return this.runDBAction(event, additional_logs);
+            }
+            if (event.type === types_1.FeatureEventTypes.STORAGE) {
+                this.clone = (0, processor_utils_1.structuredClone)(event);
+                (0, processor_utils_1.cleanBlob)(this.clone);
+                const additional_logs = {
+                    parent_tag: event.event,
+                    type: types_1.LogEventTypes.STORAGE,
+                    name: 'Process feature storage',
+                };
+                return this.runStorage(event, additional_logs);
+            }
+            if (event.type === types_1.FeatureEventTypes.FEATURE) {
+                // this.processFeature({})
+                // this.processFeature TODO: do some processing to get this to reuse this.processFeature from abov
+            }
+            if (event.type === types_1.FeatureEventTypes.NOTIFICATION) {
+                const [parent_tag, child_tag] = event.event.split(':');
+                const additional_logs = {
+                    parent_tag,
+                    child_tag,
+                    type: types_1.LogEventTypes.NOTIFICATIONS,
+                    name: 'Process feature notification',
+                };
+                return this.runNotification(event, additional_logs);
+            }
+            if (event.type === types_1.FeatureEventTypes.PUBLISH) {
+                const [parent_tag, child_tag] = event.event.split(':');
+                const additional_logs = {
+                    parent_tag,
+                    child_tag,
+                    type: types_1.LogEventTypes.MESSAGEBROKER,
+                    name: 'Process feature broker event',
+                };
+                try {
+                    console.log("GRENADYE ALASOOOO!");
+                    return this.runBrokerPublish(event, additional_logs);
+                }
+                catch (e) {
+                    console.log("GRENADYE ALASOOOO!!!!");
+                }
+            }
+            if (event.type === types_1.FeatureEventTypes.JOB) {
+                const additional_logs = {
+                    type: types_1.LogEventTypes.JOB,
+                    parent_tag: event.event,
+                    name: 'Process feature job',
+                };
+                return this.runJob(event, additional_logs);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    runJob(event, additional_logs) {
+        throw new Error('Method not implemented.');
+    }
+    async processFailedAndWaiting() { }
+    async generateOutput(process_id) {
+        var _a, _b, _c, _d;
+        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+        if (!result) {
+            throw new Error(`Invalid process id ${process_id}`);
+        }
+        if (result.component === types_1.LogEventTypes.FEATURE) {
+            const additional_logs = {
+                parent_tag: result.input.tag,
+                type: types_1.LogEventTypes.FEATURE,
+                name: 'Fetching Process Result',
+            };
+            if (result.status === types_1.LogEventStatus.SUCCESS) {
+                this.productTag = result.input.product;
+                await this.intializeProduct(additional_logs);
+                this.processingOutput = result.result;
+                this.process_id = process_id;
+                this.input = result.input;
+                this.feature = await this.fetchFeature(result.input.tag, additional_logs);
+                const { input: featureInput, sequence, output } = this.feature;
+                const data = await this.generatePayload(output, null, additional_logs, []);
+                return { process_id, status: result.status, data };
+            }
+            else if (result.status === types_1.LogEventStatus.FAIL) {
+                const errors = result.result.failure.map((data) => data.reason);
+                return { process_id, status: result.status, errors };
+            }
+        }
+        else {
+            if ((_a = result.result.success[0]) === null || _a === void 0 ? void 0 : _a.output) {
+                return { process_id, status: result.status, data: (_b = result.result.success[0]) === null || _b === void 0 ? void 0 : _b.output };
+            }
+            else if ((_c = result.result.failure[0]) === null || _c === void 0 ? void 0 : _c.reason) {
+                return { process_id, status: result.status, errors: [(_d = result.result.failure[0]) === null || _d === void 0 ? void 0 : _d.reason] };
+            }
+            else {
+                return { process_id, status: result.status };
+            }
+        }
+    }
+    async resumeProcess(process_id) {
+        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+        if (!result) {
+            throw new Error(`Invalid process id ${process_id}`);
+        }
+        const additional_logs = {
+            parent_tag: result.input.tag,
+            type: result.component,
+            name: 'Resume Process',
+        };
+        this.productTag = result.input.product;
+        await this.intializeProduct(additional_logs);
+        this.processingOutput = result.result;
+        this.process_id = process_id;
+        await this.processFailedEvents(additional_logs);
+        await this.processWaitingEvents(additional_logs);
+        this.input = result.input;
+        this.start = Date.now();
+        if (result.component === types_1.LogEventTypes.FEATURE) {
+            this.feature = await this.fetchFeature(result.input.tag, additional_logs);
+            const { input: featureInput, sequence, output } = this.feature;
+            this.processEnv = this.fetchEnv(result.env, additional_logs);
+            if (!this.processEnv.active) {
+                throw new Error(`Environment ${result.env} is not active`);
+            }
+            // validate feature input and log failure
+            this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
+            // split processes
+            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            await this.processSequenceLevels(additional_logs);
+        }
+        else {
+            this.end = Date.now();
+            let status = types_1.LogEventStatus.SUCCESS;
+            if (this.processingOutput.failure.length > 0) {
+                status = types_1.LogEventStatus.FAIL;
+            }
+            this.writeResult(status);
+        }
+        return { process_id };
+    }
+    async replayProcess(process_id) {
+        var _a, _b, _c;
+        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+        if (!result) {
+            throw new Error(`Invalid process id ${process_id}`);
+        }
+        this.productTag = result.input.product;
+        this.process_id = process_id;
+        this.input = result.input;
+        this.start = Date.now();
+        this.component = result.component;
+        const additional_logs = {
+            parent_tag: result.input.tag,
+            type: result.component,
+            name: 'Replay Process',
+        };
+        await this.intializeProduct(additional_logs);
+        //await this.processFailedEvents(additional_logs);
+        if (result.component === types_1.LogEventTypes.FEATURE) {
+            //await this.processWaitingEvents(additional_logs);
+            this.feature = await this.fetchFeature(result.input.tag, additional_logs);
+            const { input: featureInput, sequence, output } = this.feature;
+            this.processEnv = this.fetchEnv(result.env, additional_logs);
+            if (!this.processEnv.active) {
+                throw new Error(`Environment ${result.env} is not active`);
+            }
+            // validate feature input and log failure
+            this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
+            // split processes
+            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            await this.processSequenceLevels(additional_logs);
+        }
+        else {
+            const event = ((_a = result.result.failure[0]) === null || _a === void 0 ? void 0 : _a.event) ||
+                ((_b = result.result.success[0]) === null || _b === void 0 ? void 0 : _b.event) ||
+                ((_c = result.result.skipped[0]) === null || _c === void 0 ? void 0 : _c.event) ||
+                result.result.waiting[0].event;
+            this.processEnv = this.fetchEnv(result.env, additional_logs);
+            this.start = Date.now();
+            await this.processEvent(event);
+            this.end = Date.now();
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+        }
+        return { process_id };
+    }
+    fetchLevelEvents(level) {
+        const events = [];
+        for (let i = 0; i < level.length; i++) {
+            events.push(...this.appendSequenceDataToLevelEvents(level[i]));
+        }
+        return events;
+    }
+    appendSequenceDataToLevelEvents(sequence) {
+        const { events, level, tag } = sequence;
+        for (let i = 0; i < events.length; i++) {
+            events[i].sequence_level = level;
+            events[i].sequence_tag = tag;
+            events[i].env = this.processEnv;
+        }
+        return events;
+    }
+    async getAndStoreAuth(appEnv, access_tag) {
+        try {
+            //  const payload = JSON.parse(decrypt(env.auth.data, this.productBuilderService.fetchProduct().private_key));
+            const payload = appEnv.auth.data;
+            let app = await this.fetchThirdPartyApp(access_tag);
+            const auth = app.auths.find((item) => item.tag === appEnv.auth.auth_tag);
+            if (!auth) {
+                // throw an error
+                throw new Error(`Cannot find auth ${appEnv.auth.auth_tag} on environment ${appEnv.product_env_slug}`);
+            }
+            if (auth.setup_type === types_1.AuthTypes.CREDENTIALS) {
+                const { action_tag, expiry, period } = auth;
+                const action = app.actions.find((item) => item.tag === action_tag);
+                const { envs: appEnvs } = app;
+                const env = appEnvs.find((item) => item.slug === appEnv.app_env_slug); // fetch the actuall app Environment variable
+                const { method, base_url, resource: url } = action;
+                let request_base_url = base_url;
+                if (env.base_url) {
+                    request_base_url = env.base_url;
+                }
+                const results = await this.sendActionRequest(request_base_url, url, payload, method, appEnv.app_env_slug);
+                const values = (0, processor_utils_1.encrypt)(JSON.stringify(results), this.productBuilderService.fetchProduct().private_key);
+                const productApp = this.productBuilderService.fetchApp(access_tag);
+                for (let i = 0; i < productApp.envs.length; i++) {
+                    if (productApp.envs[i].app_env_slug === env.slug) {
+                        productApp.envs[i].auth.values = values; // write new values
+                        productApp.envs[i].auth.expiry = (0, processor_utils_1.calculateExpiry)(expiry, period); // write new expiry
+                    }
+                }
+                await this.productBuilderService.updateApp(access_tag, productApp); // stores auth values
+                return values;
+            }
+            else {
+                return appEnv.auth.values;
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async fetchThirdPartyApp(access_tag) {
+        try {
+            let details = this.apps.find((item) => item.access_tag === access_tag);
+            let version;
+            let workspace_id;
+            let _id;
+            if (!details) {
+                const _a = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag), { version: appVersion } = _a, app = __rest(_a, ["version"]);
+                version = appVersion;
+                workspace_id = app.workspace_id;
+                _id = app._id;
+                details = { access_tag, app, version, workspace_id: app.workspace_id, _id: app._id };
+                this.apps.push(details);
+            }
+            else {
+                version = details.version;
+                workspace_id = details.workspace_id;
+                _id = details._id;
+            }
+            const appVersion = details.app.versions.find((data) => data.tag === version);
+            return Object.assign(Object.assign({}, appVersion), { workspace_id, _id, version });
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async processConditionalCheck(event, additional_logs = {}) {
+        const parts = (0, string_utils_1.extractConditionalParts)(event.condition.check);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Check conditional - initiated', data: { condition: event.condition, parts }, status: types_1.LogEventStatus.PROCESSING, action: event.event }));
+        const [, initiator, operator, value] = parts;
+        const initiatorValue = await this.generateStringValues(initiator, event.app, additional_logs);
+        let valueValue;
+        if (!(0, string_utils_1.isNumeric)(value)) {
+            if (value.startsWith('$')) {
+                valueValue = await this.generateStringValues(value, event.app, additional_logs);
+            }
+        }
+        else {
+            valueValue = value;
+        }
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate check conditional - initiated', data: { condition: { initiatorValue, operator, valueValue } }, status: types_1.LogEventStatus.PROCESSING, action: event.event }));
+        const pass = (0, processor_utils_1.compareValues)(initiatorValue, operator, valueValue);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate check condition - success', data: { condition: { initiatorValue, operator, valueValue }, pass }, status: types_1.LogEventStatus.SUCCESS, action: event.event }));
+        if (!pass) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate check condition - skipped', data: { condition: { initiatorValue, operator, valueValue }, pass }, status: types_1.LogEventStatus.SUCCESS, action: event.event }));
+            // add to skipped queue
+            this.processingOutput.skipped.push({
+                allow_fail: false,
+                retry_at: 0,
+                error_code: 0,
+                reason: `check condition "${initiatorValue} ${operator} ${valueValue} failed, event skipped`,
+                payload: {
+                    query: {},
+                    params: {},
+                    body: {},
+                    headers: {},
+                },
+                event: event,
+            });
+            return false;
+        }
+        return true;
+    }
+    async extractLoopIndexes(event, additional_logs = {}) {
+        const parts = (0, string_utils_1.extractConditionalParts)(event.condition.check);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Loop conditional - initiated', data: { condition: event.condition, parts }, status: types_1.LogEventStatus.PROCESSING, action: event.event }));
+        const [, initiator, operator, value] = parts;
+        let valueValue;
+        if (!(0, string_utils_1.isNumeric)(value)) {
+            if (value.startsWith('$')) {
+                valueValue = await this.generateStringValues(value, event.app, additional_logs);
+            }
+        }
+        else {
+            valueValue = value;
+        }
+        const init = event.condition.init || 0;
+        const iter = event.condition.iter || 1;
+        // generate indexes
+        return (0, processor_utils_1.generateIndexes)(operator, iter, init, valueValue);
+    }
+    async runAction(event, additional_logs, returnValue = false) {
+        try {
+            const { event: action_tag, app: access_tag, condition, cache: cache_tag } = event;
+            let indexes = [];
+            if (condition &&
+                condition.type === types_1.Conditions.CHECK &&
+                (await this.processConditionalCheck(event, additional_logs))) {
+                // if it fails, it would add to skipped queue
+                return;
+            }
+            if (condition && condition.type === types_1.Conditions.LOOP) {
+                indexes = await this.extractLoopIndexes(event, additional_logs);
+            }
+            let app = await this.fetchThirdPartyApp(access_tag);
+            const { actions, envs: appEnvs, retries, workspace_id: recipient_workspace_id, active } = app;
+            const productApp = this.productBuilderService.fetchApp(access_tag);
+            const { envs: productEnvs, version } = productApp;
+            const { app_env_slug } = productEnvs.find((item) => item.product_env_slug === this.processEnv.slug);
+            additional_logs.app_env = app_env_slug;
+            const env = appEnvs.find((item) => item.slug === app_env_slug); // fetch the actuall app Environment variable
+            if (!active) {
+                throw new Error(`App ${event.app} version ${app.version} is not active`);
+            }
+            if (!env.active) {
+                throw new Error(`Action environment ${app_env_slug} is not active`);
+            }
+            const action = actions.find((item) => item.tag === action_tag);
+            if (!action) {
+                throw new Error(`Action ${action_tag} not found in ${access_tag}`);
+            }
+            const { query, headers, body, params, request_type, method, base_url, resource } = action;
+            let request_base_url = base_url;
+            if (env.base_url) {
+                request_base_url = env.base_url;
+            }
+            const samples = {
+                query: (query === null || query === void 0 ? void 0 : query.data) || [],
+                headers: (headers === null || headers === void 0 ? void 0 : headers.data) || [],
+                body: (body === null || body === void 0 ? void 0 : body.data) || [],
+                params: (params === null || params === void 0 ? void 0 : params.data) || [],
+            };
+            let payloads;
+            let result;
+            const product = this.productBuilderService.fetchProduct();
+            if (cache_tag && this.redisClient) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(event.input);
+                const check = await this.fetchFromCache({
+                    cache_tag,
+                    input: inputString,
+                    privateKey: product.private_key,
+                    expiry: productCache.expiry,
+                });
+                if (check) {
+                    result = JSON.parse(check);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Run action - return from cache', data: { result }, status: types_1.LogEventStatus.PROCESSING }));
+                    if (returnValue) {
+                        return result;
+                    }
+                }
+            }
+            if (request_type === types_1.DataFormats.JSON || !request_type) {
+                if (indexes.length == 0) {
+                    payloads = await this.constructJSONDataPayloads(event.input, additional_logs, samples, event);
+                    additional_logs.recipient_workspace_id = recipient_workspace_id;
+                    result = await this.processRequest({ request_base_url, resource, method, env, payloads, app_id: app._id }, event, retries, additional_logs, returnValue);
+                }
+                else {
+                    const promises = indexes.map(async (index) => {
+                        payloads = await this.constructJSONDataPayloads(event.input, additional_logs, samples, event, index);
+                        additional_logs.recipient_workspace_id = recipient_workspace_id;
+                        await this.processRequest({ request_base_url, resource, method, env, payloads, app_id: app._id }, event, retries, additional_logs, returnValue);
+                    });
+                    result = await Promise.all(promises);
+                }
+            }
+            if (cache_tag && this.redisClient && result) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(event.input);
+                await this.addToCache({
+                    input: inputString,
+                    privateKey: product.private_key,
+                    data: JSON.stringify(result),
+                    cache_tag,
+                    timestamp: Date.now(),
+                    component_tag: action_tag,
+                    component_type: types_1.ProductComponents.ACTION,
+                    product_tag: this.productTag,
+                });
+            }
+            if (result && returnValue) {
+                return result;
+            }
+        }
+        catch (e) {
+            console.log(e);
+            //throw e;
+        }
+    }
+    async processRequest(payload, event, retries, additional_logs, returnValue = false) {
+        const { request_base_url, resource, payloads, method, env, app_id } = payload;
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process http request - initiated', data: { request: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.PROCESSING, app_id, action: event.event }));
+        const start = Date.now();
+        try {
+            const results = await this.sendActionRequest(request_base_url, resource, payloads, method, env.slug);
+            const end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process http request - success', successful_execution: true, data: { response: (0, processor_utils_1.anonymizeObject)(results) }, status: types_1.LogEventStatus.SUCCESS, app_id, action: event.event, start,
+                end }));
+            await this.addToSuccessOutput(event, results, additional_logs);
+            if (returnValue) {
+                return { process_id: this.process_id, status: true, data: results };
+            }
+            else {
+                return true;
+            }
+        }
+        catch (e) {
+            const end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process http request - failed', failed_execution: true, data: { e }, status: types_1.LogEventStatus.FAIL, app_id, action: event.event, start,
+                end }));
+            try {
+                const value = this.addToFailureOutput(e, event, {
+                    request_base_url,
+                    resource,
+                    method,
+                    env,
+                    payloads,
+                    app_id,
+                }, additional_logs, retries);
+                //if (returnValue) {
+                return {
+                    process_id: this.process_id,
+                };
+                /*} else {
+                  throw e;
+                }*/
+            }
+            catch (err) {
+                throw err;
+            }
+        }
+    }
+    async addToSuccessOutput(event, output, additional_logs) {
+        // Remove event from failed, skipped, and waiting arrays
+        this.processingOutput.failure = this.processingOutput.failure.filter((data) => !(data.event.sequence_tag === event.sequence_tag && data.event.event === event.event));
+        this.processingOutput.skipped = this.processingOutput.skipped.filter((data) => !(data.event.sequence_tag === event.sequence_tag && data.event.event === event.event));
+        this.processingOutput.waiting = this.processingOutput.waiting.filter((data) => !(data.event.sequence_tag === event.sequence_tag && data.event.event === event.event));
+        this.processingOutput.success.push({ event, output });
+        await this.processWaitingEvents(additional_logs);
+    }
+    addToWaitingOutput(event, dependants) {
+        const exists = this.processingOutput.waiting.findIndex((item) => {
+            return item.event.event === event.event && item.event.sequence_tag === event.sequence_tag;
+        });
+        const skipped = this.processingOutput.skipped.findIndex((item) => {
+            return item.event.event === event.event && item.event.sequence_tag === event.sequence_tag;
+        });
+        if (!exists && !skipped) {
+            this.processingOutput.waiting.push({ event, dependants });
+        }
+        // addToSkippedOutput()
+    }
+    addToFailureOutput(e, event, payload, additional_logs, policy = {}) {
+        try {
+            const exists = this.processingOutput.failure.findIndex((item) => {
+                if (item.event.sequence_tag) {
+                    return item.event.event === event.event && item.event.sequence_tag === event.sequence_tag;
+                }
+                else {
+                    return item.event.event === event.event;
+                }
+            });
+            let error_code = '1000';
+            let retry_at = 500;
+            let max = event.retries || 0;
+            if (event.type === types_1.FeatureEventTypes.ACTION) {
+                e.response && e.response.status ? e.response.status : '500';
+                const metrices = this.generateRetryMetrices(String(error_code), policy);
+                retry_at = metrices.retry_at;
+                max = metrices.max;
+            }
+            const { allow_fail, retries } = event;
+            let retries_left = retries || max;
+            if (exists > -1) {
+                retries_left = this.processingOutput.failure[exists].retries_left - 1;
+                this.processingOutput.failure.splice(exists, 1);
+            }
+            let reason = JSON.stringify((0, processor_utils_1.extractAxiosErrorDetails)(e));
+            if (event.type === types_1.FeatureEventTypes.ACTION) {
+                reason = JSON.stringify((0, processor_utils_1.extractAxiosErrorDetails)(e));
+            }
+            const output = {
+                allow_fail,
+                retry_at,
+                retries_left,
+                payload: payload.payloads || event.input,
+                error_code,
+                reason,
+                event,
+            };
+            if (allow_fail === true && retries === 0) {
+                this.processingOutput.skipped.push(output);
+            }
+            else {
+                this.processingOutput.failure.push(output);
+            }
+            if (retries_left > 0) {
+                setTimeout(() => {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Retrying Request', data: Object.assign(Object.assign({}, output), { payload: (0, processor_utils_1.anonymizeObject)(output.payload) }), status: types_1.LogEventStatus.PROCESSING }));
+                    if (event.type === types_1.FeatureEventTypes.ACTION) {
+                        this.processRequest(payload, event, policy, additional_logs);
+                    }
+                    if (event.type === types_1.FeatureEventTypes.DB_ACTION) {
+                        this.processDBRequest(event, event.input, payload.database_tag, payload.databaseEnv, payload.action_tag, additional_logs);
+                    }
+                    if (event.type === types_1.FeatureEventTypes.STORAGE) {
+                        this.processStorageRequest(event, event.input, payload.storageEnv, additional_logs);
+                    }
+                }, retry_at);
+            }
+            if (allow_fail === false && retries_left === 0) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Ran out of retries - failed', data: Object.assign(Object.assign({}, output), { payload: (0, processor_utils_1.anonymizeObject)(output.payload) }), status: types_1.LogEventStatus.FAIL }));
+                //throw new Error("Run out of retries")
+                this.end = Date.now();
+                this.writeResult(types_1.LogEventStatus.FAIL);
+                this.logService.publish();
+            }
+            return output;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    generateRetryMetrices(error_code, retries) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        let allow_fail = true;
+        let retry_at = 5000;
+        let max = (retries === null || retries === void 0 ? void 0 : retries.max) || 0;
+        switch (error_code) {
+            case '500':
+                allow_fail = ((_a = retries === null || retries === void 0 ? void 0 : retries.policy[500]) === null || _a === void 0 ? void 0 : _a.available) || false;
+                retry_at = ((_b = retries === null || retries === void 0 ? void 0 : retries.policy[500]) === null || _b === void 0 ? void 0 : _b.lag) || 0;
+                break;
+            case '502':
+                allow_fail = ((_c = retries === null || retries === void 0 ? void 0 : retries.policy[502]) === null || _c === void 0 ? void 0 : _c.available) || false;
+                retry_at = ((_d = retries === null || retries === void 0 ? void 0 : retries.policy[502]) === null || _d === void 0 ? void 0 : _d.lag) || 0;
+                break;
+            case '503':
+                allow_fail = ((_e = retries === null || retries === void 0 ? void 0 : retries.policy[503]) === null || _e === void 0 ? void 0 : _e.available) || false;
+                retry_at = ((_f = retries === null || retries === void 0 ? void 0 : retries.policy[503]) === null || _f === void 0 ? void 0 : _f.lag) || 0;
+                break;
+            case '504':
+                allow_fail = ((_g = retries === null || retries === void 0 ? void 0 : retries.policy[504]) === null || _g === void 0 ? void 0 : _g.available) || false;
+                retry_at = ((_h = retries === null || retries === void 0 ? void 0 : retries.policy[504]) === null || _h === void 0 ? void 0 : _h.lag) || 0;
+                break;
+            case '400':
+                allow_fail = ((_j = retries === null || retries === void 0 ? void 0 : retries.policy[400]) === null || _j === void 0 ? void 0 : _j.available) || false;
+                retry_at = ((_k = retries === null || retries === void 0 ? void 0 : retries.policy[400]) === null || _k === void 0 ? void 0 : _k.lag) || 0;
+                break;
+            case '401':
+                allow_fail = ((_l = retries === null || retries === void 0 ? void 0 : retries.policy[401]) === null || _l === void 0 ? void 0 : _l.available) || false;
+                retry_at = ((_m = retries === null || retries === void 0 ? void 0 : retries.policy[401]) === null || _m === void 0 ? void 0 : _m.lag) || 0;
+                break;
+            case '403':
+                allow_fail = ((_o = retries === null || retries === void 0 ? void 0 : retries.policy[403]) === null || _o === void 0 ? void 0 : _o.available) || false;
+                retry_at = ((_p = retries === null || retries === void 0 ? void 0 : retries.policy[403]) === null || _p === void 0 ? void 0 : _p.lag) || 0;
+                break;
+            case '404':
+                allow_fail = ((_q = retries === null || retries === void 0 ? void 0 : retries.policy[404]) === null || _q === void 0 ? void 0 : _q.available) || false;
+                retry_at = ((_r = retries === null || retries === void 0 ? void 0 : retries.policy[404]) === null || _r === void 0 ? void 0 : _r.lag) || 0;
+                break;
+            case '1000': // all non http errors
+                allow_fail = true;
+                retry_at = 500;
+            default:
+                allow_fail = true;
+                retry_at = 0;
+                max = 0;
+                break;
+        }
+        return { allow_fail, max, retry_at };
+    }
+    async sendActionRequest(base_url, resource, payload, method, env) {
+        try {
+            const { headers, query, body, params } = payload;
+            if (params) {
+                const paramsKeys = Object.keys(params);
+                for (let i = 0; i < paramsKeys.length; i++) {
+                    resource = (0, processor_utils_1.parameterizeResource)(resource, paramsKeys[i], params[paramsKeys[i]]);
+                }
+            }
+            const authHeaders = headers;
+            const request = {
+                url: resource,
+                method,
+                data: body,
+                params: query,
+                headers: authHeaders,
+            };
+            if (!base_url.endsWith('/') && !resource.startsWith('/')) {
+                base_url = base_url + '/';
+            }
+            const response = await (0, http_client_1.default)(base_url).request(request);
+            return response.data;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async processStorage(action) {
+        //TODO: schema validation
+        const { env, input, retries, event, product: product_tag } = action;
+        const additional_logs = {
+            parent_tag: event,
+            type: types_1.LogEventTypes.STORAGE,
+            name: 'Process Storage',
+        };
+        try {
+            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
+            this.input = action;
+            this.start = Date.now();
+            this.component = types_1.LogEventTypes.STORAGE;
+            // clone
+            this.clone = (0, processor_utils_1.structuredClone)(input);
+            (0, processor_utils_1.cleanBlob)(this.clone);
+            this.productTag = product_tag;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env,
+                process_id, data: this.clone }, additional_logs);
+            await this.intializeProduct(additional_logs);
+            this.process_id = process_id;
+            const productEnv = this.fetchEnv(env, additional_logs);
+            this.processEnv = productEnv;
+            if (!productEnv.active) {
+                throw new Error(`Environment ${env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - initiated', status: types_1.LogEventStatus.PROCESSING, storage: new Blob([action.input.buffer]).size }));
+            const payload = {
+                type: types_1.FeatureEventTypes.STORAGE,
+                event,
+                cache: action.cache,
+                input,
+                env: productEnv,
+                retries: retries || 0,
+                allow_fail: false,
+            };
+            const result = await this.runStorage(payload);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - success', data: { input: this.clone, result }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async processMessageBrokerSubscribe(data) {
+        const [brokerTag, topicTag] = data.event.split(':');
+        if (!brokerTag || !topicTag) {
+            throw new Error(`message broker events should be in the format broker_tag:event_tag`);
+        }
+        const additional_logs = {
+            parent_tag: brokerTag,
+            child_tag: topicTag,
+            type: types_1.LogEventTypes.MESSAGEBROKER,
+            name: `Subscribe to broker topic`,
+        };
+        try {
+            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.STORAGE);
+            this.start = Date.now();
+            this.productTag = data.product;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.input = data;
+            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env: data.env, process_id, data: data.input }, additional_logs);
+            await this.intializeProduct(additional_logs);
+            this.baseLogs.product_id = this.productId;
+            this.process_id = process_id;
+            const productEnv = this.fetchEnv(data.env, additional_logs);
+            this.processEnv = productEnv;
+            if (!productEnv.active) {
+                throw new Error(`Environment ${data.env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Subscribe to topic - initiated', status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {
+                type: types_1.FeatureEventTypes.SUBSCRIBE,
+                event: data.event,
+                input: data.input,
+                env: productEnv,
+                retries: 0,
+                allow_fail: false,
+            };
+            const result = await this.runBrokerSubscribe(payload);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Subscribe to topic - success', data: { input: this.clone, result }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Subscribe to topic - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async processMessageBrokerPublish(data) {
+        const [brokerTag, topicTag] = data.event.split(':');
+        if (!brokerTag || !topicTag) {
+            throw new Error(`message broker events should be in the format broker_tag:event_tag`);
+        }
+        const additional_logs = {
+            parent_tag: brokerTag,
+            child_tag: topicTag,
+            type: types_1.LogEventTypes.MESSAGEBROKER,
+            name: 'Publish to broker topic',
+        };
+        try {
+            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.PUBLISH);
+            console.log("JAPANESE MIRRORS", data.input);
+            this.start = Date.now();
+            // clone
+            this.clone = (0, processor_utils_1.structuredClone)(data.input);
+            this.input = data;
+            this.productTag = data.product;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.component = types_1.LogEventTypes.MESSAGEBROKER;
+            this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env: data.env, process_id, data: this.clone }, additional_logs);
+            await this.intializeProduct(additional_logs);
+            this.baseLogs.product_id = this.productId;
+            this.process_id = process_id;
+            const productEnv = this.fetchEnv(data.env, additional_logs);
+            this.processEnv = productEnv;
+            console.log("JAPANESE MIRRORS 2", productEnv);
+            if (!productEnv.active) {
+                throw new Error(`Environment ${data.env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publish to topic - initiated', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {
+                type: types_1.FeatureEventTypes.PUBLISH,
+                event: data.event,
+                cache: data.cache,
+                input: data.input,
+                env: productEnv,
+                retries: 0,
+                allow_fail: false,
+            };
+            const result = await this.runBrokerPublish(payload);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publishing to topic - success', data: { input: (0, processor_utils_1.anonymizeObject)(this.clone), result }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return result;
+        }
+        catch (e) {
+            console.log(e);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publishing to topic - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async processJob(job) { }
+    async sendExpoNotification(payload, device_tokens) {
+        const message = {
+            to: device_tokens,
+            sound: 'default',
+            title: payload.title,
+            body: payload.body,
+            data: (0, processor_utils_1.convertStringToObject)(payload.data),
+        };
+        console.log("MESSAGE!!!", message);
+        try {
+            await (0, expo_client_1.default)().post('', message, (0, processor_utils_1.generateAxiosConfig)());
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async sendFirebaseNotification(payload, device_tokens, credentials) {
+        const message = {
+            notification: {
+                title: payload.title,
+                body: payload.body,
+            },
+            tokens: device_tokens,
+        };
+        try {
+            const admin = require('firebase-admin');
+            const serviceAccount = credentials;
+            console.log("MESSAGE", message);
+            admin.initializeApp({
+                credential: admin.credential.cert(serviceAccount),
+            });
+            await admin.messaging().sendMulticast(message);
+        }
+        catch (e) {
+            if (this.environment === types_1.EnvType.PRODUCTION) {
+                throw e;
+            }
+        }
+    }
+    async ProcessExpoNotification(notification, template, payload, additional_logs) {
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate notification payload - initiated', data: { notification, payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.PROCESSING }));
+        (0, processor_utils_1.validateNotification)(template, payload);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate notification payload - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate notification template - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+        const { title, body, data } = (0, processor_utils_1.generateNotificationTemplate)(template, payload);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate notification template - success', data: { title, body, data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Expo notification - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+        await this.sendExpoNotification({ title, body, data }, payload.device_tokens);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Expo notification - success', data: { title, body, data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+    }
+    async ProcessFirebaseNotification(notification, template, payload, additional_logs) {
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate Firebase notification payload - initiated', data: { notification, payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.PROCESSING }));
+        (0, processor_utils_1.validateNotification)(template, payload);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate Firebase notification payload - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate Firebase notification template - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+        const { title, body, data } = (0, processor_utils_1.generateNotificationTemplate)(template, payload);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate Firebase notification template - success', data: { title, body: (0, processor_utils_1.anonymizeObject)(data), data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Firebase notification - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+        await this.sendFirebaseNotification({ title, body, data }, payload.device_tokens, notification.credentials);
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Firebase notification - success', data: { title, body: (0, processor_utils_1.anonymizeObject)(data), data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+    }
+    async runNotification(notification, additional_logs) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const { event } = notification;
+        const input = notification.input;
+        try {
+            //await this.intializeProduct(additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempting notification', data: { notification }, status: types_1.LogEventStatus.PROCESSING }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching notification details', data: { notification }, status: types_1.LogEventStatus.PROCESSING }));
+            const notificationEvent = this.productBuilderService.fetchNotification(event.split(":")[0]);
+            const message = this.productBuilderService.fetchNotificationMessage(event);
+            const { envs } = notificationEvent;
+            const { push_notifications: notifications, emails, callbacks, sms: smses } = envs.find((data) => data.slug === notification.env.slug);
+            const { push_notification: push, email, callback, sms } = message;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching notification', data: notificationEvent, status: types_1.LogEventStatus.SUCCESS }));
+            if (push) {
+                input.push_notification.title = (0, processor_utils_1.replacePlaceholderString)(push.title, input.push_notification.title || {});
+                input.push_notification.body = await this.generatePayload(input.push_notification.body || {}, notification, additional_logs, message.push_notification_data.filter((data) => data.parent_key === 'body') || []);
+                input.push_notification.data = await this.generatePayload(input.push_notification.data || {}, notification, additional_logs, message.push_notification_data.filter((data) => data.parent_key === 'data') || []);
+            }
+            const validationPayload = (await this.inputService.parseJson({
+                data: Object.assign(Object.assign({}, input.push_notification.title), input.push_notification.body),
+                expected: types_1.ExpectedValues.PARSEINPUT,
+            }));
+            //await this.inputService.validateInput(validationPayload, message.push_notification_data, "Push Notifications");
+            if (push && notifications.type === types_1.Notifiers.FIREBASE) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Processing Expo notification - initiated', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.PROCESSING }));
+                await this.ProcessExpoNotification(notifications, message, input.push_notification, additional_logs);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Processing Expo notification - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+            }
+            if (push && notifications.type === types_1.Notifiers.EXPO) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Processing Firebase notification - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+                await this.ProcessFirebaseNotification(notifications, message, input.push_notification, additional_logs);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Processing Firebase notification - success', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.SUCCESS }));
+            }
+            if (email && emails) {
+                input.email.subject = await this.generatePayload(input.email.subject, notification, additional_logs, message.email_data.filter((data) => data.parent_key === 'subject'));
+                input.email.template = await this.generatePayload(input.email.template, notification, additional_logs, message.email_data.filter((data) => data.parent_key === 'template'));
+                input.email.recipients = await Promise.all(input.email.recipients.map(async (email) => await this.generateStringValues(email, notification.event, additional_logs)));
+                const validationPayload = (await this.inputService.parseJson({
+                    data: input.email,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                //await this.inputService.validateInput(validationPayload, message.email_data);
+                input.email.recipients.map((email) => this.inputService.validateEmailString({ key: 'to', value: email }));
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process email - initiated', data: { email: (0, processor_utils_1.anonymizeObject)(email), input: (0, processor_utils_1.anonymizeObject)(input.email) }, status: types_1.LogEventStatus.PROCESSING }));
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt email auth fetch - initiated', data: { emails: (0, processor_utils_1.anonymizeObject)(emails) }, status: types_1.LogEventStatus.PROCESSING }));
+                const { sender_email: from } = emails, auth = __rest(emails, ["sender_email"]);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt email auth fetch - success', data: { from: (0, processor_utils_1.anonymizeValue)(from), host: (0, processor_utils_1.anonymizeValue)(auth.host), port: (0, processor_utils_1.anonymizeValue)(auth.port) }, status: types_1.LogEventStatus.SUCCESS }));
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate email template - initiated', data: {
+                        template: (0, processor_utils_1.anonymizeValue)(email.template),
+                        subject: (0, processor_utils_1.anonymizeValue)(email.subject),
+                        input: (0, processor_utils_1.anonymizeObject)(input.email),
+                    }, status: types_1.LogEventStatus.PROCESSING }));
+                const templateMaker = (0, handlebars_1.compile)(email.template);
+                const template = templateMaker(input.email.template);
+                const subject = (0, processor_utils_1.replacePlaceholderString)(email.subject, input.email.subject || {});
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate email template - success', data: { template: (0, processor_utils_1.anonymizeValue)(template), subject: (0, processor_utils_1.anonymizeValue)(subject) }, status: types_1.LogEventStatus.SUCCESS }));
+                const mailOptions = {
+                    from,
+                    to: input.email.recipients,
+                    subject,
+                    template,
+                };
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send email - initiated', data: { template: (0, processor_utils_1.anonymizeValue)(template), subject: (0, processor_utils_1.anonymizeValue)(subject), to: input.email.recipients.map((data) => (0, processor_utils_1.anonymizeValue)(data)) }, status: types_1.LogEventStatus.PROCESSING }));
+                try {
+                    const transporter = await (0, processor_utils_1.mailerClient)(auth);
+                    const response = await transporter.sendMail(mailOptions);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send email - success', data: { response }, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send email - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                }
+            }
+            if (callback && callbacks) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process callback - initiated', data: Object.assign(Object.assign({}, callbacks), { data: (0, processor_utils_1.anonymizeObject)(callback) }), status: types_1.LogEventStatus.PROCESSING }));
+                const payload = {
+                    query: Object.assign(Object.assign({}, (_a = input.callback) === null || _a === void 0 ? void 0 : _a.query), (_b = callbacks.auth) === null || _b === void 0 ? void 0 : _b.query),
+                    headers: Object.assign(Object.assign({}, (_c = input.callback) === null || _c === void 0 ? void 0 : _c.headers), (_d = callbacks.auth) === null || _d === void 0 ? void 0 : _d.headers),
+                    params: Object.assign(Object.assign({}, (_e = input.callback) === null || _e === void 0 ? void 0 : _e.params), (_f = callbacks.auth) === null || _f === void 0 ? void 0 : _f.params),
+                    body: Object.assign(Object.assign({}, (_g = input.callback) === null || _g === void 0 ? void 0 : _g.body), (_h = callbacks.auth) === null || _h === void 0 ? void 0 : _h.body),
+                };
+                input.callback.body = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'body'));
+                input.callback.query = await this.generatePayload(payload.query, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'query'));
+                input.callback.params = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'params'));
+                input.callback.headers = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'headers'));
+                const validationPayload = (await this.inputService.parseJson({
+                    data: input.callback,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                //this.inputService.validateInput(validationPayload, message.callback_data);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate callback payload - initiated', data: Object.assign(Object.assign({}, callbacks), { data: (0, processor_utils_1.anonymizeObject)(payload) }), status: types_1.LogEventStatus.PROCESSING }));
+                const url = new URL(callbacks.url);
+                try {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send callback - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+                    console.log("CALLBACK!!!!", {
+                        url,
+                        payload,
+                        method: callbacks.method
+                    });
+                    await this.sendActionRequest(url.origin, url.pathname, payload, callbacks.method, '');
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send callback - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send callback - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                }
+            }
+            if (sms && smses) {
+                try {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process sms - initiated', data: { data: sms, config: (0, processor_utils_1.anonymizeObject)(smses) }, status: types_1.LogEventStatus.PROCESSING }));
+                    input.sms.body = await (0, processor_utils_1.replacePlaceholderString)(sms, input.sms.body);
+                    const SmsClient = await (0, sms_repo_1.loadSMSClient)();
+                    const smsClient = new SmsClient(smses);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send sms - initiated', data: { message: input.sms.body, config: (0, processor_utils_1.anonymizeObject)(smses) }, status: types_1.LogEventStatus.SUCCESS }));
+                    console.log("SMS!!!!", input.sms, smses);
+                    const res = await smsClient.sendMessage(input.sms.body, input.sms.recipients);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send sms - success', data: res, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process sms - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Attempt notification - success', data: notification, status: types_1.LogEventStatus.SUCCESS }));
+        }
+        catch (e) {
+            console.log(e);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt notification - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.logService.publish();
+        }
+    }
+    async runMigration(product_tag, tag, env, type) {
+        try {
+            this.productTag = product_tag;
+            const [dbTag, migrationTag] = tag.split(':');
+            if (!dbTag || !migrationTag) {
+                throw new Error('tag should be in the format database_tag:migration_tag');
+            }
+            this.start = Date.now();
+            const additional_logs = {
+                parent_tag: dbTag,
+                child_tag: migrationTag,
+                type: types_1.LogEventTypes.DB_MIGRATION,
+                name: 'Run Migration',
+            };
+            await this.intializeProduct(additional_logs);
+            const db = this.productBuilderService.fetchDatabase(dbTag);
+            if (!db) {
+                throw new Error('Database not found');
+            }
+            if (db.type === types_1.DatabaseTypes.MONGODB) {
+                throw new Error(`${db.type} does not support migrations`);
+            }
+            const migration = this.productBuilderService.fetchDatabaseMigration(tag);
+            if (!migration) {
+                throw new Error('Database migration not found');
+            }
+            const dbEnv = db.envs.find((el) => el.slug === env);
+            if (!dbEnv) {
+                throw new Error(`Environment ${env} not found`);
+            }
+            const productEnv = this.fetchEnv(env, additional_logs);
+            if (!productEnv.active) {
+                throw new Error(`Environment ${env} is not active`);
+            }
+            const product = this.productBuilderService.fetchProduct();
+            const migrations = this.productBuilderService.fetchDatabaseMigrations(dbTag);
+            //this.processEnv = productEnv;
+            /* const check = migration.envs.find((migrationEnv) => migrationEnv.slug === env);
+             if (!check) {
+               throw new Error(`Migration does not exist for environment ${env}`);
+             }*/
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env,
+                process_id, data: { tag, env } }, additional_logs);
+            const migrationsToRun = (0, processor_utils_1.getMigrationsToRun)((0, processor_utils_1.structuredClone)(migrations), type, migrationTag, env);
+            if (db.type === types_1.DatabaseTypes.POSTGRES) {
+                const PostgresDBHandler = await (0, postgres_repo_1.loadPostgresHandler)();
+                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(dbEnv.connection_url, product.private_key));
+                for (const migrationToRun of migrationsToRun) {
+                    const envS = migration.envs.find((envT) => envT.slug === env && type === envT.type);
+                    if (envS && envS.status === types_1.MigrationStatus.PROCESSED) {
+                        continue;
+                    }
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: `Starting migration ${type} name: ${migrationToRun.name}`, data: { migration: migrationToRun, type }, status: types_1.LogEventStatus.PROCESSING }));
+                    const { type: migType, result, status, processed_at, } = await pgHandler.runMigration(migrationToRun.value[type], type, envS);
+                    if (!envS) {
+                        migrationToRun.envs.push({ slug: env, results: result, status, type, processed_at });
+                    }
+                    else {
+                        migrationToRun.envs.map((envT) => {
+                            if (envT.slug === env && type === envT.type) {
+                                envT.results = [...result];
+                                envT.processed_at = processed_at;
+                                return envT;
+                            }
+                            return envT;
+                        });
+                    }
+                    this.productBuilderService.updateDatabaseMigration(Object.assign(Object.assign({}, migrationToRun), { tag }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: `Starting migration ${type} name: ${migrationToRun.name}`, data: { migration: migrationToRun, type }, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                return { process_id };
+            }
+        }
+        catch (e) {
+            console.log(e);
+            this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { failed_execution: true, message: 'Attempt migration - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            this.logService.publish();
+        }
+    }
+    /*async runFunction(data: IFeatureEvent, additional_logs: Partial<ILogData>): Promise<any> {
+      const { product_id, env } = data;
+      const input = data.input as IFunctionRequest;
+  
+      this.productId = product_id;
+  
+      this.logService = new LogsService({
+        product_id,
+        workspace_id: this.workspace_id,
+        public_key: this.public_key,
+        user_id: this.user_id,
+        token: this.token,
+        env_type: this.environment,
+      });
+  
+      const process_id = generateObjectId();
+      this.process_id = process_id;
+      
+  
+      try {
+        await this.intializeProduct(additional_logs);
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Attempt function - initiated',
+          data,
+          status: LogEventStatus.PROCESSING,
+        });
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Fetch function - initiated',
+          data: data,
+          status: LogEventStatus.PROCESSING,
+        });
+  
+        const cloudFunction = this.productBuilderService.fetchFunction(data.event);
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Fetch function - success',
+          data: data,
+          status: LogEventStatus.SUCCESS,
+        });
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Validate function payload - initiated',
+          data: { data, payload: input.payload },
+          status: LogEventStatus.PROCESSING,
+        });
+  
+        validateFunctionInputKeys(cloudFunction.inputs, input.payload);
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Validate function payload - success',
+          data: { data, payload: input.payload },
+          status: LogEventStatus.SUCCESS,
+        });
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Run function - initiated',
+          data: { data, payload: input.payload },
+          status: LogEventStatus.PROCESSING,
+        });
+  
+        const response = await makeFunctionsRequest(cloudFunction, input.payload);
+  
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Run function - success',
+          data: { data, payload: input.payload },
+          status: LogEventStatus.SUCCESS,
+        });
+      } catch (e) {
+        this.logService.add({
+          ...this.baseLogs,
+          ...additional_logs,
+          message: 'Run function - failed',
+          data: e,
+          status: LogEventStatus.FAIL,
+        });
+        this.logService.publish();
+      }
+    }*/
+    async runStorage(data, additional_logs = {}) {
+        const { product_id, env, event, cache: cache_tag } = data;
+        const input = data.input;
+        try {
+            await this.intializeProduct(additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt storage - initiated', data: this.clone, status: types_1.LogEventStatus.PROCESSING }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch storage details - initiated', data: this.clone, status: types_1.LogEventStatus.PROCESSING }));
+            const storage = await this.productBuilderService.fetchStorage(event);
+            const storageEnv = storage.envs.find((el) => el.slug === env.slug);
+            if (!storageEnv) {
+                throw new Error(`Storage env for ${env.slug} not found`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch storage details - success', data: { storage }, status: types_1.LogEventStatus.SUCCESS }));
+            const product = this.productBuilderService.fetchProduct();
+            let result;
+            if (cache_tag && this.redisClient) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(input);
+                const check = await this.fetchFromCache({
+                    cache_tag,
+                    input: inputString,
+                    privateKey: product.private_key,
+                    expiry: productCache.expiry,
+                });
+                if (check) {
+                    result = JSON.parse(check);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Store file - return from cache', data: { result }, status: types_1.LogEventStatus.PROCESSING }));
+                    return result;
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Store file - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+            const file = await this.generateStringValues(input.buffer, '', additional_logs, []);
+            input.buffer = file.buffer;
+            input.fileName = file.fileName;
+            input.mimeType = file.mimeType;
+            result = await this.processStorageRequest(data, input, storageEnv, additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Store file - success', data: { result }, status: types_1.LogEventStatus.PROCESSING }));
+            if (cache_tag && this.redisClient) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(input);
+                await this.addToCache({
+                    input: inputString,
+                    privateKey: product.private_key,
+                    data: JSON.stringify(result),
+                    cache_tag,
+                    timestamp: Date.now(),
+                    component_tag: event,
+                    component_type: types_1.ProductComponents.STORAGE,
+                    product_tag: this.productTag,
+                });
+            }
+            return result;
+        }
+        catch (e) {
+            console.log(e);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt storage - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async runDBAction(db_action, additional_logs = {}) {
+        const { product_id, env, event, cache: cache_tag } = db_action;
+        const input = db_action.input;
+        try {
+            //await this.intializeProduct(additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt database action - initiated', data: db_action, status: types_1.LogEventStatus.PROCESSING }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch database action - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+            const [database_tag, action_tag] = event.split(':');
+            const product = this.productBuilderService.fetchProduct();
+            const database = await this.productBuilderService.fetchDatabase(database_tag);
+            const databaseAction = await this.productBuilderService.fetchDatabaseAction(event);
+            const databaseEnv = database.envs.find((el) => el.slug === env.slug);
+            if (!databaseEnv) {
+                throw new Error(`Database env for ${env.slug} not found`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch database action - success', data: databaseAction, status: types_1.LogEventStatus.SUCCESS }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate database action payload - initiated', data: { payload: (0, processor_utils_1.anonymizeObject)(input.data) }, status: types_1.LogEventStatus.PROCESSING }));
+            input.data = await this.generatePayload(input.data, db_action, additional_logs, databaseAction.data);
+            if (Array.isArray(input.data)) {
+                await Promise.all(input.data.map(async (d) => {
+                    const dataValidationPayload = (await this.inputService.parseJson({
+                        data: d,
+                        expected: types_1.ExpectedValues.PARSEINPUT,
+                    }));
+                    this.inputService.validateInput(dataValidationPayload, databaseAction.data);
+                }));
+            }
+            else {
+                const dataValidationPayload = (await this.inputService.parseJson({
+                    data: input.data,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                const filterValidationPayload = (await this.inputService.parseJson({
+                    data: input.filter,
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                this.inputService.validateInput(dataValidationPayload, databaseAction.data);
+                this.inputService.validateInput(filterValidationPayload, databaseAction.filterData);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate database action payload - success', data: { db_action, payload: (0, processor_utils_1.anonymizeObject)(input.data) }, status: types_1.LogEventStatus.SUCCESS }));
+            if (database.type === types_1.DatabaseTypes.MONGODB) {
+                if (databaseAction.type === types_1.DatabaseActionTypes.UPDATE) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate database update action filter - initiated', data: { filter: (0, processor_utils_1.anonymizeObject)(input.filter) }, status: types_1.LogEventStatus.PROCESSING }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate database update action filter - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Run database action query - initiated', data: { payload: (0, processor_utils_1.anonymizeObject)(input) }, status: types_1.LogEventStatus.PROCESSING }));
+            let result;
+            if (cache_tag && this.redisClient) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(input);
+                const check = await this.fetchFromCache({
+                    cache_tag,
+                    input: inputString,
+                    privateKey: product.private_key,
+                    expiry: productCache.expiry,
+                });
+                if (check) {
+                    result = JSON.parse(check);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Run database action query - return from cache', data: { result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+                    return result;
+                }
+            }
+            const template = typeof databaseAction.template === 'string' ? databaseAction.template : JSON.stringify(databaseAction.template);
+            if (database.type === types_1.DatabaseTypes.MONGODB) {
+                const MongoDBHandler = await (0, mongo_repo_1.loadMongoDbHandler)();
+                if (!MongoDBHandler) {
+                    throw new Error(`Running in browser, mongo handler not loaded.`);
+                }
+                const mongoHandler = new MongoDBHandler((0, processor_utils_1.decrypt)(databaseEnv.connection_url, this.productBuilderService.fetchProduct().private_key));
+                if (databaseAction.type === types_1.DatabaseActionTypes.UPDATE) {
+                    const filterTemplate = typeof databaseAction.filterTemplate === 'string'
+                        ? databaseAction.filterTemplate
+                        : JSON.stringify(databaseAction.filterTemplate);
+                    result = await mongoHandler[databaseAction.type](databaseAction.data, template, input.data, databaseAction.tableName, databaseAction.filterData, filterTemplate, input.filter);
+                }
+                else {
+                    result = await mongoHandler[databaseAction.type](databaseAction.data, template, input.data, databaseAction.tableName);
+                }
+            }
+            else if (database.type === types_1.DatabaseTypes.POSTGRES) {
+                const PostgresDBHandler = await (0, postgres_repo_1.loadPostgresHandler)();
+                if (!PostgresDBHandler) {
+                    throw new Error(`Running in browser, postgres handler not loaded.`);
+                }
+                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(databaseEnv.connection_url, this.productBuilderService.fetchProduct().private_key));
+                if (databaseAction.type !== types_1.DatabaseActionTypes.AGGREGATE) {
+                    result = await pgHandler[databaseAction.type](databaseAction.data, template, input.data);
+                }
+            }
+            //this.logService.publish();
+            // const result = this.processDBRequest(db_action, input, database_tag, databaseEnv, action_tag, additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Run database action query - success', data: { result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+            await this.addToSuccessOutput(db_action, result, additional_logs);
+            if (cache_tag && this.redisClient) {
+                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                if (!productCache) {
+                    throw new Error('Invalid cache tag ');
+                }
+                const inputString = JSON.stringify(input);
+                await this.addToCache({
+                    input: inputString,
+                    privateKey: product.private_key,
+                    data: JSON.stringify(result),
+                    cache_tag,
+                    timestamp: Date.now(),
+                    product_tag: this.productTag,
+                    component_tag: database_tag,
+                    component_type: types_1.ProductComponents.DATABASE_ACTION,
+                });
+            }
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt database action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+        }
+    }
+    async runBrokerSubscribe(data, additional_logs = {}) {
+        const { env, event } = data;
+        const input = data.input;
+        try {
+            await this.intializeProduct(additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt broker topic subscription - initiated', data: { event }, status: types_1.LogEventStatus.PROCESSING }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - initiated', data: { event }, status: types_1.LogEventStatus.PROCESSING }));
+            const [brokerTag, topicTag] = event.split(':');
+            const broker = this.productBuilderService.fetchMessageBroker(brokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${brokerTag} not found`);
+            }
+            const brokerEnv = broker.envs.find((el) => el.slug === env.slug);
+            if (!brokerEnv) {
+                throw new Error(`Broker env for ${env.slug} not found`);
+            }
+            const topic = this.productBuilderService.fetchMessageBrokerTopic(event);
+            if (!topic) {
+                throw new Error(`Topic ${topicTag} not found in broker ${brokerTag}`);
+            }
+            let url = topic.name;
+            if (brokerEnv.type === types_1.MessageBrokerTypes.AWS_SQS) {
+                const queueUrl = topic.queueUrls.find((el) => el.env_slug == env.slug);
+                if (!queueUrl) {
+                    throw new Error(`AWS SQS topic requires a queue url defined in env ${env.slug}`);
+                }
+                if (!(0, processor_utils_1.isValidSqsUrl)(queueUrl.url)) {
+                    throw new Error('AWS SQS queueUrl is expected to be a url in the format "https://sqs.<region>.amazonaws.com/<account-id>/<queue-name>"');
+                }
+                url = queueUrl.url;
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - success', data: { event, broker }, status: types_1.LogEventStatus.SUCCESS }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Subscribe to broker topic - initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+            const createBrokerService = await loadBrokerService();
+            if (createBrokerService) {
+                const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
+                await brokerService.subscribe(url, input.callback);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Subscribe to broker topic - success', data: { event }, status: types_1.LogEventStatus.SUCCESS }));
+                return;
+            }
+            else {
+                throw new Error(`Running in browser, broker service not loaded.`);
+            }
+            //return this.processStorageRequest(data, input, storageEnv, additional_logs);
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt broker subcription - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async runBrokerPublish(data, additional_logs = {}) {
+        const { env, event } = data;
+        const input = data.input;
+        try {
+            await this.intializeProduct(additional_logs);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt publish to broker topic - initiated', data: { event }, status: types_1.LogEventStatus.PROCESSING }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - initiated', data: { event }, status: types_1.LogEventStatus.PROCESSING }));
+            const [brokerTag, topicTag] = event.split(':');
+            const broker = this.productBuilderService.fetchMessageBroker(brokerTag);
+            if (!broker) {
+                throw new Error(`Message Broker ${brokerTag} not found`);
+            }
+            const brokerEnv = broker.envs.find((el) => el.slug === env.slug);
+            if (!brokerEnv) {
+                throw new Error(`Broker env for ${env.slug} not found`);
+            }
+            const topic = this.productBuilderService.fetchMessageBrokerTopic(event);
+            if (!topic) {
+                throw new Error(`Topic ${topicTag} not found in broker ${brokerTag}`);
+            }
+            let url = topic.name;
+            if (brokerEnv.type === types_1.MessageBrokerTypes.AWS_SQS) {
+                const queueUrl = topic.queueUrls.find((el) => el.env_slug == env.slug);
+                if (!queueUrl) {
+                    throw new Error(`AWS SQS topic requires a queue url defined in env ${env.slug}`);
+                }
+                if (!(0, processor_utils_1.isValidSqsUrl)(queueUrl.url)) {
+                    throw new Error('AWS SQS queueUrl is expected to be a url in the format "https://sqs.<region>.amazonaws.com/<account-id>/<queue-name>"');
+                }
+                url = queueUrl.url;
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - success', data: { event, broker }, status: types_1.LogEventStatus.SUCCESS }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publish to broker topic initiated', data: {}, status: types_1.LogEventStatus.PROCESSING }));
+            const createBrokerService = await loadBrokerService();
+            if (createBrokerService) {
+                const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
+                await brokerService.publish(url, input.message);
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publish to broker topic - success', successful_execution: true, data: { event }, status: types_1.LogEventStatus.SUCCESS }));
+                return;
+            }
+            else {
+                throw new Error(`Running in browser, broker service not loaded.`);
+            }
+            //return this.processStorageRequest(data, input, storageEnv, additional_logs);
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt publish to broker topic - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            console.log("JERMOOOOO!!!");
+            throw e;
+        }
+    }
+    async processStorageRequest(data, input, storageEnv, additional_logs) {
+        try {
+            /*const result = await this.processorApiService.processProduct(
+              this.productId,
+              {
+                slug: storageEnv.slug,
+                tag: data.event,
+                component: ProductComponents.STORAGE,
+                destinationPath: input.fileName,
+                input,
+              },
+              this.getUserAccess(),
+            );*/
+            const cloudConfig = storageEnv.config;
+            const config = {
+                provider: storageEnv.type,
+            };
+            if (storageEnv.type === types_1.StorageProviders.AWS) {
+                Object.assign(config, { awsConfig: cloudConfig });
+            }
+            if (storageEnv.type === types_1.StorageProviders.GCP) {
+                Object.assign(config, { gcpConfig: cloudConfig });
+            }
+            if (storageEnv.type === types_1.StorageProviders.AWS) {
+                Object.assign(config, { awsConfig: cloudConfig });
+            }
+            const result = { url: await (0, storage_util_1.uploadBlobToCloud)({ data: input.buffer, destinationPath: input.fileName, config }) };
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Run storage request - success', data: { payload: this.clone, result }, status: types_1.LogEventStatus.SUCCESS }));
+            await this.addToSuccessOutput(data, result, additional_logs);
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Run storage request - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            const value = this.addToFailureOutput(e, data, { storageEnv }, additional_logs);
+            throw e;
+        }
+    }
+    async processDBRequest(db_action, input, database_tag, databaseEnv, action_tag, additional_logs, returnValue = false) {
+        try {
+            const result = await this.processorApiService.processProduct(this.productId, {
+                input: input,
+                database_tag: database_tag,
+                database_env_slug: databaseEnv.slug,
+                tag: action_tag,
+                component: types_1.ProductComponents.DATABASE_ACTION,
+            }, {
+                user_id: this.user_id,
+                token: this.token,
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+            });
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Run database query - success', data: { payload: (0, processor_utils_1.anonymizeObject)(input) }, status: types_1.LogEventStatus.SUCCESS }));
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Running database query - failed', data: { payload: (0, processor_utils_1.anonymizeObject)(input), e }, status: types_1.LogEventStatus.FAIL }));
+            const value = this.addToFailureOutput(e, db_action, {
+                db_action,
+                input,
+                database_tag,
+                databaseEnv,
+                action_tag,
+            }, additional_logs);
+            return value;
+        }
+    }
+    async writeResult(status) {
+        this.processorApiService.saveResult({
+            status,
+            component: this.component,
+            start: this.start,
+            end: this.end,
+            result: this.processingOutput,
+            process_id: this.process_id,
+            feature_id: this.feature ? this.feature._id : null,
+            product_id: this.productId,
+            env: this.processEnv.slug,
+            input: this.input,
+        }, this.getUserAccess());
+    }
+    async validateActionDataMappingInput(input, type) {
+        try {
+            if (type === types_1.FeatureEventTypes.ACTION || type === types_1.WebhookEventTypes.WEBHOOK_REGISTER) {
+                await create_productFeature_validator_1.ActionInputSchema.validateAsync(input);
+            }
+            if (type === types_1.FeatureEventTypes.DB_ACTION) {
+                await create_productFeature_validator_1.DBActionInputSchema.validateAsync(input);
+            }
+            if (type === types_1.FeatureEventTypes.NOTIFICATION) {
+                await create_productFeature_validator_1.NotificationInputschema.validateAsync(input);
+            }
+            (0, processor_utils_1.validateStringsInObject)(input);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async processAction(action) {
+        //TODO: schema validation
+        const { env, input, retries, event, app, product: product_tag } = action;
+        const additional_logs = {
+            parent_tag: (0, string_utils_1.extractOriginAndTag)(app),
+            child_tag: event,
+            type: types_1.LogEventTypes.ACTION,
+            name: 'Process Action',
+        };
+        this.component = types_1.LogEventTypes.ACTION;
+        try {
+            // validate input do not allow $Sequence or $Length and $Size of $Input
+            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
+            this.input = action;
+            this.start = Date.now();
+            this.productTag = product_tag;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.baseLogs = {
+                product_tag: this.productTag,
+                workspace_id: this.workspace_id,
+                env,
+                type: types_1.LogEventTypes.ACTION,
+                process_id,
+                data: input,
+            };
+            await this.intializeProduct(additional_logs);
+            this.process_id = process_id;
+            this.baseLogs.product_id = this.productId;
+            const productEnv = this.fetchEnv(env, additional_logs);
+            this.processEnv = productEnv;
+            if (!productEnv.active) {
+                throw new Error(`Environment ${env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action initiated', status: types_1.LogEventStatus.PROCESSING }));
+            const result = await this.runAction({
+                type: types_1.FeatureEventTypes.ACTION,
+                event,
+                cache: action.cache,
+                app,
+                input,
+                env: productEnv,
+                retries: retries || 0,
+                allow_fail: false,
+            }, additional_logs, true);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - success', data: { input: (0, processor_utils_1.anonymizeObject)(input), result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async processDBAction(action) {
+        //TODO: schema validation
+        const { env, input, retries, event, product: product_tag } = action;
+        const [parent_tag, child_tag] = event.split(':');
+        this.component = types_1.LogEventTypes.DB_ACTION;
+        if (!parent_tag || !child_tag) {
+            throw new Error(`database action events should be in the format notification_tag:message_tag`);
+        }
+        const additional_logs = {
+            parent_tag,
+            child_tag,
+            type: types_1.LogEventTypes.DB_ACTION,
+            name: 'Process database action',
+        };
+        try {
+            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
+            this.input = action;
+            this.start = Date.now();
+            this.productTag = product_tag;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env,
+                process_id, data: input }, additional_logs);
+            await this.intializeProduct(additional_logs);
+            this.baseLogs.product_id = this.productId;
+            this.process_id = process_id;
+            const productEnv = this.fetchEnv(env, additional_logs);
+            this.processEnv = productEnv;
+            if (!productEnv.active) {
+                throw new Error(`Environment ${env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute database action', data: { action: (0, processor_utils_1.anonymizeObject)(action) }, status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {
+                type: types_1.FeatureEventTypes.DB_ACTION,
+                event,
+                input,
+                cache: action.cache,
+                env: productEnv,
+                retries: retries || 0,
+                allow_fail: false,
+            };
+            const result = await this.runDBAction(payload, additional_logs);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute database action', data: { input: (0, processor_utils_1.anonymizeObject)(input), result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute database action', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async processFunction(data) { }
+    async processNotification(action) {
+        //TODO: schema validation
+        const { env, input, retries, event, product: product_tag } = action;
+        const [parent_tag, child_tag] = event.split(':');
+        if (!parent_tag || !child_tag) {
+            throw new Error(`database action events should be in the format notification_tag:message_tag`);
+        }
+        this.component = types_1.LogEventTypes.NOTIFICATIONS;
+        const additional_logs = {
+            parent_tag,
+            child_tag,
+            type: types_1.LogEventTypes.NOTIFICATIONS,
+            name: 'Process Notification',
+        };
+        try {
+            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
+            this.input = action;
+            this.start = Date.now();
+            this.productTag = product_tag;
+            const process_id = (0, processor_utils_1.generateObjectId)();
+            this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env,
+                process_id, data: input }, additional_logs);
+            await this.intializeProduct(additional_logs);
+            this.process_id = process_id;
+            this.baseLogs.product_id = this.productId;
+            const productEnv = this.fetchEnv(env, additional_logs);
+            this.processEnv = productEnv;
+            if (!productEnv.active) {
+                throw new Error(`Environment ${env} is not active`);
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send notification - initiated', data: { action: (0, processor_utils_1.anonymizeObject)(action) }, status: types_1.LogEventStatus.PROCESSING }));
+            const payload = {
+                type: types_1.FeatureEventTypes.NOTIFICATION,
+                event,
+                input,
+                cache: action.cache,
+                env: productEnv,
+                retries: retries || 0,
+                allow_fail: false,
+            };
+            const result = await this.runNotification(payload, additional_logs);
+            this.end = Date.now();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send notification - success', data: { input: (0, processor_utils_1.anonymizeObject)(input), result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+            this.writeResult(types_1.LogEventStatus.SUCCESS);
+            this.logService.publish();
+            return { process_id };
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send notification - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.end = Date.now();
+            this.logService.publish();
+            return { process_id: this.process_id };
+        }
+    }
+    async fetchRemoteCaches(payload) {
+        try {
+            const data = await this.processorApiService.fetchRemoteCaches(payload, this.getUserAccess());
+            return data.map((data) => {
+                data.value = (0, processor_utils_1.decrypt)(data.value, this.productBuilderService.fetchProduct().private_key);
+                return data;
+            });
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    getUserAccess() {
+        return {
+            user_id: this.user_id,
+            workspace_id: this.workspace_id,
+            token: this.token,
+            public_key: this.public_key,
+        };
+    }
+    async addToCache(payload) {
+        if (!this.redisClient) {
+            throw 'redis client not setup';
+        }
+        const { input, privateKey, data, cache_tag, timestamp, expiry, product_tag, component_tag, component_type } = payload;
+        // sha-512 instead of md5, private key is fetch product.privatekey
+        const key = `${cache_tag}-${CryptoJS.SHA512(input)}`;
+        const encryptedData = (0, processor_utils_1.encrypt)(data, privateKey);
+        let expiresAt = null;
+        if (expiry) {
+            expiresAt = timestamp + expiry;
+        }
+        await this.processorApiService.addToRemoteCache(Object.assign(Object.assign({}, (expiresAt && { expiry: new Date(expiresAt) })), { key, value: encryptedData, cache_tag,
+            product_tag,
+            component_tag,
+            component_type }), this.getUserAccess());
+        await this.redisClient.hSet(key, 'data', encryptedData);
+        await this.redisClient.hSet(key, 'lastUpdated', timestamp);
+    }
+    async fetchFromCache(payload) {
+        var _a;
+        const { input, privateKey, cache_tag, expiry } = payload;
+        const key = `${cache_tag}-${CryptoJS.SHA512(input)}`;
+        if (!this.redisClient) {
+            return null;
+        }
+        let record = await this.redisClient.hGetAll(key);
+        if (!record || !record.data || !record.lastUpdated) {
+            const checkRemote = await this.processorApiService.fetchRemoteCacheByKey(key, this.getUserAccess());
+            if (!checkRemote) {
+                return null;
+            }
+            record = { data: checkRemote.value, expiresAt: (_a = checkRemote.expiry) === null || _a === void 0 ? void 0 : _a.getTime().toString() };
+        }
+        if (record.lastUpdated) {
+            const lastUpdated = Number(record.lastUpdated);
+            if (expiry) {
+                const expiryTime = lastUpdated + expiry;
+                if (Date.now() > expiryTime) {
+                    await this.redisClient.del(key);
+                    return null;
+                }
+            }
+        }
+        return (0, processor_utils_1.decrypt)(record.data, privateKey);
+    }
+}
+exports.default = ProcessorService;
+//# sourceMappingURL=processor.service.js.map