@my-devkit/core 1.0.121 → 1.0.122

package/src/serialize/type-helper.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-types */
 import { Deserialize, GenericDeserialize, Serialize, __TypeMap } from 'cerialize';
 
 import { _get, _isObjectLike, _keys, _trimEnd } from '../vendors/lodash';
@@ -8,8 +7,7 @@ export class TypeHelper {
         const serialized = Serialize(rawJson, classType);
         const deserialized = GenericDeserialize(serialized, classType);
 
-        if ((new classType())['_type'] === classType.name)
-            deserialized['_type'] = classType.name;
+        if (new classType()['_type'] === classType.name) deserialized['_type'] = classType.name;
 
         return deserialized;
     }
@@ -21,7 +19,9 @@ export class TypeHelper {
         const remaining = metaData.map(m => ({ parent: null, m }));
         while (remaining.length > 0) {
             const property = remaining.shift();
-            const path = property.parent ? `${property.parent}.${property.m.name}` : property.m.name;
+            const path = property.parent
+                ? `${property.parent}.${property.m.name}`
+                : property.m.name;
             result.push({
                 parent: property.parent ? _trimEnd(property.parent, '[]') : null,
                 path,
@@ -33,7 +33,7 @@ export class TypeHelper {
 
             if (property.m.type === TypeHelper.Type.Object) {
                 const parent = property.m.isArray ? `${path}[]` : path;
-                remaining.push(...property.m.objectMetadata.map(m => ({ parent, m })))
+                remaining.push(...property.m.objectMetadata.map(m => ({ parent, m })));
             }
         }
         return result;
@@ -49,15 +49,24 @@ export class TypeHelper {
             const metaDataType = TypeHelper.getMetaDataType(m.deserializedType);
             const metadata: TypeHelper.MetaData = {
                 name: m.keyName,
-                serializedKey: (m.serializedKey ? m.serializedKey : m.keyName),
-                deserializedKey: (m.deserializedKey ? m.deserializedKey : m.keyName),
+                serializedKey: m.serializedKey ? m.serializedKey : m.keyName,
+                deserializedKey: m.deserializedKey ? m.deserializedKey : m.keyName,
                 type: metaDataType,
-                enumName: metaDataType === TypeHelper.Type.Enum ? this.getEnumName(m.deserializedType) : null,
+                enumName:
+                    metaDataType === TypeHelper.Type.Enum
+                        ? this.getEnumName(m.deserializedType)
+                        : null,
                 isArray: Array.isArray(instance[m.keyName]),
                 arrayLength: Array.isArray(instance[m.keyName]) ? instance[m.keyName].length : null,
                 objectName: metaDataType === TypeHelper.Type.Object ? m.deserializedType.name : [],
-                objectMetadata: metaDataType === TypeHelper.Type.Object ? this.getMetaData(m.deserializedType) : [],
-                enumValues: metaDataType === TypeHelper.Type.Enum ? this.getEnumValues(m.deserializedType) : []
+                objectMetadata:
+                    metaDataType === TypeHelper.Type.Object
+                        ? this.getMetaData(m.deserializedType)
+                        : [],
+                enumValues:
+                    metaDataType === TypeHelper.Type.Enum
+                        ? this.getEnumValues(m.deserializedType)
+                        : []
             };
             return metadata;
         });
@@ -132,21 +141,33 @@ export class TypeHelper {
     }
 
     private static isString(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'String') {
+        if (
+            propType &&
+            propType.Deserialize &&
+            propType.Deserialize.name.replace('deserialize', '') === 'String'
+        ) {
             return true;
         }
         return false;
     }
 
     private static isBoolean(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'Boolean') {
+        if (
+            propType &&
+            propType.Deserialize &&
+            propType.Deserialize.name.replace('deserialize', '') === 'Boolean'
+        ) {
             return true;
         }
         return false;
     }
 
     private static isNumber(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'Number') {
+        if (
+            propType &&
+            propType.Deserialize &&
+            propType.Deserialize.name.replace('deserialize', '') === 'Number'
+        ) {
             return true;
         }
         return false;
@@ -194,8 +215,11 @@ export namespace TypeHelper {
     }
 
     type NonFunctionPropertyNames<T> = {
-        [K in keyof T]: T[K] extends Function ? never : K
+        [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;
     }[keyof T];
 
-    export type ClassProperties<T> = Omit<Pick<T, NonFunctionPropertyNames<T>>, '_path' | 'publishedAt' | 'publishedAt'>;
+    export type ClassProperties<T> = Omit<
+        Pick<T, NonFunctionPropertyNames<T>>,
+        '_path' | 'publishedAt' | 'publishedAt'
+    >;
 }

package/src/sleep.ts

@@ -7,4 +7,4 @@ import { Logger } from './logger';
 export const sleep = async (miliseconds: number): Promise<void> => {
     Logger.info(`Sleeping ${miliseconds} ms`);
     return new Promise<void>(resolve => setTimeout(() => resolve(), miliseconds));
-}
+};

package/src/validators/custom-validators/greater-than-date.ts

@@ -1,6 +1,10 @@
 import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
 
-export function GreaterThanDate(property: string, milliSecondsOffset?: number, validationOptions?: ValidationOptions) {
+export function GreaterThanDate(
+    property: string,
+    milliSecondsOffset?: number,
+    validationOptions?: ValidationOptions
+) {
     return function (object: Record<string, any>, propertyName: string): void {
         registerDecorator({
             name: 'greaterThanDate',

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

@@ -1,8 +1,10 @@
-// eslint-disable-next-line no-restricted-imports
 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',
@@ -15,7 +17,12 @@ export function IsEmptyIf<T>(condition: (object: T) => boolean, validationOption
                     const [relatedCondition] = args.constraints;
                     const cond = relatedCondition(args.object);
 
-                    if (cond && Array.isArray(value) && validationOptions && validationOptions.each) {
+                    if (
+                        cond &&
+                        Array.isArray(value) &&
+                        validationOptions &&
+                        validationOptions.each
+                    ) {
                         return value.every(v => isNil(v));
                     } else if (cond) {
                         return isNil(value);

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

@@ -1,7 +1,10 @@
 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',

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

@@ -1,12 +1,22 @@
-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) {

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

@@ -1,12 +1,14 @@
-// eslint-disable-next-line no-restricted-imports
 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);
+        const valueIsNil = value === '' || value === null || value === undefined;
         return !valueIsNil || !condition(object, value);
     }, validationOptions);
 }

package/src/validators/index.ts

@@ -1,21 +1,75 @@
 export {
     // array validation methods
-    ArrayContains, ArrayMaxSize, ArrayMinSize, ArrayNotContains, ArrayNotEmpty, ArrayUnique,
+    ArrayContains,
+    ArrayMaxSize,
+    ArrayMinSize,
+    ArrayNotContains,
+    ArrayNotEmpty,
+    ArrayUnique,
     // string validation methods
-    Contains, Equals, IsAlpha, IsAlphanumeric,
+    Contains,
+    Equals,
+    IsAlpha,
+    IsAlphanumeric,
     // type validation methods
-    IsArray, IsAscii, IsBase64, IsBoolean,
+    IsArray,
+    IsAscii,
+    IsBase64,
+    IsBoolean,
     // string-type validation methods
-    IsBooleanString, IsByteLength,
-    IsCreditCard, IsCurrency, IsDate, IsDefined,
+    IsBooleanString,
+    IsByteLength,
+    IsCreditCard,
+    IsCurrency,
+    IsDate,
+    IsDefined,
     // number validation methods
-    IsDivisibleBy, IsEmail, IsEmpty, IsEnum, IsFQDN, IsFullWidth, IsHalfWidth, IsHexColor, IsHexadecimal, IsIP, IsISBN, IsISIN, IsISO8601, IsIn, IsInt, IsJSON, IsLowercase, IsMilitaryTime, IsMobilePhone,
-    IsMongoId, IsMultibyte, IsNegative, IsNotEmpty, IsNotIn, IsNumber, IsNumberString, IsOptional, IsPositive, IsString, IsSurrogatePair, IsUUID, IsUppercase, IsUrl, IsVariableWidth, Length, Matches, Max, MaxDate, MaxLength, Min,
+    IsDivisibleBy,
+    IsEmail,
+    IsEmpty,
+    IsEnum,
+    IsFQDN,
+    IsFullWidth,
+    IsHalfWidth,
+    IsHexColor,
+    IsHexadecimal,
+    IsIP,
+    IsISBN,
+    IsISIN,
+    IsISO8601,
+    IsIn,
+    IsInt,
+    IsJSON,
+    IsLowercase,
+    IsMilitaryTime,
+    IsMobilePhone,
+    IsMongoId,
+    IsMultibyte,
+    IsNegative,
+    IsNotEmpty,
+    IsNotIn,
+    IsNumber,
+    IsNumberString,
+    IsOptional,
+    IsPositive,
+    IsString,
+    IsSurrogatePair,
+    IsUUID,
+    IsUppercase,
+    IsUrl,
+    IsVariableWidth,
+    Length,
+    Matches,
+    Max,
+    MaxDate,
+    MaxLength,
+    Min,
     // date validation methods
-    MinDate, MinLength, NotContains, NotEquals, ValidateNested
+    MinDate,
+    MinLength,
+    NotContains,
+    NotEquals,
+    ValidateNested
 } from 'class-validator';
 export * from './custom-validators';
 export { validate } from './validate';
-
-
-

package/src/validators/validate.ts

@@ -89,43 +89,75 @@ const validationPriorities = [
     'pascalCase'
 ];
 
-function recursiveGetErrors(validationErrors: ClassValidatorValidationError[], errors: ValidationError[] = [],
-    propertyName = '', previousValueWasArray = false): ValidationError[] {
+function recursiveGetErrors(
+    validationErrors: ClassValidatorValidationError[],
+    errors: ValidationError[] = [],
+    propertyName = '',
+    previousValueWasArray = false
+): ValidationError[] {
     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 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));
+            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++;
             }
 
-            if (validationError.contexts && validationError.contexts[domainErrorCode] && validationError.contexts[domainErrorCode].domainErrorCodes) {
+            if (
+                validationError.contexts &&
+                validationError.contexts[domainErrorCode] &&
+                validationError.contexts[domainErrorCode].domainErrorCodes
+            ) {
                 domainErrorCode = validationError.contexts[domainErrorCode].domainErrorCodes;
             }
 
-            const domainErrorProperty = propertyName ? (containsNestedValidation ? propertyName : `${propertyName}.${validationError.property}`) : validationError.property;
+            const domainErrorProperty = propertyName
+                ? containsNestedValidation
+                    ? propertyName
+                    : `${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) {
             let childName = validationError.property;
             if (propertyName) {
-                childName = previousValueWasArray ? `${propertyName}[${validationError.property}]` : `${propertyName}.${validationError.property}`;
+                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),
+                validationError.children.filter(ve =>
+                    ve.constraints
+                        ? !Object.keys(ve.constraints).includes('nestedValidation') ||
+                          ve.children.length === 0
+                        : true
+                ),
                 errors,
                 childName,
                 Array.isArray(validationError.value)

package/src/validators/validation-error.ts

@@ -5,9 +5,8 @@ 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 {
         if (this.message && typeof this.message === 'string') {

package/src/vendors/lodash.ts

@@ -41,4 +41,3 @@ export {
     values as _values,
     words as _words
 } from 'lodash';
-

package/tsconfig.json

@@ -10,8 +10,6 @@
         "declaration": true,
         "emitDecoratorMetadata": true,
         "experimentalDecorators": true,
-        "lib": [
-          "ES2021"
-        ]
+        "lib": ["ES2021"]
     }
 }