@ductape/sdk 0.1.6 → 0.1.8

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

@@ -1,1436 +0,0 @@
-"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, access_key }) {
-        this.workspace_id = workspace_id;
-        this.user_id = user_id;
-        this.public_key = public_key;
-        this.token = token;
-        this.access_key = access_key !== null && access_key !== void 0 ? access_key : null;
-        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(versionTag) {
-        if (versionTag) {
-            this.appVersion = this.app.versions.find((version) => version.tag === versionTag);
-            if (!this.appVersion) {
-                throw new Error(`Version ${versionTag} not found`);
-            }
-        }
-        else {
-            this.appVersion = this.app.versions.find((version) => version.latest === true);
-        }
-    }
-    async initializeAppByTag(app_tag) {
-        try {
-            this.app = await this.appApi.initApp(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.initApp(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
-            const existingEnv = await this.fetchEnv(data.slug, false);
-            if (!existingEnv) {
-                const payload = Object.assign({}, data);
-                if (payload.base_url) {
-                    const keys = (0, string_utils_1.extractBaseUrlVariables)(payload.base_url);
-                    payload.base_url_variables = keys.length ? keys.map(key => ({ key })) : undefined;
-                }
-                await validators_1.CreateAppEnvSchema.validateAsync(payload);
-                await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, payload), { 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 payload = Object.assign(Object.assign({}, data), { slug });
-            if (payload.base_url !== undefined) {
-                const keys = (0, string_utils_1.extractBaseUrlVariables)(payload.base_url);
-                payload.base_url_variables = keys.length ? keys.map(key => ({ key })) : undefined;
-            }
-            await validators_1.UpdateAppEnvSchema.validateAsync(payload);
-            if (data.slug) {
-                const existingEnv = await this.fetchEnv(data.slug, false);
-                if (existingEnv) {
-                    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 }, payload), { component: types_1.AppComponents.ENV, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
-            //await this.initializeApp(this.app_id);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async fetchEnvs() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'env', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    async fetchEnv(slug, throwErrorIfExists = true) {
-        const envs = await this.fetchEnvs();
-        const env = 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,
-            },
-        };
-    }
-    // Helper function to merge metadata into parsed schema data
-    mergeMetadataIntoSchema(parsedData, metadataMap) {
-        if (!metadataMap || Object.keys(metadataMap).length === 0) {
-            return parsedData;
-        }
-        return parsedData.map(item => {
-            const metadata = metadataMap[item.key || ''];
-            if (metadata) {
-                return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, item), (metadata.minLength !== undefined ? { minLength: metadata.minLength } : {})), (metadata.maxLength !== undefined ? { maxLength: metadata.maxLength } : {})), (metadata.required !== undefined ? { required: metadata.required } : {})), (metadata.type !== undefined ? { type: metadata.type } : {}));
-            }
-            return item;
-        });
-    }
-    // Helper function to merge nested metadata for body fields
-    mergeNestedBodyMetadata(parsedData, fieldsMetadata) {
-        if (!fieldsMetadata || Object.keys(fieldsMetadata).length === 0) {
-            return parsedData;
-        }
-        const applyMetadataRecursively = (data, pathPrefix = '') => {
-            return data.map((item) => {
-                const fullPath = pathPrefix ? `${pathPrefix}.${item.key}` : item.key;
-                const metadata = fieldsMetadata[fullPath];
-                let updatedItem = Object.assign({}, item);
-                if (metadata) {
-                    updatedItem = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, updatedItem), (metadata.minLength !== undefined ? { minLength: metadata.minLength } : {})), (metadata.maxLength !== undefined ? { maxLength: metadata.maxLength } : {})), (metadata.required !== undefined ? { required: metadata.required } : {})), (metadata.type !== undefined ? { type: metadata.type } : {}));
-                }
-                // Recursively apply to nested data (if the parsed item has nested structure)
-                if (updatedItem.data && Array.isArray(updatedItem.data) && updatedItem.data.length > 0) {
-                    updatedItem.data = applyMetadataRecursively(updatedItem.data, fullPath);
-                }
-                return updatedItem;
-            });
-        };
-        return applyMetadataRecursively(parsedData);
-    }
-    async createAction(data, throwErrorIfExists = false) {
-        // Validate schema
-        await validators_1.CreateAppActionSchema.validateAsync(data);
-        data.tag = (0, string_utils_1.tagify)(data.tag);
-        const { tag } = data;
-        // Check if action already exists
-        let exists;
-        try {
-            exists = await this.fetchAction(tag);
-        }
-        catch (e) {
-            exists = false;
-        }
-        if (exists && throwErrorIfExists) {
-            throw new Error(`App action ${tag} already exists`);
-        }
-        if (exists) {
-            return; // Silently skip if already exists and not throwing error
-        }
-        // Build the action body (similar to updateAction but without fetching existing action)
-        const body = Object.assign({ tag: data.tag, name: data.name, method: data.method, request_type: data.request_type || types_1.DataFormats.JSON, description: data.description || '', responses: [] }, (data.folder_id ? { folder_id: data.folder_id } : {}));
-        // Batch all parsing operations for parallel execution
-        const parseOperations = [];
-        const parseKeys = [];
-        // Prepare params parsing
-        if (data.params) {
-            parseKeys.push('params');
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.params.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.PARAMS
-            }).then(parsedData => ({
-                key: 'params',
-                parsedData: parsedData,
-                metadata: this.extractMetadata(data.params)
-            })));
-        }
-        // Prepare query parsing
-        if (data.query) {
-            parseKeys.push('query');
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.query.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.QUERY
-            }).then(parsedData => ({
-                key: 'query',
-                parsedData: parsedData,
-                metadata: this.extractMetadata(data.query)
-            })));
-        }
-        // Prepare body parsing
-        if (data.body) {
-            const fieldsMetadata = data.body.fieldsMetadata;
-            const bodySample = data.body.sample || data.body;
-            parseKeys.push('body');
-            parseOperations.push(this.inputsService.parseJson({
-                data: bodySample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.BODY
-            }).then(parsedData => ({
-                key: 'body',
-                parsedData: parsedData,
-                fieldsMetadata,
-                bodySample,
-                metadata: fieldsMetadata ? null : this.extractMetadata(data.body)
-            })));
-        }
-        // Prepare headers parsing
-        if (data.headers) {
-            parseKeys.push('headers');
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.headers.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.HEADER
-            }).then(parsedData => ({
-                key: 'headers',
-                parsedData: parsedData,
-                metadata: this.extractMetadata(data.headers)
-            })));
-        }
-        // Prepare response parsing
-        if (data.response) {
-            parseKeys.push('response');
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.response.body,
-                expected: types_1.ExpectedValues.PARSESAMPLE
-            }).then(parsedData => ({
-                key: 'response',
-                parsedData: parsedData
-            })));
-        }
-        // Execute all parsing operations in parallel
-        const parseResults = await Promise.all(parseOperations);
-        // Process parsed results
-        for (const result of parseResults) {
-            switch (result.key) {
-                case 'params':
-                    body.params = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.params.sample),
-                        data: this.mergeMetadataIntoSchema(result.parsedData, result.metadata)
-                    };
-                    break;
-                case 'query':
-                    body.query = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.query.sample),
-                        data: this.mergeMetadataIntoSchema(result.parsedData, result.metadata)
-                    };
-                    break;
-                case 'body':
-                    let finalData = result.parsedData;
-                    if (result.fieldsMetadata) {
-                        finalData = this.mergeNestedBodyMetadata(result.parsedData, result.fieldsMetadata);
-                    }
-                    else if (result.metadata && Object.keys(result.metadata).length > 0) {
-                        finalData = this.mergeMetadataIntoSchema(result.parsedData, result.metadata);
-                    }
-                    body.body = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(result.bodySample),
-                        data: finalData
-                    };
-                    break;
-                case 'headers':
-                    body.headers = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.headers.sample),
-                        data: this.mergeMetadataIntoSchema(result.parsedData, result.metadata)
-                    };
-                    break;
-                case 'response':
-                    const response = {
-                        name: data.response.name || `Response - ${data.response.status_code}`,
-                        tag: data.tag,
-                        response_format: data.response.response_format,
-                        status_code: data.response.status_code,
-                        success: data.response.success,
-                        body: {
-                            sample: JSON.stringify(data.response.body),
-                            type: types_1.InputsTypes.JSON,
-                            data: result.parsedData,
-                            status_code: data.response.status_code,
-                        }
-                    };
-                    body.responses = [response];
-                    break;
-            }
-        }
-        // Handle resource URL parsing
-        if (data.resource) {
-            body.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            // Only extract params/query from resource if they weren't already provided
-            if (!data.params && !data.query) {
-                const { params, query: queryData } = await this.extractResourceData(data.resource);
-                // Only set if not already defined and sample exists
-                if (!body.params && params.sample) {
-                    body.params = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: params.sample,
-                        data: params.data
-                    };
-                }
-                if (!body.query && queryData.sample) {
-                    body.query = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: queryData.sample,
-                        data: queryData.data
-                    };
-                }
-            }
-        }
-        // Create action via API
-        await this.updateActionProcess(tag, body, types_1.RequestAction.CREATE);
-        // Update local cache instead of full app refetch
-        //this.appVersion.actions.push(body as IAppAction);
-    }
-    // Helper method to extract metadata from data object
-    extractMetadata(data) {
-        const metadataMap = {};
-        if (data && data.data && Array.isArray(data.data)) {
-            data.data.forEach((item) => {
-                if (item.metadata) {
-                    metadataMap[item.key] = item.metadata;
-                }
-            });
-        }
-        return metadataMap;
-    }
-    async fetchActions() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'action', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    async fetchAction(identifier) {
-        const actions = await this.fetchActions();
-        const action = actions.find((data) => data.tag === identifier || data._id === identifier);
-        if (!action)
-            throw new Error(`Action ${identifier} not found`);
-        return action;
-    }
-    async updateAction(tag, data) {
-        // Validate schema
-        await validators_1.UpdateAppActionSchema.validateAsync(data);
-        const action = await this.fetchAction(tag);
-        const body = action;
-        if (!action) {
-            throw new Error(`Action ${tag} not found`);
-        }
-        // Batch all parsing operations for parallel execution
-        const parseOperations = [];
-        // Prepare params parsing
-        if (data.params) {
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.params.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.PARAMS
-            }).then(parsedData => ({
-                key: 'params',
-                parsedData: parsedData
-            })));
-        }
-        // Prepare query parsing
-        if (data.query) {
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.query.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.QUERY
-            }).then(parsedData => ({
-                key: 'query',
-                parsedData: parsedData
-            })));
-        }
-        // Prepare body parsing
-        if (data.body) {
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.body.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.BODY
-            }).then(parsedData => ({
-                key: 'body',
-                parsedData: parsedData
-            })));
-        }
-        // Prepare headers parsing
-        if (data.headers) {
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.headers.sample,
-                expected: types_1.ExpectedValues.PARSESAMPLE,
-                category: types_1.Categories.HEADER
-            }).then(parsedData => ({
-                key: 'headers',
-                parsedData: parsedData
-            })));
-        }
-        // Prepare response parsing
-        if (data.response) {
-            parseOperations.push(this.inputsService.parseJson({
-                data: data.response.body,
-                expected: types_1.ExpectedValues.PARSESAMPLE
-            }).then(parsedData => ({
-                key: 'response',
-                parsedData: parsedData
-            })));
-        }
-        // Execute all parsing operations in parallel
-        const parseResults = await Promise.all(parseOperations);
-        // Process parsed results
-        for (const result of parseResults) {
-            switch (result.key) {
-                case 'params':
-                    body.params = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.params),
-                        data: result.parsedData
-                    };
-                    break;
-                case 'query':
-                    body.query = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.query),
-                        data: result.parsedData
-                    };
-                    break;
-                case 'body':
-                    body.body = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.body),
-                        data: result.parsedData
-                    };
-                    break;
-                case 'headers':
-                    body.headers = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: JSON.stringify(data.headers),
-                        data: result.parsedData
-                    };
-                    break;
-                case 'response':
-                    body.responses = action.responses;
-                    const response = {
-                        name: `Response - ${data.response.status_code}`,
-                        response_format: data.response.response_format,
-                        status_code: data.response.status_code,
-                        success: data.response.success,
-                        body: {
-                            sample: JSON.stringify(data.response.body),
-                            type: types_1.InputsTypes.JSON,
-                            data: result.parsedData,
-                            status_code: data.response.status_code,
-                        }
-                    };
-                    const statusIndex = body.responses.findIndex((resp) => resp.status_code === data.response.status_code);
-                    if (data.response.success === true) {
-                        const index = action.responses.findIndex((resp) => resp.success === true);
-                        if (index > -1) {
-                            body.responses[index] = response;
-                        }
-                        else {
-                            if (statusIndex > -1) {
-                                body.responses.splice(statusIndex, 1);
-                            }
-                            body.responses.push(response);
-                        }
-                    }
-                    else {
-                        if (statusIndex > -1) {
-                            body.responses.splice(statusIndex, 1);
-                        }
-                        body.responses.push(response);
-                    }
-                    break;
-            }
-        }
-        // Handle resource URL parsing
-        if (data.resource) {
-            body.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            // Only extract params/query from resource if they weren't already provided in update data
-            if (!data.params && !data.query) {
-                const { params, query: queryData } = await this.extractResourceData(data.resource);
-                // Only set if not already defined in body (from existing action)
-                if (!body.params && params.sample) {
-                    body.params = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: params.sample,
-                        data: params.data
-                    };
-                }
-                if (!body.query && queryData.sample) {
-                    body.query = {
-                        type: types_1.InputsTypes.JSON,
-                        sample: queryData.sample,
-                        data: queryData.data
-                    };
-                }
-            }
-        }
-        // Update simple fields
-        if (data.description) {
-            body.description = data.description;
-        }
-        if (data.method) {
-            body.method = data.method;
-        }
-        if (data.request_type) {
-            body.request_type = data.request_type;
-        }
-        // Update action via API
-        await this.updateActionProcess(tag, body, types_1.RequestAction.UPDATE);
-        // Update local cache instead of full app refetch
-        //const actionIndex = this.appVersion.actions.findIndex(a => a.tag === tag || a._id === action._id);
-        //if (actionIndex > -1) {
-        //this.appVersion.actions[actionIndex] = body as IAppAction;
-        //}
-    }
-    async updateActionProcess(tag, data, action) {
-        const query = Object.assign({ component: types_1.AppComponents.ACTION, action,
-            tag }, data);
-        await this.appApi.updateApp(this.app_id, query, this.getUserAccess());
-    }
-    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
-    async fetchActionRequestData(category, tag) {
-        try {
-            let data;
-            const action = await 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;
-        }
-    }
-    async fetchActionRequestSample(category, tag) {
-        try {
-            let sample;
-            const action = await 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 {
-            await this.fetchAction(action_tag);
-            await validators_1.CreateAppActionResponseSchema.validateAsync(Object.assign({}, payload));
-            payload.tag = (0, string_utils_1.tagify)(payload.tag);
-            const exists = await 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) {
-            const envIds = await Promise.all(payload.envs.map(async (slug) => {
-                const env = await this.fetchEnv(slug);
-                return env._id;
-            }));
-            payload.envs = envIds;
-        }
-        return payload;
-    }
-    async fetchAppActionResponse(action_tag, response_tag, throwErrorIfExists = false) {
-        const action = await this.fetchAction(action_tag);
-        const { responses } = action;
-        const response = responses.find((data) => data.tag === response_tag);
-        if (!response && throwErrorIfExists)
-            throw new Error(`Response ${response_tag} not found`);
-        return response;
-    }
-    /*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) {
-                await 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 = await 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;
-        }
-    }
-    async fetchAuths() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'auth', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    async fetchAuth(tag) {
-        const auths = await this.fetchAuths();
-        const auth = 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 = await 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);
-            await 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;
-        }
-    }
-    async fetchVariables() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'variable', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    async fetchVariable(key, throwErrorIfExists = true) {
-        const variables = await this.fetchVariables();
-        const variable = 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 = await 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);
-        await 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);
-    }
-    async fetchConstants() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'constant', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    async fetchConstant(key, throwErrorIfExists = true) {
-        const constants = await this.fetchConstants();
-        const variable = 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}`);
-        }
-        // Convert stages to string[] for functions expecting string[]
-        const stringStages = stages.map(stage => String(stage));
-        if (locator.startsWith('$Body{')) {
-            await this.updateValidation(types_1.AppCategories.BODY, stringStages, update);
-        }
-        else if (locator.startsWith('$Query{')) {
-            await this.updateValidation(types_1.AppCategories.QUERY, stringStages, update);
-        }
-        else if (locator.startsWith('$Params{')) {
-            await this.updateValidation(types_1.AppCategories.PARAMS, stringStages, update);
-        }
-        else if (locator.startsWith('$Header{')) {
-            await this.updateValidation(types_1.AppCategories.HEADER, stringStages, update);
-        }
-        else {
-            throw new Error(`Invalid input ${locator}`);
-        }
-    }
-    async updateValidation(category, stages, update) {
-        try {
-            const action_tag = stages[0];
-            const action = await 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 }, 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
-            const existingWebhook = await this.fetchWebhook(data.tag);
-            if (!existingWebhook) {
-                await create_appWebhook_validator_1.IAppWebhookSchema.validateAsync(data);
-                data.envs = await Promise.all(data.envs.map(async (env) => {
-                    const exists = await 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 = await 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 webhook = await this.fetchWebhook(tag);
-            const { _id, envs } = webhook;
-            await update_appWebhook_validator_1.IAppWebhookUpdateSchema.validateAsync(data); // Change to update;
-            if (data.tag) {
-                const existingWebhook = await this.fetchWebhook(data.tag);
-                if (existingWebhook) {
-                    throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
-                }
-            }
-            data.envs = await Promise.all(data.envs.map(async (env) => {
-                const exists = await 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 = [];
-            for (const env of envs) {
-                const exists = data.envs.findIndex((dataEnv) => env.slug === dataEnv.slug);
-                const envExists = await this.fetchEnv(env.slug, false);
-                if (!envExists) {
-                    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;
-        }
-    }
-    async fetchWebhook(tag) {
-        const webhooks = await this.fetchWebhooks();
-        const exists = webhooks === null || webhooks === void 0 ? void 0 : webhooks.find((data) => data.tag === tag);
-        return exists;
-    }
-    async fetchWebhooks() {
-        const components = await this.appApi.fetchAppComponents(this.app_id, 'webhook', this.getUserAccess(), this.appVersion.tag);
-        return components;
-    }
-    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 = await this.fetchWebhookEvent(data.tag);
-            data.tag = tag;
-            if (!exists) {
-                // Handle comma-separated selectors (e.g., "$Event{Status},$Event{Type}")
-                const selectors = data.selector.split(',').map(s => s.trim());
-                const selectorValues = {};
-                for (const selector of selectors) {
-                    if (!selector.startsWith('$Event{')) {
-                        throw new Error('Selector should be in the format $Event{...}{key}');
-                    }
-                    const stages = (0, string_utils_2.extractStages)(selector);
-                    let current = data.sample;
-                    for (const stage of stages) {
-                        if (current && typeof current === 'object' && stage in current) {
-                            current = current[stage];
-                        }
-                        else {
-                            throw new Error(`${selector} not found in event sample`);
-                        }
-                    }
-                    if (current === null ||
-                        typeof current === "undefined" ||
-                        typeof current === "object") {
-                        throw new Error("Selector value is not allowed to be an object|array|null|undefined");
-                    }
-                    // Store the selector and its value
-                    selectorValues[selector] = current;
-                }
-                // For single selector, use the value directly; for multiple, use the object
-                const combinedSelectorValue = selectors.length === 1
-                    ? selectorValues[selectors[0]]
-                    : selectorValues;
-                //check other webhooksevents to see if there are other places where selector and selectorValue match up
-                const existing = await this.fetchWebhookEvents(webhookTag);
-                existing === null || existing === void 0 ? void 0 : existing.map((event) => {
-                    if (selectors.length === 1) {
-                        // Single selector comparison (backward compatible)
-                        if (event.selector === data.selector && event.selectorValue === combinedSelectorValue) {
-                            throw new Error(`Selector ${data.selector} with value ${combinedSelectorValue} already exists on event ${event.tag}`);
-                        }
-                    }
-                    else {
-                        // Multiple selectors - compare the full selector string and combined values
-                        if (event.selector === data.selector && JSON.stringify(event.selectorValue) === JSON.stringify(combinedSelectorValue)) {
-                            throw new Error(`Selectors ${data.selector} with values ${JSON.stringify(combinedSelectorValue)} already exists on event ${event.tag}`);
-                        }
-                    }
-                });
-                data.sample_data = await this.inputsService.parseJson({
-                    data: data.sample,
-                    expected: types_1.ExpectedValues.PARSESAMPLE
-                });
-                data.selectorValue = combinedSelectorValue;
-                delete data.tag;
-                const payload = Object.assign(Object.assign({}, data), { webhookTag,
-                    tag, component: types_1.AppComponents.WEBHOOK_EVENT, action: types_1.RequestAction.CREATE });
-                await this.appApi.updateApp(this.app_id, payload, 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 && !data.selector) {
-                throw new Error(`selector is required when new event sample is supplied`);
-            }
-            if (data.sample) {
-                // Handle comma-separated selectors (e.g., "$Event{Status},$Event{Type}")
-                const selectors = data.selector.split(',').map(s => s.trim());
-                const selectorValues = {};
-                for (const selector of selectors) {
-                    if (!selector.startsWith('$Event{')) {
-                        throw new Error('Selector should be in the format $Event{...}{key}');
-                    }
-                    const stages = (0, string_utils_2.extractStages)(selector);
-                    let current = data.sample;
-                    for (const stage of stages) {
-                        if (current && typeof current === 'object' && stage in current) {
-                            current = current[stage];
-                        }
-                        else {
-                            throw new Error(`${selector} not found in event sample`);
-                        }
-                    }
-                    if (current === null ||
-                        typeof current === "undefined" ||
-                        typeof current === "object") {
-                        throw new Error("Selector value is not allowed to be an object|array|null|undefined");
-                    }
-                    // Store the selector and its value
-                    selectorValues[selector] = current;
-                }
-                // For single selector, use the value directly; for multiple, use the object
-                const combinedSelectorValue = selectors.length === 1
-                    ? selectorValues[selectors[0]]
-                    : selectorValues;
-                //check other webhooksevents to see if there are other places where selector and selectorValue match up
-                const existing = await this.fetchWebhookEvents(webhookTag);
-                existing === null || existing === void 0 ? void 0 : existing.map((existingEvent) => {
-                    if (selectors.length === 1) {
-                        // Single selector comparison (backward compatible)
-                        if (existingEvent.selector === data.selector && existingEvent.selectorValue === combinedSelectorValue && existingEvent.tag !== tag) {
-                            throw new Error(`Selector ${data.selector} with value ${combinedSelectorValue} already exists on event ${existingEvent.tag}`);
-                        }
-                    }
-                    else {
-                        // Multiple selectors - compare the full selector string and combined values
-                        if (existingEvent.selector === data.selector && JSON.stringify(existingEvent.selectorValue) === JSON.stringify(combinedSelectorValue) && existingEvent.tag !== tag) {
-                            throw new Error(`Selectors ${data.selector} with values ${JSON.stringify(combinedSelectorValue)} already exists on event ${existingEvent.tag}`);
-                        }
-                    }
-                });
-                data.sample_data = await this.inputsService.parseJson({
-                    data: data.sample,
-                    expected: types_1.ExpectedValues.PARSESAMPLE
-                });
-                data.selectorValue = combinedSelectorValue;
-            }
-            // 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;
-        }
-    }
-    async 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 = await this.fetchWebhookEvents(webhookTag);
-        const event = events.find((event) => {
-            return event.tag === eventTag;
-        });
-        return event;
-    }
-    async fetchWebhookEvents(tag) {
-        const webhook = await this.fetchWebhook(tag);
-        if (!webhook) {
-            throw new Error(`Webhook ${tag} does not exist`);
-        }
-        return webhook.events;
-    }
-    getUserAccess() {
-        var _a;
-        return {
-            user_id: this.user_id,
-            workspace_id: this.workspace_id,
-            token: this.token,
-            public_key: this.public_key,
-            access_key: (_a = this.access_key) !== null && _a !== void 0 ? _a : undefined,
-        };
-    }
-}
-exports.default = AppBuilderService;
-//# sourceMappingURL=app.service.js.map