@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/integrationsBuilder/services/integration.service.js

@@ -1,1148 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const appApi_service_1 = require("../../api/services/appApi.service");
-const productsApi_service_1 = require("../../api/services/productsApi.service");
-const userApi_service_1 = require("../../api/services/userApi.service");
-const inputs_service_1 = require("../../inputs/inputs.service");
-const inputs_utils_create_1 = require("../../inputs/utils/inputs.utils.create");
-const enums_1 = require("../../types/enums");
-const productsBuilder_types_1 = require("../../types/productsBuilder.types");
-const validators_1 = require("../validators");
-const objects_utils_1 = require("../utils/objects.utils");
-const inputs_types_1 = require("../../types/inputs.types");
-const string_utils_1 = require("../utils/string.utils");
-const workspaceApi_service_1 = require("../../api/services/workspaceApi.service");
-const string_utils_2 = require("../../appBuilder/utils/string.utils");
-class IntegrationsBuilderService {
-    constructor({ workspace_id, public_key, user_id, token }) {
-        this.workspace_id = workspace_id;
-        this.public_key = public_key;
-        this.user_id = user_id;
-        this.token = token;
-        this.userApi = new userApi_service_1.UserApiService();
-        this.integrationApi = new productsApi_service_1.IntegrationsApiService();
-        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService();
-        this.appApi = new appApi_service_1.AppApiService();
-        this.inputsService = new inputs_service_1.default();
-        this.thirdPartyApps = [];
-    }
-    async createIntegration(data) {
-        try {
-            await validators_1.CreateIntegrationBuilderSchema.validateAsync(data);
-            const exists = await this.checkIfIntegrationExists(data.name);
-            if (exists && (exists === null || exists === void 0 ? void 0 : exists._id)) {
-                await this.initializeIntegration(exists === null || exists === void 0 ? void 0 : exists._id);
-            }
-            else {
-                const integration = await this.createNewIntegration(data);
-                await this.initializeIntegration(integration._id);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async initializeWorkspace() {
-        if (!this.workspace) {
-            this.workspace = await this.workspaceApi.fetchWorkspaceById(this.getUserAccess());
-        }
-    }
-    async initializeIntegration(integration_id) {
-        try {
-            this.integration = await this.integrationApi.fetchIntegration(integration_id, this.getUserAccess());
-            this.integration_id = integration_id;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateIntegration(data) {
-        try {
-            if (!this.app_id)
-                throw new Error('Integration not initialized');
-            await validators_1.CreateIntegrationBuilderSchema.validateAsync(data);
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign({}, data), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async createNewIntegration(data) {
-        return this.integrationApi.createIntegration(Object.assign({}, data), this.getUserAccess());
-    }
-    async checkIfIntegrationExists(name) {
-        try {
-            return await this.integrationApi.checkIntegrationNameExists(name, this.getUserAccess());
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    fetchIntegration() {
-        if (!this.integration) {
-            throw new Error('Integration not yet initiated');
-        }
-        return this.integration;
-    }
-    async createEnv(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchEnv(data.slug)) {
-                await validators_1.CreateIntegrationEnvSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.ENV, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Environment ${data.slug} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateEnv(slug, data) {
-        try {
-            const { _id } = this.fetchEnv(slug, true);
-            await validators_1.UpdateIntegrationEnvSchema.validateAsync(data); // Change to update;
-            if (data.slug && this.fetchEnv(data.slug)) {
-                throw new Error(`slug ${slug} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.ENV, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchEnvs() {
-        return this.integration.envs;
-    }
-    fetchEnv(slug, throwErrorIfExists = false) {
-        const env = this.integration.envs.find((data) => data.slug === slug);
-        if (!env && throwErrorIfExists)
-            throw new Error(`Env ${slug} not found`);
-        return env;
-    }
-    async validateAppData(appData, app) {
-        // TODO:
-        const { envs } = app;
-        // const { envs: appEnvs, auths: appAuths } = appData
-        await this.validateAppEnvs(envs, appData);
-        // await this.validateAppAuth(auth, appData);
-    }
-    validateVariablesSchema(variables, appVariables) {
-        if (variables && variables.length) {
-            variables.map((data) => {
-                const appVar = appVariables.find((value) => value.key === data.key);
-                if (!appVar) {
-                    throw new Error(`variable key: ${data.key} not found`);
-                }
-                // if()
-            });
-        }
-    }
-    validateVariablesValues(variables, appVariables) {
-        if (appVariables && appVariables.length) {
-            appVariables.map((data) => {
-                const find = variables.find((value) => value.key === data.key);
-                if (data.required) {
-                    if (!find) {
-                        throw new Error(`variable key: ${data.key} is required`);
-                    }
-                }
-                if (find && data.type === enums_1.DataTypes.STRING) {
-                    this.inputsService.validateLength(data, find);
-                }
-                if (find && data.type === enums_1.DataTypes.BOOLEAN) {
-                    this.inputsService.validateBoolean(find);
-                }
-                if (find && data.type === enums_1.DataTypes.NUMBER_STRING) {
-                    this.inputsService.validateNumberString(data, find);
-                }
-                if (find && data.type === enums_1.DataTypes.UUID) {
-                    this.inputsService.validateUUID(find);
-                }
-            });
-        }
-    }
-    async validateAppEnvs(envs, app) {
-        const { envs: appEnvs } = app;
-        envs.map(async (env) => {
-            const { auth } = env;
-            this.fetchEnv(env.integration_env_slug, true);
-            const appEnv = appEnvs.find((appEnv) => appEnv.slug === env.app_env_slug);
-            if (!appEnv) {
-                throw new Error(`app_env_slug ${env.app_env_slug} not found`);
-            }
-            await this.validateAppAuth(auth, app);
-            this.validateVariablesSchema(env.variables, app.variables);
-            this.validateVariablesValues(env.variables, app.variables);
-        });
-    }
-    async validateAppAuth(auth, app) {
-        const { auths: appAuth, actions } = app;
-        const exists = appAuth.find((appAuth) => appAuth.tag === auth.auth_tag);
-        if (!exists) {
-            throw new Error(`app_auth ${auth.auth_tag} not found`);
-        }
-        const { data } = auth;
-        let bodySchema;
-        let headerSchema;
-        let paramsSchema;
-        let querySchema;
-        if (exists.action_tag) {
-            const action = actions.find((action) => action.tag === exists.action_tag);
-            if (!action)
-                throw new Error(`Auth action tag ${exists.action_tag} not found`);
-            bodySchema = action.body;
-            headerSchema = action.headers;
-            paramsSchema = action.params;
-            querySchema = action.query;
-            const { body, headers, params, query } = data;
-            if (!body)
-                throw new Error(`Auth body not allowed to be undefined. If empty set as {}`);
-            if (!headers)
-                throw new Error(`Auth headers not allowed to be undefined. If empty set as {}`);
-            if (!params)
-                throw new Error(`Auth params not allowed to be undefined. If empty set as {}`);
-            if (!query)
-                throw new Error(`Auth query not allowed to be undefined. If empty set as {}`);
-            if (bodySchema && bodySchema.data) {
-                const bodyValues = (await this.inputsService.parseData({
-                    data: body,
-                    category: enums_1.Categories.SETUP,
-                    expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-                    type: enums_1.InputsTypes.JSON,
-                }));
-                (0, inputs_utils_create_1.validateInputSchema)(bodyValues, bodySchema);
-            }
-            if (headerSchema && headerSchema.data) {
-                const headerValues = (await this.inputsService.parseData({
-                    data: headers,
-                    category: enums_1.Categories.SETUP,
-                    expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-                    type: enums_1.InputsTypes.JSON,
-                }));
-                (0, inputs_utils_create_1.validateInputSchema)(headerValues, headerSchema);
-            }
-            if (paramsSchema && paramsSchema.data) {
-                const paramsValues = (await this.inputsService.parseData({
-                    data: params,
-                    category: enums_1.Categories.SETUP,
-                    expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-                    type: enums_1.InputsTypes.JSON,
-                }));
-                (0, inputs_utils_create_1.validateInputSchema)(paramsValues, paramsSchema);
-            }
-            if (querySchema && querySchema.data) {
-                const queryValues = (await this.inputsService.parseData({
-                    data: query,
-                    category: enums_1.Categories.SETUP,
-                    expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-                    type: enums_1.InputsTypes.JSON,
-                }));
-                (0, inputs_utils_create_1.validateInputSchema)(queryValues, querySchema);
-            }
-        }
-    }
-    async createAppAccessTag(app_tag) {
-        await this.initializeWorkspace();
-        const { name: workspace_name } = this.workspace;
-        const app = await this.appApi.fetchAppByTag(app_tag, this.getUserAccess());
-        if (!app) {
-            throw new Error(`App ${app_tag} not found`);
-        }
-        const { _id: app_id } = app;
-        const access_tag = `${app_tag}:${(0, string_utils_2.tagify)(workspace_name)}`;
-        const { access } = await this.appApi.createAppAccess(app_id, this.integration_id, access_tag, this.getUserAccess());
-        return {
-            access_tag,
-            access,
-        };
-    }
-    async addApp(app, throwErrorIfExists = false) {
-        try {
-            await validators_1.CreateIntegrationAppSchema.validateAsync(app);
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchApp(app.access_tag, throwErrorIfExists)) {
-                // console.log("ZOOMER =====>", app);
-                const access = await this.appApi.fetchAccessByTag(app.access_tag, this.getUserAccess());
-                if (!access) {
-                    throw new Error(`Access to app ${app.access_tag} not found`);
-                }
-                const appData = await this.appApi.fetchApp(access.app_id, this.getUserAccess());
-                if (!appData) {
-                    throw new Error(`App ${app.access_tag} not found`);
-                }
-                await this.validateAppData(appData, app);
-                // console.log("UPDATE INTEGRATION HERE ====>>>>>", app);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, app), { component: enums_1.IntegrationComponents.APP, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`App ${app.access_tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateApp(access_tag, data) {
-        try {
-            const { _id } = this.fetchApp(access_tag);
-            //await UpdateIntegrationAppSchema.validateAsync(data); // Change to update;
-            if (data.access_tag && data.access_tag !== access_tag) {
-                throw new Error(`access_tag mismatch between ${access_tag} and ${data.access_tag}`);
-            }
-            if (!this.fetchApp(access_tag)) {
-                throw new Error(`access_tag ${access_tag} not found`); // TODO: also check on the backend
-            }
-            /*if (data.access_tag && this.fetchApp(data.access_tag)) {
-                      throw new Error(`access_tag ${access_tag} is in use`); // TODO: also check on the backend
-                  }*/
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { access_tag, component: enums_1.IntegrationComponents.APP, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchApps() {
-        return this.integration.apps;
-    }
-    fetchApp(tag, throwErrorIfExists = false) {
-        const app = this.integration.apps.find((data) => data.access_tag === tag);
-        if (!app && throwErrorIfExists)
-            throw new Error(`App ${tag} not found`);
-        return app;
-    }
-    async createFunction(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchFunction(data.tag)) {
-                await validators_1.CreateIntegrationFunctionSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.FUNCTION }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Function ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateFunction(tag, data) {
-        try {
-            const { _id } = this.fetchFunction(tag);
-            await validators_1.UpdateIntegrationFunctionSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchFunction(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.FUNCTION }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchFunctions() {
-        return this.integration.functions;
-    }
-    fetchFunction(tag) {
-        const func = this.integration.functions.find((data) => data.tag === tag);
-        if (!func)
-            throw new Error(`Function ${tag} not found`);
-        return func;
-    }
-    async createCache(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchCache(data.tag)) {
-                await validators_1.CreateIntegrationCacheSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.CACHE }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Cache ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateCache(tag, data) {
-        try {
-            const { _id } = this.fetchCache(tag);
-            await validators_1.UpdateIntegrationCacheSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchCache(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.CACHE }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchCache(tag) {
-        const cache = this.integration.caches.find((data) => data.tag === tag);
-        if (!cache)
-            throw new Error(`Function ${tag} not found`);
-        return cache;
-    }
-    fetchCaches() {
-        return this.integration.caches;
-    }
-    async createNotification(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchNotification(data.tag)) {
-                await validators_1.CreateIntegrationNotificationSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.NOTIFICATION }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Notification ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateNotification(tag, data) {
-        try {
-            const { _id } = this.fetchNotification(tag);
-            await validators_1.UpdateIntegrationNotificationSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchNotification(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.NOTIFICATION }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchNotification(tag, notification_slug = '') {
-        const notification = this.integration.notifications.find((data) => data.tag === tag);
-        if (!notification)
-            throw new Error(`Function ${tag} not found`);
-        if (notification_slug) {
-            const { notifications, emails, webhook } = notification.envs.find((data) => (data.slug = notification_slug));
-            return { notifications, emails, webhook };
-        }
-        return notification;
-    }
-    fetchNotifications() {
-        return this.integration.notifications;
-    }
-    validateFeatureSequence(array) {
-        // Validate uniqueness of sequence_tag
-        const uniqueTags = new Set();
-        for (const item of array) {
-            if (uniqueTags.has(item.sequence_tag)) {
-                throw new Error(`Duplicate sequence_tag found: ${item.sequence_tag}`);
-            }
-            uniqueTags.add(item.sequence_tag);
-        }
-        // Validate levels are in order starting from 0
-        /*let expectedLevel = 0;
-            for (const item of array) {
-                if (item.level !== expectedLevel) {
-                    throw new Error(`Invalid level found: expected ${expectedLevel}, found ${item.level}`);
-                }
-                expectedLevel++;
-            }*/
-    }
-    validateUniqueEventTags(data) {
-        // TODO: this might not be necessary o
-        const eventTagsSet = new Set(); // TODO: this might have to be moved to line 658
-        data.sequence.forEach((sequence) => {
-            sequence.events.forEach((data) => {
-                const { event } = data;
-                if (eventTagsSet.has(event)) {
-                    throw new Error(`Duplicate event_tag found: ${event}`);
-                }
-                eventTagsSet.add(event);
-            });
-        });
-    }
-    async validateFeatureData(data) {
-        const { sequence } = data;
-        this.validateUniqueEventTags(data); // TODO: this might be unnecessary
-        this.validateFeatureSequence(sequence);
-        const promises = sequence.map((obj, sequence_index) => {
-            const { events, parents } = obj;
-            if (parents && parents.length) {
-                this.validateSequenceParents(parents, sequence_index, sequence);
-            }
-            events.map((event, event_index) => {
-                return this.validateEvent(data, sequence_index, event, event_index);
-            });
-        });
-        Promise.all(promises);
-    }
-    validateSequenceParents(parents, sequence_index, sequence) {
-        const map = new Map();
-        for (let i = 0; i < sequence_index; i++) {
-            map.set(sequence[i].sequence_tag, i);
-        }
-        for (let i = 0; i < parents.length; i++) {
-            if (map.get(parents[i]) === undefined) {
-                throw new Error(`Invalid parent ${parents[i]} in sequence ${sequence[sequence_index].sequence_tag}, parents have to be declared before their children`);
-            }
-        }
-    }
-    validateSequenceInputParents(parent, sequence_index, sequence) {
-        let found = false;
-        const parents = sequence[sequence_index].parents;
-        if (!parents || parents.length === 0)
-            throw new Error(`Parents array cannot be empty or null when there is a $Sequence value in sequence ${sequence[sequence_index].sequence_tag}`);
-        for (let i = 0; i < sequence_index; i++) {
-            if (sequence[i].sequence_tag === parent)
-                found = true;
-        }
-        if (!found)
-            throw new Error(`Parents array needs to contain parent sequence ${parent} in ${sequence[sequence_index].sequence_tag}`);
-    }
-    async validateEvent(data, sequence_index, event, event_index) {
-        const app = this.fetchApp(event.app, true);
-        const { access_tag } = app;
-        // validate action_tag
-        const { actions } = await this.fetchThirdPartyAppByAccessTag(access_tag);
-        if (event.type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
-            const action = this.fetchThirdPartyAppActionByTag(actions, event.event);
-            await this.validateActionDataInput(data, action, event.input, event_index, sequence_index);
-            // validate input
-        }
-    }
-    async validateActionDataInput(data, action, event_input, event_index, sequence_index) {
-        const { params, query, headers, body } = event_input;
-        const { params: actionParams, query: actionQuery, headers: actionHeaders, body: actionBody } = action;
-        const indexes = {
-            parent_key: '',
-            level: 0,
-            key: '',
-            index: 0,
-        };
-        await this.validateActionInputData({
-            obj: params,
-            sample: actionParams,
-            event_index,
-            sequence_index,
-            feature: data,
-            type: enums_1.Categories.PARAMS,
-            indexes,
-        });
-        await this.validateActionInputData({
-            obj: query,
-            sample: actionQuery,
-            event_index,
-            sequence_index,
-            feature: data,
-            type: enums_1.Categories.QUERY,
-            indexes,
-        });
-        await this.validateActionInputData({
-            obj: headers,
-            sample: actionHeaders,
-            event_index,
-            sequence_index,
-            feature: data,
-            type: enums_1.Categories.HEADER,
-            indexes,
-        });
-        await this.validateActionInputData({
-            obj: body,
-            sample: actionBody,
-            event_index,
-            sequence_index,
-            feature: data,
-            type: enums_1.Categories.BODY,
-            indexes,
-        });
-    }
-    async validateActionInputData(data) {
-        const { obj } = data, base_data = __rest(data, ["obj"]);
-        const sequence = data.feature.sequence[data.sequence_index];
-        if (obj === undefined || obj === null) {
-            throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[data.event_index].event} ${data.type} should not be ${obj}`);
-        }
-        if (Object.values(obj).length > 0 && data.sample.data.length === 0) {
-            throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[data.event_index].event} ${data.type} should be an empty object`);
-        }
-        if (Object.values(obj).length === 0 && data.sample.data.length === 0) {
-            return;
-        }
-        if (Object.values(obj).length === 0 && data.sample.data.length > 0) {
-            throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[data.event_index].event} ${data.type} should not be an empty object`);
-        }
-        let index = 0;
-        for (const key in obj) {
-            if (typeof obj[key] === 'object') {
-                // Check if the object has keys "function" and "values"
-                if ('function' in obj[key] && 'values' in obj[key]) {
-                    // Special handling for objects with keys "function" and "values"
-                    await this.parseActionEventInput(Object.assign({ key, value: obj[key] }, base_data));
-                }
-                else {
-                    // Normal recursive call for nested objects
-                    await this.validateActionInputData(Object.assign(Object.assign({}, base_data), { obj: obj[key], indexes: {
-                            key,
-                            index,
-                            parent_key: data.indexes.key,
-                            level: data.indexes.level++,
-                        } }));
-                }
-            }
-            else if (Array.isArray(obj[key])) {
-                // If it's an array, iterate through each element
-                Object.keys(obj[key]).forEach(async (elementKey) => {
-                    const element = obj[key][elementKey];
-                    if (typeof element === 'object') {
-                        // Check if the object within array has keys "function" and "values"
-                        if ('function' in element && 'values' in element) {
-                            // Special handling for objects within array with keys "function" and "values"
-                            await this.parseActionEventInput(Object.assign({ key: elementKey, value: element }, base_data));
-                        }
-                        else {
-                            // Normal recursive call for nested objects within arrays
-                            await this.validateActionInputData(Object.assign(Object.assign({}, base_data), { obj: element, indexes: {
-                                    key: elementKey,
-                                    index,
-                                    parent_key: data.indexes.key,
-                                    level: data.indexes.level++,
-                                } }));
-                        }
-                    }
-                    else {
-                        await this.parseActionEventInput(Object.assign({ key: elementKey, value: element }, base_data));
-                    }
-                });
-            }
-            else {
-                await this.parseActionEventInput(Object.assign({ key, value: obj[key] }, base_data));
-            }
-            index++;
-        }
-    }
-    async parseActionEventInput(data) {
-        const datapoint = this.validateActionKeyPlacement(data);
-        let stages, input;
-        if (typeof data.value === 'object') {
-            // TOPICAL PARSER
-            const { function: func, values } = data.value;
-            this.fetchFunction(func);
-            for (let i = 0; i < values.length; i++) {
-                stages = this.extractStages(values[i]);
-                input = data.feature.input;
-                this.parseInputString({ datapoint, value: values[i], input, stages }, {
-                    feature: data.feature,
-                    sequence_index: data.sequence_index,
-                    event_index: data.event_index,
-                    type: data.type,
-                });
-            }
-        }
-        else if (typeof data.value === 'string') {
-            stages = this.extractStages(data.value);
-            input = data.feature.input;
-            this.parseInputString({ datapoint, value: data.value, input, stages }, {
-                feature: data.feature,
-                sequence_index: data.sequence_index,
-                event_index: data.event_index,
-                type: data.type,
-            });
-        }
-    }
-    async parseInputString(payload, meta) {
-        const { datapoint, value, input, stages } = payload;
-        const sequence = meta.feature.sequence[meta.sequence_index];
-        if (value.startsWith('$Input{')) {
-            let current_input = input;
-            for (let i = 0; i < stages.length; i++) {
-                let stage = stages[i];
-                const matches = stage.match(/^\[(\d+)\]$/);
-                if (matches && matches.length === 2) {
-                    const number = parseInt(matches[1], 10);
-                    if (!isNaN(number)) {
-                        stage = number;
-                    }
-                    else {
-                        throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
-                    }
-                }
-                if (!current_input[stage])
-                    throw new Error(`Input key ${stage} in ${value} does not exist`);
-                current_input = current_input[stage];
-            }
-            if ((0, objects_utils_1.deepEqual)(current_input, input)) {
-                throw new Error(`Error 490101: something unexpected happened`);
-            }
-            this.compareInputWithExpectedInput(datapoint, current_input, value);
-        }
-        else if (value.startsWith('$Auth{')) {
-            // TODO: make sure that all auths have the same responses
-            // TODO: make sure apps have only one auth, for now
-            const { app: access_tag } = meta.feature.sequence[meta.sequence_index].events[meta.event_index];
-            const { actions, auths } = await this.fetchThirdPartyAppByAccessTag(access_tag);
-            const auth_tag = stages[0];
-            let auth;
-            for (let i = 0; i < auths.length; i++) {
-                if (auths[i].tag === auth_tag) {
-                    auth = auths[i];
-                }
-            }
-            if (!auth) {
-                throw new Error(`Auth in ${value} not found in app ${access_tag}`);
-            }
-            /*const { envs } = this.fetchApp(access_tag, false);
-      
-                  for(let i=0; i< envs.length; i++) {
-                      if (envs[i].auth.auth_tag ) {
-                          throw new Error(`Auth ${auth_tag} not in use in integration environment ${envs[i].integration_env_slug}, please be uniform in environment auth definition`)
-                      }
-                  }*/
-            const action = actions.find((item) => {
-                return item.tag === auth.action_tag;
-            });
-            if (!action) {
-                throw new Error(`Could not find auth action ${auth.action_tag}`);
-            }
-            const response = action.responses.find((item) => item.success === true);
-            if (response) {
-                let parent_index = 0;
-                let increment = false;
-                let level = 0;
-                let parent_key = '';
-                let i = 1;
-                while (i < stages.length) {
-                    let stage = stages[i];
-                    const matches = stage.match(/^\[(\d+)\]$/);
-                    if (matches && matches.length === 2) {
-                        const number = parseInt(matches[1], 10);
-                        if (!isNaN(number)) {
-                            stage = number;
-                            parent_index = number; // TODO: check whether this handles the array issue
-                            i++; // move to next stage instantly
-                            increment = true;
-                        }
-                        else {
-                            throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
-                        }
-                    }
-                    const found = response.body.data.find((item) => {
-                        if (!increment) {
-                            return item.parent_key === parent_key && item.key === stage && level === item.level;
-                        }
-                        else {
-                            return (item.parent_key === parent_key &&
-                                parent_index === stage &&
-                                stages[i] === item.key &&
-                                level === item.level);
-                        }
-                    });
-                    if (!found) {
-                        throw new Error(`Cannot find key: ${stage} in  ${value}`);
-                    }
-                    level++;
-                    parent_key = String(stages[i]);
-                    if (i === stages.length - 1) {
-                        this.compareInputWithExpectedInput(datapoint, found, value);
-                    }
-                    i++;
-                }
-            }
-            else {
-                throw new Error(`There is no successful response sample for Action ${auth.action_tag} in app ${access_tag}`);
-            }
-        }
-        else if (value.startsWith('$Sequence{')) {
-            //let current_input = input as unknown as Record<string, unknown>;
-            //const { feature, sequence_index, event_index} = meta;
-            let parent_key = '';
-            let level = 0;
-            let i = 0;
-            while (i < stages.length) {
-                let stage = stages[i];
-                let sequence;
-                let event;
-                let response;
-                // 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);
-                }
-                if (i === 1 && sequence) {
-                    event = this.fetchSequenceEvent(sequence, stage);
-                    if (!event) {
-                        throw new Error(`event ${stage} not found in sequence ${sequence.sequence_tag}`);
-                    }
-                    let { type, app: access_tag, event: event_tag } = event;
-                    if (type === productsBuilder_types_1.FeatureEventTypes.ACTION) {
-                        const { actions } = await this.fetchThirdPartyAppByAccessTag(access_tag);
-                        const { responses } = this.fetchThirdPartyAppActionByTag(actions, event_tag);
-                        response = responses.find((item) => item.success === true);
-                        // fetch success result
-                        if (!response) {
-                            throw new Error(`event ${stage} does not have a success response`);
-                        }
-                    }
-                    //TODO: handle other types
-                }
-                if (i > 1 && response) {
-                    let parent_index = 0;
-                    let increment = false;
-                    const matches = stage.match(/^\[(\d+)\]$/);
-                    if (matches && matches.length === 2) {
-                        const number = parseInt(matches[1], 10);
-                        if (!isNaN(number)) {
-                            stage = number;
-                            parent_index = number; // TODO: check whether this handles the array issue
-                            i++; // move to next stage instantly
-                            increment = true;
-                        }
-                        else {
-                            throw new Error(`Invalid array value ${matches[1]}, should be an integer value`);
-                        }
-                    }
-                    const found = response.body.data.find((item) => {
-                        if (!increment) {
-                            return item.parent_key === parent_key && item.key === stage && level === item.level;
-                        }
-                        else {
-                            return (item.parent_key === parent_key &&
-                                parent_index === stage &&
-                                stages[i] === item.key &&
-                                level === item.level);
-                        }
-                    });
-                    if (!found) {
-                        throw new Error(`Cannot find key: ${stage} in  ${value}`);
-                    }
-                    level++;
-                    parent_key = String(stages[i]);
-                    if (i === stages.length - 1) {
-                        this.compareInputWithExpectedInput(datapoint, found, value);
-                    }
-                }
-                i++;
-            }
-        }
-        else if (value === '$Default') {
-            if (!datapoint.defaultValue) {
-                throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[meta.event_index].event} ${meta.type}, the key {${datapoint.key}: ${value}} does not have a default`);
-            }
-        }
-        else if (value.startsWith('$Variable{')) {
-            // $Variable{APP_NAME}$
-            const stages = this.extractStages(value);
-            if (stages.length < 2) {
-                throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}, you have to define what variable is to be used`);
-            }
-            if (stages.length > 2) {
-                throw new Error(`sequence ${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]);
-            if (!app) {
-                throw new Error(`App ${stages[0]} not found in sequence ${sequence.sequence_tag} event ${sequence.events[meta.event_index].event} ${meta.type}, has invalid varibale definition ${value}. `);
-            }
-            if (!app.envs[0]) {
-                throw new Error(`App ${stages[0]} has not environments defined`);
-            }
-            const { variables } = app.envs[0];
-            if (!variables.find((item) => item.key === stages[1])) {
-                throw new Error(`Variable ${stages[1]} does not exist in app ${stages[0]} in value ${value} in sequence ${sequence.sequence_tag} event ${sequence.events[meta.event_index].event} ${meta.type}`);
-            }
-        }
-        else if (value.startsWith('$Constant{')) {
-            const stages = this.extractStages(value);
-            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 = await this.fetchThirdPartyAppByAccessTag(app_tag);
-            if (!app) {
-                throw new Error(`App ${app_tag} not found in constant ${value}`);
-            }
-            const { constants } = app;
-            const exists = constants.find((item) => item.key === key);
-            if (!exists) {
-                throw new Error(`Constant with key ${key} in ${value}, does not exist on app ${app}`);
-            }
-        }
-        else {
-            throw new Error(`sequence ${sequence.sequence_tag} event ${sequence.events[meta.event_index].event} ${meta.type} has invalid : {${datapoint.key}: ${value}}`);
-        }
-    }
-    compareInputWithExpectedInput(datapoint, found_input, value) {
-        if (datapoint.maxLength != 0 && (!found_input.maxLength || found_input.maxLength > datapoint.maxLength)) {
-            throw new Error(`maxlength of ${value} cannot be greater than ${datapoint.maxLength}`);
-        }
-        if (datapoint.minLength != 0 && (!found_input.minLength || found_input.minLength < datapoint.minLength)) {
-            throw new Error(`minlength of ${value} cannot be less than ${datapoint.minLength}`);
-        }
-        if (datapoint.type !== found_input.type) {
-            throw new Error(`${value} is required to be ${datapoint.type} not ${found_input.type}`);
-        }
-    }
-    extractStages(input) {
-        return (0, string_utils_1.extractStages)(input);
-    }
-    fetchSequenceEvent(sequence, event) {
-        return sequence.events.find((item) => item.event === event);
-    }
-    fetchPriorSequence(meta, stage) {
-        let found;
-        for (let i = 0; i < meta.sequence_index; i++) {
-            if (meta.feature.sequence[i].sequence_tag === stage) {
-                found = meta.feature.sequence[i];
-            }
-        }
-        if (!found) {
-            const sequence = meta.feature.sequence[meta.sequence_index].sequence_tag;
-            throw `sequence ${stage} not found before ${sequence}, values can only inherit from sequences before them in the feature chain`;
-        }
-        return found;
-    }
-    validateActionKeyPlacement(data) {
-        const actionData = data.sample.data;
-        const { indexes } = data;
-        const sequence = data.feature.sequence[data.sequence_index];
-        const datapoint = actionData.find((item) => {
-            return (item.parent_key === indexes.parent_key &&
-                item.key === data.key &&
-                item.level === indexes.level &&
-                indexes.index === item.index);
-        });
-        if (!datapoint) {
-            console.log(indexes.parent_key + ' ' + data.key + ' ' + indexes.level + ' ' + indexes.index);
-            throw new Error(`Key ${data.key} not found for ${data.type} for sequence ${sequence.sequence_tag} event ${sequence.events[data.event_index].event}`);
-        }
-        return datapoint;
-    }
-    async fetchThirdPartyAppByAccessTag(access_tag) {
-        try {
-            const app = this.thirdPartyApps.find((item) => access_tag === item.access_tag);
-            if (app) {
-                return app.app;
-            }
-            const access = await this.appApi.fetchAccessByTag(access_tag, this.getUserAccess());
-            if (!access) {
-                throw new Error(`Access to app ${access_tag} not found`);
-            }
-            const appData = await this.appApi.fetchApp(access.app_id, this.getUserAccess());
-            this.thirdPartyApps.push({ access_tag, app: appData });
-            return appData;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchThirdPartyAppActionByTag(actions, action_tag) {
-        const action = actions.find((action) => action.tag === action_tag);
-        if (!action) {
-            throw new Error(`Action ${action_tag} not found`);
-        }
-        return action;
-    }
-    async createFeature(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchFeature(data.tag, false)) {
-                await validators_1.CreateIntegrationFeatureSchema.validateAsync(data);
-                await this.validateFeatureData(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.FEATURE }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Feature ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateFeature(tag, data) {
-        try {
-            const { _id } = this.fetchFeature(tag);
-            await validators_1.UpdateIntegrationFeatureSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchFeature(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.FEATURE }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchFeature(tag, throwErrorIfExists = true) {
-        const feature = this.integration.features.find((data) => data.tag === tag);
-        if (!feature && throwErrorIfExists)
-            throw new Error(`Feature ${tag} not found`);
-        return feature;
-    }
-    fetchFeatures() {
-        return this.integration.features;
-    }
-    async createDatabase(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchDatabase(data.tag)) {
-                await validators_1.CreateIntegrationDatabaseSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.DATABASE }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Database ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateDatabase(tag, data) {
-        try {
-            const { _id } = this.fetchDatabase(tag);
-            await validators_1.UpdateIntegrationDatabaseSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchDatabase(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.DATABASE }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchDatabase(tag) {
-        const database = this.integration.databases.find((data) => data.tag === tag);
-        if (!database)
-            throw new Error(`Function ${tag} not found`);
-        return database;
-    }
-    fetchDatabases() {
-        return this.integration.databases;
-    }
-    async createDatabaseAction(databaseTag, data, throwErrorIfExists) {
-        try {
-            if (!this.fetchDatabaseAction(databaseTag, data.tag)) {
-                await validators_1.CreateIntegrationDatabaseSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { databaseTag, component: enums_1.IntegrationComponents.DATABASE_ACTION }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Database ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async fetchDatabaseAction(databaseTag, tag) {
-        const database = this.integration.databases.find((data) => data.tag === databaseTag);
-        if (!database)
-            throw new Error(`Database ${tag} not found`);
-        const action = database.actions.find((data) => data.tag === tag);
-        if (!action)
-            throw new Error(`Database action ${tag} not found`);
-        return action;
-    }
-    async updateDatabaseAction(databaseTag, data) {
-        try {
-            const { _id } = await this.fetchDatabaseAction(databaseTag, data.tag);
-            await validators_1.UpdateIntegrationDatabaseSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchDatabaseAction(databaseTag, data.tag)) {
-                throw new Error(`tag ${databaseTag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.DATABASE_ACTION }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async fetchDatabaseActions(databaseTag) {
-        const database = this.integration.databases.find((data) => data.tag === databaseTag);
-        if (!database)
-            throw new Error(`Database ${databaseTag} not found`);
-        return database.actions;
-    }
-    async createJob(data, throwErrorIfExists = false) {
-        try {
-            // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchJob(data.tag)) {
-                await validators_1.CreateIntegrationJobSchema.validateAsync(data);
-                await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({}, data), { component: enums_1.IntegrationComponents.JOB }), this.getUserAccess());
-                await this.initializeIntegration(this.integration_id);
-            }
-            else {
-                if (throwErrorIfExists)
-                    throw new Error(`Job ${data.tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateJob(tag, data) {
-        try {
-            const { _id } = this.fetchJob(tag);
-            await validators_1.UpdateIntegrationJobSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchJob(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-            }
-            await this.integrationApi.updateIntegration(this.integration_id, Object.assign(Object.assign({ _id }, data), { component: enums_1.IntegrationComponents.JOB }), this.getUserAccess());
-            await this.initializeIntegration(this.integration_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchJob(tag) {
-        const job = this.integration.jobs.find((data) => data.tag === tag);
-        if (!job)
-            throw new Error(`Job ${tag} not found`);
-        return job;
-    }
-    fetchJobs() {
-        return this.integration.jobs;
-    }
-    runJobs() {
-        throw new Error('Method not implemented.');
-    }
-    getUserAccess() {
-        return {
-            user_id: this.user_id,
-            workspace_id: this.workspace_id,
-            token: this.token,
-            public_key: this.public_key,
-        };
-    }
-}
-exports.default = IntegrationsBuilderService;
-//# sourceMappingURL=integration.service.js.map