@ductape/sdk 0.0.4 → 0.0.6

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

@@ -36,7 +36,7 @@ class AppBuilderService {
             }
             else {
                 const app = await this.createNewApp(data);
-                await this.initializeApp(app._id);
+                //await this.initializeApp(app._id);
             }
             return { app_id: this.app._id };
         }
@@ -44,12 +44,20 @@ class AppBuilderService {
             throw e;
         }
     }
-    initAppVersion() {
-        this.appVersion = this.app.versions.find((version) => version.latest === true);
+    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.fetchAppByTag(app_tag, this.getUserAccess());
+            this.app = await this.appApi.initApp(app_tag, this.getUserAccess());
             this.app_id = this.app._id;
             this.initAppVersion();
         }
@@ -59,7 +67,7 @@ class AppBuilderService {
     }
     async initializeApp(app_id) {
         try {
-            this.app = await this.appApi.fetchApp(app_id, this.getUserAccess());
+            this.app = await this.appApi.initApp(app_id, this.getUserAccess());
             this.app_id = app_id;
             this.initAppVersion();
         }
@@ -106,7 +114,7 @@ class AppBuilderService {
                 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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
@@ -115,10 +123,11 @@ class AppBuilderService {
     async createEnv(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchEnv(data.slug, false)) {
+            const existingEnv = await this.fetchEnv(data.slug, false);
+            if (!existingEnv) {
                 await validators_1.CreateAppEnvSchema.validateAsync(data);
                 await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({}, data), { component: types_1.AppComponents.ENV, action: types_1.RequestAction.CREATE }), this.getUserAccess());
-                await this.initializeApp(this.app_id);
+                //await this.initializeApp(this.app_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -131,24 +140,29 @@ class AppBuilderService {
     }
     async updateEnv(slug, data) {
         try {
-            // const { _id } = this.fetchEnv(slug);
+            // const { _id } = await this.fetchEnv(slug);
             await validators_1.UpdateAppEnvSchema.validateAsync(Object.assign(Object.assign({}, data), { slug }));
-            if (data.slug && this.fetchEnv(data.slug)) {
-                throw new Error(`slug ${slug} is in use`); // TODO: also check on the backend
+            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 }, data), { component: types_1.AppComponents.ENV, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchEnvs() {
-        return this.appVersion.envs;
+    async fetchEnvs() {
+        const components = await this.appApi.fetchAppComponents(this.app_id, 'env', this.getUserAccess(), this.appVersion.tag);
+        return components;
     }
-    fetchEnv(slug, throwErrorIfExists = true) {
-        const env = this.appVersion.envs.find((data) => data.slug === slug);
+    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;
@@ -179,137 +193,418 @@ class AppBuilderService {
             },
         };
     }
+    // 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 {
-            let url = data.resource;
-            if (!data.resource)
-                throw new Error('resource is required');
-            data.resource = (0, strings_utils_1.extractURLPath)(url);
-            await validators_1.CreateAppActionSchema.validateAsync(data);
-            data.tag = (0, string_utils_1.tagify)(data.tag);
-            const { tag } = data;
-            let exists;
-            try {
-                exists = this.fetchAction(tag);
-            }
-            catch (e) {
-                exists = false;
-            }
-            if (!exists) {
-                data.resource = url;
-                //await this.updateActionProcess(tag, { ...data }, RequestAction.CREATE);
+            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;
             }
-            if (exists && throwErrorIfExists) {
-                throw new Error(`App action ${tag} already exists`);
+        }
+        // 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
+                    };
+                }
             }
         }
-        catch (e) {
-            throw e;
+        // 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;
     }
-    fetchActions() {
-        return this.appVersion.actions;
+    async fetchActions() {
+        const components = await this.appApi.fetchAppComponents(this.app_id, 'action', this.getUserAccess(), this.appVersion.tag);
+        return components;
     }
-    fetchAction(identifier) {
-        const action = this.appVersion.actions.find((data) => data.tag === identifier || data._id === identifier);
+    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 = this.fetchAction(tag);
+        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) {
-            body.params = {
-                type: types_1.InputsTypes.JSON,
-                sample: JSON.stringify(data.params),
-                data: await this.inputsService.parseJson({ data: data.params, expected: types_1.ExpectedValues.PARSESAMPLE, category: types_1.Categories.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) {
-            body.query = {
-                type: types_1.InputsTypes.JSON,
-                sample: JSON.stringify(data.query),
-                data: await this.inputsService.parseJson({ data: data.query, expected: types_1.ExpectedValues.PARSESAMPLE, category: types_1.Categories.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) {
-            body.body = {
-                type: types_1.InputsTypes.JSON,
-                sample: JSON.stringify(data.body),
-                data: await this.inputsService.parseJson({ data: data.body, expected: types_1.ExpectedValues.PARSESAMPLE, category: types_1.Categories.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) {
-            body.headers = {
-                type: types_1.InputsTypes.JSON,
-                sample: data.headers,
-                data: await this.inputsService.parseJson({ data: data.headers, expected: types_1.ExpectedValues.PARSESAMPLE, category: types_1.Categories.HEADER })
-            };
+            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) {
-            const { params, query: queryData } = await this.extractResourceData(data.resource);
             body.resource = (0, strings_utils_1.extractURLPath)(data.resource);
-            body.params = Object.assign(Object.assign({}, body.params), params);
-            body.query = Object.assign(Object.assign({}, body.query), queryData);
+            // 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(body.description === ''){
-          body.description = undefined
-        }*/
         if (data.method) {
             body.method = data.method;
         }
         if (data.request_type) {
             body.request_type = data.request_type;
         }
-        if (data.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: await this.inputsService.parseJson({
-                        data: data.response.body,
-                        expected: types_1.ExpectedValues.PARSESAMPLE
-                    }),
-                    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);
-            }
-        }
+        // 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: types_1.RequestAction.UPDATE, tag }, data);
+        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) {
@@ -341,10 +636,10 @@ class AppBuilderService {
         return Object.assign(Object.assign({}, payload), { sample, data });
     }
     // private fetc
-    fetchActionRequestData(category, tag) {
+    async fetchActionRequestData(category, tag) {
         try {
             let data;
-            const action = this.fetchAction(tag);
+            const action = await this.fetchAction(tag);
             if (category === types_1.Categories.BODY) {
                 const { body } = action;
                 data = body.data;
@@ -370,10 +665,10 @@ class AppBuilderService {
             throw e;
         }
     }
-    fetchActionRequestSample(category, tag) {
+    async fetchActionRequestSample(category, tag) {
         try {
             let sample;
-            const action = this.fetchAction(tag);
+            const action = await this.fetchAction(tag);
             if (category === types_1.Categories.BODY) {
                 const { body } = action;
                 sample = body.sample;
@@ -401,10 +696,10 @@ class AppBuilderService {
     }
     async createAppActionResponse(action_tag, payload) {
         try {
-            this.fetchAction(action_tag);
+            await this.fetchAction(action_tag);
             await validators_1.CreateAppActionResponseSchema.validateAsync(Object.assign({}, payload));
             payload.tag = (0, string_utils_1.tagify)(payload.tag);
-            const exists = this.fetchAppActionResponse(action_tag, payload.tag);
+            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());
@@ -451,19 +746,21 @@ class AppBuilderService {
         payload.body.data = data;
         payload.body.sample = JSON.stringify(payload.body.sample);
         if (payload.envs && payload.envs.length) {
-            payload.envs = payload.envs.map((slug) => {
-                const { _id: env_id } = this.fetchEnv(slug);
-                return env_id;
-            });
+            const envIds = await Promise.all(payload.envs.map(async (slug) => {
+                const env = await this.fetchEnv(slug);
+                return env._id;
+            }));
+            payload.envs = envIds;
         }
         return payload;
     }
-    fetchAppActionResponse(action_tag, response_tag, throwErrorIfExists = false) {
-        const { responses } = this.fetchAction(action_tag);
-        const action = responses.find((data) => data.tag === response_tag);
-        if (!action && throwErrorIfExists)
+    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 action;
+        return response;
     }
     /*async extractEventData(data: Partial<IAppEvent>): Promise<Partial<IAppEvent>> {
       if (data.response) {
@@ -541,7 +838,7 @@ class AppBuilderService {
           this.getUserAccess(),
         );
   
-        await this.initializeApp(this.app_id);
+        //await this.initializeApp(this.app_id);
       } catch (e) {
         throw e;
       }
@@ -572,7 +869,7 @@ class AppBuilderService {
           this.getUserAccess(),
         );
   
-        await this.initializeApp(this.app_id);
+        //await this.initializeApp(this.app_id);
       } catch (e) {
         throw e;
       }
@@ -647,11 +944,11 @@ class AppBuilderService {
                 throw new Error(`token has to have one of body, headers, params or query set`);
             }
             if (setup_type === types_1.AuthTypes.CREDENTIALS) {
-                this.fetchAction(action_tag);
+                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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
@@ -660,21 +957,23 @@ class AppBuilderService {
     async updateAuth(tag, data) {
         try {
             await validators_1.UpdateAppAuthSchema.validateAsync(data);
-            const auth = this.fetchAuth(tag);
+            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);
+            //await this.initializeApp(this.app_id);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchAuths() {
-        return this.appVersion.auths;
+    async fetchAuths() {
+        const components = await this.appApi.fetchAppComponents(this.app_id, 'auth', this.getUserAccess(), this.appVersion.tag);
+        return components;
     }
-    fetchAuth(tag) {
-        const auth = this.appVersion.auths.find((data) => data.tag === tag);
+    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;
@@ -682,13 +981,13 @@ class AppBuilderService {
     async createVariable(data, throwErrorIfExists = false) {
         try {
             await validators_1.CreateAppVariableSchema.validateAsync(data);
-            const exists = this.fetchVariable(data.key, false);
+            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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
@@ -697,19 +996,21 @@ class AppBuilderService {
     async updateVariable(key, data) {
         try {
             await validators_1.UpdateAppVariableSchema.validateAsync(data);
-            this.fetchVariable(key);
+            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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchVariables() {
-        return this.appVersion.variables;
+    async fetchVariables() {
+        const components = await this.appApi.fetchAppComponents(this.app_id, 'variable', this.getUserAccess(), this.appVersion.tag);
+        return components;
     }
-    fetchVariable(key, throwErrorIfExists = true) {
-        const variable = this.appVersion.variables.find((data) => data.key === key);
+    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;
@@ -717,11 +1018,11 @@ class AppBuilderService {
     async createConstant(data, throwErrorIfExists = false) {
         try {
             await validators_1.CreateAppConstantSchema.validateAsync(data);
-            const exists = this.fetchConstant(data.key, false);
+            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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
@@ -729,15 +1030,17 @@ class AppBuilderService {
     }
     async updateConstant(key, data) {
         await validators_1.UpdateAppConstantSchema.validateAsync(data);
-        this.fetchConstant(key);
+        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);
+        //await this.initializeApp(this.app_id);
     }
-    fetchConstants() {
-        return this.appVersion.constants;
+    async fetchConstants() {
+        const components = await this.appApi.fetchAppComponents(this.app_id, 'constant', this.getUserAccess(), this.appVersion.tag);
+        return components;
     }
-    fetchConstant(key, throwErrorIfExists = true) {
-        const variable = this.appVersion.constants.find((data) => data.key === key);
+    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;
@@ -747,17 +1050,19 @@ class AppBuilderService {
         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, stages, update);
+            await this.updateValidation(types_1.AppCategories.BODY, stringStages, update);
         }
         else if (locator.startsWith('$Query{')) {
-            await this.updateValidation(types_1.AppCategories.QUERY, stages, update);
+            await this.updateValidation(types_1.AppCategories.QUERY, stringStages, update);
         }
         else if (locator.startsWith('$Params{')) {
-            await this.updateValidation(types_1.AppCategories.PARAMS, stages, update);
+            await this.updateValidation(types_1.AppCategories.PARAMS, stringStages, update);
         }
         else if (locator.startsWith('$Header{')) {
-            await this.updateValidation(types_1.AppCategories.HEADER, stages, update);
+            await this.updateValidation(types_1.AppCategories.HEADER, stringStages, update);
         }
         else {
             throw new Error(`Invalid input ${locator}`);
@@ -766,7 +1071,7 @@ class AppBuilderService {
     async updateValidation(category, stages, update) {
         try {
             const action_tag = stages[0];
-            const action = this.fetchAction(action_tag);
+            const action = await this.fetchAction(action_tag);
             const data = action[category];
             let level = -1;
             let key = '';
@@ -805,8 +1110,8 @@ class AppBuilderService {
                 'responses',
                 ...exclude,
             ]);
-            await this.appApi.updateApp(this.app_id, Object.assign(Object.assign({ tag: action_tag }, cleaned_action), { component: types_1.AppComponents.VALIDATION, action: types_1.RequestAction.UPDATE }), this.getUserAccess());
-            await this.initializeApp(this.app_id);
+            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;
@@ -815,10 +1120,11 @@ class AppBuilderService {
     async createWebhook(data, throwErrorIfExists = false) {
         try {
             // TODO: figure out a way to check if this has run before, halt if it has
-            if (!this.fetchWebhook(data.tag)) {
+            const existingWebhook = await this.fetchWebhook(data.tag);
+            if (!existingWebhook) {
                 await create_appWebhook_validator_1.IAppWebhookSchema.validateAsync(data);
-                data.envs = data.envs.map((env) => {
-                    const exists = this.fetchEnv(env.slug);
+                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`);
                     }
@@ -836,8 +1142,8 @@ class AppBuilderService {
                         env.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
                     }
                     return env;
-                });
-                const envs = this.fetchEnvs();
+                }));
+                const envs = await this.fetchEnvs();
                 envs.map((env) => {
                     const exists = data.envs.findIndex((dbEnv) => dbEnv.slug === env.slug);
                     if (exists === -1) {
@@ -845,7 +1151,7 @@ class AppBuilderService {
                     }
                 });
                 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);
+                //await this.initializeApp(this.app_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -858,13 +1164,17 @@ class AppBuilderService {
     }
     async updateWebhook(tag, data) {
         try {
-            const { _id, envs } = this.fetchWebhook(tag);
+            const webhook = await this.fetchWebhook(tag);
+            const { _id, envs } = webhook;
             await update_appWebhook_validator_1.IAppWebhookUpdateSchema.validateAsync(data); // Change to update;
-            if (data.tag && this.fetchWebhook(data.tag)) {
-                throw new Error(`tag ${tag} is in use`); // TODO: also check on the backend
+            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 = data.envs.map((env) => {
-                const exists = this.fetchEnv(env.slug);
+            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`);
                 }
@@ -880,12 +1190,13 @@ class AppBuilderService {
                     env.sample_data = [...bodyTemplate, ...queryTemplate, ...paramsTemplate, ...headerTemplate];
                 }
                 return env;
-            });
+            }));
             const overwrite = [];
             const newEnvs = [];
-            envs.map((env) => {
+            for (const env of envs) {
                 const exists = data.envs.findIndex((dataEnv) => env.slug === dataEnv.slug);
-                if (!this.fetchEnv(env.slug)) {
+                const envExists = await this.fetchEnv(env.slug, false);
+                if (!envExists) {
                     throw new Error(`Product Environment ${env.slug} doesn't exist`);
                 }
                 if (exists === -1) {
@@ -894,7 +1205,7 @@ class AppBuilderService {
                 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;
@@ -906,20 +1217,20 @@ class AppBuilderService {
             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);
+            //await this.initializeApp(this.app_id);
         }
         catch (e) {
             throw e;
         }
     }
-    fetchWebhook(tag) {
-        var _a, _b;
-        const exists = (_b = (_a = this.appVersion) === null || _a === void 0 ? void 0 : _a.webhooks) === null || _b === void 0 ? void 0 : _b.find((data) => data.tag === tag);
+    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;
     }
-    fetchWebhooks() {
-        var _a;
-        return (_a = this.appVersion) === null || _a === void 0 ? void 0 : _a.webhooks;
+    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 {
@@ -931,44 +1242,64 @@ class AppBuilderService {
             if (!webhookTag || !tag) {
                 throw new Error(`tag is expected to be defined as "webhook_tag:event_tag"`);
             }
-            const exists = this.fetchWebhookEvent(data.tag);
+            const exists = await this.fetchWebhookEvent(data.tag);
             data.tag = tag;
             if (!exists) {
-                if (!data.selector.startsWith('$Event{')) {
-                    throw new Error('Selector should be in the format $Event{...}{key}');
-                }
-                const stages = (0, string_utils_2.extractStages)(data.selector);
-                let current = data.sample;
-                for (const stage of stages) {
-                    if (current && typeof current === 'object' && stage in current) {
-                        current = current[stage];
+                // 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}');
                     }
-                    else {
-                        throw new Error(`${data.selector} not found in event sample`);
+                    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;
                 }
-                if (current === null ||
-                    typeof current === "undefined" ||
-                    typeof current === "object") {
-                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
-                }
+                // 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 = this.fetchWebhookEvents(webhookTag);
+                const existing = await this.fetchWebhookEvents(webhookTag);
                 existing === null || existing === void 0 ? void 0 : existing.map((event) => {
-                    if (event.selector === data.selector && event.selectorValue === current) {
-                        throw new Error(`Selector ${data.selector} with value ${current} already exists on event ${event.tag}`);
+                    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 = current;
+                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);
+                //await this.initializeApp(this.app_id);
             }
             else {
                 if (throwErrorIfExists)
@@ -998,36 +1329,56 @@ class AppBuilderService {
                 throw new Error(`selector is required when new event sample is supplied`);
             }
             if (data.sample) {
-                if (!data.selector.startsWith('$Event{')) {
-                    throw new Error('Selector should be in the format $Event{...}{key}');
-                }
-                const stages = (0, string_utils_2.extractStages)(data.selector);
-                let current = data.sample;
-                for (const stage of stages) {
-                    if (current && typeof current === 'object' && stage in current) {
-                        current = current[stage];
+                // 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}');
                     }
-                    else {
-                        throw new Error(`${data.selector} not found in event sample`);
+                    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;
                 }
-                if (current === null ||
-                    typeof current === "undefined" ||
-                    typeof current === "object") {
-                    throw new Error("Selector value is not allowed to be an object|array|null|undefined");
-                }
+                // 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 = this.fetchWebhookEvents(webhookTag);
-                existing === null || existing === void 0 ? void 0 : existing.map((event) => {
-                    if (event.selector === data.selector && event.selectorValue === current && event.tag !== tag) {
-                        throw new Error(`Selector ${data.selector} with value ${current} already exists on event ${event.tag}`);
+                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 = current;
+                data.selectorValue = combinedSelectorValue;
             }
             // Construct payload
             delete data.tag;
@@ -1035,26 +1386,26 @@ class AppBuilderService {
                 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);
+            //await this.initializeApp(this.app_id);
         }
         catch (error) {
             throw error;
         }
     }
-    fetchWebhookEvent(tag) {
+    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 = this.fetchWebhookEvents(webhookTag);
+        const events = await this.fetchWebhookEvents(webhookTag);
         const event = events.find((event) => {
             return event.tag === eventTag;
         });
         return event;
     }
-    fetchWebhookEvents(tag) {
-        const webhook = this.fetchWebhook(tag);
+    async fetchWebhookEvents(tag) {
+        const webhook = await this.fetchWebhook(tag);
         if (!webhook) {
             throw new Error(`Webhook ${tag} does not exist`);
         }