@my-devkit/core 1.0.54 → 1.0.58

package/src/validators/validate.ts

@@ -0,0 +1,134 @@
+import { getFromContainer, MetadataStorage, validateSync, ValidationError as ClassValidatorValidationError } from 'class-validator';
+import { ValidationMetadata } from 'class-validator/metadata/ValidationMetadata';
+
+import { Logger } from '../logger';
+import { ValidationError } from './validation-error';
+
+export function validate(data: unknown): ValidationError[] {
+    const errors = validateSync(data);
+    return recursiveGetErrors(errors);
+}
+
+const validationPriorities = [
+    // common validation methods
+    'isDefined',
+    'equals',
+    'notEquals',
+    'isEmpty',
+    'isNotEmpty',
+    'isIn',
+    'isNotIn',
+    // type validation methods
+    'isArray',
+    'isBoolean',
+    'isDate',
+    'isString',
+    'isNumber',
+    'isInt',
+    'isEnum',
+    // number validation methods
+    'isDivisibleBy',
+    'isPositive',
+    'isNegative',
+    'max',
+    'min',
+    // date validation methods
+    'minDate',
+    'maxDate',
+    // string-type validation methods
+    'isBooleanString',
+    'isNumberString',
+    // string validation methods
+    'contains',
+    'notContains',
+    'isAlpha',
+    'isAlphanumeric',
+    'isAscii',
+    'isBase64',
+    'isByteLength',
+    'isCreditCard',
+    'isCurrency',
+    'isEmail',
+    'isFQDN',
+    'isFullWidth',
+    'isHalfWidth',
+    'isVariableWidth',
+    'isHexColor',
+    'isHexadecimal',
+    'isIP',
+    'isISBN',
+    'isISIN',
+    'isISO8601',
+    'isJSON',
+    'isLowercase',
+    'isMobilePhone',
+    'isMongoId',
+    'isMultibyte',
+    'isSurrogatePair',
+    'isUrl',
+    'isUUID',
+    'isUppercase',
+    'length',
+    'minLength',
+    'maxLength',
+    'matches',
+    'isMilitaryTime',
+    // array validation methods
+    'arrayContains',
+    'arrayNotContains',
+    'arrayNotEmpty',
+    'arrayMinSize',
+    'arrayMaxSize',
+    'arrayUnique',
+    // custom
+    'camelCase',
+    'equalsTo',
+    'greaterOrEqualThan',
+    'greaterThanDate',
+    'isNotInRelativeTo',
+    'isOptionalIf',
+    '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;
+            }
+
+            actualPreviousValueWasArray = Array.isArray(validationError.value);
+            validationErrors = validationError.children;
+
+            errors = recursiveGetErrors(validationErrors, errors, actualPropertyName, actualPreviousValueWasArray);
+        } else {
+            actualPropertyName = actualPropertyName ? `${actualPropertyName}.${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));
+            }
+
+        }
+    });
+    return errors;
+}

package/src/validators/validation-error.ts

@@ -0,0 +1,27 @@
+import { ValidationArguments } from 'class-validator';
+
+export class ValidationError {
+    constructor(
+        public readonly property: string,
+        public readonly value: string,
+        public readonly type: string,
+        public readonly message: string | ((args: ValidationArguments) => string)) {
+
+    }
+
+    public getErrorMessage(): string {
+        if (this.message && typeof this.message === 'string') {
+            return this.message;
+        }
+        switch (this.type) {
+            case 'isNotEmpty':
+                return 'Value is mandatory';
+            case 'camelCase':
+                return 'Value should be camel case (ex: fooBar)';
+            case 'pascalCase':
+                return 'Value should be pascal case (ex: FooBar)';
+            default:
+                return this.type;
+        }
+    }
+}

package/src/vendors/index.ts

@@ -0,0 +1 @@
+export * from './lodash';

package/src/vendors/lodash.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import {
+    cloneDeep,
+    deburr,
+    first,
+    flatten,
+    flattenDeep,
+    groupBy,
+    isEqual,
+    kebabCase,
+    last,
+    maxBy,
+    minBy,
+    shuffle,
+    sum,
+    sumBy,
+    trim,
+    trimEnd,
+    trimStart,
+    uniq,
+    words,
+} from 'lodash';
+
+// Define type (not exported)
+type List<T> = ArrayLike<T>;
+interface Dictionary<T> { [index: string]: T; }
+type NotVoid = unknown;
+type PropertyName = string | number | symbol;
+type PartialShallow<T> = { [P in keyof T]?: T[P] extends object ? object : T[P] };
+type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialShallow<T>;
+type Many<T> = T | ReadonlyArray<T>;
+type ValueIteratee<T> = ((value: T) => NotVoid) | IterateeShorthand<T>;
+type RecursiveArray<T> = Array<T | RecursiveArray<T>>;
+type ListOfRecursiveArraysOrValues<T> = List<T | RecursiveArray<T>>;
+type Flat<T> = T extends string ? T : (T extends List<any> ? never : T);
+
+// Export functions with proper type
+export const _uniq: <T>(array: List<T> | null | undefined) => T[] = uniq;
+export const _flatten: <T>(array: List<Many<T>>) => T[] = flatten;
+export const _flattenDeep: <T>(array: ListOfRecursiveArraysOrValues<T>) => Flat<T>[] = flattenDeep;
+export const _sumBy: <T>(collection: List<T>, iteratee?: string | ((value: T) => number)) => number = sumBy;
+export const _sum: (collection: List<any>) => number = sum;
+export const _words: {
+    (string?: string, pattern?: string | RegExp): string[];
+    (string: string, index: string | number, guard: object): string[];
+} = words;
+export const _isEqual: (value: any, other: any) => boolean = isEqual;
+export const _deburr: (string?: string) => string = deburr;
+export const _kebabCase: (string?: string) => string = kebabCase;
+export const _shuffle: {
+    <T>(collection: List<T>): T[];
+    <T extends object>(collection: T): T[keyof T][];
+} = shuffle;
+export const _groupBy: <T>(collection: List<T>, iteratee?: ValueIteratee<T>) => Dictionary<T[]> = groupBy;
+export const _cloneDeep: <T>(value: T) => T = cloneDeep;
+export const _maxBy: <T>(collection: List<T>, iteratee?: ValueIteratee<T>) => T = maxBy;
+export const _minBy: <T>(collection: List<T>, iteratee?: ValueIteratee<T>) => T = minBy;
+export const _first: <T>(array: List<T>) => T = first;
+export const _last: <T>(array: List<T>) => T = last;
+export const _trim: (string?: string, chars?: string) => string = trim;
+export const _trimStart: (string?: string, chars?: string) => string = trimStart;
+export const _trimEnd: (string?: string, chars?: string) => string = trimEnd;

package/tsconfig.json

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