@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -56,12 +56,10 @@ 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 functions_utils_1 = require("../../products/services/utils/functions.utils");
+const string_utils_1 = require("../../products/services/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");
@@ -69,6 +67,9 @@ 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"));
 async function loadBrokerService() {
     if (typeof window === 'undefined') {
         const { createBrokerService } = await Promise.resolve().then(() => __importStar(require('./messagebrokers')));
@@ -77,14 +78,14 @@ async function loadBrokerService() {
     return null;
 }
 async function loadJWT() {
-    if (typeof window === undefined) {
+    if (typeof window === 'undefined') {
         const JWT = await Promise.resolve().then(() => __importStar(require("jsonwebtoken")));
         return JWT;
     }
     return null;
 }
 class ProcessorService {
-    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client, queues }) {
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
@@ -98,6 +99,14 @@ class ProcessorService {
             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;
         this.totalRequests = 0;
@@ -108,10 +117,89 @@ 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;
-        if (redis_client) {
+        if (redis_client && this.productTag) {
             this.redisClient = redis_client;
+            // Start healthcheck workers automatically
+            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,
+                            event: 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,
+                        event: 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) {
@@ -122,23 +210,37 @@ class ProcessorService {
                 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 expiry = (0, processor_utils_1.calculateExpiry)(session.expiry, session.period);
+            const stages = (0, string_utils_1.extractStages)(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 token = JWT.sign(JSON.stringify(Object.assign({ type: "token" }, data)), this.productBuilderService.fetchProduct().private_key, { expiresIn: expiry });
-                const refreshToken = (0, processor_utils_1.encrypt)(JSON.stringify(data), this.productBuilderService.fetchProduct().private_key);
+                const session_id = (0, uuid_1.v4)();
+                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
-                await this.processorApiService.createRefreshToken({ product_tag, env: slug, refreshToken }, this.getUserAccess());
+                const details = {
+                    identifier: user,
+                    start_at: Date.now(),
+                    end_at,
+                    session_tag: tag,
+                    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 {
                     token,
                     refreshToken,
@@ -152,100 +254,46 @@ class ProcessorService {
             throw e;
         }
     }
-    async registerWebhook(data) {
-        const { product: product_tag, access_tag, webhook_tag, envs } = data;
-        await this.productBuilderService.initializeProductByTag(product_tag);
-        const product = this.productBuilderService.fetchProduct();
-        const { version, envs: appEnvs } = this.productBuilderService.fetchApp(access_tag);
-        const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(access_tag);
-        const { webhooks } = app.versions.find((data) => data.tag === version);
-        if (!webhooks) {
-            throw new Error(`Webhooks not found for app ${access_tag}`);
+    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, privateKey));
+            return await this.generateSession(Object.assign(Object.assign({}, payloadData), { data }));
         }
-        await validators_1.RegisterWebhookEnvSchema.validateAsync(envs);
-        const webhook = webhooks.find((data) => data.tag === webhook_tag);
-        if (!webhook) {
-            throw new Error(`Webhook tag ${webhook_tag} not found`);
+        else {
+            throw new Error(`Invalid refresh token`);
+        }
+    }
+    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.`);
         }
-        const productEnvs = this.productBuilderService.fetchEnvs();
-        productEnvs.map((env) => {
-            const exists = envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
-            if (exists === -1) {
-                throw new Error(`Product env ${env.slug} is not defined, please provide connection details`);
+        try {
+            const res = await JWT.verify(data.token, privateKey);
+            if (res.session !== data.tag) {
+                throw new Error(`Invalid token for session ${data.tag}`);
             }
-        });
-        const dataArray = await Promise.all(envs.map(async (env) => {
-            await this.validateActionDataMappingInput(env.auth, types_1.WebhookEventTypes.WEBHOOK_REGISTER);
-            const productEnvData = productEnvs.find((data) => data.slug === env.slug);
-            if (!productEnvData) {
-                throw new Error(`Error finding product env ${env.slug}`);
-            }
-            const envData = productEnvData.envs.find((productEnvMap) => productEnvMap.product_env_slug === env.slug);
-            if (!envData) {
-                throw new Error(`Error finding env data for ${env.slug}`);
-            }
-            const { app_env_slug: appEnv, product_env_slug: productEnv } = envData;
-            const envWebhookData = webhook.envs.find((webhookEnv) => webhookEnv.slug === appEnv);
-            if (!envWebhookData) {
-                throw new Error(`Error finding webhook registration sample ${webhook_tag} for  env ${env.slug}`);
-            }
-            const uuid = (0, uuid_1.v4)();
-            const url = `${urls_1.WEBHOOK_BASE_URL}/webhooks/v1/process/${uuid}`;
-            let active = false;
-            if (envWebhookData.sample) {
-                const samples = {
-                    query: envWebhookData.sample_data.filter((data) => data.parent_key === 'query'),
-                    params: envWebhookData.sample_data.filter((data) => data.parent_key === 'params'),
-                    body: envWebhookData.sample_data.filter((data) => data.parent_key === 'body'),
-                    headers: envWebhookData.sample_data.filter((data) => data.parent_key === 'headers'),
-                };
-                let payload = (await this.constructJSONDataPayloads(env.auth, {}, samples, {
-                    app: access_tag,
-                    event: '',
-                    input: env.auth,
-                    type: types_1.FeatureEventTypes.ACTION,
-                    retries: 0,
-                    allow_fail: false,
-                }));
-                const { updatedObj, replacedUrl } = (0, processor_utils_1.updateUrlsInObject)(payload, url);
-                if (replacedUrl && replacedUrl !== env.url && replacedUrl) {
-                    throw new Error(`Ductape expects the url ${replacedUrl} in request body to match inputted url ${env.url}`);
-                }
-                const exists = this.fetchEnv(env.slug, {});
-                if (!exists) {
-                    throw new Error(`Env ${env.slug} does not exist`);
-                }
-                payload = updatedObj;
-                if (!replacedUrl) {
-                    payload.body.url = url;
-                }
-                const parsedUrl = new URL(envWebhookData.registration_url);
-                await this.sendActionRequest(parsedUrl.origin, parsedUrl.pathname, payload, envWebhookData.method, env.slug);
-                active = true;
+            if (res.env !== data.env) {
+                throw new Error(`Invalid session env`);
             }
-            return {
-                appEnv,
-                productEnv,
-                uuid,
-                url: env.url,
-                method: env.method,
-                access_tag,
-                webhook_tag,
-                version,
-                sender_workspace_id: app.workspace_id,
-                receiver_workspace_id: product.workspace_id,
-                app_tag: app.tag,
-                product_tag,
-                active,
-            };
-        }));
-        await this.webhookApi.registerWebhooks(dataArray, this.getUserAccess());
+            return res.data;
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error("Invalid/Expired token");
+        }
     }
     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) {
@@ -266,7 +314,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,
@@ -296,12 +344,12 @@ class ProcessorService {
                 process_id,
                 data: input,
             };
-            this.quota = this.fetchQuota(quota_tag, additional_logs);
+            this.quota = await 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);
+            this.processEnv = await this.fetchEnv(env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
             }
@@ -358,10 +406,14 @@ class ProcessorService {
     }
     async overrideQuotaFallbackInput(value, quotaInput, app) {
         if (value.startsWith('$Input{')) {
-            return quotaInput[(0, string_utils_1.extractStages)(value)[0]];
+            const stages = (0, string_utils_1.extractStages)(value);
+            return quotaInput[String(stages[0])];
         }
         else if (value.startsWith('$Auth')) {
-            return await this.generateAuthValue((0, string_utils_1.extractStages)(value), app, [], {});
+            const stages = (0, string_utils_1.extractStages)(value);
+            // Convert stages to string[] for functions expecting string[]
+            const stringStages = stages.map(stage => String(stage));
+            return await this.generateAuthValue(stringStages, app, [], {});
         }
         else if (value.startsWith('$')) {
             this.input = Object.assign(Object.assign({}, this.input), { input: quotaInput });
@@ -423,12 +475,12 @@ class ProcessorService {
                 process_id,
                 data: input,
             };
-            this.fallback = this.fetchFallback(fallback_tag, additional_logs);
+            this.fallback = await 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);
+            this.processEnv = await this.fetchEnv(env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
             }
@@ -461,7 +513,7 @@ class ProcessorService {
             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);
+            this.feature = await this.fetchFeature(feature_tag, additional_logs);
             if (!this.feature) {
                 throw new Error(`Feature "${feature_tag}" not found`);
             }
@@ -477,7 +529,7 @@ class ProcessorService {
                 feature_id: this.feature._id,
             };
             this.logService.setFeatureId(this.feature._id);
-            this.processEnv = this.fetchEnv(env, additional_logs);
+            this.processEnv = await this.fetchEnv(env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${data.env} is not active`);
             }
@@ -525,8 +577,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');
             }
@@ -537,9 +589,35 @@ class ProcessorService {
             throw e;
         }
     }
-    fetchFeature(tag, additional_logs) {
+    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,
+            });
+        }
+        try {
+            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: 'Pricing initialize - failed', data: e, status: types_1.LogEventStatus.FAIL }));
+            throw e;
+        }
+    }
+    async fetchFeature(tag, additional_logs) {
         try {
-            const feature = this.productBuilderService.fetchFeature(tag); // validate feature exists
+            const feature = await 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;
         }
@@ -548,9 +626,9 @@ class ProcessorService {
             throw e;
         }
     }
-    fetchQuota(tag, additional_logs) {
+    async fetchQuota(tag, additional_logs) {
         try {
-            const quota = this.productBuilderService.fetchQuota(tag); // validate feature exists
+            const quota = await 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;
         }
@@ -559,9 +637,9 @@ class ProcessorService {
             throw e;
         }
     }
-    fetchFallback(tag, additional_logs) {
+    async fetchFallback(tag, additional_logs) {
         try {
-            const fallback = this.productBuilderService.fetchFallback(tag); // validate feature exists
+            const fallback = await 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;
         }
@@ -570,9 +648,9 @@ class ProcessorService {
             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`);
             }
@@ -787,8 +865,8 @@ class ProcessorService {
                             if (values[i].startsWith('$Sequence')) {
                                 const stages = this.productBuilderService.extractStages(values[i]);
                                 dependants.push({
-                                    sequence_tag: stages[0],
-                                    event_tag: stages[1],
+                                    sequence_tag: String(stages[0]),
+                                    event_tag: String(stages[1]),
                                 });
                             }
                             else if (values[i].startsWith('$')) {
@@ -798,8 +876,8 @@ class ProcessorService {
                                         if (arg.startsWith('$Sequence')) {
                                             const stages = this.productBuilderService.extractStages(arg);
                                             dependants.push({
-                                                sequence_tag: stages[0],
-                                                event_tag: stages[1],
+                                                sequence_tag: String(stages[0]),
+                                                event_tag: String(stages[1]),
                                             });
                                         }
                                     });
@@ -825,7 +903,7 @@ class ProcessorService {
         const dependants = [];
         if (value.startsWith('$Sequence')) {
             const stages = this.productBuilderService.extractStages(value);
-            dependants.push({ sequence_tag: stages[0], event_tag: stages[1] });
+            dependants.push({ sequence_tag: String(stages[0]), event_tag: String(stages[1]) });
         }
         else if (value.startsWith('$')) {
             const funcArgs = (0, functions_utils_1.extractFunctionAndArgs)(value);
@@ -834,8 +912,8 @@ class ProcessorService {
                     if (arg.startsWith('$Sequence')) {
                         const stages = this.productBuilderService.extractStages(arg);
                         dependants.push({
-                            sequence_tag: stages[0],
-                            event_tag: stages[1],
+                            sequence_tag: String(stages[0]),
+                            event_tag: String(stages[1]),
                         });
                     }
                     else {
@@ -908,6 +986,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];
@@ -953,22 +1032,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);
@@ -1093,6 +1182,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);
             }));
@@ -1365,7 +1455,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}`);
@@ -1411,6 +1501,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) {
@@ -1426,7 +1517,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`);
             }
@@ -1437,6 +1528,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
@@ -1444,9 +1536,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);
         }
@@ -1556,7 +1649,18 @@ class ProcessorService {
                     parent_tag: event.event,
                     name: 'Process feature job',
                 };
-                return this.runJob(event, additional_logs);
+                const input = {
+                    env: event.env.slug,
+                    product: this.productTag,
+                    event: event.event,
+                    retries: event.retries,
+                    input: event.input,
+                    start_at: event.start_at || 0,
+                    cache: event.cache,
+                    session: this.input.session
+                };
+                // TODO: fix this
+                return this.processJob(input, additional_logs);
             }
         }
         catch (e) {
@@ -1580,8 +1684,10 @@ class ProcessorService {
         }
         return output;
     }
-    runJob(event, additional_logs) {
-        throw new Error('Method not implemented.');
+    async runJobs(job, additional_logs = {}) {
+        if (job.name === types_1.FeatureEventTypes.ACTION) {
+            await this.processAction(job.data);
+        }
     }
     async processFailedAndWaiting() { }
     async fetchResult(process_id) {
@@ -1590,8 +1696,8 @@ class ProcessorService {
             throw new Error(`Invalid process id ${process_id}`);
         }
         await this.productBuilderService.initializeProduct(result.product_id);
-        result.result = JSON.parse((0, processor_utils_1.decrypt)(String(result.result), this.productBuilderService.fetchProduct().private_key));
-        result.input = JSON.parse((0, processor_utils_1.decrypt)(String(result.input), this.productBuilderService.fetchProduct().private_key));
+        result.result = JSON.parse((0, processor_utils_1.decrypt)(String(result.result), this.productBuilderService.fetchPrivateKey()));
+        result.input = JSON.parse((0, processor_utils_1.decrypt)(String(result.input), this.productBuilderService.fetchPrivateKey()));
         return result;
     }
     async generateOutput(process_id) {
@@ -1655,7 +1761,7 @@ class ProcessorService {
         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);
+            this.processEnv = await this.fetchEnv(result.env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${result.env} is not active`);
             }
@@ -1697,7 +1803,7 @@ class ProcessorService {
             //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);
+            this.processEnv = await this.fetchEnv(result.env, additional_logs);
             if (!this.processEnv.active) {
                 throw new Error(`Environment ${result.env} is not active`);
             }
@@ -1712,7 +1818,7 @@ class ProcessorService {
                 ((_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.processEnv = await this.fetchEnv(result.env, additional_logs);
             this.start = Date.now();
             await this.processEvent(event);
             this.end = Date.now();
@@ -1739,10 +1845,11 @@ class ProcessorService {
     }
     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}`);
@@ -1757,9 +1864,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
@@ -1870,12 +1984,13 @@ class ProcessorService {
             }
             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 productApp = await 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;
+            console.log(app, appEnvs);
             const env = appEnvs.find((item) => item.slug === app_env_slug); // fetch the actuall app Environment variable
-            if (!active) {
+            if (!active && recipient_workspace_id !== this.baseLogs.workspace_id) {
                 throw new Error(`App ${event.app} version ${app.version} is not active`);
             }
             if (!env.active) {
@@ -1890,6 +2005,12 @@ 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 === app_env_slug);
+                if (env && env.base_url) {
+                    request_base_url = env.base_url;
+                }
+            }
             const samples = {
                 query: (query === null || query === void 0 ? void 0 : query.data) || [],
                 headers: (headers === null || headers === void 0 ? void 0 : headers.data) || [],
@@ -1898,9 +2019,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 ');
                 }
@@ -1908,7 +2029,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) {
@@ -1938,14 +2059,14 @@ class ProcessorService {
                 }
             }
             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(),
@@ -1962,6 +2083,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 {
@@ -1972,7 +2094,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) {
@@ -1985,7 +2111,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;
@@ -2018,6 +2144,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));
@@ -2143,52 +2330,15 @@ class ProcessorService {
         }
     }
     generateRetryMetrices(error_code, retries) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-        let allow_fail = true;
-        let retry_at = 5000;
-        let max = (retries === null || retries === void 0 ? void 0 : retries.max) || 0;
-        switch (error_code) {
-            case '500':
-                allow_fail = ((_a = retries === null || retries === void 0 ? void 0 : retries.policy[500]) === null || _a === void 0 ? void 0 : _a.available) || false;
-                retry_at = ((_b = retries === null || retries === void 0 ? void 0 : retries.policy[500]) === null || _b === void 0 ? void 0 : _b.lag) || 0;
-                break;
-            case '502':
-                allow_fail = ((_c = retries === null || retries === void 0 ? void 0 : retries.policy[502]) === null || _c === void 0 ? void 0 : _c.available) || false;
-                retry_at = ((_d = retries === null || retries === void 0 ? void 0 : retries.policy[502]) === null || _d === void 0 ? void 0 : _d.lag) || 0;
-                break;
-            case '503':
-                allow_fail = ((_e = retries === null || retries === void 0 ? void 0 : retries.policy[503]) === null || _e === void 0 ? void 0 : _e.available) || false;
-                retry_at = ((_f = retries === null || retries === void 0 ? void 0 : retries.policy[503]) === null || _f === void 0 ? void 0 : _f.lag) || 0;
-                break;
-            case '504':
-                allow_fail = ((_g = retries === null || retries === void 0 ? void 0 : retries.policy[504]) === null || _g === void 0 ? void 0 : _g.available) || false;
-                retry_at = ((_h = retries === null || retries === void 0 ? void 0 : retries.policy[504]) === null || _h === void 0 ? void 0 : _h.lag) || 0;
-                break;
-            case '400':
-                allow_fail = ((_j = retries === null || retries === void 0 ? void 0 : retries.policy[400]) === null || _j === void 0 ? void 0 : _j.available) || false;
-                retry_at = ((_k = retries === null || retries === void 0 ? void 0 : retries.policy[400]) === null || _k === void 0 ? void 0 : _k.lag) || 0;
-                break;
-            case '401':
-                allow_fail = ((_l = retries === null || retries === void 0 ? void 0 : retries.policy[401]) === null || _l === void 0 ? void 0 : _l.available) || false;
-                retry_at = ((_m = retries === null || retries === void 0 ? void 0 : retries.policy[401]) === null || _m === void 0 ? void 0 : _m.lag) || 0;
-                break;
-            case '403':
-                allow_fail = ((_o = retries === null || retries === void 0 ? void 0 : retries.policy[403]) === null || _o === void 0 ? void 0 : _o.available) || false;
-                retry_at = ((_p = retries === null || retries === void 0 ? void 0 : retries.policy[403]) === null || _p === void 0 ? void 0 : _p.lag) || 0;
-                break;
-            case '404':
-                allow_fail = ((_q = retries === null || retries === void 0 ? void 0 : retries.policy[404]) === null || _q === void 0 ? void 0 : _q.available) || false;
-                retry_at = ((_r = retries === null || retries === void 0 ? void 0 : retries.policy[404]) === null || _r === void 0 ? void 0 : _r.lag) || 0;
-                break;
-            case '1000': // all non http errors
-                allow_fail = true;
-                retry_at = 500;
-            default:
-                allow_fail = true;
-                retry_at = 0;
-                max = 0;
-                break;
-        }
+        var _a;
+        const isSpecial = error_code === '1000';
+        if (isSpecial) {
+            return { allow_fail: true, max: (retries === null || retries === void 0 ? void 0 : retries.max) || 0, retry_at: 500 };
+        }
+        const policy = (_a = retries === null || retries === void 0 ? void 0 : retries.policy) === null || _a === void 0 ? void 0 : _a[error_code];
+        const allow_fail = policy ? policy.available : true;
+        const retry_at = policy ? policy.lag : 0;
+        const max = (retries === null || retries === void 0 ? void 0 : retries.max) || 0;
         return { allow_fail, max, retry_at };
     }
     async sendActionRequest(base_url, resource, payload, method, env) {
@@ -2214,6 +2364,7 @@ class ProcessorService {
                 timeout: 15000,
                 withCredentials: false
             };
+            console.log("REQUEST!!!!", request);
             const response = await axios_1.default.request(request);
             return response.data;
         }
@@ -2231,7 +2382,7 @@ class ProcessorService {
             name: 'Process Storage',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.STORAGE);
             this.input = input;
             this.start = Date.now();
             this.component = types_1.LogEventTypes.STORAGE;
@@ -2244,7 +2395,7 @@ class ProcessorService {
                 process_id, data: this.clone }, additional_logs);
             await this.intializeProduct(additional_logs);
             this.process_id = process_id;
-            const productEnv = this.fetchEnv(env, additional_logs);
+            const productEnv = await this.fetchEnv(env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
@@ -2284,16 +2435,17 @@ class ProcessorService {
             name: `Subscribe to broker topic`,
         };
         try {
-            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.STORAGE);
+            //await this.validateActionDataMappingInput(data.input, FeatureEventTypes.STORAGE);
+            const input = { callback: data.callback };
             this.start = Date.now();
             this.productTag = data.product;
             const process_id = (0, processor_utils_1.generateObjectId)();
-            this.input = data;
-            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env: data.env, process_id, data: data.input }, additional_logs);
+            this.input = Object.assign(Object.assign({}, data), { input });
+            this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env: data.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(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`);
@@ -2302,7 +2454,7 @@ class ProcessorService {
             const payload = {
                 type: types_1.FeatureEventTypes.SUBSCRIBE,
                 event: data.event,
-                input: data.input,
+                input: input,
                 env: productEnv,
                 retries: 0,
                 allow_fail: false,
@@ -2333,10 +2485,11 @@ class ProcessorService {
             name: 'Publish to broker topic',
         };
         try {
-            this.validateActionDataMappingInput(data.input, types_1.FeatureEventTypes.PUBLISH);
+            const input = { message: data.message };
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.PUBLISH);
             this.start = Date.now();
             // clone
-            this.clone = (0, processor_utils_1.structuredClone)(data.input);
+            this.clone = (0, processor_utils_1.structuredClone)(input);
             this.input = data;
             this.productTag = data.product;
             const process_id = (0, processor_utils_1.generateObjectId)();
@@ -2345,7 +2498,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`);
@@ -2354,7 +2507,7 @@ class ProcessorService {
                 type: types_1.FeatureEventTypes.PUBLISH,
                 event: data.event,
                 cache: data.cache,
-                input: data.input,
+                input: input,
                 env: productEnv,
                 retries: 0,
                 allow_fail: false,
@@ -2373,7 +2526,113 @@ class ProcessorService {
             return { process_id: this.process_id };
         }
     }
-    async processJob(job) { }
+    async processJob(job, additional_logs = {}) {
+        var _a;
+        const productJob = await this.productBuilderService.fetchJob(job.event);
+        if (!productJob) {
+            throw new Error(`Job ${job.event} not found`);
+        }
+        await this.validateActionDataMappingInput(job.input, productJob.type);
+        const NOW = Date.now();
+        // Treat anything above Jan 1, 2023 as a timestamp (to be safe and future-proof)
+        const IS_PROBABLY_TIMESTAMP = job.start_at > 1672531200000;
+        const delay = Math.max(0, IS_PROBABLY_TIMESTAMP ? job.start_at - NOW : job.start_at);
+        let jobInput;
+        if (productJob.type === types_1.JobEventTypes.ACTION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                app: productJob.app,
+                cache: job.cache,
+                input: job.input,
+                event: job.event,
+                session: job.session
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.DATABASE_ACTION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                cache: job.cache,
+                input: job.input,
+                event: job.event,
+                session: job.session,
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.FALLBACK || productJob.type === types_1.JobEventTypes.QUOTA || productJob.type === types_1.JobEventTypes.FEATURE) {
+            const input = {
+                input: job.input,
+                product: job.product,
+                env: job.env,
+                tag: job.event,
+                session: job.session,
+                cache: job.cache,
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.NOTIFICATION) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                input: job.input,
+                session: job.session,
+                cache: job.cache
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.PUBLISH) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                cache: job.cache,
+                session: job.session,
+                message: job.input
+            };
+            jobInput = input;
+        }
+        else if (productJob.type === types_1.JobEventTypes.STORAGE) {
+            const input = {
+                env: job.env,
+                product: job.product,
+                event: job.event,
+                cache: job.cache,
+                session: job.session,
+                input: job.input
+            };
+            jobInput = input;
+        }
+        else {
+            throw new Error(`Job type ${productJob.type} not supported`);
+        }
+        const options = {};
+        // Handle `delay` only if repeat.every is not defined
+        if (!((_a = job.repeat) === null || _a === void 0 ? void 0 : _a.every)) {
+            options.delay = delay;
+        }
+        // Add repeat config if defined
+        if (job.repeat) {
+            const { every, cron, tz, limit, endDate } = job.repeat;
+            options.repeat = cron
+                ? {
+                    cron,
+                    tz,
+                    limit,
+                    endDate,
+                }
+                : every
+                    ? {
+                        every,
+                        limit,
+                        endDate,
+                    }
+                    : undefined;
+        }
+        await this.queues.jobs.add(productJob.type, jobInput, options);
+    }
     async sendExpoNotification(payload, device_tokens) {
         const message = {
             to: device_tokens,
@@ -2433,8 +2692,8 @@ class ProcessorService {
         const input = notification.input;
         try {
             //await this.intializeProduct(additional_logs);
-            const notificationEvent = this.productBuilderService.fetchNotification(event.split(":")[0]);
-            const message = this.productBuilderService.fetchNotificationMessage(event);
+            const notificationEvent = await this.productBuilderService.fetchNotification(event.split(":")[0]);
+            const message = await this.productBuilderService.fetchNotificationMessage(event);
             if (!message) {
                 throw new Error(`Message ${event} not found`);
             }
@@ -2562,14 +2821,14 @@ class ProcessorService {
                 name: 'Run Migration',
             };
             await this.intializeProduct(additional_logs);
-            const db = this.productBuilderService.fetchDatabase(dbTag);
+            const db = await 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);
+            const migration = await this.productBuilderService.fetchDatabaseMigration(tag);
             if (!migration) {
                 throw new Error('Database migration not found');
             }
@@ -2577,12 +2836,11 @@ class ProcessorService {
             if (!dbEnv) {
                 throw new Error(`Environment ${env} not found`);
             }
-            const productEnv = this.fetchEnv(env, additional_logs);
+            const productEnv = await 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);
+            const migrations = await this.productBuilderService.fetchDatabaseMigrations(dbTag);
             //this.processEnv = productEnv;
             /* const check = migration.envs.find((migrationEnv) => migrationEnv.slug === env);
              if (!check) {
@@ -2594,7 +2852,7 @@ class ProcessorService {
             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));
+                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(dbEnv.connection_url, this.productBuilderService.fetchPrivateKey()));
                 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) {
@@ -2663,7 +2921,7 @@ class ProcessorService {
           status: LogEventStatus.PROCESSING,
         });
   
-        const cloudFunction = this.productBuilderService.fetchFunction(data.event);
+        const cloudFunction = await this.productBuilderService.fetchFunction(data.event);
   
         this.logService.add({
           ...this.baseLogs,
@@ -2730,10 +2988,9 @@ class ProcessorService {
                 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 ');
                 }
@@ -2741,7 +2998,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) {
@@ -2755,14 +3012,14 @@ class ProcessorService {
             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(),
@@ -2783,7 +3040,6 @@ class ProcessorService {
         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);
@@ -2823,7 +3079,7 @@ class ProcessorService {
             }
             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 ');
                 }
@@ -2831,7 +3087,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) {
@@ -2862,7 +3118,7 @@ class ProcessorService {
                 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));
+                const pgHandler = new PostgresDBHandler((0, processor_utils_1.decrypt)(databaseEnv.connection_url, this.productBuilderService.fetchPrivateKey()));
                 if (databaseAction.type !== types_1.DatabaseActionTypes.AGGREGATE) {
                     result = await pgHandler[databaseAction.type](databaseAction.data, template, input.data);
                 }
@@ -2871,14 +3127,14 @@ class ProcessorService {
             // 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);
+                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(),
@@ -2901,7 +3157,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`);
             }
@@ -2909,7 +3165,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}`);
             }
@@ -2950,7 +3206,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`);
             }
@@ -2958,7 +3214,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}`);
             }
@@ -3022,7 +3278,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,
@@ -3083,12 +3339,12 @@ 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,
             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());
     }
     async validateActionDataMappingInput(input, type) {
@@ -3120,7 +3376,7 @@ class ProcessorService {
         this.component = types_1.LogEventTypes.ACTION;
         try {
             // validate input do not allow $Sequence or $Length and $Size of $Input
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.ACTION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -3134,9 +3390,10 @@ class ProcessorService {
                 data: input,
             };
             await this.intializeProduct(additional_logs);
+            await this.initializePricing(additional_logs, app);
             this.process_id = process_id;
             this.baseLogs.product_id = this.productId;
-            const productEnv = this.fetchEnv(env, additional_logs);
+            const productEnv = await this.fetchEnv(env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
@@ -3158,7 +3415,8 @@ 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();
@@ -3180,7 +3438,7 @@ class ProcessorService {
             name: 'Process database action',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.DB_ACTION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -3190,7 +3448,7 @@ class ProcessorService {
             await this.intializeProduct(additional_logs);
             this.baseLogs.product_id = this.productId;
             this.process_id = process_id;
-            const productEnv = this.fetchEnv(env, additional_logs);
+            const productEnv = await this.fetchEnv(env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
@@ -3234,7 +3492,7 @@ class ProcessorService {
             name: 'Process Notification',
         };
         try {
-            this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
+            await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
             this.input = action;
             this.start = Date.now();
             this.productTag = product_tag;
@@ -3244,7 +3502,7 @@ class ProcessorService {
             await this.intializeProduct(additional_logs);
             this.process_id = process_id;
             this.baseLogs.product_id = this.productId;
-            const productEnv = this.fetchEnv(env, additional_logs);
+            const productEnv = await this.fetchEnv(env, additional_logs);
             this.processEnv = productEnv;
             if (!productEnv.active) {
                 throw new Error(`Environment ${env} is not active`);
@@ -3276,7 +3534,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;
             });
         }
@@ -3344,6 +3602,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