@ductape/sdk 0.0.4-v2 → 0.0.4-v21

package/dist/products/services/products.service.js

@@ -42,7 +42,7 @@ const functions_utils_1 = require("../utils/functions.utils");
 const objects_utils_2 = require("../../apps/utils/objects.utils");
 const webhooksApi_service_1 = require("../../api/services/webhooksApi.service");
 class ProductsBuilderService {
-    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;
@@ -54,6 +54,137 @@ class ProductsBuilderService {
         this.appApi = new appApi_service_1.AppApiService(env_type, redis_client);
         this.inputsService = new inputs_service_1.default();
         this.thirdPartyApps = [];
+        if (redis_client) {
+            this.redisClient = redis_client;
+            // Start healthcheck workers automatically
+            //this.startHealthcheckWorkers();
+        }
+        if (queues) {
+            this.queues = queues;
+        }
+    }
+    async createHealthcheck(data) {
+        try {
+            await validators_1.CreateProductHealthcheckSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const exists = this.fetchHealthcheck(data.app, data.tag);
+            if (!exists) {
+                const { app: access_tag, event: action } = data;
+                const app = await this.fetchThirdPartyAppByAccessTag(access_tag);
+                const version = app.versions.find((data) => data.tag === app.version);
+                if (!version) {
+                    throw new Error(`Version ${app.version} not found`);
+                }
+                const event = version.actions.find((act) => act.tag === action);
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    await this.validateActionDataInput({ input: env.input }, event, env.input, 0, 0);
+                    env.input = (0, processor_utils_1.encrypt)(JSON.stringify(env.input), this.fetchProduct().private_key);
+                    console.log("INPUT", env);
+                    return env;
+                }));
+                const envs = this.fetchEnvs();
+                console.log("ENVS ===>>>>", envs);
+                console.log("DBENVS ====>>>>", data.envs);
+                envs.map((env) => {
+                    const exists = data.envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
+                    if (exists === -1) {
+                        throw new Error(`Product env ${env.slug} is not defined, please provide details`);
+                    }
+                });
+                console.log("UPDATING VALUE", data);
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.ProductComponents.HEALTHCHECK }), this.getUserAccess());
+                await this.initializeProduct(this.product_id);
+                data.envs.map(async (env) => {
+                    const payload = {
+                        app: data.app,
+                        event: data.event,
+                        input: env.input,
+                        env: env.slug,
+                        product: this.product.tag,
+                        retries: data.retries,
+                    };
+                    const jobId = `healthcheck-${data.tag}`;
+                    const job = await this.queues.health.getJob(jobId);
+                    if (job) {
+                        await job.remove();
+                    }
+                    await this.queues.health.add(jobId, payload, { jobId, repeat: { every: data.interval } });
+                });
+            }
+        }
+        catch (e) {
+            console.log(e);
+            throw e;
+        }
+    }
+    async updateHealthcheck(tag, data) {
+        try {
+            // 1. Fetch the existing healthcheck
+            const healthcheck = this.fetchHealthcheck(data.app, tag);
+            if (!healthcheck) {
+                throw new Error(`Healthcheck with tag: ${tag} not found`);
+            }
+            // 2. Validate the incoming data
+            await validators_1.CreateProductHealthcheckSchema.validateAsync(data); // No Update schema, use Create
+            // 3. Check for tag conflicts
+            if (data.tag && data.tag !== tag && this.fetchHealthcheck(data.app, data.tag)) {
+                throw new Error(`Healthcheck with tag ${data.tag} already exists`);
+            }
+            // 4. Validate and process envs
+            if (data.envs) {
+                data.envs = await Promise.all(data.envs.map(async (env) => {
+                    const exists = this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    // Validate input if present
+                    if (env.input) {
+                        const app = await this.fetchThirdPartyAppByAccessTag(data.app);
+                        const version = app.versions.find((v) => v.tag === app.version);
+                        if (!version) {
+                            throw new Error(`Version ${app.version} not found`);
+                        }
+                        const event = version.actions.find((act) => act.tag === data.event);
+                        await this.validateActionDataInput({ input: env.input }, event, env.input, 0, 0);
+                        env.input = (0, processor_utils_1.encrypt)(JSON.stringify(env.input), this.fetchProduct().private_key);
+                    }
+                    return env;
+                }));
+            }
+            // 5. Ensure all product envs are covered
+            const envs = this.fetchEnvs();
+            envs.map((env) => {
+                var _a;
+                const exists = (_a = data.envs) === null || _a === void 0 ? void 0 : _a.findIndex((dbEnv) => dbEnv.slug === env.slug);
+                if (exists === -1) {
+                    throw new Error(`Product env ${env.slug} is not defined, please provide details`);
+                }
+            });
+            // 6. Update the healthcheck
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign(Object.assign({}, healthcheck), data), { tag, component: enums_1.ProductComponents.HEALTHCHECK, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeProduct(this.product_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchHealthcheck(access_tag, tag, throwError = false) {
+        const health = this.product.healthchecks.find((data) => data.tag === tag && data.app === access_tag);
+        if (!health && throwError)
+            throw new Error(`Healthcheck ${tag} not found`);
+        return health;
+    }
+    fetchHealthchecks(access_tag, throwError = false) {
+        const health = this.product.healthchecks.filter((data) => data.app === access_tag);
+        if (!health && throwError)
+            throw new Error(`Access tag ${access_tag} not found`);
+        return health;
     }
     async updateDataValidation(selector, update) {
         if (!selector.startsWith('$Data{') && !selector.startsWith('$Filter')) {
@@ -68,8 +199,8 @@ class ProductsBuilderService {
         if (stages.length < 3) {
             throw new Error(`Invalid selector ${selector}`);
         }
-        const tag = stages[0];
-        const type = stages[1];
+        const tag = String(stages[0]);
+        const type = String(stages[1]);
         let size = 2;
         let data;
         switch (type) {
@@ -81,13 +212,14 @@ class ProductsBuilderService {
                 break;
             case productsBuilder_types_1.FeatureEventTypes.NOTIFICATION:
                 size = 3;
-                if (!stages[3] || (stages[3] !== 'push' && stages[3] !== 'callback' && stages[3] !== 'email')) {
-                    throw new Error(`Invalid value ${stages[3]} in ${selector}, expected to be "push", "callback" or "email" in notification`);
+                const stage3Str = String(stages[3]);
+                if (!stages[3] || (stage3Str !== 'push' && stage3Str !== 'callback' && stage3Str !== 'email')) {
+                    throw new Error(`Invalid value ${stage3Str} in ${selector}, expected to be "push", "callback" or "email" in notification`);
                 }
                 const notification = this.fetchNotificationMessage(tag);
                 if (!notification)
                     throw new Error(`Notification ${tag} not found`);
-                if (stages[3] === 'push') {
+                if (stage3Str === 'push') {
                     data = notification.push_notification_data;
                 }
                 if (stages[3] === 'callback') {
@@ -157,6 +289,9 @@ class ProductsBuilderService {
     async initializeProductByTag(tag) {
         try {
             this.product = await this.productApi.fetchProductByTag(tag, this.getUserAccess());
+            if (!this.product) {
+                throw new Error(`Product with tag "${tag}" not found or failed to fetch`);
+            }
             this.product_id = this.product._id;
         }
         catch (e) {
@@ -192,19 +327,45 @@ class ProductsBuilderService {
         }
         return this.product;
     }
-    async createSession(data) {
+    async createSession(data, throwErrorIfExists = false) {
         try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchSession(data.tag)) {
-                await validators_1.CreateProductSessionSchema.validateAsync(data);
-                data.schema_data = (await this.inputsService.parseJson({
+            await validators_1.CreateProductSessionSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const exists = this.fetchSession(data.tag);
+            if (!exists) {
+                if (!data.selector.startsWith('$Session{')) {
+                    throw new Error('Selector should be in the format $Session{...}{key}');
+                }
+                const stages = (0, string_utils_1.extractStages)(data.selector);
+                let current = data.schema;
+                for (const stage of stages) {
+                    if (current && typeof current === 'object' && stage in current) {
+                        current = current[stage];
+                    }
+                    else {
+                        throw new Error(`${data.selector} not found in event sample`);
+                    }
+                }
+                if (current === null ||
+                    typeof current === "undefined" ||
+                    typeof current === "object") {
+                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
+                }
+                data.schema_data = await this.inputsService.parseJson({
                     data: data.schema,
-                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-                    category: enums_1.Categories.DATA,
-                }));
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                    expected: inputs_types_1.ExpectedValues.PARSESAMPLE
+                });
+                data.selectorValue = current;
+                const payload = Object.assign(Object.assign({}, data), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.CREATE });
+                await this.productApi.updateProduct(this.product_id, payload, this.getUserAccess());
                 await this.initializeProduct(this.product_id);
             }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Session ${data.tag} already exists`);
+            }
         }
         catch (e) {
             throw e;
@@ -212,13 +373,13 @@ class ProductsBuilderService {
     }
     async updateSession(tag, data) {
         try {
-            const auth = this.fetchSession(tag);
-            if (!auth) {
-                throw new Error(`Session ${tag} not found`);
+            const session = this.fetchSession(tag);
+            if (!session) {
+                throw new Error(`Session with tag: ${tag} not found`);
             }
             //const { _id } = auth;
             await validators_1.UpdateProductSessionSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchEnv(data.tag) && data.tag !== tag) {
+            if (data.tag && this.fetchSession(data.tag) && data.tag !== tag) {
                 throw new Error(`tag ${data.tag} is in use`); // TODO: also check on the backend
             }
             if (!data.tag) {
@@ -230,8 +391,28 @@ class ProductsBuilderService {
                     expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
                     category: enums_1.Categories.DATA,
                 }));
+                if (!data.selector) {
+                    throw new Error('Selector is expected when updating schema');
+                }
             }
-            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, auth), data)), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
+            if (data.selector) {
+                const stages = (0, string_utils_1.extractStages)(data.selector);
+                let current = data.schema;
+                for (const stage of stages) {
+                    if (current && typeof current === 'object' && stage in current) {
+                        current = current[stage];
+                    }
+                    else {
+                        throw new Error(`${data.selector} not found in event sample`);
+                    }
+                }
+                if (current === null ||
+                    typeof current === "undefined" ||
+                    typeof current === "object") {
+                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
+                }
+            }
+            await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, Object.assign(Object.assign({}, session), data)), { component: enums_1.ProductComponents.SESSION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
             await this.initializeProduct(this.product_id);
         }
         catch (e) {
@@ -862,11 +1043,43 @@ class ProductsBuilderService {
         return messageBroker;
     }
     fetchMessageBrokers() {
-        console.log("PROD!", this.product);
         return this.product.messageBrokers.map((broker) => {
             return this.fetchMessageBroker(broker.tag);
         });
     }
+    async fetchStorageFiles(filter) {
+        try {
+            const result = await this.productApi.fetchProductStorageFiles(Object.assign(Object.assign({}, filter), { product: this.product.tag }), this.getUserAccess());
+            if (!result)
+                return [];
+            return result.map((res) => {
+                delete res._id;
+                delete res.workspace_id;
+                delete res.__v;
+                res.url = (0, processor_utils_1.decrypt)(res.url, this.product.private_key);
+                return res;
+            });
+        }
+        catch (e) {
+            throw (e);
+        }
+    }
+    async fetchSessionUsers(filter) {
+        try {
+            const result = await this.productApi.fetchProductSessionUsers(Object.assign(Object.assign({}, filter), { product: this.product.tag }), this.getUserAccess());
+            if (!result)
+                return [];
+            return result.map((res) => {
+                delete res._id;
+                delete res.workspace_id;
+                delete res.__v;
+                return res;
+            });
+        }
+        catch (e) {
+            throw (e);
+        }
+    }
     async createStorage(data, throwErrorIfExists = false) {
         if (!this.fetchStorage(data.tag, false)) {
             await create_productStorage_validator_1.CreateProductStorageSchema.validateAsync(data);
@@ -999,6 +1212,9 @@ class ProductsBuilderService {
         }
     }
     validateVariablesValues(variables, appVariables) {
+        if (!variables) {
+            variables = [];
+        }
         if (appVariables && appVariables.length) {
             appVariables.map((data) => {
                 const find = variables.find((value) => value.key === data.key);
@@ -1141,7 +1357,10 @@ class ProductsBuilderService {
                     throw new Error(`App ${app.access_tag} not found`);
                 }
                 const cleanedAppData = await this.validateAppData(appData, app);
-                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, cleanedAppData), { component: enums_1.ProductComponents.APP, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
+                if (!cleanedAppData.pricing_tag) {
+                    cleanedAppData.pricing_tag = `${appData.tag}:${productsBuilder_types_1.PricingTag.FREE}`;
+                }
+                await this.productApi.updateProduct(this.product_id, Object.assign(Object.assign({}, cleanedAppData), { app_tag: appData.tag, component: enums_1.ProductComponents.APP, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
                 await this.initializeProduct(this.product_id);
             }
             else {
@@ -1160,7 +1379,7 @@ class ProductsBuilderService {
                 throw new Error(`App with access tag ${access_tag} not found`);
             }
             const version = app.versions.find((version) => version.tag === app.version);
-            const status = await this.webhooksApi.fetchWebhooks({ access_tag, app_tag: app.tag, version: app.version }, this.getUserAccess());
+            //const status = await this.webhooksApi.fetchWebhooks({access_tag, app_tag: app.tag, version: app.version}, this.getUserAccess())
             console.log(status);
             if (!version) {
                 throw new Error(`Required app version not found`);
@@ -1199,7 +1418,7 @@ class ProductsBuilderService {
         return this.product.apps;
     }
     fetchApp(tag, throwErrorIfExists = false) {
-        const app = this.product.apps.find((data) => data.access_tag === tag);
+        const app = this.product.apps.find((data) => data.app_tag === tag || data.access_tag === tag);
         if (!app && throwErrorIfExists)
             throw new Error(`App ${tag} not found`);
         return app;
@@ -1940,7 +2159,7 @@ class ProductsBuilderService {
         });
     }
     async validateActionInputData(data, skipSample = false, option = false, optionIndex = 0) {
-        var _a;
+        var _a, _b;
         const { obj } = data, base_data = __rest(data, ["obj"]);
         if (!data.sample && Object.keys(obj).length === 0) {
             return;
@@ -1948,8 +2167,8 @@ class ProductsBuilderService {
         if (!data.sample) {
             throw new Error('Something unexpected happened in validating action input');
         }
-        const sequence = data.feature.sequence[data.sequence_index];
-        if (obj === undefined || obj === null) {
+        const sequence = data.feature.sequence ? (_a = data.feature) === null || _a === void 0 ? void 0 : _a.sequence[data.sequence_index] : null;
+        if ((obj === undefined || obj === null) && sequence) {
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should not be ${obj}`);
             }
@@ -1957,7 +2176,7 @@ class ProductsBuilderService {
                 throw new Error(`option event index ${optionIndex}, ${data.type} should not be ${obj}`);
             }
         }
-        if (Object.values(obj).length > 0 && ((_a = data.sample.data) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+        if (sequence && (Object.values(obj).length > 0 && ((_b = data.sample.data) === null || _b === void 0 ? void 0 : _b.length) === 0)) {
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should be an empty object`);
             }
@@ -1968,7 +2187,7 @@ class ProductsBuilderService {
         if (Object.values(obj).length === 0 && data.sample.data.length === 0 /*data.sample?.data?.length === 0*/) {
             return;
         }
-        if (Object.values(obj).length === 0 && data.sample.data.length > 0 && !skipSample) {
+        if (sequence && Object.values(obj).length === 0 && data.sample.data.length > 0 && !skipSample) {
             //console.log("validity err: ",obj, data.sample)
             if (!option) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[data.event_index].event} ${data.type} should not be an empty object`);
@@ -2144,7 +2363,9 @@ class ProductsBuilderService {
             let current_input = input;
             for (let i = 0; i < stages.length; i++) {
                 let stage = stages[i];
-                const matches = stage.match(/^\[(\d+)\]$/);
+                // Convert to string for .match() call
+                const stageStr = String(stage);
+                const matches = stageStr.match(/^\[(\d+)\]$/);
                 if (matches && matches.length === 2) {
                     const number = parseInt(matches[1], 10);
                     if (!isNaN(number)) {
@@ -2207,7 +2428,9 @@ class ProductsBuilderService {
                         throw new Error(`Auth ${stages[0]} does not exist on env ${env.product_env_slug} on app ${access_tag}`);
                     }
                     const decrypted = JSON.parse((0, processor_utils_1.decrypt)(env.auth.values, this.fetchProduct().private_key));
-                    const check = (0, objects_utils_1.findFaultyKeys)(stages.slice(1), decrypted);
+                    // Convert stages to string[] for findFaultyKeys
+                    const stringStages = stages.slice(1).map(stage => String(stage));
+                    const check = (0, objects_utils_1.findFaultyKeys)(stringStages, decrypted);
                     if (check.faultyKeys) {
                         throw new Error(`Auth Key(s) ${check.faultyKeys.join(', ')} is/are invalid, they do not exist in authorization for ${env.product_env_slug} on app ${access_tag}`);
                     }
@@ -2223,7 +2446,9 @@ class ProductsBuilderService {
                 let i = 1;
                 while (i < stages.length) {
                     let stage = stages[i];
-                    const matches = stage.match(/^\[(\d+)\]$/);
+                    // Convert to string for .match() call
+                    const stageStr = String(stage);
+                    const matches = stageStr.match(/^\[(\d+)\]$/);
                     if (matches && matches.length === 2) {
                         const number = parseInt(matches[1], 10);
                         if (!isNaN(number)) {
@@ -2297,11 +2522,15 @@ class ProductsBuilderService {
                 // let current_data;
                 if (i === 0) {
                     // find sequence by tag, see if it exists and its before current sequence
-                    this.validateSequenceInputParents(stage, meta.sequence_index, meta.feature.sequence);
-                    sequence = this.fetchPriorSequence(meta, stage);
+                    // Convert stage to string for function calls
+                    const stageStr = String(stage);
+                    this.validateSequenceInputParents(stageStr, meta.sequence_index, meta.feature.sequence);
+                    sequence = this.fetchPriorSequence(meta, stageStr);
                 }
                 if (i === 1 && sequence) {
-                    event = this.fetchSequenceEvent(sequence, stage);
+                    // Convert stage to string for function calls
+                    const stageStr = String(stage);
+                    event = this.fetchSequenceEvent(sequence, stageStr);
                     if (!event) {
                         throw new Error(`event ${stage} not found in sequence ${sequence.tag}`);
                     }
@@ -2330,7 +2559,9 @@ class ProductsBuilderService {
                 if (i > 1 && response) {
                     let parent_index = 0;
                     let increment = false;
-                    const matches = stage.match(/^\[(\d+)\]$/);
+                    // Convert to string for .match() call
+                    const stageStr = String(stage);
+                    const matches = stageStr.match(/^\[(\d+)\]$/);
                     if (matches && matches.length === 2) {
                         const number = parseInt(matches[1], 10);
                         if (!isNaN(number)) {
@@ -2388,7 +2619,7 @@ class ProductsBuilderService {
             if (stages.length > 2) {
                 throw new Error(`sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}, only two keys is required`);
             }
-            const app = this.fetchApp(stages[0]);
+            const app = this.fetchApp(String(stages[0]));
             if (!app) {
                 throw new Error(`App ${stages[0]} not found in sequence ${sequence.tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}. `);
             }
@@ -2405,8 +2636,8 @@ class ProductsBuilderService {
             if (stages.length !== 2) {
                 throw new Error(`When using constants you need to specify the constant in the format $Constant{app_tag}{key} instead of ${value}`);
             }
-            const app_tag = stages[0];
-            const key = stages[1];
+            const app_tag = String(stages[0]);
+            const key = String(stages[1]);
             const _c = await this.fetchThirdPartyAppByAccessTag(app_tag), { version } = _c, app = __rest(_c, ["version"]);
             if (!app) {
                 throw new Error(`App ${app_tag} not found in constant ${value}`);
@@ -2496,9 +2727,10 @@ class ProductsBuilderService {
         return found;
     }
     validateActionKeyPlacement(data) {
+        var _a;
         const actionData = data.sample.data;
         const { indexes } = data;
-        const sequence = data.feature.sequence[data.sequence_index];
+        const sequence = data.feature.sequence ? (_a = data.feature) === null || _a === void 0 ? void 0 : _a.sequence[data.sequence_index] : null;
         const datapoint = actionData.find((item) => {
             return (item.parent_key === indexes.parent_key && item.key === data.key && item.level === indexes.level //&&
             //indexes.index === item.index
@@ -2506,7 +2738,12 @@ class ProductsBuilderService {
         });
         if (!datapoint) {
             console.log('VALIDATE', data.key, data.value, actionData, indexes);
-            throw new Error(`Key ${data.key} not found for ${data.type} for sequence ${sequence.tag} event ${sequence.events[data.event_index].event}`);
+            if (sequence) {
+                throw new Error(`Key ${data.key} not found for ${data.type} for sequence ${sequence.tag} event ${sequence.events[data.event_index].event}`);
+            }
+            else {
+                throw new Error(`Key ${data.key} not found`);
+            }
         }
         return datapoint;
     }
@@ -2674,11 +2911,13 @@ class ProductsBuilderService {
     }
     fetchDatabase(tag, throwErrorIfExists = false) {
         const database = this.product.databases.find((data) => data.tag === tag);
-        database.envs.map((env) => {
-            env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.fetchProduct().private_key);
-        });
         if (!database && throwErrorIfExists)
             throw new Error(`Database ${tag} not found`);
+        if (database && database.envs.length > 0) {
+            database.envs.map((env) => {
+                env.connection_url = (0, processor_utils_1.decrypt)(env.connection_url, this.fetchProduct().private_key);
+            });
+        }
         return database;
     }
     fetchDatabases() {
@@ -2980,6 +3219,9 @@ class ProductsBuilderService {
             public_key: this.public_key,
         };
     }
+    async fetchSessionUser(ductape_user_id) {
+        return await this.productApi.fetchProductSessionUser(ductape_user_id, this.getUserAccess());
+    }
 }
 exports.default = ProductsBuilderService;
 //# sourceMappingURL=products.service.js.map