@ductape/sdk 0.1.8 → 0.1.10

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

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