@ductape/sdk 0.0.1

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

@@ -0,0 +1,737 @@
+"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