@ductape/sdk 0.0.3-beta9 → 0.0.4-v10

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

@@ -52,10 +52,11 @@ 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 axios_1 = __importDefault(require("axios"));
 const processorApi_service_1 = require("../../api/services/processorApi.service");
 const expo_client_1 = __importDefault(require("../../clients/expo.client"));
 const handlebars_1 = require("handlebars");
+const functions_utils_1 = require("../../products/utils/functions.utils");
 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");
@@ -67,6 +68,8 @@ 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");
+const quota_service_1 = __importDefault(require("./quota.service"));
+//import { Job, Queue, Worker } from 'bullmq';
 async function loadBrokerService() {
     if (typeof window === 'undefined') {
         const { createBrokerService } = await Promise.resolve().then(() => __importStar(require('./messagebrokers')));
@@ -74,20 +77,31 @@ async function loadBrokerService() {
     }
     return null;
 }
+async function loadJWT() {
+    if (typeof window === 'undefined') {
+        const JWT = await Promise.resolve().then(() => __importStar(require("jsonwebtoken")));
+        return JWT;
+    }
+    return null;
+}
 class ProcessorService {
-    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client, queues }) {
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
         this.token = token;
+        this.published = false;
         this.productBuilderService = new products_service_1.default({
             workspace_id,
             public_key,
             user_id,
             token,
             env_type,
+            redis_client
         });
         this.inputService = new inputs_service_1.default();
+        this.requestTime = 0;
+        this.totalRequests = 0;
         this.processingOutput = {
             success: [],
             failure: [],
@@ -100,6 +114,93 @@ class ProcessorService {
         if (redis_client) {
             this.redisClient = redis_client;
         }
+        if (queues) {
+            this.queues = queues;
+        }
+    }
+    async generateSession(payload) {
+        try {
+            const { product: product_tag, env: slug, tag, data } = payload;
+            const input = await this.inputService.parseJson({
+                data,
+                expected: types_1.ExpectedValues.PARSEINPUT,
+            });
+            await this.productBuilderService.initializeProductByTag(product_tag);
+            // const product = this.productBuilderService.fetchProduct();
+            const session = this.productBuilderService.fetchSession(tag);
+            if (!session) {
+                throw new Error(`Session with tag ${tag} does not exist`);
+            }
+            const env = this.productBuilderService.fetchEnv(slug);
+            if (!env) {
+                throw new Error(`Env with slug ${slug} does not exist`);
+            }
+            await this.inputService.validateInput(input, session.schema_data);
+            const stages = (0, string_utils_1.extractStages)(session.selector);
+            const user = (0, processor_utils_1.extractSelectorValue)(data, stages, session.selector);
+            const expiry = (0, processor_utils_1.calculateJWTExpiry)(session.expiry, session.period);
+            const end_at = (0, processor_utils_1.calculateExpiry)(session.expiry, session.period);
+            const JWT = await loadJWT();
+            if (JWT) {
+                const session_id = (0, uuid_1.v4)();
+                const token = JWT.sign({ session: payload.tag, env: payload.env, session_id, data }, this.productBuilderService.fetchProduct().private_key, { expiresIn: expiry });
+                const refreshToken = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.productBuilderService.fetchProduct().private_key);
+                // WRITE REFRESH TOKEN TO DATABASE... TO INVALIDATE DELETE FROM DATABASE
+                const details = {
+                    identifier: user,
+                    start_at: Date.now(),
+                    end_at,
+                    session_tag: tag,
+                    data: (0, processor_utils_1.encrypt)(JSON.stringify(JSON.stringify(data)), this.productBuilderService.fetchProduct().private_key),
+                    session_id
+                };
+                await this.processorApiService.createSessionInfo(Object.assign({ product_tag, env: slug, refreshToken }, details), this.getUserAccess());
+                return {
+                    token,
+                    refreshToken,
+                };
+            }
+            else {
+                throw new Error(`Running in browser, token service not loaded.`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async refreshSession(payload) {
+        await this.productBuilderService.initializeProductByTag(payload.product);
+        // validate token validity
+        const { refreshToken } = payload, payloadData = __rest(payload, ["refreshToken"]);
+        const valid = await this.processorApiService.validateRefreshToken({ refreshToken, product: payload.product, env: payload.env }, this.getUserAccess());
+        if (valid) {
+            const data = JSON.parse((0, processor_utils_1.decrypt)(refreshToken, this.productBuilderService.fetchProduct().private_key));
+            return await this.generateSession(Object.assign(Object.assign({}, payloadData), { data }));
+        }
+        else {
+            throw new Error(`Invalid refresh token`);
+        }
+    }
+    async decryptSession(data) {
+        await this.productBuilderService.initializeProductByTag(data.product);
+        const JWT = await loadJWT();
+        if (!JWT) {
+            throw new Error(`Running in browser, token service not loaded.`);
+        }
+        try {
+            const res = await JWT.verify(data.token, this.productBuilderService.fetchProduct().private_key);
+            if (res.session !== data.tag) {
+                throw new Error(`Invalid token for session ${data.tag}`);
+            }
+            if (res.env !== data.env) {
+                throw new Error(`Invalid session env`);
+            }
+            return res.data;
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error("Invalid/Expired token");
+        }
     }
     async registerWebhook(data) {
         const { product: product_tag, access_tag, webhook_tag, envs } = data;
@@ -225,7 +326,6 @@ class ProcessorService {
     }
     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;
@@ -247,8 +347,10 @@ class ProcessorService {
                 data: input,
             };
             this.quota = this.fetchQuota(quota_tag, additional_logs);
+            if (!this.quota) {
+                throw new Error(`Quota ${quota_tag} not found`);
+            }
             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`);
@@ -258,19 +360,99 @@ class ProcessorService {
             this.validateJSONFeatureInput(input, quotaInput, additional_logs);
             // split processes
             //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
-            return await this.runQuotaOptions(options, additional_logs);
+            await this.logService.publish();
+            return await this.runQuotaOptions(options, input, additional_logs);
         }
         catch (e) {
             this.end = Date.now();
-            this.logService.publish();
+            await this.logService.publish();
             throw e;
         }
     }
-    async runQuotaOptions(options, additional_logs) { }
-    async runFallbackOptions(options, additional_logs) { }
+    async runQuotaOptions(options, input, additional_logs) {
+        try {
+            const quotaManager = new quota_service_1.default(options, this.redisClient);
+            const getNextProvider = quotaManager.getNextProvider();
+            const quotaInput = await this.mapQuotaFallbackInput(getNextProvider.input, input, getNextProvider.app);
+            const result = await this.processEvent({
+                app: getNextProvider.app,
+                type: getNextProvider.type,
+                event: getNextProvider.event,
+                input: quotaInput,
+                retries: getNextProvider.retries,
+                allow_fail: false
+            });
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process quota successful', successful_execution: true, data: { result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.PROCESSING }));
+            return result;
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process quota failed', failed_execution: true, data: { e }, status: types_1.LogEventStatus.PROCESSING }));
+            throw e;
+        }
+    }
+    async mapQuotaFallbackInput(providerInput, quotaInput, app) {
+        if (Array.isArray(providerInput)) {
+            return providerInput.map(async (item) => await this.mapQuotaFallbackInput(item, quotaInput, app));
+        }
+        else if (providerInput && typeof providerInput === 'object') {
+            const result = {};
+            for (const key in providerInput) {
+                result[key] = await this.mapQuotaFallbackInput(providerInput[key], quotaInput, app);
+            }
+            return result;
+        }
+        else {
+            // Base case: primitive value
+            return await this.overrideQuotaFallbackInput(providerInput, quotaInput, app);
+        }
+    }
+    async overrideQuotaFallbackInput(value, quotaInput, app) {
+        if (value.startsWith('$Input{')) {
+            return quotaInput[(0, string_utils_1.extractStages)(value)[0]];
+        }
+        else if (value.startsWith('$Auth')) {
+            return await this.generateAuthValue((0, string_utils_1.extractStages)(value), app, [], {});
+        }
+        else if (value.startsWith('$')) {
+            this.input = Object.assign(Object.assign({}, this.input), { input: quotaInput });
+            return await this.generateOperatorValues(value, '', {});
+        }
+        else {
+            return value;
+        }
+    }
+    async runFallbackOptions(options, input, additional_logs) {
+        return await this.executeActionWithFallback(options, input);
+    }
+    async executeActionWithFallback(providers, input) {
+        let index = 0;
+        for (const provider of providers) {
+            try {
+                const payload = {
+                    app: provider.app,
+                    type: provider.type,
+                    event: provider.event,
+                    input: await this.mapQuotaFallbackInput(provider.input, input, provider.app),
+                    retries: provider.retries,
+                    allow_fail: false
+                };
+                const result = await this.processEvent(payload);
+                if (result.status === types_1.LogEventStatus.FAIL) {
+                    throw new Error(result.errors);
+                }
+                index++;
+            }
+            catch (error) {
+                if (index > 0) {
+                    throw error;
+                }
+                console.warn(`${provider.app || provider.event} failed: ${error}`);
+            }
+        }
+        //throw new Error("All providers failed.");
+    }
     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;
@@ -287,13 +469,15 @@ class ProcessorService {
                 product_id: this.productId,
                 workspace_id: this.workspace_id,
                 env,
-                type: types_1.LogEventTypes.QUOTA,
+                type: types_1.LogEventTypes.FALLBACK,
                 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 }));
+            if (!this.fallback) {
+                throw new Error(`Fallback "${fallback_tag}" not found`);
+            }
+            this.logService.setFeatureId(this.fallback._id);
             this.processEnv = this.fetchEnv(env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
@@ -303,15 +487,15 @@ class ProcessorService {
             this.validateJSONFeatureInput(input, fallbackInput, additional_logs);
             // split processes
             //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
-            return await this.runFallbackOptions(options, additional_logs);
+            return await this.runFallbackOptions(options, input, additional_logs);
         }
         catch (e) {
             this.end = Date.now();
-            this.logService.publish();
+            await this.logService.publish();
             throw e;
         }
     }
-    async processFeature(data) {
+    async processFeature(data, awaitResolution = false) {
         this.start = Date.now();
         this.input = data;
         const { product: product_tag, env, input, tag: feature_tag } = data;
@@ -322,12 +506,15 @@ class ProcessorService {
             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.feature = this.fetchFeature(feature_tag, additional_logs);
+            if (!this.feature) {
+                throw new Error(`Feature "${feature_tag}" not found`);
+            }
             this.baseLogs = {
                 product_tag: this.productTag,
                 product_id: this.productId,
@@ -336,10 +523,10 @@ class ProcessorService {
                 type: types_1.LogEventTypes.FEATURE,
                 process_id,
                 data: input,
+                feature_tag: feature_tag,
+                feature_id: this.feature._id,
             };
-            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`);
@@ -348,7 +535,7 @@ class ProcessorService {
             // validate feature input and log failure
             this.validateJSONFeatureInput(input, featureInput, additional_logs);
             // split processes
-            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
             await this.processSequenceLevels(additional_logs);
             return { process_id };
             //return this.generateOutput(output as unknown as Record<string, IFeatureOutput>);
@@ -357,7 +544,7 @@ class ProcessorService {
             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();
+                await this.logService.publish();
                 if (passedValidation) {
                     return { process_id: this.process_id };
                 }
@@ -371,13 +558,7 @@ class ProcessorService {
         }
     }
     async intializeProduct(additional_logs) {
-        try {
-            if (this.productTag) {
-                await this.productBuilderService.initializeProductByTag(this.productTag); // validate product_exists
-            }
-            else {
-                await this.productBuilderService.initializeProduct(this.productId);
-            }
+        if (!this.logService) {
             this.logService = new logs_service_1.default({
                 product_id: this.productId,
                 workspace_id: this.workspace_id,
@@ -386,6 +567,14 @@ class ProcessorService {
                 token: this.token,
                 env_type: this.environment,
             });
+        }
+        try {
+            if (this.productTag) {
+                await this.productBuilderService.initializeProductByTag(this.productTag); // validate product_exists
+            }
+            else {
+                await this.productBuilderService.initializeProduct(this.productId);
+            }
             const { _id: product_id, workspace_id } = this.productBuilderService.fetchProduct();
             this.productId = product_id;
             if (workspace_id !== this.workspace_id) {
@@ -394,14 +583,12 @@ class ProcessorService {
             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) {
-            console.log(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;
@@ -413,7 +600,6 @@ class ProcessorService {
     }
     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;
@@ -425,7 +611,6 @@ class ProcessorService {
     }
     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;
@@ -437,7 +622,6 @@ class ProcessorService {
     }
     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`);
@@ -452,7 +636,6 @@ class ProcessorService {
     }
     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 }));
         }
@@ -461,9 +644,8 @@ class ProcessorService {
             throw e;
         }
     }
-    splitSequenceIntoLevels(data, additional_logs) {
+    async 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();
@@ -500,10 +682,9 @@ class ProcessorService {
     }
     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);
+                levelEvents[parseInt(level)] = this.fetchLevelEvents(sequences, parseInt(level));
             });
             let previousLevelComplete = true;
             for (const level of Object.keys(levelEvents)
@@ -516,58 +697,93 @@ class ProcessorService {
                     break;
                 }
             }
-            if (previousLevelComplete) {
-                this.logService.publish();
+            this.doneWithProcessing = true;
+            if (previousLevelComplete && !this.published) {
+                let message;
+                let status;
+                let successful_feature_execution;
+                let failed_feature_execution;
+                if (this.processingOutput.failure.length === 0) {
+                    message = 'Process feature - success';
+                    status = types_1.LogEventStatus.SUCCESS;
+                    successful_feature_execution = true;
+                }
+                else if (this.processingFailure) {
+                    message = 'Process feature - processing';
+                    status = types_1.LogEventStatus.PROCESSING;
+                    successful_feature_execution = false;
+                    failed_feature_execution = false;
+                }
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_feature_execution,
+                    failed_feature_execution,
+                    message, data: {}, status }));
+                await this.logService.publish();
                 this.end = Date.now();
-                this.writeResult(types_1.LogEventStatus.SUCCESS);
+                await this.writeResult(status);
             }
+            return true;
         }
         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 }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process sequence 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);
+        try {
+            const promises = events.map((event) => {
+                const dependants = this.fetchActionRequestDependents(event.input, additional_logs);
+                const passed = this.checkDependentsSuccess(dependants);
+                if (passed) {
+                    // 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);
+        }
+        catch (e) {
+            throw e;
+        }
     }
     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);
+        try {
+            const { failure } = this.processingOutput;
+            const promises = failure.map((failed) => {
+                if (failed.retries_left > 0 && new Date().getTime() > failed.retry_at) {
+                    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);
+        }
+        catch (e) {
+            throw e;
+        }
     }
     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);
+        try {
+            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);
+        }
+        catch (e) {
+            throw e;
+        }
     }
     checkDependentsSuccess(dependants) {
         let pass = true;
@@ -580,7 +796,6 @@ class ProcessorService {
     }
     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));
@@ -597,6 +812,12 @@ class ProcessorService {
             if (input.data) {
                 dependents.push(...this.fetchDependents(input.data, additional_logs));
             }
+            if (input.fileName) {
+                dependents.push(...this.valueStringDepsCheck(input.fileName));
+            }
+            if (input.buffer) {
+                dependents.push(...this.valueStringDepsCheck(input.buffer));
+            }
             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;
         }
@@ -606,7 +827,6 @@ class ProcessorService {
     }
     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];
@@ -621,6 +841,20 @@ class ProcessorService {
                                     event_tag: stages[1],
                                 });
                             }
+                            else if (values[i].startsWith('$')) {
+                                const funcArgs = (0, functions_utils_1.extractFunctionAndArgs)(values[i]);
+                                if (funcArgs.args.length) {
+                                    funcArgs.args.map((arg) => {
+                                        if (arg.startsWith('$Sequence')) {
+                                            const stages = this.productBuilderService.extractStages(arg);
+                                            dependants.push({
+                                                sequence_tag: stages[0],
+                                                event_tag: stages[1],
+                                            });
+                                        }
+                                    });
+                                }
+                            }
                         }
                     }
                     else {
@@ -628,22 +862,45 @@ class ProcessorService {
                     }
                 }
                 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] });
-                    }
+                    dependants.push(...this.valueStringDepsCheck(value.trim()));
                 }
             }
             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;
         }
     }
+    valueStringDepsCheck(value) {
+        const dependants = [];
+        if (value.startsWith('$Sequence')) {
+            const stages = this.productBuilderService.extractStages(value);
+            dependants.push({ sequence_tag: stages[0], event_tag: stages[1] });
+        }
+        else if (value.startsWith('$')) {
+            const funcArgs = (0, functions_utils_1.extractFunctionAndArgs)(value);
+            if (funcArgs && funcArgs.args.length) {
+                funcArgs.args.map((arg) => {
+                    if (arg.startsWith('$Sequence')) {
+                        const stages = this.productBuilderService.extractStages(arg);
+                        dependants.push({
+                            sequence_tag: stages[0],
+                            event_tag: stages[1],
+                        });
+                    }
+                    else {
+                        const args = arg.split(',');
+                        args.map((arg) => {
+                            dependants.push(...this.valueStringDepsCheck(arg.trim()));
+                        });
+                    }
+                });
+            }
+        }
+        return dependants;
+    }
     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) {
@@ -700,7 +957,6 @@ class ProcessorService {
     }
     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++) {
@@ -797,7 +1053,7 @@ class ProcessorService {
             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);
+            return await this.subtractValues(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);
@@ -1189,7 +1445,7 @@ class ProcessorService {
         }
     }
     decorateValue(value, sample) {
-        if (sample.decorator) {
+        if (sample && sample.decorator) {
             if (sample.decoratorPosition &&
                 sample.decoratorPosition == types_1.DecoratorPostions.APPEND &&
                 !value.endsWith(sample.decorator)) {
@@ -1220,7 +1476,6 @@ class ProcessorService {
     }
     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`);
@@ -1286,7 +1541,7 @@ class ProcessorService {
             }*/
             if (event.type === types_1.FeatureEventTypes.ACTION) {
                 const additional_logs = {
-                    parent_tag: (0, string_utils_1.extractOriginAndTag)(event.app),
+                    parent_tag: event.app,
                     child_tag: event.event,
                     type: types_1.LogEventTypes.ACTION,
                     name: 'Process feature action',
@@ -1314,8 +1569,12 @@ class ProcessorService {
                 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
+                const additional_logs = {
+                    parent_tag: event.event,
+                    type: types_1.LogEventTypes.FEATURE,
+                    name: 'Process sub-feature',
+                };
+                return this.runFeature(event, additional_logs);
             }
             if (event.type === types_1.FeatureEventTypes.NOTIFICATION) {
                 const [parent_tag, child_tag] = event.event.split(':');
@@ -1336,11 +1595,9 @@ class ProcessorService {
                     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) {
@@ -1349,30 +1606,70 @@ class ProcessorService {
                     parent_tag: event.event,
                     name: 'Process feature job',
                 };
-                return this.runJob(event, additional_logs);
+                const input = {
+                    env: event.env.slug,
+                    product: this.productTag,
+                    event: event.event,
+                    retries: event.retries,
+                    input: event.input,
+                    start_at: event.start_at || 0,
+                    cache: event.cache,
+                    session: this.input.session
+                };
+                // TODO: fix this
+                return this.processJob(input, additional_logs);
             }
         }
         catch (e) {
             throw e;
         }
     }
-    runJob(event, additional_logs) {
-        throw new Error('Method not implemented.');
+    async runFeature(event, additional_logs) {
+        const freshInstance = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        const result = await freshInstance.processFeature({
+            product: this.productTag,
+            tag: event.event,
+            env: this.processEnv.slug,
+            input: event.input,
+        }, true);
+        const output = await freshInstance.generateOutput(result.process_id);
+        if (output.status === types_1.LogEventStatus.FAIL) {
+            await this.addToFailureOutput(output.errors, event, { process_id: result.process_id }, Object.assign(Object.assign({}, additional_logs), { process_id: result.process_id }));
+        }
+        else if (output.status === types_1.LogEventStatus.SUCCESS) {
+            await this.addToSuccessOutput(event, output.data, Object.assign(Object.assign({}, additional_logs), { process_id: result.process_id }));
+        }
+        return output;
+    }
+    async runJobs(job, additional_logs = {}) {
+        if (job.name === types_1.FeatureEventTypes.ACTION) {
+            await this.processAction(job.data);
+        }
     }
     async processFailedAndWaiting() { }
-    async generateOutput(process_id) {
-        var _a, _b, _c, _d;
-        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+    async fetchResult(process_id) {
+        const result = await this.processorApiService.fetchResult(process_id, this.getUserAccess());
         if (!result) {
             throw new Error(`Invalid process id ${process_id}`);
         }
+        await this.productBuilderService.initializeProduct(result.product_id);
+        result.result = JSON.parse((0, processor_utils_1.decrypt)(String(result.result), this.productBuilderService.fetchProduct().private_key));
+        result.input = JSON.parse((0, processor_utils_1.decrypt)(String(result.input), this.productBuilderService.fetchProduct().private_key));
+        return result;
+    }
+    async generateOutput(process_id) {
+        var _a, _b, _c, _d;
+        const result = await this.fetchResult(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) {
+            if (result.status === types_1.LogEventStatus.PROCESSING) {
+                return { process_id, status: result.status };
+            }
+            else if (result.status === types_1.LogEventStatus.SUCCESS) {
                 this.productTag = result.input.product;
                 await this.intializeProduct(additional_logs);
                 this.processingOutput = result.result;
@@ -1388,7 +1685,7 @@ class ProcessorService {
                 return { process_id, status: result.status, errors };
             }
         }
-        else {
+        else if (result) {
             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 };
             }
@@ -1401,7 +1698,7 @@ class ProcessorService {
         }
     }
     async resumeProcess(process_id) {
-        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+        const result = await this.fetchResult(process_id);
         if (!result) {
             throw new Error(`Invalid process id ${process_id}`);
         }
@@ -1428,7 +1725,7 @@ class ProcessorService {
             // validate feature input and log failure
             this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
             // split processes
-            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
             await this.processSequenceLevels(additional_logs);
         }
         else {
@@ -1437,13 +1734,13 @@ class ProcessorService {
             if (this.processingOutput.failure.length > 0) {
                 status = types_1.LogEventStatus.FAIL;
             }
-            this.writeResult(status);
+            await this.writeResult(status);
         }
         return { process_id };
     }
     async replayProcess(process_id) {
         var _a, _b, _c;
-        const result = (await this.processorApiService.fetchResult(process_id, this.getUserAccess()));
+        const result = await this.fetchResult(process_id);
         if (!result) {
             throw new Error(`Invalid process id ${process_id}`);
         }
@@ -1470,7 +1767,7 @@ class ProcessorService {
             // validate feature input and log failure
             this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
             // split processes
-            this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
+            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
             await this.processSequenceLevels(additional_logs);
         }
         else {
@@ -1482,20 +1779,20 @@ class ProcessorService {
             this.start = Date.now();
             await this.processEvent(event);
             this.end = Date.now();
-            this.writeResult(types_1.LogEventStatus.SUCCESS);
-            this.logService.publish();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await this.logService.publish();
         }
         return { process_id };
     }
-    fetchLevelEvents(level) {
+    fetchLevelEvents(sequence, level) {
         const events = [];
-        for (let i = 0; i < level.length; i++) {
-            events.push(...this.appendSequenceDataToLevelEvents(level[i]));
+        for (let i = 0; i < sequence.length; i++) {
+            events.push(...this.appendSequenceDataToLevelEvents(sequence[i], level));
         }
         return events;
     }
-    appendSequenceDataToLevelEvents(sequence) {
-        const { events, level, tag } = sequence;
+    appendSequenceDataToLevelEvents(sequence, level) {
+        const { events, tag } = sequence;
         for (let i = 0; i < events.length; i++) {
             events[i].sequence_level = level;
             events[i].sequence_tag = tag;
@@ -1571,7 +1868,6 @@ class ProcessorService {
     }
     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;
@@ -1583,7 +1879,6 @@ class ProcessorService {
         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) {
@@ -1608,7 +1903,6 @@ class ProcessorService {
     }
     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)) {
@@ -1624,15 +1918,13 @@ class ProcessorService {
         // generate indexes
         return (0, processor_utils_1.generateIndexes)(operator, iter, init, valueValue);
     }
-    async runAction(event, additional_logs, returnValue = false) {
+    async runAction(event, additional_logs, returnValue = true) {
         try {
-            console.log("RUNNING ACTION!!!!!");
             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))) {
-                console.log("RUNNING ACTION SKIPPED!!!!!");
                 // if it fails, it would add to skipped queue
                 return;
             }
@@ -1681,18 +1973,21 @@ class ProcessorService {
                     input: inputString,
                     privateKey: product.private_key,
                     expiry: productCache.expiry,
-                });
+                }, additional_logs);
                 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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Run action - response from cache', data: { result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS, cache_tag, action: event.event }));
                     if (returnValue) {
                         return result;
                     }
                 }
             }
-            if (request_type === types_1.DataFormats.JSON || !request_type) {
+            if (request_type === types_1.DataFormats.JSON || request_type === types_1.DataFormats.URLENCODED || !request_type) {
                 if (indexes.length == 0) {
                     payloads = await this.constructJSONDataPayloads(event.input, additional_logs, samples, event);
+                    if (request_type === types_1.DataFormats.URLENCODED) {
+                        payloads.body = (0, processor_utils_1.toFormUrlEncoded)(payloads.body);
+                    }
                     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);
                 }
@@ -1720,24 +2015,26 @@ class ProcessorService {
                     component_tag: action_tag,
                     component_type: types_1.ProductComponents.ACTION,
                     product_tag: this.productTag,
-                });
-            }
-            if (result && returnValue) {
-                return 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 Action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Run Action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
             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);
+            let results = (0, processor_utils_1.generateMockData)(resource, env.slug, payloads);
+            if (!results) {
+                results = await this.sendActionRequest(request_base_url, resource, payloads, method, env.slug);
+            }
             const end = Date.now();
+            this.requestTime += end - start;
+            this.totalRequests += 1;
             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);
@@ -1750,10 +2047,17 @@ class ProcessorService {
         }
         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,
+            let error = e;
+            if (e.response.data) {
+                error = e.response.data;
+            }
+            this.requestTime += end - start;
+            this.totalRequests += 1;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process http request - failed', failed_execution: true, data: { e: error, input: (0, processor_utils_1.anonymizeObject)(payloads) }, status: types_1.LogEventStatus.FAIL, app_id, action: event.event, start,
                 end }));
             try {
-                const value = this.addToFailureOutput(e, event, {
+                console.log(e);
+                const value = await this.addToFailureOutput(e, event, {
                     request_base_url,
                     resource,
                     method,
@@ -1761,6 +2065,9 @@ class ProcessorService {
                     payloads,
                     app_id,
                 }, additional_logs, retries);
+                if (value) {
+                    return value;
+                }
                 //if (returnValue) {
                 return {
                     process_id: this.process_id,
@@ -1779,8 +2086,29 @@ class ProcessorService {
         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));
+        if (event.type === types_1.FeatureEventTypes.STORAGE) {
+            event = (0, processor_utils_1.cleanBlob)(event);
+        }
         this.processingOutput.success.push({ event, output });
         await this.processWaitingEvents(additional_logs);
+        if (this.checkIsSuccessful() && this.doneWithProcessing) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_feature_execution: true, message: 'Process feature - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+            await this.logService.publish();
+            this.end = Date.now();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+        }
+    }
+    checkIsSuccessful() {
+        let success = true;
+        this.processingOutput.failure.find((output) => {
+            if (!output.allow_fail) {
+                success = false;
+            }
+        });
+        if (this.processingOutput.waiting.length > 0) {
+            success = false;
+        }
+        return success;
     }
     addToWaitingOutput(event, dependants) {
         const exists = this.processingOutput.waiting.findIndex((item) => {
@@ -1794,8 +2122,9 @@ class ProcessorService {
         }
         // addToSkippedOutput()
     }
-    addToFailureOutput(e, event, payload, additional_logs, policy = {}) {
+    async addToFailureOutput(e, event, payload, additional_logs, policy = {}) {
         try {
+            this.processingFailure = true;
             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;
@@ -1814,6 +2143,12 @@ class ProcessorService {
                 max = metrices.max;
             }
             const { allow_fail, retries } = event;
+            let retryable = true;
+            if (event.type === types_1.FeatureEventTypes.STORAGE) {
+                event = (0, processor_utils_1.cleanBlob)(event);
+                if (!this.feature || (this.feature && !event.allow_fail))
+                    retryable = false;
+            }
             let retries_left = retries || max;
             if (exists > -1) {
                 retries_left = this.processingOutput.failure[exists].retries_left - 1;
@@ -1853,11 +2188,16 @@ class ProcessorService {
                 }, retry_at);
             }
             if (allow_fail === false && retries_left === 0) {
+                this.published = true;
+                if (this.feature) {
+                    additional_logs.failed_feature_execution = true;
+                }
                 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();
+                await this.writeResult(types_1.LogEventStatus.FAIL, retryable);
+                await this.logService.publish();
+                //throw new Error("Terminate Process")
             }
             return output;
         }
@@ -1866,52 +2206,15 @@ class ProcessorService {
         }
     }
     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;
-        }
+        var _a;
+        const isSpecial = error_code === '1000';
+        if (isSpecial) {
+            return { allow_fail: true, max: (retries === null || retries === void 0 ? void 0 : retries.max) || 0, retry_at: 500 };
+        }
+        const policy = (_a = retries === null || retries === void 0 ? void 0 : retries.policy) === null || _a === void 0 ? void 0 : _a[error_code];
+        const allow_fail = policy ? policy.available : true;
+        const retry_at = policy ? policy.lag : 0;
+        const max = (retries === null || retries === void 0 ? void 0 : retries.max) || 0;
         return { allow_fail, max, retry_at };
     }
     async sendActionRequest(base_url, resource, payload, method, env) {
@@ -1924,20 +2227,24 @@ class ProcessorService {
                 }
             }
             const authHeaders = headers;
+            if (!base_url.endsWith('/') && !resource.startsWith('/')) {
+                base_url = base_url + '/';
+            }
             const request = {
                 url: resource,
                 method,
+                baseURL: base_url,
                 data: body,
                 params: query,
                 headers: authHeaders,
+                timeout: 15000,
+                withCredentials: false
             };
-            if (!base_url.endsWith('/') && !resource.startsWith('/')) {
-                base_url = base_url + '/';
-            }
-            const response = await (0, http_client_1.default)(base_url).request(request);
+            const response = await axios_1.default.request(request);
             return response.data;
         }
         catch (e) {
+            //console.error("LOG ERROR", e);
             throw e;
         }
     }
@@ -1950,8 +2257,8 @@ class ProcessorService {
             name: 'Process Storage',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
-            this.input = action;
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
+            this.input = input;
             this.start = Date.now();
             this.component = types_1.LogEventTypes.STORAGE;
             // clone
@@ -1968,7 +2275,6 @@ class ProcessorService {
             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,
@@ -1981,14 +2287,14 @@ class ProcessorService {
             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;
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await this.logService.publish();
+            return Object.assign(Object.assign({}, result), { process_id: this.process_id });
         }
         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();
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
@@ -2004,7 +2310,7 @@ class ProcessorService {
             name: `Subscribe to broker topic`,
         };
         try {
-            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.STORAGE);
+            await this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.STORAGE);
             this.start = Date.now();
             this.productTag = data.product;
             const process_id = (0, processor_utils_1.generateObjectId)();
@@ -2030,14 +2336,14 @@ class ProcessorService {
             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();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await 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();
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
@@ -2053,8 +2359,7 @@ class ProcessorService {
             name: 'Publish to broker topic',
         };
         try {
-            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.PUBLISH);
-            console.log("JAPANESE MIRRORS", data.input);
+            await this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.PUBLISH);
             this.start = Date.now();
             // clone
             this.clone = (0, processor_utils_1.structuredClone)(data.input);
@@ -2068,11 +2373,9 @@ class ProcessorService {
             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,
@@ -2085,19 +2388,124 @@ class ProcessorService {
             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();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await 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();
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
-    async processJob(job) { }
+    async processJob(job, additional_logs = {}) {
+        var _a;
+        const productJob = this.productBuilderService.fetchJob(job.event);
+        if (!productJob) {
+            throw new Error(`Job ${job.event} not found`);
+        }
+        await this.validateActionDataMappingInput(job.input, productJob.type);
+        const NOW = Date.now();
+        // Treat anything above Jan 1, 2023 as a timestamp (to be safe and future-proof)
+        const IS_PROBABLY_TIMESTAMP = job.start_at > 1672531200000;
+        const delay = Math.max(0, IS_PROBABLY_TIMESTAMP ? job.start_at - NOW : job.start_at);
+        let jobInput;
+        if (productJob.type === types_1.JobEventTypes.ACTION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                app: productJob.app,
+                cache: job.cache,
+                input: job.input,
+                event: job.event,
+                session: job.session
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.DATABASE_ACTION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                cache: job.cache,
+                input: job.input,
+                event: job.event,
+                session: job.session,
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.FALLBACK || productJob.type === types_1.JobEventTypes.QUOTA || productJob.type === types_1.JobEventTypes.FEATURE) {
+            const input = {
+                input: job.input,
+                product: job.product,
+                env: job.env,
+                tag: job.event,
+                session: job.session,
+                cache: job.cache,
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.NOTIFICATION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                input: job.input,
+                session: job.session,
+                cache: job.cache
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.PUBLISH) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                cache: job.cache,
+                session: job.session,
+                input: job.input
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.STORAGE) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                cache: job.cache,
+                session: job.session,
+                input: job.input
+            };
+            jobInput = input;
+        }
+        else {
+            throw new Error(`Job type ${productJob.type} not supported`);
+        }
+        const options = {};
+        // Handle `delay` only if repeat.every is not defined
+        if (!((_a = job.repeat) === null || _a === void 0 ? void 0 : _a.every)) {
+            options.delay = delay;
+        }
+        // Add repeat config if defined
+        if (job.repeat) {
+            const { every, cron, tz, limit, endDate } = job.repeat;
+            options.repeat = cron
+                ? {
+                    cron,
+                    tz,
+                    limit,
+                    endDate,
+                }
+                : every
+                    ? {
+                        every,
+                        limit,
+                        endDate,
+                    }
+                    : undefined;
+        }
+        await this.queues.jobs.add(productJob.type, jobInput, options);
+    }
     async sendExpoNotification(payload, device_tokens) {
         const message = {
             to: device_tokens,
@@ -2106,7 +2514,6 @@ class ProcessorService {
             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)());
         }
@@ -2125,7 +2532,6 @@ class ProcessorService {
         try {
             const admin = require('firebase-admin');
             const serviceAccount = credentials;
-            console.log("MESSAGE", message);
             admin.initializeApp({
                 credential: admin.credential.cert(serviceAccount),
             });
@@ -2138,24 +2544,18 @@ class ProcessorService {
         }
     }
     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 }));
     }
@@ -2165,10 +2565,11 @@ class ProcessorService {
         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);
+            if (!message) {
+                throw new Error(`Message ${event} not found`);
+            }
             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;
@@ -2183,15 +2584,23 @@ class ProcessorService {
                 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 }));
+                try {
+                    await this.ProcessExpoNotification(notifications, message, input.push_notification, additional_logs);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Processing Expo notification - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Processing Expo notification - failed', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                }
+            }
+            if (push && notifications.type === types_1.Notifiers.FIREBASE) {
+                try {
+                    await this.ProcessFirebaseNotification(notifications, message, input.push_notification, additional_logs);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Processing Firebase notification - success', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Processing Firebase notification - failed', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.FAIL }));
+                }
             }
             if (email && emails) {
                 input.email.subject = await this.generatePayload(input.email.subject, notification, additional_logs, message.email_data.filter((data) => data.parent_key === 'subject'));
@@ -2203,37 +2612,28 @@ class ProcessorService {
                 }));
                 //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 }));
+                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), input: (0, processor_utils_1.anonymizeObject)(input.email), }, 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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send email - success', successful_execution: true, 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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, 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),
@@ -2249,43 +2649,34 @@ class ProcessorService {
                     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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, 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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, 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 }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send sms - success', successful_execution: true, 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), { failed_execution: true, 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 }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { 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();
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt notification - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+            //await this.logService.publish();
+            throw e;
         }
     }
     async runMigration(product_tag, tag, env, type) {
@@ -2363,9 +2754,8 @@ class ProcessorService {
             }
         }
         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();
+            await this.logService.publish();
         }
     }
     /*async runFunction(data: IFeatureEvent, additional_logs: Partial<ILogData>): Promise<any> {
@@ -2458,7 +2848,7 @@ class ProcessorService {
           data: e,
           status: LogEventStatus.FAIL,
         });
-        this.logService.publish();
+        await this.logService.publish();
       }
     }*/
     async runStorage(data, additional_logs = {}) {
@@ -2466,8 +2856,6 @@ class ProcessorService {
         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) {
@@ -2487,20 +2875,17 @@ class ProcessorService {
                     input: inputString,
                     privateKey: product.private_key,
                     expiry: productCache.expiry,
-                });
+                }, additional_logs);
                 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;
+            input.buffer = input.buffer ? await this.generateStringValues(input.buffer, '', additional_logs, []) : undefined;
+            input.fileName = input.fileName ? await this.generateStringValues(input.fileName, '', additional_logs, []) : undefined;
+            input.mimeType = input.mimeType ? await this.generateStringValues(input.mimeType, '', additional_logs, []) : undefined;
             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) {
@@ -2516,13 +2901,11 @@ class ProcessorService {
                     component_tag: event,
                     component_type: types_1.ProductComponents.STORAGE,
                     product_tag: this.productTag,
-                });
+                }, additional_logs);
             }
             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;
         }
     }
@@ -2531,8 +2914,6 @@ class ProcessorService {
         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);
@@ -2542,7 +2923,6 @@ class ProcessorService {
                 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) => {
@@ -2558,21 +2938,21 @@ class ProcessorService {
                     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);
+                if (input.filter) {
+                    const filterValidationPayload = (await this.inputService.parseJson({
+                        data: input.filter,
+                        expected: types_1.ExpectedValues.PARSEINPUT,
+                    }));
+                    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);
@@ -2585,7 +2965,7 @@ class ProcessorService {
                     input: inputString,
                     privateKey: product.private_key,
                     expiry: productCache.expiry,
-                });
+                }, additional_logs);
                 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 }));
@@ -2598,7 +2978,7 @@ class ProcessorService {
                 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));
+                const mongoHandler = new MongoDBHandler(databaseEnv.connection_url);
                 if (databaseAction.type === types_1.DatabaseActionTypes.UPDATE) {
                     const filterTemplate = typeof databaseAction.filterTemplate === 'string'
                         ? databaseAction.filterTemplate
@@ -2619,9 +2999,8 @@ class ProcessorService {
                     result = await pgHandler[databaseAction.type](databaseAction.data, template, input.data);
                 }
             }
-            //this.logService.publish();
+            //await 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);
@@ -2638,12 +3017,14 @@ class ProcessorService {
                     product_tag: this.productTag,
                     component_tag: database_tag,
                     component_type: types_1.ProductComponents.DATABASE_ACTION,
-                });
+                }, additional_logs);
             }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Attempt database action - successful', data: { result: (0, processor_utils_1.anonymizeObject)(result) }, 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: 'Attempt database action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt database action - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
         }
     }
     async runBrokerSubscribe(data, additional_logs = {}) {
@@ -2651,8 +3032,6 @@ class ProcessorService {
         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) {
@@ -2678,12 +3057,13 @@ class ProcessorService {
                 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 }));
+                if (this.feature) {
+                    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 {
@@ -2701,8 +3081,6 @@ class ProcessorService {
         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) {
@@ -2728,12 +3106,13 @@ class ProcessorService {
                 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 }));
+                if (this.feature) {
+                    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 {
@@ -2743,7 +3122,6 @@ class ProcessorService {
         }
         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;
         }
     }
@@ -2774,13 +3152,30 @@ class ProcessorService {
                 Object.assign(config, { awsConfig: cloudConfig });
             }
             const result = { url: await (0, storage_util_1.uploadBlobToCloud)({ data: input.buffer, destinationPath: input.fileName, config }) };
+            try {
+                await this.processorApiService.saveFileURL({
+                    url: (0, processor_utils_1.encrypt)(result.url, this.productBuilderService.fetchProduct().private_key),
+                    provider: storageEnv.type,
+                    product: this.productTag,
+                    process_id: this.process_id,
+                    workspace_id: this.workspace_id,
+                    type: input.mimeType,
+                    event: data.event,
+                    env: data.env.slug,
+                    size: Buffer.from(input.buffer).length
+                }, this.getUserAccess());
+            }
+            catch (e) { }
             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);
+            const value = await this.addToFailureOutput(e, data, { storageEnv }, additional_logs);
+            if (value) {
+                return value;
+            }
             throw e;
         }
     }
@@ -2803,7 +3198,7 @@ class ProcessorService {
         }
         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, {
+            const value = await this.addToFailureOutput(e, db_action, {
                 db_action,
                 input,
                 database_tag,
@@ -2813,18 +3208,19 @@ class ProcessorService {
             return value;
         }
     }
-    async writeResult(status) {
+    async writeResult(status, retryable = true) {
         this.processorApiService.saveResult({
             status,
             component: this.component,
             start: this.start,
             end: this.end,
-            result: this.processingOutput,
+            retryable,
+            result: (0, processor_utils_1.encrypt)(JSON.stringify(this.processingOutput), this.productBuilderService.fetchProduct().private_key),
             process_id: this.process_id,
             feature_id: this.feature ? this.feature._id : null,
             product_id: this.productId,
             env: this.processEnv.slug,
-            input: this.input,
+            input: (0, processor_utils_1.encrypt)(JSON.stringify(this.input), this.productBuilderService.fetchProduct().private_key),
         }, this.getUserAccess());
     }
     async validateActionDataMappingInput(input, type) {
@@ -2856,7 +3252,7 @@ class ProcessorService {
         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);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -2877,7 +3273,6 @@ class ProcessorService {
             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,
@@ -2888,18 +3283,17 @@ class ProcessorService {
                 retries: retries || 0,
                 allow_fail: false,
             }, additional_logs, true);
-            console.log("RESULT ===>>>>", result);
             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();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await this.logService.publish();
             return result;
         }
         catch (e) {
-            console.log(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();
+            await this.writeResult(types_1.LogEventStatus.FAIL);
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
@@ -2918,7 +3312,7 @@ class ProcessorService {
             name: 'Process database action',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -2933,7 +3327,6 @@ class ProcessorService {
             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,
@@ -2946,14 +3339,14 @@ class ProcessorService {
             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();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await 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();
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
@@ -2973,7 +3366,7 @@ class ProcessorService {
             name: 'Process Notification',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -2988,7 +3381,6 @@ class ProcessorService {
             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,
@@ -3001,14 +3393,14 @@ class ProcessorService {
             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();
+            await this.writeResult(types_1.LogEventStatus.SUCCESS);
+            await 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();
+            await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
@@ -3032,7 +3424,7 @@ class ProcessorService {
             public_key: this.public_key,
         };
     }
-    async addToCache(payload) {
+    async addToCache(payload, additional_logs) {
         if (!this.redisClient) {
             throw 'redis client not setup';
         }
@@ -3048,13 +3440,15 @@ class ProcessorService {
             product_tag,
             component_tag,
             component_type }), this.getUserAccess());
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Renewing expired Cache Value', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
         await this.redisClient.hSet(key, 'data', encryptedData);
         await this.redisClient.hSet(key, 'lastUpdated', timestamp);
     }
-    async fetchFromCache(payload) {
+    async fetchFromCache(payload, additional_logs) {
         var _a;
         const { input, privateKey, cache_tag, expiry } = payload;
         const key = `${cache_tag}-${CryptoJS.SHA512(input)}`;
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching from Cache', data: { key }, status: types_1.LogEventStatus.PROCESSING, cache_tag }));
         if (!this.redisClient) {
             return null;
         }
@@ -3062,8 +3456,10 @@ class ProcessorService {
         if (!record || !record.data || !record.lastUpdated) {
             const checkRemote = await this.processorApiService.fetchRemoteCacheByKey(key, this.getUserAccess());
             if (!checkRemote) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Remote Cache Not Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.FAIL, cache_tag }));
                 return null;
             }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Remote Cache Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
             record = { data: checkRemote.value, expiresAt: (_a = checkRemote.expiry) === null || _a === void 0 ? void 0 : _a.getTime().toString() };
         }
         if (record.lastUpdated) {
@@ -3071,11 +3467,13 @@ class ProcessorService {
             if (expiry) {
                 const expiryTime = lastUpdated + expiry;
                 if (Date.now() > expiryTime) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Deleting expired Cache Value', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
                     await this.redisClient.del(key);
                     return null;
                 }
             }
         }
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
         return (0, processor_utils_1.decrypt)(record.data, privateKey);
     }
 }