@ductape/sdk 0.0.4-v6 → 0.0.4-v60

package/dist/appBuilder/services/app.service.js

@@ -1,737 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validators_1 = require("../validators");
-const appApi_service_1 = require("../../api/services/appApi.service");
-const inputs_service_1 = require("../../inputs/inputs.service");
-const inputs_types_1 = require("../../types/inputs.types");
-const enums_1 = require("../../types/enums");
-const string_utils_1 = require("../utils/string.utils");
-const strings_utils_1 = require("../../api/utils/strings.utils");
-const workspaceApi_service_1 = require("../../api/services/workspaceApi.service");
-const string_utils_2 = require("../../integrationsBuilder/utils/string.utils");
-const objects_utils_1 = require("../utils/objects.utils");
-class AppBuilderService {
-    constructor({ workspace_id, public_key, user_id, token }) {
-        this.workspace_id = workspace_id;
-        this.user_id = user_id;
-        this.public_key = public_key;
-        this.token = token;
-        this.appApi = new appApi_service_1.AppApiService();
-        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService();
-        this.inputsService = new inputs_service_1.default();
-    }
-    async createApp(data) {
-        try {
-            await validators_1.CreateAppBuilderSchema.validateAsync(data);
-            const exists = await this.checkIfAppExists(data.app_name);
-            if (exists && (exists === null || exists === void 0 ? void 0 : exists._id)) {
-                this.app = exists;
-                this.app_id = exists === null || exists === void 0 ? void 0 : exists._id;
-            }
-            else {
-                const app = await this.createNewApp(data);
-                await this.initializeApp(app._id);
-            }
-            return { app_id: this.app._id };
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async initializeAppByTag(app_tag) {
-        try {
-            this.app = await this.appApi.fetchAppByTag(app_tag, this.getUserAccess());
-            this.app_id = this.app._id;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async initializeApp(app_id) {
-        try {
-            this.app = await this.appApi.fetchApp(app_id, this.getUserAccess());
-            this.app_id = app_id;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async initializeWorkspace() {
-        if (!this.workspace) {
-            this.workspace = await this.workspaceApi.fetchWorkspaceById(this.getUserAccess());
-        }
-    }
-    async createNewApp(data) {
-        await this.initializeWorkspace();
-        return this.appApi.createApp(Object.assign(Object.assign({}, data), { tag: `${(0, string_utils_1.tagify)(this.workspace.name)}:${(0, string_utils_1.tagify)(data.app_name)}` }), this.getUserAccess());
-    }
-    async initializeAppByName(app_name) {
-        try {
-            const app = await this.checkIfAppExists(app_name);
-            if (!app)
-                throw new Error(`${app_name} not found in workspace`);
-            this.app = app;
-            this.app_id = app._id;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async checkIfAppExists(app_name) {
-        try {
-            return await this.appApi.checkAppNameExists(app_name, this.getUserAccess());
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    fetchApp() {
-        return this.app;
-    }
-    async updateApp(data) {
-        try {
-            if (!this.app_id)
-                throw new Error('App not initialized');
-            await validators_1.UpdateAppBuilderSchema.validateAsync(data);
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { component: enums_1.AppComponents.APP }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    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, false)) {
-                await validators_1.CreateAppEnvSchema.validateAsync(data);
-                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { component: enums_1.AppComponents.ENV, action: enums_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeApp(this.app_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);
-            await validators_1.UpdateAppEnvSchema.validateAsync(Object.assign(Object.assign({}, data), { slug }));
-            if (data.slug && this.fetchEnv(data.slug)) {
-                throw new Error(`slug ${slug} is in use`); // TODO: also check on the backend
-            }
-            // TODO: check
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ slug }, data), { component: enums_1.AppComponents.ENV, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchEnvs() {
-        return this.app.envs;
-    }
-    fetchEnv(slug, throwErrorIfExists = true) {
-        const env = this.app.envs.find((data) => data.slug === slug);
-        if (!env && throwErrorIfExists)
-            throw new Error(`Env ${slug} not found`);
-        return env;
-    }
-    async extractResourceData(url) {
-        const pathParamsSample = (0, strings_utils_1.extractPathParams)(url);
-        const pathParamsData = (await this.inputsService.parseData({
-            data: pathParamsSample,
-            category: enums_1.Categories.PARAMS,
-            type: enums_1.InputsTypes.JSON,
-            expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-        }));
-        const queryParamsSample = (0, strings_utils_1.extractQueryParams)(url);
-        const queryParamsData = (await this.inputsService.parseData({
-            data: queryParamsSample,
-            category: enums_1.Categories.QUERY,
-            type: enums_1.InputsTypes.JSON,
-            expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-        }));
-        return {
-            query: {
-                sample: JSON.stringify(queryParamsSample),
-                data: queryParamsData,
-            },
-            params: {
-                sample: JSON.stringify(pathParamsSample),
-                data: pathParamsData,
-            },
-        };
-    }
-    async createAction(data, throwErrorIfExists = false) {
-        try {
-            let url = data.resource;
-            if (!data.resource)
-                throw new Error('resource is required');
-            data.resource = (0, strings_utils_1.extractURLPath)(url);
-            await validators_1.CreateAppActionSchema.validateAsync(data);
-            data.tag = (0, string_utils_1.tagify)(data.tag);
-            const { tag } = data;
-            let exists;
-            try {
-                exists = this.fetchAction(tag);
-            }
-            catch (e) {
-                exists = false;
-            }
-            console.log('EXISTSSSSSSSS =====>>>>>>>', exists);
-            if (!exists) {
-                data.resource = url;
-                console.log('URLSSSSSSSS =====>>>>>>>', url, data.resource);
-                await this.updateActionProcess(tag, Object.assign({}, data), enums_1.RequestAction.CREATE);
-            }
-            else {
-                delete data.tag;
-                this.updateAction(tag, data);
-            }
-            if (exists && throwErrorIfExists) {
-                throw new Error(`App action ${tag} already exists`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchActions() {
-        return this.app.actions;
-    }
-    fetchAction(identifier) {
-        const action = this.app.actions.find((data) => data.tag === identifier || data._id === identifier);
-        if (!action)
-            throw new Error(`Action ${identifier} not found`);
-        return action;
-    }
-    async updateAction(tag, data) {
-        await validators_1.UpdateAppActionSchema.validateAsync(data);
-        // TODO: add logic to see whether it has run before, halt if it has
-        this.fetchAction(tag);
-        console.log('FOLLOW THE TRAIL');
-        await this.updateActionProcess(tag, data, enums_1.RequestAction.UPDATE);
-    }
-    async updateActionProcess(tag, data, action) {
-        if (data.envs) {
-            /*data.envs = data.envs.map((slug) => {
-                      const { _id: env_id } = this.fetchEnv(slug);
-      
-                      return {env_id};
-                  });*/
-        }
-        let responses = [];
-        if (data.responses) {
-            responses = data.responses;
-            delete data.responses;
-        }
-        const query = Object.assign(Object.assign({ tag }, data), { component: enums_1.AppComponents.ACTION, action });
-        if (data.resource) {
-            const { params, query: queryData } = await this.extractResourceData(data.resource);
-            data.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            Object.assign(query, {
-                params: Object.assign(Object.assign({}, params), { type: enums_1.InputsTypes.JSON }),
-                query: Object.assign(Object.assign({}, queryData), { type: enums_1.InputsTypes.JSON }),
-            });
-        }
-        if (data.body) {
-            const parsedData = (await this.inputsService.parseData({
-                data: data.body.sample,
-                category: enums_1.Categories.BODY,
-                type: data.body.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            Object.assign(data.body, { data: parsedData, sample: JSON.stringify(data.body.sample) });
-        }
-        if (data.headers) {
-            const parsedData = (await this.inputsService.parseData({
-                data: data.headers.sample,
-                category: enums_1.Categories.HEADER,
-                type: data.headers.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            Object.assign(data.headers, { data: parsedData, sample: JSON.stringify(data.headers.sample) });
-        }
-        console.log('QUERY!!! ======>>>>>>>', query);
-        await this.appApi.updateApp(this.app_id, query, this.getUserAccess());
-        await this.initializeApp(this.app_id);
-        if (responses.length) {
-            const promises = responses.map((response) => {
-                console.log('RESPONSES =========>>>>>>', response);
-                this.createAppActionResponse(tag, response);
-            });
-            Promise.all(promises);
-        }
-        this.initializeApp(this.app_id);
-    }
-    async createActionRequestData(category, tag, payload, throwErrorIfExists = false) {
-        try {
-            const bodyData = await this.fetchActionRequestData(category, tag);
-            const exists = bodyData && bodyData.length > 0;
-            if (!exists) {
-                let data = await this.parseRequestData(category, payload);
-                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { app_id: this.app_id, category: enums_1.Categories.BODY }), this.getUserAccess());
-            }
-            else if (throwErrorIfExists) {
-                throw new Error(`Body exists for action ${tag}`);
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async parseRequestData(category, payload) {
-        await validators_1.CreateAppActionBodySchema.validateAsync(payload);
-        const data = (await this.inputsService.parseData({
-            data: payload.sample,
-            category,
-            type: payload.type,
-            expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-        }));
-        let sample = payload.sample.toString();
-        if (payload.type === enums_1.InputsTypes.JSON) {
-            sample = JSON.stringify(payload.sample);
-        }
-        return Object.assign(Object.assign({}, payload), { sample, data });
-    }
-    // private fetc
-    fetchActionRequestData(category, tag) {
-        try {
-            let data;
-            const action = this.fetchAction(tag);
-            if (category === enums_1.Categories.BODY) {
-                const { body } = action;
-                data = body.data;
-            }
-            else if (category === enums_1.Categories.QUERY) {
-                const { query } = action;
-                data = query.data;
-            }
-            else if (category === enums_1.Categories.PARAMS) {
-                const { params } = action;
-                data = params.data;
-            }
-            else if (category === enums_1.Categories.HEADER) {
-                const { headers } = action;
-                data = headers.data;
-            }
-            else {
-                throw new Error(`Category ${category} doesn't exist`);
-            }
-            return data;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchActionRequestSample(category, tag) {
-        try {
-            let sample;
-            const action = this.fetchAction(tag);
-            if (category === enums_1.Categories.BODY) {
-                const { body } = action;
-                sample = body.sample;
-            }
-            else if (category === enums_1.Categories.QUERY) {
-                const { query } = action;
-                sample = query.sample;
-            }
-            else if (category === enums_1.Categories.PARAMS) {
-                const { params } = action;
-                sample = params.sample;
-            }
-            else if (category === enums_1.Categories.HEADER) {
-                const { headers } = action;
-                sample = headers.sample;
-            }
-            else {
-                throw new Error(`Category ${category} doesn't exist`);
-            }
-            return sample;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateRequestDataValidation(category, action_tag, body) {
-        try {
-            const { _id: action_id } = this.fetchAction(action_tag);
-            await validators_1.UpdateEntityValidationDataSchema.validateAsync({ body, type: category });
-            const original = this.fetchActionRequestData(category, action_tag);
-            const missingKeys = this.inputsService.compareIndexes(original, body);
-            if (!missingKeys.length) {
-                throw new Error(`KEYS: parent_key_level_key_index ${JSON.stringify(missingKeys)} do not exist in original sample`);
-            }
-            await this.appApi.updateApp(this.app_id, {
-                action_id,
-                body,
-            }, this.getUserAccess());
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async createAppActionResponse(action_tag, payload) {
-        try {
-            this.fetchAction(action_tag);
-            await validators_1.CreateAppActionResponseSchema.validateAsync(Object.assign({}, payload));
-            payload.tag = (0, string_utils_1.tagify)(payload.tag);
-            const exists = this.fetchAppActionResponse(action_tag, payload.tag);
-            if (!exists) {
-                payload = await this.parseResponsePayload(payload);
-                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, payload), { action_tag, action: enums_1.RequestAction.CREATE, component: enums_1.AppComponents.ACTION_RESPONSE }), this.getUserAccess());
-            }
-            else {
-                await validators_1.UpdateAppActionResponseSchema.validateAsync(Object.assign({}, payload));
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async parseResponsePayload(payload) {
-        await validators_1.CreateAppActionResponseSchema.validateAsync(Object.assign({}, payload));
-        const data = (await this.inputsService.parseData({
-            data: payload.body.sample,
-            category: enums_1.Categories.RESPONSE,
-            type: payload.body.type,
-            expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-        }));
-        if (payload.success &&
-            !((payload.success_values && Object.keys(payload.success_values).length) || payload.is_status_code_success)) {
-            throw new Error('success_values or is_status_code_success required for success responses');
-        }
-        if (payload.success &&
-            payload.success_values &&
-            payload.success_values.body &&
-            payload.success_values.body.sample &&
-            Object.keys(payload.success_values.body.sample).length) {
-            const success_markers = (await this.inputsService.parseData({
-                data: payload.success_values.body.sample,
-                category: enums_1.Categories.RESPONSE,
-                type: enums_1.InputsTypes.JSON,
-                expected: inputs_types_1.ExpectedValues.PARSEINPUT,
-            }));
-            const invalidMarkers = await this.inputsService.compareIndexes(data, success_markers);
-            if (invalidMarkers.length)
-                throw new Error(`SUCCESS MARKERS KEYS: parent_key_level_key_index ${JSON.stringify(invalidMarkers)} do not exist in original sample`);
-            else {
-                payload.success_markers = success_markers;
-                payload.marker_type = payload.success_values.type;
-            }
-        }
-        payload.body.data = data;
-        payload.body.sample = JSON.stringify(payload.body.sample);
-        if (payload.envs && payload.envs.length) {
-            payload.envs = payload.envs.map((slug) => {
-                const { _id: env_id } = this.fetchEnv(slug);
-                return env_id;
-            });
-        }
-        return payload;
-    }
-    fetchAppActionResponse(action_tag, response_tag, throwErrorIfExists = false) {
-        const { responses } = this.fetchAction(action_tag);
-        const action = responses.find((data) => data.tag === response_tag);
-        if (!action && throwErrorIfExists)
-            throw new Error(`Response ${response_tag} not found`);
-        return action;
-    }
-    async extractEventData(data) {
-        if (data.response) {
-            data.response.data = (await this.inputsService.parseData({
-                data: data.response.sample,
-                category: enums_1.Categories.WEBHOOK,
-                type: data.response.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            data.response.sample = JSON.stringify(data.response.sample);
-        }
-        if (data.request) {
-            data.request.data = (await this.inputsService.parseData({
-                data: data.request.sample,
-                category: enums_1.Categories.WEBHOOK,
-                type: data.response.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            data.request.sample = JSON.stringify(data.request.sample);
-        }
-        if (data.body) {
-            data.body.data = (await this.inputsService.parseData({
-                data: data.body.sample,
-                category: enums_1.Categories.WEBHOOK,
-                type: data.body.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            data.body.sample = JSON.stringify(data.body.sample);
-        }
-        if (data.resource) {
-            const { query, params } = await this.extractResourceData(data.resource);
-            data.query = Object.assign({ type: enums_1.InputsTypes.JSON }, query);
-            data.params = Object.assign({ type: enums_1.InputsTypes.JSON }, params);
-            data.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-        }
-        return data;
-    }
-    // TODO: make this better
-    async createEvent(data) {
-        try {
-            if (data.envs) {
-                for (const env of data.envs) {
-                    const found = this.app.envs.findIndex((appEnv) => appEnv.slug === env.slug);
-                    if (found === -1) {
-                        throw new Error(`invalid env slug ${env.slug} is not defined`);
-                    }
-                }
-            }
-            if (data.action_tag) {
-                const found = this.app.actions.findIndex((action) => action.tag === data.action_tag);
-                if (found === -1) {
-                    throw new Error(`invalid action tag ${data.action_tag} is not defined`);
-                }
-            }
-            const { resource } = data;
-            if (data.resource)
-                data.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            await validators_1.CreateAppEventSchema.validateAsync(data);
-            data = await this.extractEventData(Object.assign(Object.assign({}, data), { resource }));
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.AppComponents.EVENT }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateEvent(tag, data) {
-        try {
-            const { resource } = data;
-            if (data.resource)
-                data.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            await validators_1.UpdateAppEventSchema.validateAsync(data);
-            data = await this.extractEventData(Object.assign(Object.assign({}, data), { resource }));
-            const { _id } = this.fetchEvent(tag);
-            data = await this.extractEventData(data);
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ _id,
-                tag }, data), { action: enums_1.RequestAction.UPDATE, component: enums_1.AppComponents.EVENT }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchEvents() {
-        return this.app.events;
-    }
-    fetchEvent(tag) {
-        const auth = this.app.events.find((data) => data.tag === tag);
-        if (!auth)
-            throw new Error(`Auth ${tag} not found`);
-        return auth;
-    }
-    async extractAuthData(data) {
-        if (data.tokens) {
-            data.tokens.data = (await this.inputsService.parseData({
-                data: data.tokens.sample,
-                category: enums_1.Categories.SETUP,
-                type: data.tokens.type,
-                expected: inputs_types_1.ExpectedValues.PARSESAMPLE,
-            }));
-            data.tokens.sample = JSON.stringify(data.tokens.sample);
-        }
-        return data;
-    }
-    // TODO: make this better
-    async createAuth(data) {
-        try {
-            const { setup_type, action_tag, tokens } = data;
-            if (setup_type === enums_1.AuthTypes.CREDENTIALS && !action_tag) {
-                throw new Error(`Action tag required for setup type ${setup_type}`);
-            }
-            if (setup_type === enums_1.AuthTypes.TOKEN && !tokens) {
-                throw new Error(`tokens sample required for setup type ${setup_type}`);
-            }
-            await validators_1.CreateAppAuthSchema.validateAsync(data);
-            if (setup_type === enums_1.AuthTypes.CREDENTIALS) {
-                this.fetchAction(action_tag);
-            }
-            data = await this.extractAuthData(Object.assign({}, data));
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.AppComponents.AUTH }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateAuth(tag, data) {
-        try {
-            await validators_1.UpdateAppAuthSchema.validateAsync(data);
-            this.fetchAuth(tag);
-            data = await this.extractAuthData(Object.assign({}, data));
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ tag }, data), { action: enums_1.RequestAction.UPDATE, component: enums_1.AppComponents.AUTH }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchAuths() {
-        return this.app.auths;
-    }
-    fetchAuth(tag) {
-        const auth = this.app.auths.find((data) => data.tag === tag);
-        if (!auth)
-            throw new Error(`Auth ${tag} not found`);
-        return auth;
-    }
-    async createVariable(data, throwErrorIfExists = false) {
-        try {
-            await validators_1.CreateAppVariableSchema.validateAsync(data);
-            const exists = this.fetchVariable(data.key, false);
-            if (exists && throwErrorIfExists)
-                throw new Error(`Variable ${data.key} exists`);
-            if (!exists) {
-                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.AppComponents.VARIABLE }), this.getUserAccess());
-            }
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateVariable(key, data) {
-        try {
-            await validators_1.UpdateAppVariableSchema.validateAsync(data);
-            this.fetchVariable(key);
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.UPDATE, component: enums_1.AppComponents.VARIABLE }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    fetchVariables() {
-        return this.app.variables;
-    }
-    fetchVariable(key, throwErrorIfExists = true) {
-        const variable = this.app.variables.find((data) => data.key === key);
-        if (!variable && throwErrorIfExists)
-            throw new Error(`Variable ${key} not found`);
-        return variable;
-    }
-    async createConstant(data, throwErrorIfExists = false) {
-        try {
-            await validators_1.CreateAppConstantSchema.validateAsync(data);
-            const exists = this.fetchConstant(data.key, false);
-            if (exists && throwErrorIfExists)
-                throw new Error(`Constant ${data.key} exists`);
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.CREATE, component: enums_1.AppComponents.CONSTANT }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateConstant(key, data) {
-        await validators_1.UpdateAppConstantSchema.validateAsync(data);
-        this.fetchConstant(key);
-        await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { action: enums_1.RequestAction.UPDATE, component: enums_1.AppComponents.CONSTANT }), this.getUserAccess());
-        await this.initializeApp(this.app_id);
-    }
-    fetchConstants() {
-        return this.app.constants;
-    }
-    fetchConstant(key, throwErrorIfExists = true) {
-        const variable = this.app.constants.find((data) => data.key === key);
-        if (!variable && throwErrorIfExists)
-            throw new Error(`Constant ${key} not found`);
-        return variable;
-    }
-    async updateDataValidation(locator, update) {
-        const stages = (0, string_utils_2.extractStages)(locator);
-        if (stages.length === 0) {
-            throw new Error(`Missing locators in ${locator}`);
-        }
-        if (locator.startsWith('$Body{')) {
-            await this.updateValidation(enums_1.AppCategories.BODY, stages, update);
-        }
-        else if (locator.startsWith('$Query{')) {
-            await this.updateValidation(enums_1.AppCategories.QUERY, stages, update);
-        }
-        else if (locator.startsWith('$Params{')) {
-            await this.updateValidation(enums_1.AppCategories.PARAMS, stages, update);
-        }
-        else if (locator.startsWith('$Header{')) {
-            await this.updateValidation(enums_1.AppCategories.HEADER, stages, update);
-        }
-        else {
-            throw new Error(`Invalid input ${locator}`);
-        }
-    }
-    async updateValidation(category, stages, update) {
-        try {
-            const action_tag = stages[0];
-            const action = this.fetchAction(action_tag);
-            const data = action[category];
-            let level = -1;
-            let key = '';
-            let datapoint;
-            let datapointIndex;
-            const exclude = category === enums_1.AppCategories.BODY
-                ? [enums_1.AppCategories.HEADER, enums_1.AppCategories.PARAMS, enums_1.AppCategories.QUERY]
-                : category === enums_1.AppCategories.HEADER
-                    ? [enums_1.AppCategories.BODY, enums_1.AppCategories.PARAMS, enums_1.AppCategories.QUERY]
-                    : category === enums_1.AppCategories.PARAMS
-                        ? [enums_1.AppCategories.BODY, enums_1.AppCategories.HEADER, enums_1.AppCategories.QUERY]
-                        : [enums_1.AppCategories.BODY, enums_1.AppCategories.PARAMS, enums_1.AppCategories.HEADER];
-            for (let i = 1; i < stages.length; i++) {
-                const parent_key = key;
-                key = stages[i];
-                level++;
-                const index = data.data.findIndex((item) => item.level === level && item.key === key && item.parent_key === parent_key);
-                if (index === -1) {
-                    throw new Error(`Datapoint ${key} not found in Action ${action_tag}'s ${category} data`);
-                }
-                if (index > -1 && i === stages.length - 1) {
-                    datapoint = data.data[index];
-                    datapointIndex = index;
-                }
-            }
-            data.data[datapointIndex] = Object.assign(Object.assign({}, data.data[datapointIndex]), update);
-            console.log('OYEBOLA!!! ====>>>', data.data[datapointIndex]);
-            action[category] = data;
-            const cleaned_action = (0, objects_utils_1.CleanObj)(action, [
-                'tag',
-                '_id',
-                'created',
-                'envs',
-                'resource',
-                'name',
-                'method',
-                'responses',
-                ...exclude,
-            ]);
-            //console.log(JSON.stringify(cleaned_action))
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ tag: action_tag }, cleaned_action), { component: enums_1.AppComponents.VALIDATION, action: enums_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    getUserAccess() {
-        return {
-            user_id: this.user_id,
-            workspace_id: this.workspace_id,
-            token: this.token,
-            public_key: this.public_key,
-        };
-    }
-}
-exports.default = AppBuilderService;
-//# sourceMappingURL=app.service.js.map