@ductape/sdk 0.0.4-v9 → 0.0.4-v91

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

@@ -56,38 +56,43 @@ 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");
 const uuid_1 = require("uuid");
 const urls_1 = require("../../api/urls");
-//import { createBrokerService } from './messagebrokers';
 const date_fns_1 = require("date-fns");
-const mongo_repo_1 = require("../repos/mongo.repo");
-const postgres_repo_1 = require("../repos/postgres.repo");
 const storage_util_1 = require("../utils/storage.util");
 const sms_repo_1 = require("../repos/sms.repo");
-const quota_service_1 = __importDefault(require("./quota.service"));
+const pricing_service_1 = __importDefault(require("../../pricing/pricing.service"));
+const request_utils_1 = require("../utils/request.utils");
+const request_service_1 = __importDefault(require("./request.service"));
+const app_service_1 = __importDefault(require("../../apps/services/app.service"));
+const utils_1 = require("../../apps/utils");
+const credential_manager_1 = require("../../apps/utils/credential-manager");
+const oauth_manager_1 = require("../../apps/utils/oauth-manager");
+const secrets_1 = require("../../secrets");
 async function loadBrokerService() {
     if (typeof window === 'undefined') {
-        const { createBrokerService } = await Promise.resolve().then(() => __importStar(require('./messagebrokers')));
-        return createBrokerService;
+        const { loadBrokerService: loadBroker } = await Promise.resolve().then(() => __importStar(require('../../brokers')));
+        return loadBroker();
     }
     return null;
 }
 async function loadJWT() {
     if (typeof window === 'undefined') {
-        const JWT = await Promise.resolve().then(() => __importStar(require("jsonwebtoken")));
+        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, queues }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, private_key, access_key, redis_client, queues }) {
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
+        this._privateKey = private_key;
+        this.accessKey = access_key;
         this.token = token;
         this.published = false;
         this.productBuilderService = new products_service_1.default({
@@ -96,7 +101,23 @@ class ProcessorService {
             user_id,
             token,
             env_type,
-            redis_client
+            redis_client,
+        });
+        this.appBuilderService = new app_service_1.default({
+            workspace_id,
+            public_key,
+            user_id,
+            token,
+            env_type,
+            redis_client,
+        });
+        this.pricingService = new pricing_service_1.default({
+            workspace_id,
+            public_key,
+            user_id,
+            token,
+            env_type,
+            redis_client,
         });
         this.inputService = new inputs_service_1.default();
         this.requestTime = 0;
@@ -108,50 +129,133 @@ class ProcessorService {
             skipped: [],
         };
         this.apps = [];
+        this.requestTrackerService = request_service_1.default.getInstance(redis_client);
         this.processorApiService = new processorApi_service_1.ProcessorApiService(env_type);
         this.environment = env_type;
+        // Store redis client for job state management
         if (redis_client) {
             this.redisClient = redis_client;
         }
+        // Start healthcheck workers only if product tag is available
+        if (redis_client && this.productTag) {
+            this.startHealthcheckWorkers();
+        }
         if (queues) {
             this.queues = queues;
         }
     }
+    /**
+     * Start healthcheck workers for all products/environments after Redis is connected.
+     * This is called automatically in the constructor if redisClient is present.
+     */
+    async startHealthcheckWorkers() {
+        // Fetch all products (or the current product if context is single-tenant)
+        // For demo, we use the current product only
+        await this.productBuilderService.initializeProductByTag(this.productTag);
+        const healthchecks = await this.productBuilderService.fetchProductHealthchecks();
+        const privateKey = this.productBuilderService.fetchPrivateKey();
+        for (const healthcheck of healthchecks) {
+            for (const env of healthcheck.envs) {
+                // Each env gets its own worker (setInterval)
+                const interval = healthcheck.interval || 60000; // default 60s
+                setInterval(async () => {
+                    try {
+                        // Decrypt input for this env
+                        let decryptedInput = env.input;
+                        if (typeof decryptedInput === 'string') {
+                            decryptedInput = JSON.parse((0, processor_utils_1.decrypt)(decryptedInput, privateKey));
+                        }
+                        // Prepare action input
+                        const actionInput = {
+                            env: env.slug,
+                            product: this.productTag,
+                            app: healthcheck.app,
+                            input: decryptedInput,
+                            action: healthcheck.event,
+                            retries: healthcheck.retries || 0,
+                        };
+                        // Process the action
+                        const result = await this.processAction(actionInput);
+                        // Log result (success/failure)
+                        this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { message: `Healthcheck processed for ${healthcheck.tag} in env ${env.slug}`, data: { result }, status: types_1.LogEventStatus.SUCCESS }));
+                    }
+                    catch (e) {
+                        this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { message: `Healthcheck failed for ${healthcheck.tag} in env ${env.slug}`, data: { error: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+                    }
+                }, interval);
+            }
+        }
+    }
+    /**
+     * Manually trigger healthcheck processing for all healthchecks (can be called externally if needed)
+     */
+    async processAllHealthchecksForProduct(productTag) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        const healthchecks = await this.productBuilderService.fetchProductHealthchecks();
+        const privateKey = this.productBuilderService.fetchPrivateKey();
+        for (const healthcheck of healthchecks) {
+            for (const env of healthcheck.envs) {
+                try {
+                    let decryptedInput = env.input;
+                    if (typeof decryptedInput === 'string') {
+                        decryptedInput = JSON.parse((0, processor_utils_1.decrypt)(decryptedInput, privateKey));
+                    }
+                    const actionInput = {
+                        env: env.slug,
+                        product: productTag,
+                        app: healthcheck.app,
+                        input: decryptedInput,
+                        action: healthcheck.event,
+                        retries: healthcheck.retries || 0,
+                    };
+                    const result = await this.processAction(actionInput);
+                    this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { message: `Manual healthcheck processed for ${healthcheck.tag} in env ${env.slug}`, data: { result }, status: types_1.LogEventStatus.SUCCESS }));
+                }
+                catch (e) {
+                    this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { message: `Manual healthcheck failed for ${healthcheck.tag} in env ${env.slug}`, data: { error: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+                }
+            }
+        }
+    }
     async generateSession(payload) {
         try {
             const { product: product_tag, env: slug, tag, data } = payload;
-            const input = await this.inputService.parseJson({
+            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);
+            const privateKey = this.productBuilderService.fetchPrivateKey();
+            const session = await this.productBuilderService.fetchSession(tag);
             if (!session) {
                 throw new Error(`Session with tag ${tag} does not exist`);
             }
-            const env = this.productBuilderService.fetchEnv(slug);
+            const env = await 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);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            const user = (0, processor_utils_1.extractSelectorValue)(data, stringStages, 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);
+                const token = JWT.sign({ session: payload.tag, env: payload.env, session_id, data }, privateKey, {
+                    expiresIn: expiry,
+                });
+                const refreshToken = (0, processor_utils_1.encrypt)(JSON.stringify(data), privateKey);
                 // 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
+                    data: (0, processor_utils_1.encrypt)(JSON.stringify(JSON.stringify(data)), privateKey),
+                    session_id,
                 };
                 await this.processorApiService.createSessionInfo(Object.assign({ product_tag, env: slug, refreshToken }, details), this.getUserAccess());
                 return {
@@ -169,11 +273,12 @@ class ProcessorService {
     }
     async refreshSession(payload) {
         await this.productBuilderService.initializeProductByTag(payload.product);
+        const privateKey = this.productBuilderService.fetchPrivateKey();
         // 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));
+            const data = JSON.parse((0, processor_utils_1.decrypt)(refreshToken, privateKey));
             return await this.generateSession(Object.assign(Object.assign({}, payloadData), { data }));
         }
         else {
@@ -182,12 +287,13 @@ class ProcessorService {
     }
     async decryptSession(data) {
         await this.productBuilderService.initializeProductByTag(data.product);
+        const privateKey = this.productBuilderService.fetchPrivateKey();
         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);
+            const res = (await JWT.verify(data.token, privateKey));
             if (res.session !== data.tag) {
                 throw new Error(`Invalid token for session ${data.tag}`);
             }
@@ -198,14 +304,13 @@ class ProcessorService {
         }
         catch (e) {
             console.log(e);
-            throw new Error("Invalid/Expired token");
+            throw new Error('Invalid/Expired token');
         }
     }
     async registerWebhook(data) {
         const { product: product_tag, access_tag, webhook_tag, envs } = data;
         await this.productBuilderService.initializeProductByTag(product_tag);
-        const product = this.productBuilderService.fetchProduct();
-        const { version, envs: appEnvs } = this.productBuilderService.fetchApp(access_tag);
+        const { version, envs: appEnvs } = await this.productBuilderService.fetchApp(access_tag);
         const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
         const { webhooks } = app.versions.find((data) => data.tag === version);
         if (!webhooks) {
@@ -216,7 +321,7 @@ class ProcessorService {
         if (!webhook) {
             throw new Error(`Webhook tag ${webhook_tag} not found`);
         }
-        const productEnvs = this.productBuilderService.fetchEnvs();
+        const productEnvs = await this.productBuilderService.fetchEnvs();
         productEnvs.map((env) => {
             const exists = envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
             if (exists === -1) {
@@ -260,7 +365,7 @@ class ProcessorService {
                 if (replacedUrl && replacedUrl !== env.url && replacedUrl) {
                     throw new Error(`Ductape expects the url ${replacedUrl} in request body to match inputted url ${env.url}`);
                 }
-                const exists = this.fetchEnv(env.slug, {});
+                const exists = await this.fetchEnv(env.slug, {});
                 if (!exists) {
                     throw new Error(`Env ${env.slug} does not exist`);
                 }
@@ -282,7 +387,7 @@ class ProcessorService {
                 webhook_tag,
                 version,
                 sender_workspace_id: app.workspace_id,
-                receiver_workspace_id: product.workspace_id,
+                receiver_workspace_id: this.getUserAccess().workspace_id,
                 app_tag: app.tag,
                 product_tag,
                 active,
@@ -293,8 +398,7 @@ class ProcessorService {
     async generateWebhookLink(data) {
         const { product: product_tag, access_tag, webhook_tag, env: product_env, url, method } = data;
         await this.productBuilderService.initializeProductByTag(product_tag);
-        const product = this.productBuilderService.fetchProduct();
-        const { version, envs: appEnvs } = this.productBuilderService.fetchApp(access_tag);
+        const { version, envs: appEnvs } = await this.productBuilderService.fetchApp(access_tag);
         const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
         const { webhooks } = app.versions.find((data) => data.tag === version);
         if (!webhooks) {
@@ -315,7 +419,7 @@ class ProcessorService {
             webhook_tag,
             version,
             sender_workspace_id: app.workspace_id,
-            receiver_workspace_id: product.workspace_id,
+            receiver_workspace_id: this.getUserAccess().workspace_id,
             app_tag: app.tag,
             product_tag,
             active: false,
@@ -323,239 +427,6 @@ class ProcessorService {
         return await this.webhookApi.generateLink(payload, this.getUserAccess());
         //return res.link;
     }
-    async processQuota(data) {
-        this.start = Date.now();
-        const { product: product_tag, env, input, tag: quota_tag } = data;
-        try {
-            this.productTag = product_tag;
-            const additional_logs = {
-                name: 'Process Quota',
-                type: types_1.LogEventTypes.QUOTA,
-                parent_tag: quota_tag,
-            };
-            await this.intializeProduct(additional_logs);
-            const process_id = this.process_id || (0, processor_utils_1.generateObjectId)();
-            this.process_id = process_id;
-            this.baseLogs = {
-                product_tag: this.productTag,
-                product_id: this.productId,
-                workspace_id: this.workspace_id,
-                env,
-                type: types_1.LogEventTypes.QUOTA,
-                process_id,
-                data: input,
-            };
-            this.quota = this.fetchQuota(quota_tag, additional_logs);
-            if (!this.quota) {
-                throw new Error(`Quota ${quota_tag} not found`);
-            }
-            this.logService.setFeatureId(this.quota._id);
-            this.processEnv = this.fetchEnv(env, additional_logs);
-            if (!this.processEnv.active) {
-                throw new Error(`Environment ${data.env} is not active`);
-            }
-            const { input: quotaInput, options } = this.quota;
-            // validate feature input and log failure
-            this.validateJSONFeatureInput(input, quotaInput, additional_logs);
-            // split processes
-            //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
-            await this.logService.publish();
-            return await this.runQuotaOptions(options, input, additional_logs);
-        }
-        catch (e) {
-            this.end = Date.now();
-            await this.logService.publish();
-            throw e;
-        }
-    }
-    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();
-        const { product: product_tag, env, input, tag: fallback_tag } = data;
-        try {
-            this.productTag = product_tag;
-            const additional_logs = {
-                name: 'Process Fallback',
-                type: types_1.LogEventTypes.FALLBACK,
-                parent_tag: fallback_tag,
-            };
-            await this.intializeProduct(additional_logs);
-            const process_id = this.process_id || (0, processor_utils_1.generateObjectId)();
-            this.process_id = process_id;
-            this.baseLogs = {
-                product_tag: this.productTag,
-                product_id: this.productId,
-                workspace_id: this.workspace_id,
-                env,
-                type: types_1.LogEventTypes.FALLBACK,
-                process_id,
-                data: input,
-            };
-            this.fallback = this.fetchFallback(fallback_tag, additional_logs);
-            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`);
-            }
-            const { input: fallbackInput, options } = this.fallback;
-            // validate feature input and log failure
-            this.validateJSONFeatureInput(input, fallbackInput, additional_logs);
-            // split processes
-            //this.sequenceLevels = this.splitSequenceIntoLevels(sequence, additional_logs);
-            return await this.runFallbackOptions(options, input, additional_logs);
-        }
-        catch (e) {
-            this.end = Date.now();
-            await this.logService.publish();
-            throw e;
-        }
-    }
-    async processFeature(data, awaitResolution = false) {
-        this.start = Date.now();
-        this.input = data;
-        const { product: product_tag, env, input, tag: feature_tag } = data;
-        let additional_logs;
-        let passedValidation;
-        try {
-            this.productTag = product_tag;
-            additional_logs = {
-                name: 'Process feature',
-                type: types_1.LogEventTypes.FEATURE,
-            };
-            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,
-                workspace_id: this.workspace_id,
-                env,
-                type: types_1.LogEventTypes.FEATURE,
-                process_id,
-                data: input,
-                feature_tag: feature_tag,
-                feature_id: this.feature._id,
-            };
-            this.logService.setFeatureId(this.feature._id);
-            this.processEnv = this.fetchEnv(env, additional_logs);
-            if (!this.processEnv.active) {
-                throw new Error(`Environment ${data.env} is not active`);
-            }
-            const { input: featureInput, sequence, output } = this.feature;
-            // validate feature input and log failure
-            this.validateJSONFeatureInput(input, featureInput, additional_logs);
-            // split processes
-            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
-            await this.processSequenceLevels(additional_logs);
-            return { process_id };
-            //return this.generateOutput(output as unknown as Record<string, IFeatureOutput>);
-        }
-        catch (e) {
-            this.end = Date.now();
-            if (this.logService) {
-                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process feature - failed', data: Object.assign(Object.assign({}, data), { input: (0, processor_utils_1.anonymizeObject)(data.input) }), status: types_1.LogEventStatus.PROCESSING }));
-                await this.logService.publish();
-                if (passedValidation) {
-                    return { process_id: this.process_id };
-                }
-                else {
-                    throw e;
-                }
-            }
-            else {
-                throw e;
-            }
-        }
-    }
     async intializeProduct(additional_logs) {
         if (!this.logService) {
             this.logService = new logs_service_1.default({
@@ -574,8 +445,8 @@ class ProcessorService {
             else {
                 await this.productBuilderService.initializeProduct(this.productId);
             }
-            const { _id: product_id, workspace_id } = this.productBuilderService.fetchProduct();
-            this.productId = product_id;
+            this.productId = this.productBuilderService.fetchProductId();
+            const workspace_id = this.productBuilderService.fetchWorkspaceId();
             if (workspace_id !== this.workspace_id) {
                 throw new Error('Access Denied');
             }
@@ -586,42 +457,35 @@ class ProcessorService {
             throw e;
         }
     }
-    fetchFeature(tag, additional_logs) {
-        try {
-            const feature = this.productBuilderService.fetchFeature(tag); // validate feature exists
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch feature - success', data: { tag, feature }, status: types_1.LogEventStatus.SUCCESS }));
-            return feature;
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch feature - failed', data: e, status: types_1.LogEventStatus.FAIL }));
-            throw e;
-        }
-    }
-    fetchQuota(tag, additional_logs) {
-        try {
-            const quota = this.productBuilderService.fetchQuota(tag); // validate feature exists
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch quota - success', data: { tag, quota }, status: types_1.LogEventStatus.SUCCESS }));
-            return quota;
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch quota - failed', data: { tag, e }, status: types_1.LogEventStatus.FAIL }));
-            throw e;
+    async initializePricing(additional_logs, access_tag) {
+        if (!this.logService) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+            });
         }
-    }
-    fetchFallback(tag, additional_logs) {
         try {
-            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;
+            console.log(`Initializing pricing for access tag: ${access_tag}`);
+            const product_app = await this.productBuilderService.fetchApp(access_tag); // validate app exists
+            console.log(`Found product app: ${JSON.stringify(product_app)}`);
+            const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(product_app.access_tag);
+            await this.pricingService.initializePricingByTag(product_app.pricing_tag, app._id);
+            const { pricing_tag } = this.pricingService.fetchPricing();
+            this.pricingTag = pricing_tag;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Pricing initialize - success', data: { pricing_tag: this.pricingTag }, status: types_1.LogEventStatus.SUCCESS }));
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch fallback - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Pricing initialize - failed', data: e, status: types_1.LogEventStatus.FAIL }));
             throw e;
         }
     }
-    fetchEnv(env, additional_logs) {
+    async fetchEnv(env, additional_logs) {
         try {
-            const product_env = this.productBuilderService.fetchEnv(env); // validate env exists
+            const product_env = await this.productBuilderService.fetchEnv(env); // validate env exists
             if (!product_env) {
                 throw new Error(`Env ${env} not found`);
             }
@@ -633,271 +497,6 @@ class ProcessorService {
             throw e;
         }
     }
-    validateJSONFeatureInput(input, feature_input, additional_logs) {
-        try {
-            (0, processor_utils_1.validateFeatureJSONInput)(input, feature_input);
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Input validation - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Input validation - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
-            throw e;
-        }
-    }
-    async splitSequenceIntoLevels(data, additional_logs) {
-        try {
-            const levels = {};
-            const tagMap = new Map(data.map((seq) => [seq.tag, seq]));
-            const assignedLevels = new Map();
-            let currentLevel = 1;
-            let remainingSequences = [...data];
-            while (remainingSequences.length > 0) {
-                const currentLevelSequences = [];
-                remainingSequences = remainingSequences.filter((seq) => {
-                    var _a;
-                    const parentLevels = ((_a = seq.parents) === null || _a === void 0 ? void 0 : _a.map((parent) => { var _a; return (_a = assignedLevels.get(parent)) !== null && _a !== void 0 ? _a : -1; })) || [];
-                    const isCurrentLevel = parentLevels.length === 0 || Math.max(...parentLevels) === currentLevel - 1;
-                    if (isCurrentLevel) {
-                        currentLevelSequences.push(seq);
-                        assignedLevels.set(seq.tag, currentLevel);
-                        return false; // Remove from remainingSequences
-                    }
-                    return true;
-                });
-                if (currentLevelSequences.length > 0) {
-                    levels[currentLevel] = currentLevelSequences;
-                    currentLevel++;
-                }
-                else {
-                    break; // Prevent infinite loop if there's a cycle
-                }
-            }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Split sequence - success', data: { levels }, status: types_1.LogEventStatus.SUCCESS }));
-            return levels;
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Split sequence - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
-            throw e;
-        }
-    }
-    async processSequenceLevels(additional_logs) {
-        try {
-            const levelEvents = {};
-            Object.entries(this.sequenceLevels).forEach(([level, sequences]) => {
-                levelEvents[parseInt(level)] = this.fetchLevelEvents(sequences, parseInt(level));
-            });
-            let previousLevelComplete = true;
-            for (const level of Object.keys(levelEvents)
-                .map(Number)
-                .sort((a, b) => a - b)) {
-                if (previousLevelComplete) {
-                    previousLevelComplete = await this.processLevelEvents(levelEvents[level], additional_logs);
-                }
-                else {
-                    break;
-                }
-            }
-            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();
-                await this.writeResult(status);
-            }
-            return true;
-        }
-        catch (e) {
-            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) {
-        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) {
-        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) {
-        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;
-        for (let i = 0; i < dependants.length; i++) {
-            if (!this.processingOutput.success.find((item) => item.event.sequence_tag === dependants[i].sequence_tag && item.event.event === dependants[i].event_tag)) {
-                pass = false;
-            }
-        }
-        return pass;
-    }
-    fetchActionRequestDependents(input, additional_logs) {
-        try {
-            const dependents = [];
-            if (input.query) {
-                dependents.push(...this.fetchDependents(input.query, additional_logs));
-            }
-            if (input.body) {
-                dependents.push(...this.fetchDependents(input.body, additional_logs));
-            }
-            if (input.headers) {
-                dependents.push(...this.fetchDependents(input.headers, additional_logs));
-            }
-            if (input.params) {
-                dependents.push(...this.fetchDependents(input.params, additional_logs));
-            }
-            if (input.data) {
-                dependents.push(...this.fetchDependents(input.data, additional_logs));
-            }
-            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;
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch request dependents - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
-        }
-    }
-    fetchDependents(obj, additional_logs) {
-        try {
-            const dependants = [];
-            for (const key in obj) {
-                const value = obj[key];
-                if (typeof value === 'object') {
-                    if ('function' in value && 'values' in value) {
-                        const { function: func, values } = value;
-                        for (let i = 0; i < values.length; i++) {
-                            if (values[i].startsWith('$Sequence')) {
-                                const stages = this.productBuilderService.extractStages(values[i]);
-                                dependants.push({
-                                    sequence_tag: stages[0],
-                                    event_tag: stages[1],
-                                });
-                            }
-                            else 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 {
-                        dependants.push(...this.fetchDependents(value, additional_logs));
-                    }
-                }
-                else if (typeof value === 'string') {
-                    dependants.push(...this.valueStringDepsCheck(value.trim()));
-                }
-            }
-            return dependants;
-        }
-        catch (e) {
-            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 {
             const payload = {};
@@ -957,6 +556,7 @@ class ProcessorService {
     async generatePayload(obj, event, additional_logs, sample = [], index = {}, loopIndex = null) {
         try {
             const payload = {};
+            console.log('Payload Construction', { obj, event, sample, index, loopIndex });
             const keys = Object.keys(obj);
             for (let i = 0; i < keys.length; i++) {
                 const key = keys[i];
@@ -1002,22 +602,32 @@ class ProcessorService {
         const locatorFor$Index = (0, string_utils_1.validateAndLocateTag)(value);
         if (value.startsWith('$Auth{') && value.endsWith('}')) {
             // should only be allowed in apps
-            return await this.generateAuthValue(stages, app, sample, additional_logs);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            return await this.generateAuthValue(stringStages, app, sample, additional_logs);
         }
         else if (value.startsWith('$Sequence{') && value.endsWith('}')) {
-            return await this.generateSequenceValue(stages, locatorFor$Index, loopIndex); // pass
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            return await this.generateSequenceValue(stringStages, locatorFor$Index, loopIndex); // pass
         }
         else if (value.startsWith('$Input{') && value.endsWith('}')) {
-            return await this.generateInputValue(this.input.input, stages);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            return await this.generateInputValue(this.input.input, stringStages);
         }
         else if (value === '$Default') {
             return await this.generateDefaultValue(sample, Object.assign(Object.assign({}, index), { key }));
         }
         else if (value.startsWith('$Variable{') && value.endsWith('}')) {
-            return await this.generateVariableValue(stages);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            return await this.generateVariableValue(stringStages);
         }
         else if (value.startsWith('$Constant{') && value.endsWith('}')) {
-            return await this.generateConstantValue(stages);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map((stage) => String(stage));
+            return await this.generateConstantValue(stringStages);
         }
         else if (value.startsWith('$Size{') || value.startsWith('$Length{')) {
             const { matchLength, matchSize } = (0, string_utils_1.checkLengthAndSizeMatches)(value);
@@ -1142,6 +752,7 @@ class ProcessorService {
             const placeholdersStr = match[1];
             const separator = match[2];
             const placeHolders = placeholdersStr.split(',').map((data) => data.trim());
+            console.log('placeHolders', { placeHolders, separator });
             const values = await Promise.all(placeHolders.map(async (holder) => {
                 return await this.generateStringValues(holder, app, additional_logs, sample, index, key, loopIndex);
             }));
@@ -1414,7 +1025,7 @@ class ProcessorService {
     }
     async generateVariableValue(stages) {
         try {
-            const app = this.productBuilderService.fetchApp(stages[0]);
+            const app = await this.productBuilderService.fetchApp(stages[0]);
             const env = app.envs.find((items) => items.product_env_slug === this.processEnv.slug);
             if (!env) {
                 throw new Error(`App ${stages[0]} variables needs to have a definition for env: ${this.processEnv.slug}`);
@@ -1460,6 +1071,7 @@ class ProcessorService {
     }
     async generateAuthValue(stages, app, sample, additional_logs) {
         try {
+            console.log('Generate Auth Data', { stages, app, sample });
             let auth_data = await this.fetchAuthData(app, additional_logs); //TODO: should use stages[0]
             // take the app tag in index 0..
             if (!auth_data) {
@@ -1475,7 +1087,7 @@ class ProcessorService {
     }
     async fetchAuthData(app_tag, additional_logs) {
         try {
-            const app = this.productBuilderService.fetchApp(app_tag);
+            const app = await this.productBuilderService.fetchApp(app_tag);
             if (!app) {
                 throw new Error(`App ${app_tag} not found in $Auth value`);
             }
@@ -1486,6 +1098,7 @@ class ProcessorService {
             if (!env.auth) {
                 throw new Error(`App ${app_tag} in auth needs to have a definition for auth in env: ${this.processEnv.slug}`);
             }
+            console.log('Envroment', env.auth);
             let values = env.auth.values;
             if (!values) {
                 // no auth values
@@ -1493,9 +1106,10 @@ class ProcessorService {
             }
             if (!env.auth.expiry || (env.auth.expiry && Date.now() > new Date(env.auth.expiry).getTime())) {
                 // refresh
+                console.log('REFRESH DATA', env, app_tag);
                 values = await this.getAndStoreAuth(env, app_tag);
             }
-            const decrypted = (0, processor_utils_1.decrypt)(values, this.productBuilderService.fetchProduct().private_key);
+            const decrypted = (0, processor_utils_1.decrypt)(values, this.productBuilderService.fetchPrivateKey());
             this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch auth data - success', data: { auth: (0, processor_utils_1.anonymizeValue)(decrypted) }, status: types_1.LogEventStatus.SUCCESS }));
             return JSON.parse(decrypted);
         }
@@ -1547,16 +1161,6 @@ class ProcessorService {
                 };
                 return this.runAction(event, additional_logs);
             }
-            if (event.type === types_1.FeatureEventTypes.DB_ACTION) {
-                const [parent_tag, child_tag] = event.event.split(':');
-                const additional_logs = {
-                    parent_tag,
-                    child_tag,
-                    type: types_1.LogEventTypes.DB_ACTION,
-                    name: 'Process feature database action',
-                };
-                return this.runDBAction(event, additional_logs);
-            }
             if (event.type === types_1.FeatureEventTypes.STORAGE) {
                 this.clone = (0, processor_utils_1.structuredClone)(event);
                 (0, processor_utils_1.cleanBlob)(this.clone);
@@ -1567,14 +1171,6 @@ class ProcessorService {
                 };
                 return this.runStorage(event, additional_logs);
             }
-            if (event.type === types_1.FeatureEventTypes.FEATURE) {
-                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(':');
                 const additional_logs = {
@@ -1596,8 +1192,7 @@ class ProcessorService {
                 try {
                     return this.runBrokerPublish(event, additional_logs);
                 }
-                catch (e) {
-                }
+                catch (e) { }
             }
             if (event.type === types_1.FeatureEventTypes.JOB) {
                 const additional_logs = {
@@ -1613,7 +1208,7 @@ class ProcessorService {
                     input: event.input,
                     start_at: event.start_at || 0,
                     cache: event.cache,
-                    session: this.input.session
+                    session: this.input.session,
                 };
                 // TODO: fix this
                 return this.processJob(input, additional_logs);
@@ -1623,188 +1218,574 @@ class ProcessorService {
             throw e;
         }
     }
-    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 fetchResult(process_id) {
-        const result = await this.processorApiService.fetchResult(process_id, this.getUserAccess());
-        if (!result) {
-            throw new Error(`Invalid process id ${process_id}`);
+        var _a;
+        const jobId = (_a = job.data) === null || _a === void 0 ? void 0 : _a._job_id;
+        const jobType = job.name;
+        // Update job status to running
+        if (jobId && this.redisClient) {
+            await this.updateJobStatus(jobId, 'running', { started_at: Date.now() });
         }
-        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.PROCESSING) {
-                return { process_id, status: result.status };
+        try {
+            let result;
+            if (jobType === types_1.JobEventTypes.ACTION || jobType === types_1.FeatureEventTypes.ACTION) {
+                result = await this.processAction(job.data);
             }
-            else if (result.status === types_1.LogEventStatus.SUCCESS) {
-                this.productTag = result.input.product;
-                await this.intializeProduct(additional_logs);
-                this.processingOutput = result.result;
-                this.process_id = process_id;
-                this.input = result.input;
-                this.feature = await this.fetchFeature(result.input.tag, additional_logs);
-                const { input: featureInput, sequence, output } = this.feature;
-                const data = await this.generatePayload(output, null, additional_logs, []);
-                return { process_id, status: result.status, data };
+            else if (jobType === types_1.JobEventTypes.NOTIFICATION) {
+                result = await this.processNotification(job.data);
             }
-            else if (result.status === types_1.LogEventStatus.FAIL) {
-                const errors = result.result.failure.map((data) => data.reason);
-                return { process_id, status: result.status, errors };
+            else if (jobType === types_1.JobEventTypes.STORAGE) {
+                result = await this.processStorage(job.data);
             }
-        }
-        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 };
+            else if (jobType === types_1.JobEventTypes.PUBLISH) {
+                result = await this.processMessageBrokerPublish(job.data);
+            }
+            else if (jobType === types_1.JobEventTypes.DATABASE_ACTION) {
+                // Database actions use processAction with database-specific input
+                result = await this.processDatabaseAction(job.data);
+            }
+            else if (jobType === types_1.JobEventTypes.DATABASE_OPERATION) {
+                // Handle database operations
+                result = await this.processDatabaseOperation(job.data);
             }
-            else if ((_c = result.result.failure[0]) === null || _c === void 0 ? void 0 : _c.reason) {
-                return { process_id, status: result.status, errors: [(_d = result.result.failure[0]) === null || _d === void 0 ? void 0 : _d.reason] };
+            else if (jobType === types_1.JobEventTypes.GRAPH_ACTION) {
+                result = await this.processGraphAction(job.data);
+            }
+            else if (jobType === types_1.JobEventTypes.GRAPH_OPERATION) {
+                result = await this.processGraphOperation(job.data);
+            }
+            else if (jobType === types_1.JobEventTypes.WORKFLOW) {
+                result = await this.processWorkflow(job.data);
             }
             else {
-                return { process_id, status: result.status };
+                throw new Error(`Unknown job type: ${jobType}`);
             }
-        }
-    }
-    async resumeProcess(process_id) {
-        const result = await this.fetchResult(process_id);
-        if (!result) {
-            throw new Error(`Invalid process id ${process_id}`);
-        }
-        const additional_logs = {
-            parent_tag: result.input.tag,
-            type: result.component,
-            name: 'Resume Process',
-        };
-        this.productTag = result.input.product;
-        await this.intializeProduct(additional_logs);
-        this.processingOutput = result.result;
-        this.process_id = process_id;
-        await this.processFailedEvents(additional_logs);
-        await this.processWaitingEvents(additional_logs);
-        this.input = result.input;
-        this.start = Date.now();
-        if (result.component === types_1.LogEventTypes.FEATURE) {
-            this.feature = await this.fetchFeature(result.input.tag, additional_logs);
-            const { input: featureInput, sequence, output } = this.feature;
-            this.processEnv = this.fetchEnv(result.env, additional_logs);
-            if (!this.processEnv.active) {
-                throw new Error(`Environment ${result.env} is not active`);
-            }
-            // validate feature input and log failure
-            this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
-            // split processes
-            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
-            await this.processSequenceLevels(additional_logs);
-        }
-        else {
-            this.end = Date.now();
-            let status = types_1.LogEventStatus.SUCCESS;
-            if (this.processingOutput.failure.length > 0) {
-                status = types_1.LogEventStatus.FAIL;
+            // Update job status to completed
+            if (jobId && this.redisClient) {
+                await this.updateJobStatus(jobId, 'completed', {
+                    completed_at: Date.now(),
+                    result,
+                });
             }
-            await this.writeResult(status);
-        }
-        return { process_id };
-    }
-    async replayProcess(process_id) {
-        var _a, _b, _c;
-        const result = await this.fetchResult(process_id);
-        if (!result) {
-            throw new Error(`Invalid process id ${process_id}`);
-        }
-        this.productTag = result.input.product;
-        this.process_id = process_id;
-        this.input = result.input;
-        this.start = Date.now();
-        this.component = result.component;
-        const additional_logs = {
-            parent_tag: result.input.tag,
-            type: result.component,
-            name: 'Replay Process',
-        };
-        await this.intializeProduct(additional_logs);
-        //await this.processFailedEvents(additional_logs);
-        if (result.component === types_1.LogEventTypes.FEATURE) {
-            //await this.processWaitingEvents(additional_logs);
-            this.feature = await this.fetchFeature(result.input.tag, additional_logs);
-            const { input: featureInput, sequence, output } = this.feature;
-            this.processEnv = this.fetchEnv(result.env, additional_logs);
-            if (!this.processEnv.active) {
-                throw new Error(`Environment ${result.env} is not active`);
-            }
-            // validate feature input and log failure
-            this.validateJSONFeatureInput(result.input.input, featureInput, additional_logs);
-            // split processes
-            this.sequenceLevels = await this.splitSequenceIntoLevels(sequence, additional_logs);
-            await this.processSequenceLevels(additional_logs);
+            return result;
         }
-        else {
-            const event = ((_a = result.result.failure[0]) === null || _a === void 0 ? void 0 : _a.event) ||
-                ((_b = result.result.success[0]) === null || _b === void 0 ? void 0 : _b.event) ||
-                ((_c = result.result.skipped[0]) === null || _c === void 0 ? void 0 : _c.event) ||
-                result.result.waiting[0].event;
-            this.processEnv = this.fetchEnv(result.env, additional_logs);
-            this.start = Date.now();
-            await this.processEvent(event);
-            this.end = Date.now();
-            await this.writeResult(types_1.LogEventStatus.SUCCESS);
-            await this.logService.publish();
+        catch (error) {
+            // Update job status to failed or schedule retry
+            if (jobId && this.redisClient) {
+                const jobData = await this.getJobData(jobId);
+                if (jobData) {
+                    const { shouldRetry, delay } = this.calculateJobRetry(jobData, error.code);
+                    if (shouldRetry) {
+                        await this.updateJobStatus(jobId, 'scheduled', {
+                            retry_count: (jobData.retry_count || 0) + 1,
+                            last_error: error.message,
+                            last_error_code: error.code,
+                            scheduled_at: Date.now() + delay,
+                        });
+                        // Re-queue the job with delay
+                        await this.queues.jobs.add(jobType, job.data, {
+                            jobId: `${jobId}_retry_${jobData.retry_count + 1}`,
+                            delay,
+                        });
+                    }
+                    else {
+                        await this.updateJobStatus(jobId, 'failed', {
+                            completed_at: Date.now(),
+                            last_error: error.message,
+                            last_error_code: error.code,
+                        });
+                    }
+                    // Add to execution history
+                    await this.addJobExecution(jobId, {
+                        number: (jobData.execution_count || 0) + 1,
+                        started_at: jobData.started_at || Date.now(),
+                        completed_at: Date.now(),
+                        duration_ms: Date.now() - (jobData.started_at || Date.now()),
+                        status: 'failed',
+                        error: error.message,
+                        error_code: error.code,
+                    });
+                }
+            }
+            throw error;
         }
-        return { process_id };
     }
-    fetchLevelEvents(sequence, level) {
-        const events = [];
-        for (let i = 0; i < sequence.length; i++) {
-            events.push(...this.appendSequenceDataToLevelEvents(sequence[i], level));
-        }
-        return events;
+    /**
+     * Get job data from Redis
+     */
+    async getJobData(jobId) {
+        if (!this.redisClient)
+            return null;
+        const redis = this.redisClient;
+        const jobKey = `job:${this.workspace_id}:${jobId}`;
+        const data = await redis.get(jobKey);
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    /**
+     * Update job status in Redis
+     */
+    async updateJobStatus(jobId, status, updates = {}) {
+        if (!this.redisClient)
+            return;
+        const redis = this.redisClient;
+        const jobKey = `job:${this.workspace_id}:${jobId}`;
+        const data = await redis.get(jobKey);
+        if (!data)
+            return;
+        const jobData = JSON.parse(data);
+        const oldStatus = jobData.status;
+        const updatedJob = Object.assign(Object.assign(Object.assign({}, jobData), updates), { status, updated_at: Date.now(), execution_count: status === 'completed' || status === 'failed'
+                ? (jobData.execution_count || 0) + 1
+                : jobData.execution_count });
+        // Update job data
+        await redis.setex(jobKey, 90 * 24 * 60 * 60, JSON.stringify(updatedJob));
+        // Update status indices
+        if (oldStatus !== status) {
+            const oldStatusKey = `job_status:${this.workspace_id}:${oldStatus}`;
+            const newStatusKey = `job_status:${this.workspace_id}:${status}`;
+            await redis.srem(oldStatusKey, jobId);
+            await redis.sadd(newStatusKey, jobId);
+        }
+    }
+    /**
+     * Add job execution record to history
+     */
+    async addJobExecution(jobId, execution) {
+        if (!this.redisClient)
+            return;
+        const redis = this.redisClient;
+        const historyKey = `job_history:${this.workspace_id}:${jobId}`;
+        await redis.lpush(historyKey, JSON.stringify(execution));
+        await redis.ltrim(historyKey, 0, 99); // Keep last 100 executions
+        await redis.expire(historyKey, 30 * 24 * 60 * 60); // 30 days TTL
+    }
+    /**
+     * Calculate retry delay based on job configuration
+     */
+    calculateJobRetry(jobData, errorCode) {
+        const retryConfig = jobData.retry_config || {};
+        const { initialDelay = 1000, maxDelay = 300000, backoffMultiplier = 2, retryableErrors, nonRetryableErrors, jitter = false, jitterPercent = 0.3, } = retryConfig;
+        // Check if we've exceeded max retries
+        if ((jobData.retry_count || 0) >= (jobData.retries || 0)) {
+            return { shouldRetry: false, delay: 0 };
+        }
+        // Check error-based retry rules
+        if (errorCode) {
+            if (nonRetryableErrors === null || nonRetryableErrors === void 0 ? void 0 : nonRetryableErrors.includes(errorCode)) {
+                return { shouldRetry: false, delay: 0 };
+            }
+            if (retryableErrors && !retryableErrors.includes(errorCode)) {
+                return { shouldRetry: false, delay: 0 };
+            }
+        }
+        // Calculate exponential backoff delay
+        let delay = initialDelay * Math.pow(backoffMultiplier, jobData.retry_count || 0);
+        delay = Math.min(delay, maxDelay);
+        // Add jitter if enabled
+        if (jitter) {
+            const jitterAmount = delay * jitterPercent * Math.random();
+            delay = delay + jitterAmount;
+        }
+        return { shouldRetry: true, delay: Math.round(delay) };
+    }
+    /**
+     * Process database action job (predefined database actions)
+     * Integrates with the database action manager to execute predefined operations
+     */
+    async processDatabaseAction(data) {
+        var _a;
+        const { env, product, database, event, input } = data;
+        // Initialize product builder if not already done
+        if (product) {
+            await this.productBuilderService.initializeProductByTag(product);
+        }
+        // Fetch the database action configuration
+        const databaseAction = await this.productBuilderService.fetchDatabaseAction(`${database}:${event}`);
+        if (!databaseAction) {
+            throw new Error(`Database action '${event}' not found on database '${database}'`);
+        }
+        // Get the database environment configuration
+        const databaseConfig = await this.productBuilderService.fetchDatabase(database);
+        if (!databaseConfig) {
+            throw new Error(`Database '${database}' not found`);
+        }
+        const databaseEnv = (_a = databaseConfig.envs) === null || _a === void 0 ? void 0 : _a.find((e) => e.slug === env);
+        if (!databaseEnv) {
+            throw new Error(`Environment '${env}' not found for database '${database}'`);
+        }
+        // Execute the database action using the database service
+        const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('../../database/databases.service')));
+        const dbService = new DatabaseService({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+            private_key: this._privateKey,
+            access_key: this.accessKey,
+        });
+        const result = await dbService.execute({
+            product,
+            env,
+            database,
+            action: event,
+            input: input || {},
+        });
+        return { success: true, data: result };
     }
-    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;
-            events[i].env = this.processEnv;
-        }
-        return events;
+    /**
+     * Process database operation job (direct CRUD operations)
+     * Handles operations like insert, find, update, delete, aggregate
+     */
+    async processDatabaseOperation(data) {
+        var _a;
+        const { env, product, database, operation, input } = data;
+        // Initialize product builder if not already done
+        if (product) {
+            await this.productBuilderService.initializeProductByTag(product);
+        }
+        // Get the database configuration
+        const databaseConfig = await this.productBuilderService.fetchDatabase(database);
+        if (!databaseConfig) {
+            throw new Error(`Database '${database}' not found`);
+        }
+        const databaseEnv = (_a = databaseConfig.envs) === null || _a === void 0 ? void 0 : _a.find((e) => e.slug === env);
+        if (!databaseEnv) {
+            throw new Error(`Environment '${env}' not found for database '${database}'`);
+        }
+        // Execute the database operation using the database service
+        const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('../../database/databases.service')));
+        const dbService = new DatabaseService({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+            private_key: this._privateKey,
+            access_key: this.accessKey,
+        });
+        // Connect to the database
+        await dbService.connect({
+            product,
+            env,
+            database,
+        });
+        let result;
+        // Execute the appropriate operation based on the operation type
+        switch (operation) {
+            case 'insert':
+                result = await dbService.insert({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    data: input.data,
+                    returning: input.returning,
+                });
+                break;
+            case 'find':
+            case 'query':
+                result = await dbService.query({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    where: input.where,
+                    select: input.select,
+                    include: input.include,
+                    orderBy: input.orderBy,
+                    limit: input.limit,
+                    offset: input.offset,
+                });
+                break;
+            case 'update':
+                result = await dbService.update({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    data: input.data,
+                    where: input.where,
+                    returning: input.returning,
+                });
+                break;
+            case 'delete':
+                result = await dbService.delete({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    where: input.where,
+                });
+                break;
+            case 'upsert':
+                result = await dbService.upsert({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    data: input.data,
+                    conflictKeys: input.conflictKeys || input.conflictFields,
+                    updateColumns: input.updateColumns,
+                    returning: input.returning,
+                });
+                break;
+            case 'aggregate':
+                result = await dbService.aggregate({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    operations: input.operations,
+                    where: input.where,
+                });
+                break;
+            case 'groupBy':
+                result = await dbService.groupBy({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    groupBy: input.groupBy || input.by,
+                    operations: input.operations,
+                    where: input.where,
+                    having: input.having,
+                    orderBy: input.orderBy,
+                    limit: input.limit,
+                    offset: input.offset,
+                });
+                break;
+            case 'count':
+                result = await dbService.count({
+                    product,
+                    env,
+                    database,
+                    table: input.table,
+                    where: input.where,
+                });
+                break;
+            default:
+                throw new Error(`Unknown database operation: ${operation}`);
+        }
+        return { success: true, data: result };
+    }
+    /**
+     * Process graph action job (predefined graph actions)
+     * Integrates with the graph service to execute predefined graph operations
+     */
+    async processGraphAction(data) {
+        const { env, product, graph, event, input } = data;
+        // Initialize product builder if not already done
+        if (product) {
+            await this.productBuilderService.initializeProductByTag(product);
+        }
+        // Execute the graph action using the graph service
+        const { GraphService } = await Promise.resolve().then(() => __importStar(require('../../graph/graphs.service')));
+        const graphService = new GraphService({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+            private_key: this._privateKey,
+            access_key: this.accessKey,
+        });
+        // Connect to the graph database
+        await graphService.connect({
+            product,
+            env,
+            graph,
+        });
+        // Execute the graph action
+        const result = await graphService.execute({
+            product,
+            env,
+            graph,
+            action: event,
+            input: input || {},
+        });
+        return { success: result.success, data: result.data, error: result.error };
+    }
+    /**
+     * Process graph operation job (direct graph operations)
+     * Handles operations like createNode, findNodes, createRelationship, traverse, etc.
+     */
+    async processGraphOperation(data) {
+        const { env, product, graph, operation, input } = data;
+        // Initialize product builder if not already done
+        if (product) {
+            await this.productBuilderService.initializeProductByTag(product);
+        }
+        // Execute the graph operation using the graph service
+        const { GraphService } = await Promise.resolve().then(() => __importStar(require('../../graph/graphs.service')));
+        const graphService = new GraphService({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+            private_key: this._privateKey,
+            access_key: this.accessKey,
+        });
+        // Connect to the graph database
+        await graphService.connect({
+            product,
+            env,
+            graph,
+        });
+        let result;
+        // Execute the appropriate operation based on the operation type
+        switch (operation) {
+            case 'createNode':
+                result = await graphService.createNode({
+                    labels: input.labels,
+                    properties: input.properties,
+                });
+                break;
+            case 'findNodes':
+                result = await graphService.findNodes({
+                    labels: input.labels,
+                    where: input.where,
+                    limit: input.limit,
+                    offset: input.offset,
+                    orderBy: input.orderBy,
+                });
+                break;
+            case 'findNodeById':
+                result = await graphService.findNodeById(input.id);
+                break;
+            case 'updateNode':
+                result = await graphService.updateNode({
+                    id: input.id,
+                    properties: input.properties,
+                    labels: input.labels,
+                });
+                break;
+            case 'deleteNode':
+                result = await graphService.deleteNode({
+                    id: input.id,
+                    detach: input.detach,
+                });
+                break;
+            case 'mergeNode':
+                result = await graphService.mergeNode({
+                    labels: input.labels,
+                    matchProperties: input.matchProperties,
+                    onCreate: input.onCreate || input.setProperties,
+                    onMatch: input.onMatch,
+                });
+                break;
+            case 'createRelationship':
+                result = await graphService.createRelationship({
+                    type: input.type,
+                    startNodeId: input.startNodeId || input.from,
+                    endNodeId: input.endNodeId || input.to,
+                    properties: input.properties,
+                });
+                break;
+            case 'findRelationships':
+                result = await graphService.findRelationships({
+                    types: input.types,
+                    startNodeId: input.startNodeId,
+                    endNodeId: input.endNodeId,
+                    where: input.where,
+                    limit: input.limit,
+                });
+                break;
+            case 'updateRelationship':
+                result = await graphService.updateRelationship({
+                    id: input.id,
+                    properties: input.properties,
+                });
+                break;
+            case 'deleteRelationship':
+                result = await graphService.deleteRelationship({
+                    id: input.id,
+                });
+                break;
+            case 'traverse':
+                result = await graphService.traverse({
+                    startNodeId: input.startNodeId,
+                    direction: input.direction,
+                    relationshipTypes: input.relationshipTypes,
+                    maxDepth: input.maxDepth,
+                    minDepth: input.minDepth,
+                    nodeFilter: input.nodeFilter || input.where,
+                    relationshipFilter: input.relationshipFilter,
+                    limit: input.limit,
+                });
+                break;
+            case 'shortestPath':
+                result = await graphService.shortestPath({
+                    startNodeId: input.startNodeId,
+                    endNodeId: input.endNodeId,
+                    relationshipTypes: input.relationshipTypes,
+                    maxDepth: input.maxDepth,
+                });
+                break;
+            case 'query':
+                result = await graphService.query(input.query, input.params);
+                break;
+            case 'countNodes':
+                result = await graphService.countNodes(input.labels, input.where);
+                break;
+            case 'countRelationships':
+                result = await graphService.countRelationships(input.types, input.where);
+                break;
+            case 'getStatistics':
+                result = await graphService.getStatistics();
+                break;
+            default:
+                throw new Error(`Unknown graph operation: ${operation}`);
+        }
+        return { success: true, data: result };
+    }
+    /**
+     * Process workflow job
+     * Executes a workflow using the workflow service
+     */
+    async processWorkflow(data) {
+        const { env, product, workflow, input, idempotency_key } = data;
+        // Initialize product builder if not already done
+        if (product) {
+            await this.productBuilderService.initializeProductByTag(product);
+        }
+        // Execute the workflow using the workflow service
+        const { WorkflowService } = await Promise.resolve().then(() => __importStar(require('../../workflows/workflows.service')));
+        const workflowService = new WorkflowService({
+            workspace_id: this.workspace_id,
+            public_key: this.public_key,
+            user_id: this.user_id,
+            token: this.token,
+            env_type: this.environment,
+            private_key: this._privateKey,
+            access_key: this.accessKey
+        });
+        // Execute the workflow
+        const result = await workflowService.execute({
+            product,
+            env,
+            tag: workflow,
+            input: input || {},
+            idempotency_key,
+        });
+        return {
+            success: result.status === 'completed',
+            data: result.output,
+            workflow_id: result.workflow_id,
+            status: result.status,
+            error: result.error,
+        };
     }
     async getAndStoreAuth(appEnv, access_tag) {
         try {
-            //  const payload = JSON.parse(decrypt(env.auth.data, this.productBuilderService.fetchProduct().private_key));
-            const payload = appEnv.auth.data;
+            //  const payload = JSON.parse(decrypt(env.auth.data, this.productBuilderService.fetchPrivateKey()));
+            const payload = JSON.parse((0, processor_utils_1.decrypt)(String(appEnv.auth.data), this.productBuilderService.fetchPrivateKey()));
             let app = await this.fetchThirdPartyApp(access_tag);
             const auth = app.auths.find((item) => item.tag === appEnv.auth.auth_tag);
+            console.log('JAMESY', auth);
             if (!auth) {
                 // throw an error
                 throw new Error(`Cannot find auth ${appEnv.auth.auth_tag} on environment ${appEnv.product_env_slug}`);
@@ -1819,9 +1800,16 @@ class ProcessorService {
                 if (env.base_url) {
                     request_base_url = env.base_url;
                 }
+                if (action.envs && action.envs.length) {
+                    const env = action.envs.find((item) => item.slug === appEnv.app_env_slug);
+                    if (env && env.base_url) {
+                        request_base_url = env.base_url;
+                    }
+                }
+                console.log('payloadabi!!!!', payload);
                 const results = await this.sendActionRequest(request_base_url, url, payload, method, appEnv.app_env_slug);
-                const values = (0, processor_utils_1.encrypt)(JSON.stringify(results), this.productBuilderService.fetchProduct().private_key);
-                const productApp = this.productBuilderService.fetchApp(access_tag);
+                const values = (0, processor_utils_1.encrypt)(JSON.stringify(results), this.productBuilderService.fetchPrivateKey());
+                const productApp = await this.productBuilderService.fetchApp(access_tag);
                 for (let i = 0; i < productApp.envs.length; i++) {
                     if (productApp.envs[i].app_env_slug === env.slug) {
                         productApp.envs[i].auth.values = values; // write new values
@@ -1917,7 +1905,7 @@ class ProcessorService {
         // generate indexes
         return (0, processor_utils_1.generateIndexes)(operator, iter, init, valueValue);
     }
-    async runAction(event, additional_logs, returnValue = true) {
+    async runAction(event, additional_logs, returnValue = true, bootstrapData) {
         try {
             const { event: action_tag, app: access_tag, condition, cache: cache_tag } = event;
             let indexes = [];
@@ -1930,28 +1918,59 @@ class ProcessorService {
             if (condition && condition.type === types_1.Conditions.LOOP) {
                 indexes = await this.extractLoopIndexes(event, additional_logs);
             }
-            let app = await this.fetchThirdPartyApp(access_tag);
-            const { actions, envs: appEnvs, retries, workspace_id: recipient_workspace_id, active } = app;
-            const productApp = this.productBuilderService.fetchApp(access_tag);
-            const { envs: productEnvs, version } = productApp;
-            const { app_env_slug } = productEnvs.find((item) => item.product_env_slug === this.processEnv.slug);
-            additional_logs.app_env = app_env_slug;
-            const env = appEnvs.find((item) => item.slug === app_env_slug); // fetch the actuall app Environment variable
-            if (!active) {
-                throw new Error(`App ${event.app} version ${app.version} is not active`);
+            let action;
+            let env;
+            let retries;
+            let recipient_workspace_id;
+            let app_active;
+            let app_id = '';
+            let app_env_slug = '';
+            // Use bootstrap data if provided, otherwise fetch via API
+            if (bootstrapData) {
+                action = bootstrapData.action;
+                env = bootstrapData.app_env;
+                retries = bootstrapData.retries;
+                recipient_workspace_id = bootstrapData.recipient_workspace_id;
+                app_active = bootstrapData.app_active;
+                app_env_slug = env.slug;
+                additional_logs.app_env = app_env_slug;
             }
-            if (!env.active) {
-                throw new Error(`Action environment ${app_env_slug} is not active`);
+            else {
+                // Fallback to original API-based fetching (for features/workflows that don't use bootstrap)
+                const appData = await this.fetchThirdPartyApp(access_tag);
+                const { actions, envs: appEnvs, retries: appRetries, workspace_id: appWorkspaceId, active } = appData;
+                const productApp = await this.productBuilderService.fetchApp(access_tag);
+                const { envs: productEnvs } = productApp;
+                const envMapping = productEnvs.find((item) => item.product_env_slug === this.processEnv.slug);
+                app_env_slug = (envMapping === null || envMapping === void 0 ? void 0 : envMapping.app_env_slug) || '';
+                additional_logs.app_env = app_env_slug;
+                env = appEnvs.find((item) => item.slug === app_env_slug);
+                action = actions.find((item) => item.tag === action_tag);
+                retries = appRetries;
+                recipient_workspace_id = appWorkspaceId;
+                app_active = active;
+                app_id = appData._id;
+                if (!action) {
+                    throw new Error(`Action ${action_tag} not found in ${access_tag}`);
+                }
+            }
+            if (!app_active && recipient_workspace_id !== this.baseLogs.workspace_id) {
+                throw new Error(`App ${event.app} is not active`);
             }
-            const action = actions.find((item) => item.tag === action_tag);
-            if (!action) {
-                throw new Error(`Action ${action_tag} not found in ${access_tag}`);
+            if (!env.active) {
+                throw new Error(`Action environment ${env.slug} is not active`);
             }
             const { query, headers, body, params, request_type, method, base_url, resource } = action;
             let request_base_url = base_url;
             if (env.base_url) {
                 request_base_url = env.base_url;
             }
+            if (action.envs && action.envs.length) {
+                const actionEnv = action.envs.find((item) => item.slug === app_env_slug);
+                if (actionEnv && actionEnv.base_url) {
+                    request_base_url = actionEnv.base_url;
+                }
+            }
             const samples = {
                 query: (query === null || query === void 0 ? void 0 : query.data) || [],
                 headers: (headers === null || headers === void 0 ? void 0 : headers.data) || [],
@@ -1960,9 +1979,9 @@ class ProcessorService {
             };
             let payloads;
             let result;
-            const product = this.productBuilderService.fetchProduct();
+            //const product = this.productBuilderService.fetchProduct();
             if (cache_tag && this.redisClient) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
                 }
@@ -1970,7 +1989,7 @@ class ProcessorService {
                 const check = await this.fetchFromCache({
                     cache_tag,
                     input: inputString,
-                    privateKey: product.private_key,
+                    privateKey: this.productBuilderService.fetchPrivateKey(),
                     expiry: productCache.expiry,
                 }, additional_logs);
                 if (check) {
@@ -1983,31 +2002,31 @@ class ProcessorService {
             }
             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);
+                    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);
+                    result = await this.processRequest({ request_base_url, resource, method, env, payloads, app_id }, event, { retries }, additional_logs, returnValue);
                 }
                 else {
                     const promises = indexes.map(async (index) => {
                         payloads = await this.constructJSONDataPayloads(event.input, additional_logs, samples, event, index);
                         additional_logs.recipient_workspace_id = recipient_workspace_id;
-                        await this.processRequest({ request_base_url, resource, method, env, payloads, app_id: app._id }, event, retries, additional_logs, returnValue);
+                        await this.processRequest({ request_base_url, resource, method, env, payloads, app_id }, event, { retries }, additional_logs, returnValue);
                     });
                     result = await Promise.all(promises);
                 }
             }
             if (cache_tag && this.redisClient && result) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
                 }
                 const inputString = JSON.stringify(event.input);
                 await this.addToCache({
                     input: inputString,
-                    privateKey: product.private_key,
+                    privateKey: this.productBuilderService.fetchPrivateKey(),
                     data: JSON.stringify(result),
                     cache_tag,
                     timestamp: Date.now(),
@@ -2024,6 +2043,7 @@ class ProcessorService {
         }
     }
     async processRequest(payload, event, retries, additional_logs, returnValue = false) {
+        var _a;
         const { request_base_url, resource, payloads, method, env, app_id } = payload;
         const start = Date.now();
         try {
@@ -2034,7 +2054,11 @@ class ProcessorService {
             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,
+            const { pricing_tag, pricing_cost, is_overage, currency } = await this.processPricingCost(Object.assign(Object.assign({}, additional_logs), { app_id, workspace_id: this.workspace_id }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { pricing_tag,
+                pricing_cost,
+                currency,
+                is_overage, message: 'Process http request - success', successful_execution: true, data: { response: (0, processor_utils_1.anonymizeObject)(results) }, status: types_1.LogEventStatus.SUCCESS, app_id, action: event.event, start,
                 end }));
             await this.addToSuccessOutput(event, results, additional_logs);
             if (returnValue) {
@@ -2047,7 +2071,7 @@ class ProcessorService {
         catch (e) {
             const end = Date.now();
             let error = e;
-            if (e.response.data) {
+            if ((_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.data) {
                 error = e.response.data;
             }
             this.requestTime += end - start;
@@ -2080,6 +2104,67 @@ class ProcessorService {
             }
         }
     }
+    async processPricingCost(additional_logs) {
+        try {
+            const { app_id, workspace_id } = additional_logs;
+            if (!app_id || !workspace_id) {
+                throw new Error('app_id and workspace_id are required in additional_logs');
+            }
+            const primaryPricing = this.pricingService.fetchPricing();
+            const overagePricing = this.pricingService.fetchOveragePricing();
+            const requests = await this.requestTrackerService.incrementRequest(app_id, workspace_id);
+            const limitCheck = (0, request_utils_1.checkLimitExceeded)(requests, primaryPricing.limits);
+            let finalCost = 0;
+            let usedPricing = primaryPricing;
+            let isOverage = false;
+            let finalCurrency = primaryPricing.currency;
+            if ((0, request_utils_1.isFreeTag)(primaryPricing.pricing_tag)) {
+                if (limitCheck.exceeded) {
+                    const overageRequests = (0, request_utils_1.calculateOverageRequests)(requests, primaryPricing.limits);
+                    finalCost = (0, request_utils_1.calculateCost)(overagePricing.pricing_mode, overagePricing.unit_price, overageRequests);
+                    usedPricing = overagePricing;
+                    isOverage = true;
+                    finalCurrency = overagePricing.currency;
+                }
+                else {
+                    finalCost = 0;
+                }
+            }
+            else {
+                if (limitCheck.exceeded) {
+                    const overageRequests = (0, request_utils_1.calculateOverageRequests)(requests, primaryPricing.limits);
+                    const overageCost = (0, request_utils_1.calculateCost)(overagePricing.pricing_mode, overagePricing.unit_price, overageRequests);
+                    finalCost = overageCost;
+                    isOverage = true;
+                }
+                else {
+                    const pricingRequests = (0, request_utils_1.calculateRequests)(requests);
+                    finalCost = (0, request_utils_1.calculateCost)(primaryPricing.pricing_mode, primaryPricing.unit_price, pricingRequests);
+                }
+            }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process Pricing Cost - success', data: {
+                    pricing_tag: usedPricing.pricing_tag,
+                    cost: finalCost,
+                    currency: finalCurrency,
+                    is_overage: isOverage,
+                    requests: requests,
+                    limit_exceeded: limitCheck.exceeded,
+                }, status: types_1.LogEventStatus.SUCCESS }));
+            return {
+                pricing_tag: usedPricing.pricing_tag,
+                pricing_cost: Math.round(finalCost * 100) / 100,
+                currency: finalCurrency,
+                is_overage: isOverage,
+                requests_made: requests,
+                limit_exceeded: limitCheck.exceeded,
+                exceeded_limits: limitCheck.exceededLimits,
+            };
+        }
+        catch (e) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process Pricing Cost - failed', data: { error: e }, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
     async addToSuccessOutput(event, output, additional_logs) {
         // Remove event from failed, skipped, and waiting arrays
         this.processingOutput.failure = this.processingOutput.failure.filter((data) => !(data.event.sequence_tag === event.sequence_tag && data.event.event === event.event));
@@ -2089,7 +2174,6 @@ class ProcessorService {
             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();
@@ -2109,18 +2193,6 @@ class ProcessorService {
         }
         return success;
     }
-    addToWaitingOutput(event, dependants) {
-        const exists = this.processingOutput.waiting.findIndex((item) => {
-            return item.event.event === event.event && item.event.sequence_tag === event.sequence_tag;
-        });
-        const skipped = this.processingOutput.skipped.findIndex((item) => {
-            return item.event.event === event.event && item.event.sequence_tag === event.sequence_tag;
-        });
-        if (!exists && !skipped) {
-            this.processingOutput.waiting.push({ event, dependants });
-        }
-        // addToSkippedOutput()
-    }
     async addToFailureOutput(e, event, payload, additional_logs, policy = {}) {
         try {
             this.processingFailure = true;
@@ -2145,7 +2217,7 @@ class ProcessorService {
             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))
+                if (!event.allow_fail)
                     retryable = false;
             }
             let retries_left = retries || max;
@@ -2178,9 +2250,6 @@ class ProcessorService {
                     if (event.type === types_1.FeatureEventTypes.ACTION) {
                         this.processRequest(payload, event, policy, additional_logs);
                     }
-                    if (event.type === types_1.FeatureEventTypes.DB_ACTION) {
-                        this.processDBRequest(event, event.input, payload.database_tag, payload.databaseEnv, payload.action_tag, additional_logs);
-                    }
                     if (event.type === types_1.FeatureEventTypes.STORAGE) {
                         this.processStorageRequest(event, event.input, payload.storageEnv, additional_logs);
                     }
@@ -2188,9 +2257,6 @@ class ProcessorService {
             }
             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();
@@ -2237,8 +2303,9 @@ class ProcessorService {
                 params: query,
                 headers: authHeaders,
                 timeout: 15000,
-                withCredentials: false
+                withCredentials: false,
             };
+            console.log('REQUEST!!!!', request);
             const response = await axios_1.default.request(request);
             return response.data;
         }
@@ -2249,12 +2316,15 @@ class ProcessorService {
     }
     async processStorage(action) {
         //TODO: schema validation
-        const { env, input, retries, event, product: product_tag } = action;
+        const { env, input, retries, event, product: product_tag, session, cache } = action;
         const additional_logs = {
             parent_tag: event,
             type: types_1.LogEventTypes.STORAGE,
             name: 'Process Storage',
         };
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedInput = input;
         try {
             await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
             this.input = input;
@@ -2267,23 +2337,57 @@ class ProcessorService {
             const process_id = (0, processor_utils_1.generateObjectId)();
             this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env,
                 process_id, data: this.clone }, additional_logs);
-            await this.intializeProduct(additional_logs);
+            // Single bootstrap call to fetch all storage data
+            const bootstrapData = await this.productBuilderService.bootstrapStorage({
+                product_tag,
+                env_slug: env,
+                storage_tag: event,
+            });
+            // Initialize from bootstrap data
+            this.productId = bootstrapData.product_id;
+            this.processEnv = bootstrapData.env;
+            // Process session if provided - verify and resolve $Session{} references
+            if (session && bootstrapData.private_key) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedInput = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+            // Initialize log service if needed
+            if (!this.logService) {
+                this.logService = new logs_service_1.default({
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    token: this.token,
+                    env_type: this.environment,
+                });
+            }
             this.process_id = process_id;
-            const productEnv = this.fetchEnv(env, additional_logs);
-            this.processEnv = productEnv;
+            this.baseLogs.product_id = this.productId;
+            // Add session fields to base logs
+            this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
+            const productEnv = bootstrapData.env;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
             }
             const payload = {
                 type: types_1.FeatureEventTypes.STORAGE,
                 event,
-                cache: action.cache,
-                input,
+                cache: cache,
+                input: resolvedInput,
                 env: productEnv,
                 retries: retries || 0,
                 allow_fail: false,
             };
-            const result = await this.runStorage(payload);
+            const result = await this.runStorage(payload, additional_logs, {
+                storage: bootstrapData.storage,
+                storage_env: bootstrapData.storage_env,
+            });
             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 }));
             await this.writeResult(types_1.LogEventStatus.SUCCESS);
@@ -2318,7 +2422,7 @@ class ProcessorService {
             await this.intializeProduct(additional_logs);
             this.baseLogs.product_id = this.productId;
             this.process_id = process_id;
-            const productEnv = this.fetchEnv(data.env, additional_logs);
+            const productEnv = await this.fetchEnv(data.env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
@@ -2357,6 +2461,9 @@ class ProcessorService {
             type: types_1.LogEventTypes.MESSAGEBROKER,
             name: 'Publish to broker topic',
         };
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedInput = data.input;
         try {
             await this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.PUBLISH);
             this.start = Date.now();
@@ -2370,7 +2477,20 @@ class ProcessorService {
             await this.intializeProduct(additional_logs);
             this.baseLogs.product_id = this.productId;
             this.process_id = process_id;
-            const productEnv = this.fetchEnv(data.env, additional_logs);
+            // Process session if provided - verify and resolve $Session{} references
+            const privateKey = this.productBuilderService.fetchPrivateKey();
+            if (data.session && privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
+                const sessionResult = await processSessionForExecution(data.session, privateKey, data.input, data.env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedInput = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+            // Add session fields to base logs
+            this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
+            const productEnv = await this.fetchEnv(data.env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
@@ -2379,7 +2499,7 @@ class ProcessorService {
                 type: types_1.FeatureEventTypes.PUBLISH,
                 event: data.event,
                 cache: data.cache,
-                input: data.input,
+                input: resolvedInput,
                 env: productEnv,
                 retries: 0,
                 allow_fail: false,
@@ -2399,8 +2519,8 @@ class ProcessorService {
         }
     }
     async processJob(job, additional_logs = {}) {
-        var _a;
-        const productJob = this.productBuilderService.fetchJob(job.event);
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const productJob = await this.productBuilderService.fetchJob(job.event);
         if (!productJob) {
             throw new Error(`Job ${job.event} not found`);
         }
@@ -2408,8 +2528,10 @@ class ProcessorService {
         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);
+        const scheduled_at = IS_PROBABLY_TIMESTAMP ? job.start_at : NOW + job.start_at;
+        const delay = Math.max(0, scheduled_at - NOW);
         let jobInput;
+        let namespace = productJob.type;
         if (productJob.type === types_1.JobEventTypes.ACTION) {
             const input = {
                 env: job.env,
@@ -2417,93 +2539,220 @@ class ProcessorService {
                 app: productJob.app,
                 cache: job.cache,
                 input: job.input,
+                action: job.event,
+                session: job.session,
+            };
+            jobInput = input;
+            namespace = 'actions';
+        }
+        else if (productJob.type === types_1.JobEventTypes.NOTIFICATION) {
+            const input = {
+                env: job.env,
+                product: job.product,
                 event: job.event,
-                session: job.session
+                input: job.input,
+                session: job.session,
+                cache: job.cache,
             };
             jobInput = input;
+            namespace = 'notifications';
         }
-        else if (productJob.type === types_1.JobEventTypes.DATABASE_ACTION) {
+        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;
+            namespace = 'events';
+        }
+        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;
+            namespace = 'storage';
         }
-        else if (productJob.type === types_1.JobEventTypes.FALLBACK || productJob.type === types_1.JobEventTypes.QUOTA || productJob.type === types_1.JobEventTypes.FEATURE) {
+        else if (productJob.type === types_1.JobEventTypes.DATABASE_ACTION) {
+            // Database action job - predefined database actions
             const input = {
-                input: job.input,
-                product: job.product,
                 env: job.env,
-                tag: job.event,
-                session: job.session,
+                product: job.product,
+                database: productJob.app,
+                event: productJob.event,
                 cache: job.cache,
+                session: job.session,
+                input: job.input,
             };
             jobInput = input;
+            namespace = 'database';
         }
-        else if (productJob.type === types_1.JobEventTypes.NOTIFICATION) {
+        else if (productJob.type === types_1.JobEventTypes.DATABASE_OPERATION) {
+            // Database operation job - direct database operations like createOne, findMany, etc.
             const input = {
                 env: job.env,
                 product: job.product,
-                event: job.event,
+                database: productJob.app,
+                operation: productJob.event,
+                cache: job.cache,
+                session: job.session,
                 input: job.input,
+            };
+            jobInput = input;
+            namespace = 'database';
+        }
+        else if (productJob.type === types_1.JobEventTypes.GRAPH_ACTION) {
+            // Graph action job - predefined graph actions
+            const input = {
+                env: job.env,
+                product: job.product,
+                graph: productJob.app,
+                event: productJob.event,
+                cache: job.cache,
                 session: job.session,
-                cache: job.cache
+                input: job.input,
             };
             jobInput = input;
+            namespace = 'graphs';
         }
-        else if (productJob.type === types_1.JobEventTypes.PUBLISH) {
+        else if (productJob.type === types_1.JobEventTypes.GRAPH_OPERATION) {
+            // Graph operation job - direct graph operations like createNode, traverse, etc.
             const input = {
                 env: job.env,
                 product: job.product,
-                event: job.event,
+                graph: productJob.app,
+                operation: productJob.event,
                 cache: job.cache,
                 session: job.session,
-                input: job.input
+                input: job.input,
             };
             jobInput = input;
+            namespace = 'graphs';
         }
-        else if (productJob.type === types_1.JobEventTypes.STORAGE) {
+        else if (productJob.type === types_1.JobEventTypes.WORKFLOW) {
+            // Workflow job - execute a workflow
             const input = {
                 env: job.env,
                 product: job.product,
-                event: job.event,
+                workflow: productJob.app,
                 cache: job.cache,
                 session: job.session,
-                input: job.input
+                input: job.input,
             };
             jobInput = input;
+            namespace = 'workflows';
         }
         else {
             throw new Error(`Job type ${productJob.type} not supported`);
         }
-        const options = {};
+        // Determine if this is a recurring job
+        const isRecurring = !!(((_a = job.repeat) === null || _a === void 0 ? void 0 : _a.cron) || ((_b = job.repeat) === null || _b === void 0 ? void 0 : _b.every));
+        // Generate a unique job ID
+        const jobId = `job_${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 16)}`;
+        // Build queue options
+        const options = {
+            jobId,
+        };
         // Handle `delay` only if repeat.every is not defined
-        if (!((_a = job.repeat) === null || _a === void 0 ? void 0 : _a.every)) {
+        if (!((_c = job.repeat) === null || _c === void 0 ? void 0 : _c.every) && delay > 0) {
             options.delay = delay;
         }
         // Add repeat config if defined
+        let next_run_at;
         if (job.repeat) {
             const { every, cron, tz, limit, endDate } = job.repeat;
-            options.repeat = cron
-                ? {
+            if (cron) {
+                options.repeat = {
                     cron,
                     tz,
                     limit,
                     endDate,
+                };
+                // Calculate next run time from cron
+                try {
+                    const cronParser = require('cron-parser');
+                    const cronOptions = {};
+                    if (tz)
+                        cronOptions.tz = tz;
+                    const interval = cronParser.parseExpression(cron, cronOptions);
+                    next_run_at = interval.next().getTime();
                 }
-                : every
-                    ? {
-                        every,
-                        limit,
-                        endDate,
-                    }
-                    : undefined;
+                catch (err) {
+                    next_run_at = NOW;
+                }
+            }
+            else if (every) {
+                options.repeat = {
+                    every,
+                    limit,
+                    endDate,
+                };
+                next_run_at = NOW + every;
+            }
         }
+        // Store job metadata in Redis if redisClient is available
+        if (this.redisClient) {
+            const jobData = {
+                id: jobId,
+                status: delay > 0 ? 'scheduled' : 'queued',
+                type: productJob.type,
+                namespace,
+                product: job.product,
+                env: job.env,
+                event: job.event,
+                app: productJob.app,
+                scheduled_at,
+                recurring: isRecurring,
+                cron: (_d = job.repeat) === null || _d === void 0 ? void 0 : _d.cron,
+                every: (_e = job.repeat) === null || _e === void 0 ? void 0 : _e.every,
+                next_run_at,
+                execution_count: 0,
+                limit: (_f = job.repeat) === null || _f === void 0 ? void 0 : _f.limit,
+                end_date: ((_g = job.repeat) === null || _g === void 0 ? void 0 : _g.endDate)
+                    ? typeof job.repeat.endDate === 'string'
+                        ? new Date(job.repeat.endDate).getTime()
+                        : job.repeat.endDate
+                    : undefined,
+                tz: (_h = job.repeat) === null || _h === void 0 ? void 0 : _h.tz,
+                retries: job.retries || 0,
+                retry_count: 0,
+                input: jobInput,
+                session: job.session,
+                cache: job.cache,
+                workspace_id: this.workspace_id,
+                created_at: NOW,
+                updated_at: NOW,
+            };
+            // Store in Redis with TTL of 90 days
+            const jobKey = `job:${this.workspace_id}:${jobId}`;
+            const redis = this.redisClient;
+            await redis.setex(jobKey, 90 * 24 * 60 * 60, JSON.stringify(jobData));
+            // Add to status index
+            const statusKey = `job_status:${this.workspace_id}:${jobData.status}`;
+            await redis.sadd(statusKey, jobId);
+            // Add to product index
+            const productKey = `job_product:${this.workspace_id}:${job.product}`;
+            await redis.sadd(productKey, jobId);
+        }
+        // Add job input with the job ID for tracking
+        jobInput._job_id = jobId;
+        // Add job to queue
         await this.queues.jobs.add(productJob.type, jobInput, options);
+        return {
+            job_id: jobId,
+            status: delay > 0 ? 'scheduled' : 'queued',
+            scheduled_at,
+            recurring: isRecurring,
+            next_run_at,
+        };
     }
     async sendExpoNotification(payload, device_tokens) {
         const message = {
@@ -2558,19 +2807,53 @@ class ProcessorService {
         await this.sendFirebaseNotification({ title, body, data }, payload.device_tokens, notification.credentials);
         this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Firebase notification - success', data: { title, body: (0, processor_utils_1.anonymizeObject)(data), data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
     }
-    async runNotification(notification, additional_logs) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+    async runNotification(notification, additional_logs, bootstrapData) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const { event } = notification;
         const input = notification.input;
         try {
-            //await this.intializeProduct(additional_logs);
-            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);
+            let notificationEvent;
+            let message;
+            let envConfig;
+            // Use bootstrap data if provided, otherwise fetch via API
+            if (bootstrapData) {
+                notificationEvent = bootstrapData.notification;
+                message = bootstrapData.message;
+                envConfig = bootstrapData.env_config;
+            }
+            else {
+                // Fallback to original API-based fetching
+                notificationEvent = (await this.productBuilderService.fetchNotification(event.split(':')[0]));
+                message = await this.productBuilderService.fetchNotificationMessage(event);
+                if (!message) {
+                    throw new Error(`Message ${event} not found`);
+                }
+                envConfig = (_a = notificationEvent.envs) === null || _a === void 0 ? void 0 : _a.find((data) => data.slug === notification.env.slug);
+            }
+            if (!envConfig) {
+                throw new Error(`Notification env config for ${notification.env.slug} not found`);
+            }
+            let { push_notifications: notifications, emails, callbacks, sms: smses, } = envConfig;
+            // Resolve any $Secret{} references in notification configs
+            const secretsService = (0, secrets_1.getSecretsService)();
+            if (secretsService) {
+                if (notifications && (0, secrets_1.mightContainSecrets)(notifications)) {
+                    const resolved = await secretsService.resolve(notifications, { env: notification.env.slug });
+                    notifications = resolved.value;
+                }
+                if (emails && (0, secrets_1.mightContainSecrets)(emails)) {
+                    const resolved = await secretsService.resolve(emails, { env: notification.env.slug });
+                    emails = resolved.value;
+                }
+                if (callbacks && (0, secrets_1.mightContainSecrets)(callbacks)) {
+                    const resolved = await secretsService.resolve(callbacks, { env: notification.env.slug });
+                    callbacks = resolved.value;
+                }
+                if (smses && (0, secrets_1.mightContainSecrets)(smses)) {
+                    const resolved = await secretsService.resolve(smses, { env: notification.env.slug });
+                    smses = resolved.value;
+                }
+            }
             const { push_notification: push, email, callback, sms } = message;
             this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching notification', data: notificationEvent, status: types_1.LogEventStatus.SUCCESS }));
             if (push) {
@@ -2616,7 +2899,11 @@ class ProcessorService {
                 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), input: (0, processor_utils_1.anonymizeObject)(input.email), }, 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,
@@ -2634,10 +2921,10 @@ class ProcessorService {
             }
             if (callback && callbacks) {
                 const payload = {
-                    query: Object.assign(Object.assign({}, (_a = input.callback) === null || _a === void 0 ? void 0 : _a.query), (_b = callbacks.auth) === null || _b === void 0 ? void 0 : _b.query),
-                    headers: Object.assign(Object.assign({}, (_c = input.callback) === null || _c === void 0 ? void 0 : _c.headers), (_d = callbacks.auth) === null || _d === void 0 ? void 0 : _d.headers),
-                    params: Object.assign(Object.assign({}, (_e = input.callback) === null || _e === void 0 ? void 0 : _e.params), (_f = callbacks.auth) === null || _f === void 0 ? void 0 : _f.params),
-                    body: Object.assign(Object.assign({}, (_g = input.callback) === null || _g === void 0 ? void 0 : _g.body), (_h = callbacks.auth) === null || _h === void 0 ? void 0 : _h.body),
+                    query: Object.assign(Object.assign({}, (_b = input.callback) === null || _b === void 0 ? void 0 : _b.query), (_c = callbacks.auth) === null || _c === void 0 ? void 0 : _c.query),
+                    headers: Object.assign(Object.assign({}, (_d = input.callback) === null || _d === void 0 ? void 0 : _d.headers), (_e = callbacks.auth) === null || _e === void 0 ? void 0 : _e.headers),
+                    params: Object.assign(Object.assign({}, (_f = input.callback) === null || _f === void 0 ? void 0 : _f.params), (_g = callbacks.auth) === null || _g === void 0 ? void 0 : _g.params),
+                    body: Object.assign(Object.assign({}, (_h = input.callback) === null || _h === void 0 ? void 0 : _h.body), (_j = callbacks.auth) === null || _j === void 0 ? void 0 : _j.body),
                 };
                 input.callback.body = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'body'));
                 input.callback.query = await this.generatePayload(payload.query, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'query'));
@@ -2659,7 +2946,7 @@ class ProcessorService {
             }
             if (sms && smses) {
                 try {
-                    input.sms.body = await (0, processor_utils_1.replacePlaceholderString)(sms, input.sms.body);
+                    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 }));
@@ -2678,193 +2965,123 @@ class ProcessorService {
             throw e;
         }
     }
-    async runMigration(product_tag, tag, env, type) {
-        try {
-            this.productTag = product_tag;
-            const [dbTag, migrationTag] = tag.split(':');
-            if (!dbTag || !migrationTag) {
-                throw new Error('tag should be in the format database_tag:migration_tag');
-            }
-            this.start = Date.now();
-            const additional_logs = {
-                parent_tag: dbTag,
-                child_tag: migrationTag,
-                type: types_1.LogEventTypes.DB_MIGRATION,
-                name: 'Run Migration',
-            };
-            await this.intializeProduct(additional_logs);
-            const db = this.productBuilderService.fetchDatabase(dbTag);
-            if (!db) {
-                throw new Error('Database not found');
-            }
-            if (db.type === types_1.DatabaseTypes.MONGODB) {
-                throw new Error(`${db.type} does not support migrations`);
-            }
-            const migration = this.productBuilderService.fetchDatabaseMigration(tag);
-            if (!migration) {
-                throw new Error('Database migration not found');
-            }
-            const dbEnv = db.envs.find((el) => el.slug === env);
-            if (!dbEnv) {
-                throw new Error(`Environment ${env} not found`);
-            }
-            const productEnv = this.fetchEnv(env, additional_logs);
-            if (!productEnv.active) {
-                throw new Error(`Environment ${env} is not active`);
-            }
-            const product = this.productBuilderService.fetchProduct();
-            const migrations = this.productBuilderService.fetchDatabaseMigrations(dbTag);
-            //this.processEnv = productEnv;
-            /* const check = migration.envs.find((migrationEnv) => migrationEnv.slug === env);
-             if (!check) {
-               throw new Error(`Migration does not exist for environment ${env}`);
-             }*/
-            const process_id = (0, processor_utils_1.generateObjectId)();
-            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env,
-                process_id, data: { tag, env } }, additional_logs);
-            const migrationsToRun = (0, processor_utils_1.getMigrationsToRun)((0, processor_utils_1.structuredClone)(migrations), type, migrationTag, env);
-            if (db.type === types_1.DatabaseTypes.POSTGRES) {
-                const PostgresDBHandler = await (0, postgres_repo_1.loadPostgresHandler)();
-                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(dbEnv.connection_url, product.private_key));
-                for (const migrationToRun of migrationsToRun) {
-                    const envS = migration.envs.find((envT) => envT.slug === env && type === envT.type);
-                    if (envS && envS.status === types_1.MigrationStatus.PROCESSED) {
-                        continue;
-                    }
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: `Starting migration ${type} name: ${migrationToRun.name}`, data: { migration: migrationToRun, type }, status: types_1.LogEventStatus.PROCESSING }));
-                    const { type: migType, result, status, processed_at, } = await pgHandler.runMigration(migrationToRun.value[type], type, envS);
-                    if (!envS) {
-                        migrationToRun.envs.push({ slug: env, results: result, status, type, processed_at });
-                    }
-                    else {
-                        migrationToRun.envs.map((envT) => {
-                            if (envT.slug === env && type === envT.type) {
-                                envT.results = [...result];
-                                envT.processed_at = processed_at;
-                                return envT;
-                            }
-                            return envT;
-                        });
-                    }
-                    this.productBuilderService.updateDatabaseMigration(Object.assign(Object.assign({}, migrationToRun), { tag }));
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: `Starting migration ${type} name: ${migrationToRun.name}`, data: { migration: migrationToRun, type }, status: types_1.LogEventStatus.SUCCESS }));
-                }
-                return { process_id };
-            }
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { failed_execution: true, message: 'Attempt migration - failed', data: e, status: types_1.LogEventStatus.FAIL }));
-            await this.logService.publish();
-        }
-    }
     /*async runFunction(data: IFeatureEvent, additional_logs: Partial<ILogData>): Promise<any> {
-      const { product_id, env } = data;
-      const input = data.input as IFunctionRequest;
-  
-      this.productId = product_id;
-  
-      this.logService = new LogsService({
-        product_id,
-        workspace_id: this.workspace_id,
-        public_key: this.public_key,
-        user_id: this.user_id,
-        token: this.token,
-        env_type: this.environment,
-      });
-  
-      const process_id = generateObjectId();
-      this.process_id = process_id;
-      
-  
-      try {
-        await this.intializeProduct(additional_logs);
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Attempt function - initiated',
-          data,
-          status: LogEventStatus.PROCESSING,
-        });
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Fetch function - initiated',
-          data: data,
-          status: LogEventStatus.PROCESSING,
-        });
-  
-        const cloudFunction = this.productBuilderService.fetchFunction(data.event);
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Fetch function - success',
-          data: data,
-          status: LogEventStatus.SUCCESS,
-        });
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Validate function payload - initiated',
-          data: { data, payload: input.payload },
-          status: LogEventStatus.PROCESSING,
-        });
-  
-        validateFunctionInputKeys(cloudFunction.inputs, input.payload);
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Validate function payload - success',
-          data: { data, payload: input.payload },
-          status: LogEventStatus.SUCCESS,
-        });
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Run function - initiated',
-          data: { data, payload: input.payload },
-          status: LogEventStatus.PROCESSING,
+        const { product_id, env } = data;
+        const input = data.input as IFunctionRequest;
+    
+        this.productId = product_id;
+    
+        this.logService = new LogsService({
+          product_id,
+          workspace_id: this.workspace_id,
+          public_key: this.public_key,
+          user_id: this.user_id,
+          token: this.token,
+          env_type: this.environment,
         });
-  
-        const response = await makeFunctionsRequest(cloudFunction, input.payload);
-  
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Run function - success',
-          data: { data, payload: input.payload },
-          status: LogEventStatus.SUCCESS,
-        });
-      } catch (e) {
-        this.logService.add({
-          ...this.baseLogs,
-          ...additional_logs,
-          message: 'Run function - failed',
-          data: e,
-          status: LogEventStatus.FAIL,
-        });
-        await this.logService.publish();
-      }
-    }*/
-    async runStorage(data, additional_logs = {}) {
+    
+        const process_id = generateObjectId();
+        this.process_id = process_id;
+        
+    
+        try {
+          await this.intializeProduct(additional_logs);
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Attempt function - initiated',
+            data,
+            status: LogEventStatus.PROCESSING,
+          });
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Fetch function - initiated',
+            data: data,
+            status: LogEventStatus.PROCESSING,
+          });
+    
+          const cloudFunction = await this.productBuilderService.fetchFunction(data.event);
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Fetch function - success',
+            data: data,
+            status: LogEventStatus.SUCCESS,
+          });
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Validate function payload - initiated',
+            data: { data, payload: input.payload },
+            status: LogEventStatus.PROCESSING,
+          });
+    
+          validateFunctionInputKeys(cloudFunction.inputs, input.payload);
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Validate function payload - success',
+            data: { data, payload: input.payload },
+            status: LogEventStatus.SUCCESS,
+          });
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Run function - initiated',
+            data: { data, payload: input.payload },
+            status: LogEventStatus.PROCESSING,
+          });
+    
+          const response = await makeFunctionsRequest(cloudFunction, input.payload);
+    
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Run function - success',
+            data: { data, payload: input.payload },
+            status: LogEventStatus.SUCCESS,
+          });
+        } catch (e) {
+          this.logService.add({
+            ...this.baseLogs,
+            ...additional_logs,
+            message: 'Run function - failed',
+            data: e,
+            status: LogEventStatus.FAIL,
+          });
+          await this.logService.publish();
+        }
+      }*/
+    async runStorage(data, additional_logs = {}, bootstrapData) {
         const { product_id, env, event, cache: cache_tag } = data;
         const input = data.input;
         try {
-            await this.intializeProduct(additional_logs);
-            const storage = await this.productBuilderService.fetchStorage(event);
-            const storageEnv = storage.envs.find((el) => el.slug === env.slug);
+            let storage;
+            let storageEnv;
+            // Use bootstrap data if provided, otherwise fetch via API
+            if (bootstrapData) {
+                storage = bootstrapData.storage;
+                storageEnv = bootstrapData.storage_env;
+            }
+            else {
+                // Fallback to original API-based fetching
+                await this.intializeProduct(additional_logs);
+                storage = await this.productBuilderService.fetchStorage(event);
+                storageEnv = storage.envs.find((el) => el.slug === env.slug);
+            }
             if (!storageEnv) {
                 throw new Error(`Storage env for ${env.slug} not found`);
             }
             this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch storage details - success', data: { storage }, status: types_1.LogEventStatus.SUCCESS }));
-            const product = this.productBuilderService.fetchProduct();
             let result;
             if (cache_tag && this.redisClient) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
                 }
@@ -2872,7 +3089,7 @@ class ProcessorService {
                 const check = await this.fetchFromCache({
                     cache_tag,
                     input: inputString,
-                    privateKey: product.private_key,
+                    privateKey: this.productBuilderService.fetchPrivateKey(),
                     expiry: productCache.expiry,
                 }, additional_logs);
                 if (check) {
@@ -2882,18 +3099,22 @@ class ProcessorService {
                 }
             }
             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;
+            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);
             if (cache_tag && this.redisClient) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
+                const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
                 }
                 const inputString = JSON.stringify(input);
                 await this.addToCache({
                     input: inputString,
-                    privateKey: product.private_key,
+                    privateKey: this.productBuilderService.fetchPrivateKey(),
                     data: JSON.stringify(result),
                     cache_tag,
                     timestamp: Date.now(),
@@ -2908,131 +3129,13 @@ class ProcessorService {
             throw e;
         }
     }
-    async runDBAction(db_action, additional_logs = {}) {
-        const { product_id, env, event, cache: cache_tag } = db_action;
-        const input = db_action.input;
-        try {
-            //await this.intializeProduct(additional_logs);
-            const [database_tag, action_tag] = event.split(':');
-            const product = this.productBuilderService.fetchProduct();
-            const database = await this.productBuilderService.fetchDatabase(database_tag);
-            const databaseAction = await this.productBuilderService.fetchDatabaseAction(event);
-            const databaseEnv = database.envs.find((el) => el.slug === env.slug);
-            if (!databaseEnv) {
-                throw new Error(`Database env for ${env.slug} not found`);
-            }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch database action - success', data: databaseAction, status: types_1.LogEventStatus.SUCCESS }));
-            input.data = await this.generatePayload(input.data, db_action, additional_logs, databaseAction.data);
-            if (Array.isArray(input.data)) {
-                await Promise.all(input.data.map(async (d) => {
-                    const dataValidationPayload = (await this.inputService.parseJson({
-                        data: d,
-                        expected: types_1.ExpectedValues.PARSEINPUT,
-                    }));
-                    this.inputService.validateInput(dataValidationPayload, databaseAction.data);
-                }));
-            }
-            else {
-                const dataValidationPayload = (await this.inputService.parseJson({
-                    data: input.data,
-                    expected: types_1.ExpectedValues.PARSEINPUT,
-                }));
-                this.inputService.validateInput(dataValidationPayload, databaseAction.data);
-                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 - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
-                }
-            }
-            let result;
-            if (cache_tag && this.redisClient) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
-                if (!productCache) {
-                    throw new Error('Invalid cache tag ');
-                }
-                const inputString = JSON.stringify(input);
-                const check = await this.fetchFromCache({
-                    cache_tag,
-                    input: inputString,
-                    privateKey: product.private_key,
-                    expiry: productCache.expiry,
-                }, 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 }));
-                    return result;
-                }
-            }
-            const template = typeof databaseAction.template === 'string' ? databaseAction.template : JSON.stringify(databaseAction.template);
-            if (database.type === types_1.DatabaseTypes.MONGODB) {
-                const MongoDBHandler = await (0, mongo_repo_1.loadMongoDbHandler)();
-                if (!MongoDBHandler) {
-                    throw new Error(`Running in browser, mongo handler not loaded.`);
-                }
-                const mongoHandler = new MongoDBHandler(databaseEnv.connection_url);
-                if (databaseAction.type === types_1.DatabaseActionTypes.UPDATE) {
-                    const filterTemplate = typeof databaseAction.filterTemplate === 'string'
-                        ? databaseAction.filterTemplate
-                        : JSON.stringify(databaseAction.filterTemplate);
-                    result = await mongoHandler[databaseAction.type](databaseAction.data, template, input.data, databaseAction.tableName, databaseAction.filterData, filterTemplate, input.filter);
-                }
-                else {
-                    result = await mongoHandler[databaseAction.type](databaseAction.data, template, input.data, databaseAction.tableName);
-                }
-            }
-            else if (database.type === types_1.DatabaseTypes.POSTGRES) {
-                const PostgresDBHandler = await (0, postgres_repo_1.loadPostgresHandler)();
-                if (!PostgresDBHandler) {
-                    throw new Error(`Running in browser, postgres handler not loaded.`);
-                }
-                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(databaseEnv.connection_url, this.productBuilderService.fetchProduct().private_key));
-                if (databaseAction.type !== types_1.DatabaseActionTypes.AGGREGATE) {
-                    result = await pgHandler[databaseAction.type](databaseAction.data, template, input.data);
-                }
-            }
-            //await this.logService.publish();
-            // const result = this.processDBRequest(db_action, input, database_tag, databaseEnv, action_tag, additional_logs);
-            await this.addToSuccessOutput(db_action, result, additional_logs);
-            if (cache_tag && this.redisClient) {
-                const productCache = this.productBuilderService.fetchCache(cache_tag);
-                if (!productCache) {
-                    throw new Error('Invalid cache tag ');
-                }
-                const inputString = JSON.stringify(input);
-                await this.addToCache({
-                    input: inputString,
-                    privateKey: product.private_key,
-                    data: JSON.stringify(result),
-                    cache_tag,
-                    timestamp: Date.now(),
-                    product_tag: this.productTag,
-                    component_tag: database_tag,
-                    component_type: types_1.ProductComponents.DATABASE_ACTION,
-                }, 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: e.toString() }, status: types_1.LogEventStatus.FAIL }));
-            throw e;
-        }
-    }
     async runBrokerSubscribe(data, additional_logs = {}) {
         const { env, event } = data;
         const input = data.input;
         try {
             await this.intializeProduct(additional_logs);
             const [brokerTag, topicTag] = event.split(':');
-            const broker = this.productBuilderService.fetchMessageBroker(brokerTag);
+            const broker = await this.productBuilderService.fetchMessageBroker(brokerTag);
             if (!broker) {
                 throw new Error(`Message Broker ${brokerTag} not found`);
             }
@@ -3040,7 +3143,7 @@ class ProcessorService {
             if (!brokerEnv) {
                 throw new Error(`Broker env for ${env.slug} not found`);
             }
-            const topic = this.productBuilderService.fetchMessageBrokerTopic(event);
+            const topic = await this.productBuilderService.fetchMessageBrokerTopic(event);
             if (!topic) {
                 throw new Error(`Topic ${topicTag} not found in broker ${brokerTag}`);
             }
@@ -3060,9 +3163,7 @@ class ProcessorService {
             if (createBrokerService) {
                 const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
                 await brokerService.subscribe(url, input.callback);
-                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 }));
-                }
+                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 {
@@ -3081,7 +3182,7 @@ class ProcessorService {
         try {
             await this.intializeProduct(additional_logs);
             const [brokerTag, topicTag] = event.split(':');
-            const broker = this.productBuilderService.fetchMessageBroker(brokerTag);
+            const broker = await this.productBuilderService.fetchMessageBroker(brokerTag);
             if (!broker) {
                 throw new Error(`Message Broker ${brokerTag} not found`);
             }
@@ -3089,7 +3190,7 @@ class ProcessorService {
             if (!brokerEnv) {
                 throw new Error(`Broker env for ${env.slug} not found`);
             }
-            const topic = this.productBuilderService.fetchMessageBrokerTopic(event);
+            const topic = await this.productBuilderService.fetchMessageBrokerTopic(event);
             if (!topic) {
                 throw new Error(`Topic ${topicTag} not found in broker ${brokerTag}`);
             }
@@ -3109,9 +3210,7 @@ class ProcessorService {
             if (createBrokerService) {
                 const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
                 await brokerService.publish(url, input.message);
-                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 }));
-                }
+                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 {
@@ -3153,7 +3252,7 @@ class ProcessorService {
             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),
+                    url: (0, processor_utils_1.encrypt)(result.url, this.productBuilderService.fetchPrivateKey()),
                     provider: storageEnv.type,
                     product: this.productTag,
                     process_id: this.process_id,
@@ -3161,7 +3260,7 @@ class ProcessorService {
                     type: input.mimeType,
                     event: data.event,
                     env: data.env.slug,
-                    size: Buffer.from(input.buffer).length
+                    size: Buffer.from(input.buffer).length,
                 }, this.getUserAccess());
             }
             catch (e) { }
@@ -3178,35 +3277,6 @@ class ProcessorService {
             throw e;
         }
     }
-    async processDBRequest(db_action, input, database_tag, databaseEnv, action_tag, additional_logs, returnValue = false) {
-        try {
-            const result = await this.processorApiService.processProduct(this.productId, {
-                input: input,
-                database_tag: database_tag,
-                database_env_slug: databaseEnv.slug,
-                tag: action_tag,
-                component: types_1.ProductComponents.DATABASE_ACTION,
-            }, {
-                user_id: this.user_id,
-                token: this.token,
-                workspace_id: this.workspace_id,
-                public_key: this.public_key,
-            });
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Run database query - success', data: { payload: (0, processor_utils_1.anonymizeObject)(input) }, status: types_1.LogEventStatus.SUCCESS }));
-            return result;
-        }
-        catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Running database query - failed', data: { payload: (0, processor_utils_1.anonymizeObject)(input), e }, status: types_1.LogEventStatus.FAIL }));
-            const value = await this.addToFailureOutput(e, db_action, {
-                db_action,
-                input,
-                database_tag,
-                databaseEnv,
-                action_tag,
-            }, additional_logs);
-            return value;
-        }
-    }
     async writeResult(status, retryable = true) {
         this.processorApiService.saveResult({
             status,
@@ -3214,14 +3284,108 @@ class ProcessorService {
             start: this.start,
             end: this.end,
             retryable,
-            result: (0, processor_utils_1.encrypt)(JSON.stringify(this.processingOutput), this.productBuilderService.fetchProduct().private_key),
+            result: (0, processor_utils_1.encrypt)(JSON.stringify(this.processingOutput), this.productBuilderService.fetchPrivateKey()),
             process_id: this.process_id,
-            feature_id: this.feature ? this.feature._id : null,
+            feature_id: null,
             product_id: this.productId,
             env: this.processEnv.slug,
-            input: (0, processor_utils_1.encrypt)(JSON.stringify(this.input), this.productBuilderService.fetchProduct().private_key),
+            input: (0, processor_utils_1.encrypt)(JSON.stringify(this.input), this.productBuilderService.fetchPrivateKey()),
         }, this.getUserAccess());
     }
+    /**
+     * Separate credentials into prefixed (e.g., 'headers:Authorization') and non-prefixed (e.g., 'api_key').
+     * Prefixed credentials are applied directly to the correct section after resolution.
+     * Non-prefixed credentials go through InputResolver to determine their placement.
+     */
+    separateCredentials(credentials) {
+        const prefixed = {};
+        const nonPrefixed = {};
+        for (const [key, value] of Object.entries(credentials)) {
+            if (key.startsWith('headers:') || key.startsWith('body:') ||
+                key.startsWith('params:') || key.startsWith('query:')) {
+                prefixed[key] = value;
+            }
+            else {
+                nonPrefixed[key] = value;
+            }
+        }
+        return { prefixed, nonPrefixed };
+    }
+    /**
+     * Check if a key exists in the action schema for a given section (headers, body, params, query).
+     * Returns true if the key is defined in the schema, false otherwise.
+     */
+    isKeyInActionSchema(action, section, key) {
+        if (!action)
+            return false;
+        const sectionSchema = action[section];
+        if (!sectionSchema || !sectionSchema.data)
+            return false;
+        // Check if the key exists in the schema's data array
+        return sectionSchema.data.some(item => item.key === key);
+    }
+    /**
+     * Apply prefixed credentials (e.g., 'headers:Authorization') to resolved input.
+     * Credentials are applied with lower priority - existing values in resolvedInput take precedence.
+     * Only applies credentials if the action schema defines the corresponding field.
+     */
+    applyPrefixedCredentials(credentials, resolvedInput, action) {
+        const result = {
+            body: Object.assign({}, (resolvedInput.body || {})),
+            params: Object.assign({}, (resolvedInput.params || {})),
+            query: Object.assign({}, (resolvedInput.query || {})),
+            headers: Object.assign({}, (resolvedInput.headers || {})),
+        };
+        for (const [key, value] of Object.entries(credentials)) {
+            if (key.startsWith('headers:')) {
+                const headerKey = key.substring(8); // Remove 'headers:' prefix
+                // Only apply if the action schema expects this header field
+                if (!this.isKeyInActionSchema(action, 'headers', headerKey)) {
+                    continue; // Skip - action doesn't expect this credential
+                }
+                // Only set if not already present (user input takes precedence)
+                if (!(headerKey in (result.headers || {}))) {
+                    result.headers = result.headers || {};
+                    result.headers[headerKey] = value;
+                }
+            }
+            else if (key.startsWith('body:')) {
+                const bodyKey = key.substring(5); // Remove 'body:' prefix
+                // Only apply if the action schema expects this body field
+                if (!this.isKeyInActionSchema(action, 'body', bodyKey)) {
+                    continue; // Skip - action doesn't expect this credential
+                }
+                if (!(bodyKey in (result.body || {}))) {
+                    result.body = result.body || {};
+                    result.body[bodyKey] = value;
+                }
+            }
+            else if (key.startsWith('params:')) {
+                const paramsKey = key.substring(7); // Remove 'params:' prefix
+                // Only apply if the action schema expects this params field
+                if (!this.isKeyInActionSchema(action, 'params', paramsKey)) {
+                    continue; // Skip - action doesn't expect this credential
+                }
+                if (!(paramsKey in (result.params || {}))) {
+                    result.params = result.params || {};
+                    result.params[paramsKey] = value;
+                }
+            }
+            else if (key.startsWith('query:')) {
+                const queryKey = key.substring(6); // Remove 'query:' prefix
+                // Only apply if the action schema expects this query field
+                if (!this.isKeyInActionSchema(action, 'query', queryKey)) {
+                    continue; // Skip - action doesn't expect this credential
+                }
+                if (!(queryKey in (result.query || {}))) {
+                    result.query = result.query || {};
+                    result.query[queryKey] = value;
+                }
+            }
+            // Ignore keys without recognized prefixes - credentials should always be prefixed
+        }
+        return result;
+    }
     async validateActionDataMappingInput(input, type) {
         try {
             if (type === types_1.FeatureEventTypes.ACTION || type === types_1.WebhookEventTypes.WEBHOOK_REGISTER) {
@@ -3241,7 +3405,7 @@ class ProcessorService {
     }
     async processAction(action) {
         //TODO: schema validation
-        const { env, input, retries, event, app, product: product_tag } = action;
+        const { env, input, retries, action: event, app, product: product_tag, session, cache } = action;
         const additional_logs = {
             parent_tag: (0, string_utils_1.extractOriginAndTag)(app),
             child_tag: event,
@@ -3249,39 +3413,141 @@ class ProcessorService {
             name: 'Process Action',
         };
         this.component = types_1.LogEventTypes.ACTION;
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedInput = input;
         try {
-            // validate input do not allow $Sequence or $Length and $Size of $Input
-            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
             this.input = action;
             this.start = Date.now();
-            this.productTag = product_tag;
             const process_id = (0, processor_utils_1.generateObjectId)();
+            if (product_tag) {
+                this.productTag = product_tag;
+            }
             this.baseLogs = {
-                product_tag: this.productTag,
+                product_tag: this.productTag || '',
                 workspace_id: this.workspace_id,
                 env,
                 type: types_1.LogEventTypes.ACTION,
                 process_id,
                 data: input,
             };
-            await this.intializeProduct(additional_logs);
+            // Single ultra-lightweight bootstrap call - returns action data directly
+            const bootstrapData = await this.productBuilderService.bootstrapAction({
+                product_tag,
+                env_slug: env,
+                access_tag: app,
+                action_tag: event,
+            });
+            // Initialize from bootstrap data
+            if (bootstrapData.product_id) {
+                this.productId = bootstrapData.product_id;
+            }
+            // Resolve flat input to structured format using action schema
+            // This must happen AFTER bootstrap when we have the action schema
+            if (bootstrapData.action && input && typeof input === 'object') {
+                if (!(0, utils_1.isStructuredInput)(input)) {
+                    // Flat input detected - resolve using action schema
+                    let flatInput = Object.assign({}, input);
+                    // Gather all credentials (static + OAuth)
+                    // Priority: user input > OAuth > static config
+                    const allCredentials = {};
+                    // Static credentials (lowest priority)
+                    const sharedCredentials = credential_manager_1.credentialManager.get({ product: product_tag, app, env });
+                    if (sharedCredentials) {
+                        Object.assign(allCredentials, sharedCredentials);
+                    }
+                    // OAuth credentials (higher priority, overwrites static)
+                    if (product_tag && oauth_manager_1.oauthManager.has(product_tag, app, env)) {
+                        const oauthCredentials = await oauth_manager_1.oauthManager.getCredentials(product_tag, app, env);
+                        if (oauthCredentials) {
+                            Object.assign(allCredentials, oauthCredentials);
+                        }
+                    }
+                    // Separate credentials into prefixed and non-prefixed
+                    const { prefixed, nonPrefixed } = this.separateCredentials(allCredentials);
+                    const inputResolver = new utils_1.InputResolver();
+                    // Build location map to check which keys exist in the schema
+                    const locationMap = inputResolver.buildLocationMap(bootstrapData.action);
+                    // Merge non-prefixed credentials into flatInput BEFORE resolution
+                    // Only include credentials that exist in the action schema
+                    // User input takes precedence over credentials
+                    for (const [key, value] of Object.entries(nonPrefixed)) {
+                        // Skip if user already provided this key
+                        if (key in flatInput) {
+                            continue;
+                        }
+                        // Only include if the key exists in the action schema
+                        if (locationMap.allValidKeys.has(key)) {
+                            flatInput[key] = value;
+                        }
+                    }
+                    try {
+                        resolvedInput = inputResolver.resolve(flatInput, bootstrapData.action, { strict: true });
+                    }
+                    catch (e) {
+                        if (e instanceof utils_1.InputResolutionError) {
+                            throw new Error(`Input resolution failed for action '${event}': ${e.message}`);
+                        }
+                        throw e;
+                    }
+                    // Apply prefixed credentials AFTER resolution (directly to correct section)
+                    // Only credentials that match fields in the action schema are applied
+                    if (Object.keys(prefixed).length > 0) {
+                        resolvedInput = this.applyPrefixedCredentials(prefixed, resolvedInput, bootstrapData.action);
+                    }
+                }
+                else {
+                    // Already structured - validate with existing schema
+                    await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
+                }
+            }
+            else {
+                // Fallback: validate with existing schema if no action bootstrap data
+                await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
+            }
+            // Process session if provided - verify and resolve $Session{} references
+            if (session && bootstrapData.private_key) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, resolvedInput, env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedInput = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+            // Initialize log service if needed
+            if (!this.logService) {
+                this.logService = new logs_service_1.default({
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    token: this.token,
+                    env_type: this.environment,
+                });
+            }
             this.process_id = process_id;
             this.baseLogs.product_id = this.productId;
-            const productEnv = this.fetchEnv(env, additional_logs);
-            this.processEnv = productEnv;
-            if (!productEnv.active) {
-                throw new Error(`Environment ${env} is not active`);
-            }
+            // Add session fields to base logs
+            this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Bootstrap action - success', data: { product_id: this.productId, env: env }, status: types_1.LogEventStatus.SUCCESS }));
             const result = await this.runAction({
                 type: types_1.FeatureEventTypes.ACTION,
                 event,
-                cache: action.cache,
+                cache: cache,
                 app,
-                input,
-                env: productEnv,
+                input: resolvedInput,
+                env: this.processEnv,
                 retries: retries || 0,
                 allow_fail: false,
-            }, additional_logs, true);
+                hasProduct: !!product_tag,
+            }, additional_logs, true, {
+                action: bootstrapData.action,
+                app_env: bootstrapData.app_env,
+                retries: bootstrapData.retries,
+                app_active: bootstrapData.app_active,
+                recipient_workspace_id: bootstrapData.recipient_workspace_id,
+            });
             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 }));
             await this.writeResult(types_1.LogEventStatus.SUCCESS);
@@ -3289,70 +3555,18 @@ class ProcessorService {
             return result;
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            console.log('ERRRRROORRRRR!!!!!!', e);
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
             this.end = Date.now();
             await this.writeResult(types_1.LogEventStatus.FAIL);
             await this.logService.publish();
             return { process_id: this.process_id };
         }
     }
-    async processDBAction(action) {
-        //TODO: schema validation
-        const { env, input, retries, event, product: product_tag } = action;
-        const [parent_tag, child_tag] = event.split(':');
-        this.component = types_1.LogEventTypes.DB_ACTION;
-        if (!parent_tag || !child_tag) {
-            throw new Error(`database action events should be in the format notification_tag:message_tag`);
-        }
-        const additional_logs = {
-            parent_tag,
-            child_tag,
-            type: types_1.LogEventTypes.DB_ACTION,
-            name: 'Process database action',
-        };
-        try {
-            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
-            this.input = action;
-            this.start = Date.now();
-            this.productTag = product_tag;
-            const process_id = (0, processor_utils_1.generateObjectId)();
-            this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env,
-                process_id, data: input }, additional_logs);
-            await this.intializeProduct(additional_logs);
-            this.baseLogs.product_id = this.productId;
-            this.process_id = process_id;
-            const productEnv = this.fetchEnv(env, additional_logs);
-            this.processEnv = productEnv;
-            if (!productEnv.active) {
-                throw new Error(`Environment ${env} is not active`);
-            }
-            const payload = {
-                type: types_1.FeatureEventTypes.DB_ACTION,
-                event,
-                input,
-                cache: action.cache,
-                env: productEnv,
-                retries: retries || 0,
-                allow_fail: false,
-            };
-            const result = await this.runDBAction(payload, additional_logs);
-            this.end = Date.now();
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute database action', data: { input: (0, processor_utils_1.anonymizeObject)(input), result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
-            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();
-            await this.logService.publish();
-            return { process_id: this.process_id };
-        }
-    }
-    async processFunction(data) { }
     async processNotification(action) {
         //TODO: schema validation
-        const { env, input, retries, event, product: product_tag } = action;
+        var _a;
+        const { env, input, retries, event, product: product_tag, session, cache } = action;
         const [parent_tag, child_tag] = event.split(':');
         if (!parent_tag || !child_tag) {
             throw new Error(`database action events should be in the format notification_tag:message_tag`);
@@ -3364,6 +3578,9 @@ class ProcessorService {
             type: types_1.LogEventTypes.NOTIFICATIONS,
             name: 'Process Notification',
         };
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedInput = input;
         try {
             await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
             this.input = action;
@@ -3372,24 +3589,61 @@ class ProcessorService {
             const process_id = (0, processor_utils_1.generateObjectId)();
             this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env,
                 process_id, data: input }, additional_logs);
-            await this.intializeProduct(additional_logs);
+            // Single bootstrap call to fetch all notification data
+            const bootstrapData = await this.productBuilderService.bootstrapNotification({
+                product_tag,
+                env_slug: env,
+                notification_tag: parent_tag,
+                message_tag: child_tag,
+            });
+            // Initialize from bootstrap data
+            this.productId = bootstrapData.product_id;
+            this.processEnv = bootstrapData.env;
+            // Process session if provided - verify and resolve $Session{} references
+            if (session && bootstrapData.private_key) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env);
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedInput = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+            // Initialize log service if needed
+            if (!this.logService) {
+                this.logService = new logs_service_1.default({
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    token: this.token,
+                    env_type: this.environment,
+                });
+            }
             this.process_id = process_id;
             this.baseLogs.product_id = this.productId;
-            const productEnv = this.fetchEnv(env, additional_logs);
-            this.processEnv = productEnv;
+            // Add session fields to base logs
+            this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
+            const productEnv = bootstrapData.env;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
             }
             const payload = {
                 type: types_1.FeatureEventTypes.NOTIFICATION,
                 event,
-                input,
-                cache: action.cache,
+                input: resolvedInput,
+                cache: cache,
                 env: productEnv,
                 retries: retries || 0,
                 allow_fail: false,
             };
-            const result = await this.runNotification(payload, additional_logs);
+            // Find the env config for the notification
+            const envConfig = (_a = bootstrapData.notification.envs) === null || _a === void 0 ? void 0 : _a.find((data) => data.slug === env);
+            const result = await this.runNotification(payload, additional_logs, {
+                notification: bootstrapData.notification,
+                message: bootstrapData.message,
+                env_config: envConfig,
+            });
             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 }));
             await this.writeResult(types_1.LogEventStatus.SUCCESS);
@@ -3407,7 +3661,7 @@ class ProcessorService {
         try {
             const data = await this.processorApiService.fetchRemoteCaches(payload, this.getUserAccess());
             return data.map((data) => {
-                data.value = (0, processor_utils_1.decrypt)(data.value, this.productBuilderService.fetchProduct().private_key);
+                data.value = (0, processor_utils_1.decrypt)(data.value, this.productBuilderService.fetchPrivateKey());
                 return data;
             });
         }
@@ -3475,6 +3729,33 @@ class ProcessorService {
         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);
     }
+    /**
+     * Writes the healthcheck result to Redis cache for fast status retrieval.
+     */
+    async writeHealthcheckResultToCache(data, result) {
+        if (!this.redisClient)
+            return;
+        const key = `healthcheck:${data.product}:${data.healthcheck}:${data.env}`;
+        console.log('LOG TO CACHE', key, JSON.stringify(result));
+        await this.redisClient.set(key, JSON.stringify(result));
+        console.log();
+    }
+    /**
+     * Fetches the latest healthcheck status for a product/env from Redis cache.
+     */
+    async getHealthcheckStatusFromCache(productTag, envSlug) {
+        if (!this.redisClient)
+            return null;
+        const key = `healthcheck:${productTag}:${envSlug}`;
+        const cached = await this.redisClient.get(key);
+        return cached ? JSON.parse(cached) : null;
+    }
+    /**
+     * Updates the healthcheck in the remote DB for a product with all envs' results.
+     */
+    async updateHealthcheckOnProcessor(productTag, envs) {
+        return this.productBuilderService.updateHealthcheck(productTag, { envs });
+    }
 }
 exports.default = ProcessorService;
 //# sourceMappingURL=processor.service.js.map