@ductape/sdk 0.0.4-v32 → 0.0.4-v34

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

@@ -139,9 +139,8 @@ class ProcessorService {
         // 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 product = this.productBuilderService.fetchProduct();
-        const healthchecks = product.healthchecks || [];
-        const privateKey = product.private_key;
+        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)
@@ -156,7 +155,7 @@ class ProcessorService {
                         // Prepare action input
                         const actionInput = {
                             env: env.slug,
-                            product: product.tag,
+                            product: this.productTag,
                             app: healthcheck.app,
                             input: decryptedInput,
                             event: healthcheck.event,
@@ -179,9 +178,8 @@ class ProcessorService {
      */
     async processAllHealthchecksForProduct(productTag) {
         await this.productBuilderService.initializeProductByTag(productTag);
-        const product = this.productBuilderService.fetchProduct();
-        const healthchecks = product.healthchecks || [];
-        const privateKey = product.private_key;
+        const healthchecks = await this.productBuilderService.fetchProductHealthchecks();
+        const privateKey = this.productBuilderService.fetchPrivateKey();
         for (const healthcheck of healthchecks) {
             for (const env of healthcheck.envs) {
                 try {
@@ -191,7 +189,7 @@ class ProcessorService {
                     }
                     const actionInput = {
                         env: env.slug,
-                        product: product.tag,
+                        product: productTag,
                         app: healthcheck.app,
                         input: decryptedInput,
                         event: healthcheck.event,
@@ -214,12 +212,12 @@ 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`);
             }
@@ -233,15 +231,15 @@ class ProcessorService {
             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),
+                    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());
@@ -260,11 +258,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 {
@@ -273,12 +272,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}`);
             }
@@ -295,8 +295,7 @@ class ProcessorService {
     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) {
@@ -307,7 +306,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) {
@@ -351,7 +350,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`);
                 }
@@ -373,7 +372,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,
@@ -384,8 +383,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) {
@@ -406,7 +404,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,
@@ -436,12 +434,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`);
             }
@@ -567,12 +565,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`);
             }
@@ -605,7 +603,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`);
             }
@@ -621,7 +619,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`);
             }
@@ -669,8 +667,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');
             }
@@ -694,7 +692,7 @@ class ProcessorService {
         }
         try {
             console.log(`Initializing pricing for access tag: ${access_tag}`);
-            const product_app = this.productBuilderService.fetchApp(access_tag); // validate app exists
+            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);
@@ -707,9 +705,9 @@ class ProcessorService {
             throw e;
         }
     }
-    fetchFeature(tag, additional_logs) {
+    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;
         }
@@ -718,9 +716,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;
         }
@@ -729,9 +727,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;
         }
@@ -740,9 +738,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`);
             }
@@ -1547,7 +1545,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}`);
@@ -1609,7 +1607,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`);
             }
@@ -1631,7 +1629,7 @@ class ProcessorService {
                 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);
         }
@@ -1788,8 +1786,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) {
@@ -1853,7 +1851,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`);
             }
@@ -1895,7 +1893,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`);
             }
@@ -1910,7 +1908,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();
@@ -1937,8 +1935,8 @@ class ProcessorService {
     }
     async getAndStoreAuth(appEnv, access_tag) {
         try {
-            //  const payload = JSON.parse(decrypt(env.auth.data, this.productBuilderService.fetchProduct().private_key));
-            const payload = JSON.parse((0, processor_utils_1.decrypt)(String(appEnv.auth.data), this.productBuilderService.fetchProduct().private_key));
+            //  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);
@@ -1964,8 +1962,8 @@ class ProcessorService {
                 }
                 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
@@ -2076,7 +2074,7 @@ 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;
@@ -2111,9 +2109,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 ');
                 }
@@ -2121,7 +2119,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) {
@@ -2151,14 +2149,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(),
@@ -2487,7 +2485,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`);
@@ -2536,7 +2534,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`);
@@ -2588,7 +2586,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`);
@@ -2618,7 +2616,7 @@ class ProcessorService {
     }
     async processJob(job, additional_logs = {}) {
         var _a;
-        const productJob = this.productBuilderService.fetchJob(job.event);
+        const productJob = await this.productBuilderService.fetchJob(job.event);
         if (!productJob) {
             throw new Error(`Job ${job.event} not found`);
         }
@@ -2782,8 +2780,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`);
             }
@@ -2911,14 +2909,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');
             }
@@ -2926,12 +2924,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) {
@@ -2943,7 +2940,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) {
@@ -3012,7 +3009,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,
@@ -3079,10 +3076,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 ');
                 }
@@ -3090,7 +3086,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) {
@@ -3104,14 +3100,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(),
@@ -3132,7 +3128,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);
@@ -3172,7 +3167,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 ');
                 }
@@ -3180,7 +3175,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) {
@@ -3211,7 +3206,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);
                 }
@@ -3220,14 +3215,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(),
@@ -3250,7 +3245,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`);
             }
@@ -3258,7 +3253,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}`);
             }
@@ -3299,7 +3294,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`);
             }
@@ -3307,7 +3302,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}`);
             }
@@ -3371,7 +3366,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,
@@ -3432,12 +3427,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) {
@@ -3486,7 +3481,7 @@ class ProcessorService {
             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`);
@@ -3541,7 +3536,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`);
@@ -3595,7 +3590,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`);
@@ -3627,7 +3622,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;
             });
         }