@my-devkit/core 1.0.122 → 1.0.124

package/src/validators/custom-validators/is-empty-if.ts

@@ -1,10 +1,7 @@
 import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
 import { isNil } from 'lodash';
 
-export function IsEmptyIf<T>(
-    condition: (object: T) => boolean,
-    validationOptions?: ValidationOptions
-) {
+export function IsEmptyIf<T>(condition: (object: T) => boolean, validationOptions?: ValidationOptions) {
     return function (object: Record<string, any>, propertyName: string): void {
         registerDecorator({
             name: 'isEmpty',
@@ -17,20 +14,15 @@ export function IsEmptyIf<T>(
                     const [relatedCondition] = args.constraints;
                     const cond = relatedCondition(args.object);
 
-                    if (
-                        cond &&
-                        Array.isArray(value) &&
-                        validationOptions &&
-                        validationOptions.each
-                    ) {
-                        return value.every(v => isNil(v));
+                    if (cond && Array.isArray(value) && validationOptions && validationOptions.each) {
+                        return value.every((v) => isNil(v));
                     } else if (cond) {
                         return isNil(value);
                     }
 
                     return true;
-                }
-            }
+                },
+            },
         });
     };
 }

package/src/validators/custom-validators/is-not-empty-if.ts

@@ -1,10 +1,7 @@
 import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
 import { isNil } from 'lodash';
 
-export function IsNotEmptyIf<T>(
-    condition: (object: T) => boolean,
-    validationOptions?: ValidationOptions
-) {
+export function IsNotEmptyIf<T>(condition: (object: T) => boolean, validationOptions?: ValidationOptions) {
     return function (object: Record<string, any>, propertyName: string): void {
         registerDecorator({
             name: 'isNotEmpty',
@@ -17,8 +14,8 @@ export function IsNotEmptyIf<T>(
                     const [relatedCondition] = args.constraints;
                     const cond = relatedCondition(args.object);
                     return cond ? !isNil(value) : true;
-                }
-            }
+                },
+            },
         });
     };
 }

package/src/validators/custom-validators/is-not-in-relative-to.ts

@@ -1,33 +1,23 @@
-import {
-    isNotIn,
-    registerDecorator,
-    ValidationArguments,
-    ValidationOptions
-} from 'class-validator';
+import { isNotIn, registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
 
-export function IsNotInRelativeTo<T, S>(
-    excludedValuesCallback: (object: T) => S[],
-    validationOptions?: ValidationOptions
-) {
+export function IsNotInRelativeTo<T, S>(excludedValuesCallback: (object: T) => S[], validationOptions?: ValidationOptions) {
     return function (object: Record<string, any>, propertyName: string): void {
         registerDecorator({
             name: 'isNotInRelativeTo',
             target: object.constructor,
             propertyName: propertyName,
-            constraints: [
-                { name: 'isNotInRelativeTo', relativeValueCallback: excludedValuesCallback }
-            ],
+            constraints: [{ name: 'isNotInRelativeTo', relativeValueCallback: excludedValuesCallback }],
             options: validationOptions,
             validator: {
                 validate(value: any, args: ValidationArguments) {
                     const excludedValues = args.constraints[0].relativeValueCallback(args.object);
                     if (Array.isArray(value) && validationOptions && validationOptions.each) {
-                        return value.every(v => isNotIn(v, excludedValues));
+                        return value.every((v) => isNotIn(v, excludedValues));
                     } else {
                         return isNotIn(value, excludedValues);
                     }
-                }
-            }
+                },
+            },
         });
     };
 }

package/src/validators/custom-validators/is-optional-if.ts

@@ -3,10 +3,7 @@ import { ValidateIf, ValidationOptions } from 'class-validator';
 /**
  * Checks if value is missing and if so, ignores all validators.
  **/
-export function IsOptionalIf<T>(
-    condition: (object: T, value: any) => boolean,
-    validationOptions?: ValidationOptions
-) {
+export function IsOptionalIf<T>(condition: (object: T, value: any) => boolean, validationOptions?: ValidationOptions) {
     return ValidateIf((object: T, value: any) => {
         const valueIsNil = value === '' || value === null || value === undefined;
         return !valueIsNil || !condition(object, value);

package/src/validators/custom-validators/pascal-case.ts

@@ -11,8 +11,8 @@ export function PascalCase(validationOptions?: ValidationOptions) {
             validator: {
                 validate(value: any) {
                     return /^([A-Z]{1,3}[a-z0-9]*)+$/.test(value);
-                }
-            }
+                },
+            },
         });
     };
 }

package/src/validators/index.ts

@@ -69,7 +69,7 @@ export {
     MinLength,
     NotContains,
     NotEquals,
-    ValidateNested
+    ValidateNested,
 } from 'class-validator';
 export * from './custom-validators';
 export { validate } from './validate';

package/src/validators/validate.ts

@@ -86,14 +86,14 @@ const validationPriorities = [
     'greaterThanDate',
     'isNotInRelativeTo',
     'isOptionalIf',
-    'pascalCase'
+    'pascalCase',
 ];
 
 function recursiveGetErrors(
     validationErrors: ClassValidatorValidationError[],
     errors: ValidationError[] = [],
     propertyName = '',
-    previousValueWasArray = false
+    previousValueWasArray = false,
 ): ValidationError[] {
     for (const validationError of validationErrors) {
         if (!validationError) {
@@ -102,20 +102,15 @@ function recursiveGetErrors(
 
         if (validationError.constraints) {
             const containsNestedValidation =
-                Object.keys(validationError.constraints).some(v => v === 'nestedValidation') &&
-                validationError.children.length > 0;
+                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)
-            );
+            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]
-                );
+                domainErrorCode = validations.find((vp) => vp.split('-')[0] === validationPriorities[i]);
                 i++;
             }
 
@@ -133,14 +128,7 @@ function recursiveGetErrors(
                     : `${propertyName}.${validationError.property}`
                 : validationError.property;
 
-            errors.push(
-                new ValidationError(
-                    domainErrorProperty,
-                    validationError.value,
-                    constraintName,
-                    null
-                )
-            );
+            errors.push(new ValidationError(domainErrorProperty, validationError.value, constraintName, null));
         }
 
         if (validationError.children && validationError.children.length) {
@@ -152,15 +140,12 @@ function recursiveGetErrors(
             }
 
             errors = recursiveGetErrors(
-                validationError.children.filter(ve =>
-                    ve.constraints
-                        ? !Object.keys(ve.constraints).includes('nestedValidation') ||
-                          ve.children.length === 0
-                        : true
+                validationError.children.filter((ve) =>
+                    ve.constraints ? !Object.keys(ve.constraints).includes('nestedValidation') || ve.children.length === 0 : true,
                 ),
                 errors,
                 childName,
-                Array.isArray(validationError.value)
+                Array.isArray(validationError.value),
             );
         }
     }

package/src/validators/validation-error.ts

@@ -5,7 +5,7 @@ export class ValidationError {
         public readonly property: string,
         public readonly value: string,
         public readonly type: string,
-        public readonly message: string | ((args: ValidationArguments) => string)
+        public readonly message: string | ((args: ValidationArguments) => string),
     ) {}
 
     public getErrorMessage(): string {

package/src/vendors/lodash.ts

@@ -39,5 +39,5 @@ export {
     uniqBy as _uniqBy,
     upperFirst as _upperFirst,
     values as _values,
-    words as _words
+    words as _words,
 } from 'lodash';