@my-devkit/core 1.0.99 → 1.0.101

package/src/validators/validate.ts

@@ -1,10 +1,9 @@
-import { ValidationError as ClassValidatorValidationError, MetadataStorage, getFromContainer, validateSync } from 'class-validator';
-import { ValidationMetadata } from 'class-validator/metadata/ValidationMetadata';
+import { ValidationError as ClassValidatorValidationError, validateSync } from 'class-validator';
 
-import { Logger } from '../logger';
+import { Command } from '../command';
 import { ValidationError } from './validation-error';
 
-export function validate(data: unknown): ValidationError[] {
+export function validate(data: Command): ValidationError[] {
     const errors = validateSync(data);
     return recursiveGetErrors(errors);
 }
@@ -90,45 +89,49 @@ const validationPriorities = [
     'pascalCase'
 ];
 
-function getMetadatas(validationError: ClassValidatorValidationError, constraintName: string): ValidationMetadata {
-    const metadatas = getFromContainer(MetadataStorage);
-    const validationMetadatas: ValidationMetadata[] = (metadatas as any).validationMetadatas;
-    const filteredMetadatas = validationMetadatas
-        .filter(vmd => vmd.target === validationError.target.constructor
-            && vmd.propertyName === validationError.property
-            && (vmd.type === constraintName || (vmd.type === 'customValidation' && vmd.constraints[0] && vmd.constraints[0].name === constraintName)));
-    return filteredMetadatas[0];
-}
-
 function recursiveGetErrors(validationErrors: ClassValidatorValidationError[], errors: ValidationError[] = [],
     propertyName = '', previousValueWasArray = false): ValidationError[] {
-    validationErrors.forEach(validationError => {
-        let actualPropertyName = propertyName;
-        let actualPreviousValueWasArray = previousValueWasArray;
-        if (validationError.children?.length > 0) {
-            if (actualPreviousValueWasArray) {
-                actualPropertyName = `${actualPropertyName}[${validationError.property}]`;
-            } else {
-                actualPropertyName =
-                    actualPropertyName ? `${actualPropertyName}.${validationError.property}` : validationError.property;
+    for (const validationError of validationErrors) {
+        if (!validationError) {
+            return null;
+        }
+
+        if (validationError.constraints) {
+            const containsNestedValidation = Object.keys(validationError.constraints).some(v => v === 'nestedValidation') && validationError.children.length > 0;
+            const validations = Object.keys(validationError.constraints);
+
+            const constraintName = validationPriorities.find(cm => validations.some(cs => cs.split('-')[0] === cm));
+
+            let domainErrorCode: string;
+            let i = 0;
+            while (!domainErrorCode) {
+                domainErrorCode = validations.find(vp => vp.split('-')[0] === validationPriorities[i]);
+                i++;
             }
 
-            actualPreviousValueWasArray = Array.isArray(validationError.value);
-            validationErrors = validationError.children;
+            if (validationError.contexts && validationError.contexts[domainErrorCode] && validationError.contexts[domainErrorCode].domainErrorCodes) {
+                domainErrorCode = validationError.contexts[domainErrorCode].domainErrorCodes;
+            }
 
-            errors = recursiveGetErrors(validationErrors, errors, actualPropertyName, actualPreviousValueWasArray);
-        } else {
-            actualPropertyName = actualPropertyName ? `${actualPropertyName}.${validationError.property}` : validationError.property;
+            const domainErrorProperty = propertyName ? (containsNestedValidation ? propertyName : `${propertyName}.${validationError.property}`) : validationError.property;
 
-            const constraintName = validationPriorities.find(cm => Object.keys(validationError.constraints).some(cs => cs === cm));
-            if (!constraintName) {
-                Logger.warn(`validate: Constraint not found for ${actualPropertyName}`);
-            } else {
-                const metadatas = getMetadatas(validationError, constraintName);
-                errors.push(new ValidationError(actualPropertyName, validationError.value, constraintName, metadatas ? metadatas.message : null));
+            errors.push(new ValidationError(domainErrorProperty, validationError.value, constraintName, null));
+        }
+
+        if (validationError.children && validationError.children.length) {
+            let childName = validationError.property;
+            if (propertyName) {
+                childName = previousValueWasArray ? `${propertyName}[${validationError.property}]` : `${propertyName}.${validationError.property}`;
             }
 
+            errors = recursiveGetErrors(
+                validationError.children.filter(ve => ve.constraints ? !Object.keys(ve.constraints).includes('nestedValidation') || ve.children.length === 0 : true),
+                errors,
+                childName,
+                Array.isArray(validationError.value)
+            );
         }
-    });
+    }
+
     return errors;
 }

package/src/vendors/lodash.ts

@@ -29,6 +29,7 @@ export {
     trimEnd as _trimEnd,
     trimStart as _trimStart,
     uniq as _uniq,
+    uniqBy as _uniqBy,
     upperFirst as _upperFirst,
     words as _words
 } from 'lodash';

package/tsconfig.json

@@ -1,20 +1,17 @@
 {
-    "compileOnSave": false,
     "compilerOptions": {
-        "target": "es5",
-        "lib": [
-            "es2016",
-            "dom"
-        ],
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "target": "es6",
+        "esModuleInterop": true,
         "outDir": "./dist",
-        "baseUrl": "src",
+        "rootDir": "./src",
         "sourceMap": true,
         "declaration": true,
-        "moduleResolution": "node",
         "emitDecoratorMetadata": true,
         "experimentalDecorators": true,
-        "typeRoots": [
-            "node_modules/@types"
+        "lib": [
+          "ES2021"
         ]
     }
 }