@ductape/sdk 0.0.4-v3 → 0.0.4-v31

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

@@ -179,33 +179,221 @@ 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);
-            }
-            if (exists && throwErrorIfExists) {
-                throw new Error(`App action ${tag} already exists`);
-            }
+            exists = this.fetchAction(tag);
         }
         catch (e) {
-            throw 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 = {
+            tag: data.tag,
+            name: data.name,
+            method: data.method,
+            request_type: data.request_type || types_1.DataFormats.JSON,
+            description: data.description || '',
+            responses: []
+        };
+        // 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,
+                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,
+                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,
+                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),
+                        data: this.mergeMetadataIntoSchema(result.parsedData, result.metadata)
+                    };
+                    break;
+                case 'query':
+                    body.query = {
+                        type: types_1.InputsTypes.JSON,
+                        sample: JSON.stringify(data.query),
+                        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),
+                        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 (only if not already provided params/query)
+        if (data.resource) {
+            const { params, query: queryData } = await this.extractResourceData(data.resource);
+            body.resource = (0, strings_utils_1.extractURLPath)(data.resource);
+            // Merge resource-extracted params/query with existing ones
+            body.params = Object.assign(Object.assign({}, body.params), params);
+            body.query = Object.assign(Object.assign({}, body.query), queryData);
+        }
+        // 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);
+    }
+    // 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;
@@ -217,99 +405,167 @@ class AppBuilderService {
         return action;
     }
     async updateAction(tag, data) {
+        // Validate schema
         await validators_1.UpdateAppActionSchema.validateAsync(data);
         const action = 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,
+                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,
+                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,
+                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,
+                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);
+            // Merge resource-extracted params/query with existing ones
             body.params = Object.assign(Object.assign({}, body.params), params);
             body.query = Object.assign(Object.assign({}, body.query), queryData);
         }
+        // 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;
+        }
     }
     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) {
@@ -747,17 +1003,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}`);
@@ -805,7 +1063,7 @@ 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.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) {