@ductape/sdk 0.0.1

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

@@ -0,0 +1,995 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const validators_1 = require("../validators");
+const appApi_service_1 = require("../../api/services/appApi.service");
+const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"));
+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("../../products/utils/string.utils");
+const objects_utils_1 = require("../utils/objects.utils");
+const create_appWebhook_validator_1 = require("../validators/joi-validators/create.appWebhook.validator");
+const update_appWebhook_validator_1 = require("../validators/joi-validators/update.appWebhook.validator");
+const create_appWebhookEvent_validator_1 = require("../validators/joi-validators/create.appWebhookEvent.validator");
+const update_appWebhookEvent_validator_1 = require("../validators/joi-validators/update.appWebhookEvent.validator");
+class AppBuilderService {
+    constructor({ workspace_id, public_key, user_id, token, env_type }) {
+        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(env_type);
+        this.workspaceApi = new workspaceApi_service_1.WorkspaceApiService(env_type);
+        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;
+        }
+    }
+    initAppVersion() {
+        this.appVersion = this.app.versions.find((version) => version.latest === true);
+    }
+    async initializeAppByTag(app_tag) {
+        try {
+            this.app = await this.appApi.fetchAppByTag(app_tag, this.getUserAccess());
+            this.app_id = this.app._id;
+            this.initAppVersion();
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async initializeApp(app_id) {
+        try {
+            this.app = await this.appApi.fetchApp(app_id, this.getUserAccess());
+            this.app_id = app_id;
+            this.initAppVersion();
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async initializeWorkspace(subCheck = true) {
+        if (!this.workspace) {
+            this.workspace = await this.workspaceApi.fetchWorkspaceById(this.getUserAccess(), subCheck);
+        }
+    }
+    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;
+            this.initAppVersion();
+        }
+        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: types_1.AppComponents.APP, action: types_1.RequestAction.UPDATE }), 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: types_1.AppComponents.ENV, action: types_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: types_1.AppComponents.ENV, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeApp(this.app_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchEnvs() {
+        return this.appVersion.envs;
+    }
+    fetchEnv(slug, throwErrorIfExists = true) {
+        const env = this.appVersion.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: types_1.Categories.PARAMS,
+            type: types_1.InputsTypes.JSON,
+            expected: types_1.ExpectedValues.PARSESAMPLE,
+        }));
+        const queryParamsSample = (0, strings_utils_1.extractQueryParams)(url);
+        const queryParamsData = (await this.inputsService.parseData({
+            data: queryParamsSample,
+            category: types_1.Categories.QUERY,
+            type: types_1.InputsTypes.JSON,
+            expected: 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;
+            }
+            if (!exists) {
+                data.resource = url;
+                await this.updateActionProcess(tag, Object.assign({}, data), types_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.appVersion.actions;
+    }
+    fetchAction(identifier) {
+        const action = this.appVersion.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);
+        await this.updateActionProcess(tag, data, types_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: types_1.AppComponents.ACTION, action: types_1.RequestAction.UPDATE });
+        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: types_1.InputsTypes.JSON }),
+                query: Object.assign(Object.assign({}, queryData), { type: types_1.InputsTypes.JSON }),
+            });
+        }
+        if (data.body) {
+            const parsedData = (await this.inputsService.parseData({
+                data: data.body.sample,
+                category: types_1.Categories.BODY,
+                type: data.body.type,
+                expected: 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: types_1.Categories.HEADER,
+                type: data.headers.type,
+                expected: types_1.ExpectedValues.PARSESAMPLE,
+            }));
+            Object.assign(data.headers, { data: parsedData, sample: JSON.stringify(data.headers.sample) });
+        }
+        await this.appApi.updateApp(this.app_id, query, this.getUserAccess());
+        await this.initializeApp(this.app_id);
+        if (responses.length) {
+            const promises = responses.map((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 && payload) {
+                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: types_1.Categories.BODY }), this.getUserAccess());
+            }
+            else if (throwErrorIfExists) {
+                throw new Error(`Body exists for action ${tag}`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async parseRequestData(category, payload, key_description = []) {
+        await validators_1.CreateAppActionBodySchema.validateAsync(payload);
+        const data = (await this.inputsService.parseData({
+            data: payload.sample,
+            category,
+            type: payload.type,
+            expected: types_1.ExpectedValues.PARSESAMPLE,
+            key_description,
+        }));
+        let 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 === types_1.Categories.BODY) {
+                const { body } = action;
+                data = body.data;
+            }
+            else if (category === types_1.Categories.QUERY) {
+                const { query } = action;
+                data = query.data;
+            }
+            else if (category === types_1.Categories.PARAMS) {
+                const { params } = action;
+                data = params.data;
+            }
+            else if (category === types_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 === types_1.Categories.BODY) {
+                const { body } = action;
+                sample = body.sample;
+            }
+            else if (category === types_1.Categories.QUERY) {
+                const { query } = action;
+                sample = query.sample;
+            }
+            else if (category === types_1.Categories.PARAMS) {
+                const { params } = action;
+                sample = params.sample;
+            }
+            else if (category === types_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 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: types_1.RequestAction.CREATE, component: types_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: types_1.Categories.RESPONSE,
+            type: payload.body.type,
+            expected: 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: types_1.Categories.RESPONSE,
+                type: types_1.InputsTypes.JSON,
+                expected: 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: Partial<IAppEvent>): Promise<Partial<IAppEvent>> {
+      if (data.response) {
+        data.response.data = (await this.inputsService.parseData({
+          data: data.response.sample,
+          category: Categories.WEBHOOK,
+          type: data.response.type,
+          expected: ExpectedValues.PARSESAMPLE,
+        })) as unknown as Array<IParsedSample>;
+        data.response.sample = JSON.stringify(data.response.sample);
+      }
+  
+      if (data.request) {
+        data.request.data = (await this.inputsService.parseData({
+          data: data.request.sample,
+          category: Categories.WEBHOOK,
+          type: data.response.type,
+          expected: ExpectedValues.PARSESAMPLE,
+        })) as unknown as Array<IParsedSample>;
+        data.request.sample = JSON.stringify(data.request.sample);
+      }
+  
+      if (data.body) {
+        data.body.data = (await this.inputsService.parseData({
+          data: data.body.sample,
+          category: Categories.WEBHOOK,
+          type: data.body.type,
+          expected: ExpectedValues.PARSESAMPLE,
+        })) as unknown as Array<IParsedSample>;
+        data.body.sample = JSON.stringify(data.body.sample);
+      }
+  
+      if (data.resource) {
+        const { query, params } = await this.extractResourceData(data.resource);
+  
+        data.query = { type: InputsTypes.JSON, ...query } as unknown as ISample;
+        data.params = { type: InputsTypes.JSON, ...params } as unknown as ISample;
+        data.resource = extractURLPath(data.resource);
+      }
+  
+      return data;
+    }*/
+    /*async createEvent(data: Partial<IAppEvent>): Promise<void> {
+      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 = extractURLPath(data.resource);
+  
+        await CreateAppEventSchema.validateAsync(data);
+        data = await this.extractEventData({ ...data, resource });
+  
+        await this.appApi.updateApp(
+          this.app_id,
+          {
+            ...data,
+            action: RequestAction.CREATE,
+            component: AppComponents.EVENT,
+          },
+          this.getUserAccess(),
+        );
+  
+        await this.initializeApp(this.app_id);
+      } catch (e) {
+        throw e;
+      }
+    }
+  
+    async updateEvent(tag: string, data: Partial<IAppEvent>): Promise<void> {
+      try {
+        const { resource } = data;
+  
+        if (data.resource) data.resource = extractURLPath(data.resource);
+  
+        await UpdateAppEventSchema.validateAsync(data);
+  
+        data = await this.extractEventData({ ...data, resource });
+  
+        const { _id } = this.fetchEvent(tag);
+  
+        data = await this.extractEventData(data);
+        await this.appApi.updateApp(
+          this.app_id,
+          {
+            _id,
+            tag,
+            ...data,
+            action: RequestAction.UPDATE,
+            component: AppComponents.EVENT,
+          },
+          this.getUserAccess(),
+        );
+  
+        await this.initializeApp(this.app_id);
+      } catch (e) {
+        throw e;
+      }
+    }
+  
+    fetchEvents(): Array<IAppEvent> {
+      return this.app.events;
+    }
+  
+    fetchEvent(tag: string): IAppEvent {
+      const auth = this.app.events.find((data: IAppEvent) => data.tag === tag);
+  
+      if (!auth) throw new Error(`Auth ${tag} not found`);
+  
+      return auth;
+    }*/
+    async extractAuthData(data) {
+        if (data.tokens.body) {
+            const sample = JSON.stringify(data.tokens.body);
+            const d = await this.inputsService.parseData({
+                data: data.tokens.body,
+                category: types_1.Categories.BODY,
+                type: types_1.InputsTypes.JSON,
+                expected: types_1.ExpectedValues.PARSESAMPLE,
+            });
+            data.tokens.body = { sample, data: d };
+        }
+        if (data.tokens.headers) {
+            const sample = JSON.stringify(data.tokens.headers);
+            const d = await this.inputsService.parseData({
+                data: data.tokens.headers,
+                category: types_1.Categories.HEADER,
+                type: types_1.InputsTypes.JSON,
+                expected: types_1.ExpectedValues.PARSESAMPLE,
+            });
+            data.tokens.headers = { sample, data: d };
+        }
+        if (data.tokens.query) {
+            const sample = JSON.stringify(data.tokens.query);
+            const d = await this.inputsService.parseData({
+                data: data.tokens.query,
+                category: types_1.Categories.QUERY,
+                type: types_1.InputsTypes.JSON,
+                expected: types_1.ExpectedValues.PARSESAMPLE,
+            });
+            data.tokens.query = { sample, data: d };
+        }
+        if (data.tokens.params) {
+            const sample = JSON.stringify(data.tokens.params);
+            const d = await this.inputsService.parseData({
+                data: data.tokens.params,
+                category: types_1.Categories.PARAMS,
+                type: types_1.InputsTypes.JSON,
+                expected: types_1.ExpectedValues.PARSESAMPLE,
+            });
+            data.tokens.params = { sample, data: d };
+        }
+        return data;
+    }
+    // TODO: make this better
+    async createAuth(data) {
+        try {
+            const { setup_type, action_tag, tokens } = data;
+            if (setup_type === types_1.AuthTypes.CREDENTIALS && !action_tag) {
+                throw new Error(`Action tag required for setup type ${setup_type}`);
+            }
+            if (setup_type === types_1.AuthTypes.TOKEN && !tokens) {
+                throw new Error(`tokens sample required for setup type ${setup_type}`);
+            }
+            await validators_1.CreateAppAuthSchema.validateAsync(data);
+            if (setup_type === types_1.AuthTypes.TOKEN && !tokens.body && !tokens.headers && !tokens.params && !tokens.query) {
+                throw new Error(`token has to have one of body, headers, params or query set`);
+            }
+            if (setup_type === types_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: types_1.RequestAction.CREATE, component: types_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);
+            const auth = this.fetchAuth(tag);
+            data = await this.extractAuthData(Object.assign(Object.assign({}, auth), data));
+            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ tag }, data), { action: types_1.RequestAction.UPDATE, component: types_1.AppComponents.AUTH }), this.getUserAccess());
+            await this.initializeApp(this.app_id);
+            await this.initializeApp(this.app_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchAuths() {
+        return this.appVersion.auths;
+    }
+    fetchAuth(tag) {
+        const auth = this.appVersion.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: types_1.RequestAction.CREATE, component: types_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), { key, action: types_1.RequestAction.UPDATE, component: types_1.AppComponents.VARIABLE }), this.getUserAccess());
+            await this.initializeApp(this.app_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchVariables() {
+        return this.appVersion.variables;
+    }
+    fetchVariable(key, throwErrorIfExists = true) {
+        const variable = this.appVersion.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: types_1.RequestAction.CREATE, component: types_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: types_1.RequestAction.UPDATE, component: types_1.AppComponents.CONSTANT }), this.getUserAccess());
+        await this.initializeApp(this.app_id);
+    }
+    fetchConstants() {
+        return this.appVersion.constants;
+    }
+    fetchConstant(key, throwErrorIfExists = true) {
+        const variable = this.appVersion.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(types_1.AppCategories.BODY, stages, update);
+        }
+        else if (locator.startsWith('$Query{')) {
+            await this.updateValidation(types_1.AppCategories.QUERY, stages, update);
+        }
+        else if (locator.startsWith('$Params{')) {
+            await this.updateValidation(types_1.AppCategories.PARAMS, stages, update);
+        }
+        else if (locator.startsWith('$Header{')) {
+            await this.updateValidation(types_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 === types_1.AppCategories.BODY
+                ? [types_1.AppCategories.HEADER, types_1.AppCategories.PARAMS, types_1.AppCategories.QUERY]
+                : category === types_1.AppCategories.HEADER
+                    ? [types_1.AppCategories.BODY, types_1.AppCategories.PARAMS, types_1.AppCategories.QUERY]
+                    : category === types_1.AppCategories.PARAMS
+                        ? [types_1.AppCategories.BODY, types_1.AppCategories.HEADER, types_1.AppCategories.QUERY]
+                        : [types_1.AppCategories.BODY, types_1.AppCategories.PARAMS, types_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);
+            action[category] = data;
+            const cleaned_action = (0, objects_utils_1.CleanObj)(action, [
+                'tag',
+                '_id',
+                'created',
+                'envs',
+                'resource',
+                'name',
+                'method',
+                'responses',
+                ...exclude,
+            ]);
+            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ tag: action_tag }, cleaned_action), { component: types_1.AppComponents.VALIDATION, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeApp(this.app_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async createWebhook(data, throwErrorIfExists = false) {
+        try {
+            // TODO: figure out a way to check if this has run before, halt if it has
+            if (!this.fetchWebhook(data.tag)) {
+                await create_appWebhook_validator_1.IAppWebhookSchema.validateAsync(data);
+                data.envs = data.envs.map((env) => {
+                    const exists = this.fetchEnv(env.slug);
+                    if (!exists) {
+                        throw new Error(`Env ${env.slug} does not exist`);
+                    }
+                    if (env.sample) {
+                        const bodyTemplate = env.sample.body ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.body), 'body') : [];
+                        const queryTemplate = env.sample.query
+                            ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.query), 'query')
+                            : [];
+                        const paramsTemplate = env.sample.params
+                            ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.params), 'params')
+                            : [];
+                        const headerTemplate = env.sample.headers
+                            ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.headers), 'headers')
+                            : [];
+                        env.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+                    }
+                    return env;
+                });
+                const envs = this.fetchEnvs();
+                envs.map((env) => {
+                    const exists = data.envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
+                    if (exists === -1) {
+                        throw new Error(`Product env ${env.slug} is not defined, please provide webhook registration details`);
+                    }
+                });
+                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { component: types_1.AppComponents.WEBHOOK, action: types_1.RequestAction.CREATE }), this.getUserAccess());
+                await this.initializeApp(this.app_id);
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Database ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateWebhook(tag, data) {
+        try {
+            const { _id, envs } = this.fetchWebhook(tag);
+            await update_appWebhook_validator_1.IAppWebhookUpdateSchema.validateAsync(data); // Change to update;
+            if (data.tag && this.fetchWebhook(data.tag)) {
+                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
+            }
+            data.envs = data.envs.map((env) => {
+                const exists = this.fetchEnv(env.slug);
+                if (!exists) {
+                    throw new Error(`Env ${env.slug} does not exist`);
+                }
+                if (env.sample) {
+                    const bodyTemplate = env.sample.body ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.body), 'body') : [];
+                    const queryTemplate = env.sample.query ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.query), 'query') : [];
+                    const paramsTemplate = env.sample.params
+                        ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.params), 'params')
+                        : [];
+                    const headerTemplate = env.sample.headers
+                        ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(env.sample.headers), 'headers')
+                        : [];
+                    env.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+                }
+                return env;
+            });
+            const overwrite = [];
+            const newEnvs = [];
+            envs.map((env) => {
+                const exists = data.envs.findIndex((dataEnv) => env.slug === dataEnv.slug);
+                if (!this.fetchEnv(env.slug)) {
+                    throw new Error(`Product Environment ${env.slug} doesn't exist`);
+                }
+                if (exists === -1) {
+                    newEnvs.push(data.envs[exists]);
+                }
+                else {
+                    overwrite.push(Object.assign(Object.assign({}, env), data.envs[exists]));
+                }
+            });
+            const unchanged = [];
+            envs.map((env) => {
+                const newEnv = newEnvs.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                const overwriteEnv = overwrite.findIndex((dataEnv) => env.slug === dataEnv.slug) > -1;
+                if (!newEnv && !overwriteEnv) {
+                    unchanged.push(env);
+                }
+            });
+            data.envs = [...unchanged, ...overwrite, ...newEnvs];
+            data.envs = [...overwrite, ...newEnvs];
+            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ _id }, data), { component: types_1.AppComponents.WEBHOOK, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
+            await this.initializeApp(this.app_id);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    fetchWebhook(tag) {
+        var _a, _b;
+        const exists = (_b = (_a = this.appVersion) === null || _a === void 0 ? void 0 : _a.webhooks) === null || _b === void 0 ? void 0 : _b.find((data) => data.tag === tag);
+        return exists;
+    }
+    fetchWebhooks() {
+        var _a;
+        return (_a = this.appVersion) === null || _a === void 0 ? void 0 : _a.webhooks;
+    }
+    async createWebhookEvent(data, throwErrorIfExists = false) {
+        try {
+            await create_appWebhookEvent_validator_1.IAppWebhookEventSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [webhookTag, tag] = data.tag.split(':');
+            if (!webhookTag || !tag) {
+                throw new Error(`tag is expected to be defined as "webhook_tag:event_tag"`);
+            }
+            const exists = this.fetchWebhookEvent(data.tag);
+            data.tag = tag;
+            if (!exists) {
+                if (data.sample) {
+                    const bodyTemplate = data.sample.body ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.body), 'body') : [];
+                    const queryTemplate = data.sample.query
+                        ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.query), 'query')
+                        : [];
+                    const paramsTemplate = data.sample.params
+                        ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.params), 'params')
+                        : [];
+                    const headerTemplate = data.sample.headers
+                        ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.headers), 'headers')
+                        : [];
+                    data.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+                }
+                delete data.tag;
+                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { webhookTag,
+                    tag, component: types_1.AppComponents.WEBHOOK_EVENT, action: types_1.RequestAction.CREATE }), this.getUserAccess());
+                await this.initializeApp(this.app_id);
+            }
+            else {
+                if (throwErrorIfExists)
+                    throw new Error(`Webhook Event ${data.tag} already exists`);
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async updateWebhookEvent(data) {
+        try {
+            await update_appWebhookEvent_validator_1.IAppWebhookEventUpdateSchema.validateAsync(data);
+            if (!data.tag) {
+                throw new Error('tag field is required');
+            }
+            const [webhookTag, tag] = data.tag.split(':');
+            if (!webhookTag || !tag) {
+                throw new Error(`tag is expected to be defined as "webhook_tag:event_tag"`);
+            }
+            // Fetch required data
+            //const notification = await this.fetchNotification(notificationTag);
+            const event = await this.fetchWebhookEvent(data.tag);
+            // Validate and process the template
+            data.tag = tag;
+            if (data.sample) {
+                const bodyTemplate = data.sample.body ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.body), 'body') : [];
+                const queryTemplate = data.sample.query ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.query), 'query') : [];
+                const paramsTemplate = data.sample.params
+                    ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.params), 'params')
+                    : [];
+                const headerTemplate = data.sample.headers
+                    ? (0, string_utils_2.extractPlaceholders)(JSON.stringify(data.sample.headers), 'headers')
+                    : [];
+                data.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
+            }
+            // Construct payload
+            delete data.tag;
+            const payload = Object.assign(Object.assign(Object.assign({}, event), data), { tag,
+                webhookTag, component: types_1.AppComponents.WEBHOOK_EVENT, action: types_1.RequestAction.UPDATE });
+            // Update product and reinitialize
+            await this.appApi.updateApp(this.app_id, payload, this.getUserAccess());
+            await this.initializeApp(this.app_id);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    fetchWebhookEvent(tag) {
+        const [webhookTag, eventTag] = tag.split(':');
+        ;
+        if (!webhookTag || !eventTag) {
+            throw new Error(`webhook events should be in the format webhook_tag:event_tag`);
+        }
+        const events = this.fetchWebhookEvents(webhookTag);
+        const event = events.find((event) => {
+            return event.tag === eventTag;
+        });
+        return event;
+    }
+    fetchWebhookEvents(tag) {
+        const webhook = this.fetchWebhook(tag);
+        if (!webhook) {
+            throw new Error(`Webhook ${tag} does not exist`);
+        }
+        return webhook.events;
+    }
+    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