@nest-omni/core 2.0.1-0 → 2.0.1-10

package/src/validator-json/default.ts

@@ -1,257 +0,0 @@
-import * as cv from 'class-validator';
-import { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
-import { groupBy, isEmpty, isString, reject } from 'lodash';
-import { defaultConverters } from './defaultConverters';
-import { defaultOptions, IOptions } from './options';
-import { I18nService } from 'nestjs-i18n';
-
-export { JSONSchema } from './decorators';
-
-/**
- * Convert an array of class-validator metadata into JSON Schema definitions.
- */
-export function validationMetadataArrayToSchemas(
-  metadatas: ValidationMetadata[],
-  i18n,
-  userOptions?: Partial<IOptions>,
-): any {
-  const options: IOptions = {
-    ...defaultOptions,
-    ...userOptions,
-  };
-  const rules = [];
-
-  Object.entries(
-    groupBy(
-      metadatas,
-      ({ target }) =>
-        target[options.schemaNameField as keyof typeof target] ??
-        (target as Function).name,
-    ),
-  ).forEach(([key, ownMetas]) => {
-    const target = ownMetas[0].target as Function;
-    const metas = ownMetas
-      .concat(getInheritedMetadatas(target, metadatas))
-      .filter(
-        (propMeta) =>
-          !(
-            isExcluded(propMeta, options) ||
-            isExcluded({ ...propMeta, target }, options)
-          ),
-      );
-
-    const required = getRequiredPropNames(target, metas, options);
-
-    Object.entries(groupBy(metas, 'propertyName')).forEach(
-      ([propName, propMetas]) => {
-        const schema = applyConverters(propMetas, options, i18n);
-        const filterSchema = schema.filter(
-          (item) => !['conditionalValidation', 'notEquals'].includes(item.type),
-        );
-
-        const fieldType = getFirstNonNullDataType(filterSchema);
-        rules.push({
-          field: propName,
-          fieldType,
-          required: required.includes(propName),
-          constraints: filterSchema,
-        });
-      },
-    );
-  });
-
-  return rules;
-}
-
-function getFirstNonNullDataType(data: any[]): string | undefined {
-  for (const item of data) {
-    const dataType = item.dataType;
-    delete item.dataType;
-    if (dataType) {
-      return dataType;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Generate JSON Schema definitions from the target object constructor.
- */
-export function targetConstructorToSchema(
-  targetConstructor: Function,
-  i18n: I18nService,
-  userOptions?: Partial<IOptions>,
-): any {
-  const options: IOptions = {
-    ...defaultOptions,
-    ...userOptions,
-  };
-
-  const storage = options.classValidatorMetadataStorage;
-  let metadatas = storage.getTargetValidationMetadatas(
-    targetConstructor,
-    '',
-    true,
-    false,
-  );
-  metadatas = populateMetadatasWithConstraints(storage, metadatas);
-  return validationMetadataArrayToSchemas(metadatas, i18n, userOptions);
-}
-
-function populateMetadatasWithConstraints(
-  storage: cv.MetadataStorage,
-  metadatas: ValidationMetadata[],
-): ValidationMetadata[] {
-  return metadatas.map((meta) => {
-    if (meta.constraintCls) {
-      const constraint = storage.getTargetValidatorConstraints(
-        meta.constraintCls,
-      );
-      if (constraint.length > 0) {
-        return { ...meta, type: constraint[0].name };
-      }
-    }
-    return { ...meta };
-  });
-}
-
-/**
- * Return target class' inherited validation metadatas, with original metadatas
- * given precedence over inherited ones in case of duplicates.
- *
- * Adapted from `class-validator` source.
- *
- * @param target Target child class.
- * @param metadatas All class-validator metadata objects.
- */
-function getInheritedMetadatas(
-  target: Function,
-  metadatas: ValidationMetadata[],
-) {
-  return metadatas.filter(
-    (d) =>
-      d.target instanceof Function &&
-      target.prototype instanceof d.target &&
-      !metadatas.find(
-        (m) =>
-          m.propertyName === d.propertyName &&
-          m.target === target &&
-          m.type === d.type,
-      ),
-  );
-}
-
-/**
- * Convert a property's class-validator metadata into a JSON Schema property.
- */
-function applyConverters(
-  propertyMetadatas: ValidationMetadata[],
-  options: IOptions,
-  i18n: I18nService,
-): any {
-  const converters = { ...defaultConverters, ...options.additionalConverters };
-
-  const convert = (meta: ValidationMetadata) => {
-    const typeMeta = options.classTransformerMetadataStorage?.findTypeMetadata(
-      meta.target as Function,
-      meta.propertyName,
-    );
-    const isMap =
-      typeMeta &&
-      typeMeta.reflectedType &&
-      new typeMeta.reflectedType() instanceof Map;
-
-    const converter =
-      converters[meta.type] || converters[cv.ValidationTypes.CUSTOM_VALIDATION];
-
-    const converterResult =
-      typeof converter === 'function' ? converter(meta, options) : converter;
-
-    const items = {};
-    let message = '';
-    // @ts-ignore
-    const originMessage = typeof meta.message === 'function' ? meta.message(meta) : meta.message;
-    if (isString(originMessage)) {
-      const [translationKey, argsString] = originMessage.split('|');
-      const args = !!argsString ? JSON.parse(argsString) : {};
-      message = i18n.translate(translationKey, {
-        ...options,
-        args: {
-          constraints: meta.constraints,
-          ...args,
-        },
-      });
-    }
-    items['type'] = meta.type;
-    items['dataType'] = converterResult?.type || undefined;
-    items['attrs'] = meta.constraints || [];
-    items['message'] = message;
-
-    if (meta.each && isMap) {
-      return {
-        additionalProperties: {
-          ...items,
-        },
-        type: 'object',
-      };
-    }
-    return meta.each ? { items, type: 'array' } : items;
-  };
-  // const constraints = [];
-  const constraints = propertyMetadatas.map((meta) => {
-    return convert(meta);
-  });
-
-  return reject(constraints, (item) => isEmpty(item));
-}
-
-/** Check whether property is excluded with class-transformer `@Exclude` decorator. */
-function isExcluded(
-  propertyMetadata: ValidationMetadata,
-  options: IOptions,
-): boolean {
-  return !!options.classTransformerMetadataStorage?.findExcludeMetadata(
-    propertyMetadata.target as Function,
-    propertyMetadata.propertyName,
-  );
-}
-
-/**
- * Get the required property names of a validated class.
- * @param target Validation target class.
- * @param metadatas Validation metadata objects of the validated class.
- * @param options Global class-validator options.
- */
-function getRequiredPropNames(
-  target: Function,
-  metadatas: ValidationMetadata[],
-  options: IOptions,
-) {
-  function isDefined(metas: ValidationMetadata[]) {
-    return (
-      metas && metas.some(({ type }) => type === cv.ValidationTypes.IS_DEFINED)
-    );
-  }
-
-  function isOptional(metas: ValidationMetadata[]) {
-    return (
-      metas &&
-      metas.some(({ type }) =>
-        [cv.ValidationTypes.CONDITIONAL_VALIDATION, cv.IS_EMPTY].includes(type),
-      )
-    );
-  }
-
-  return (
-    Object.entries(groupBy(metadatas, (m) => m.propertyName))
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      .filter(([_, metas]) => {
-        const own = metas.filter((m) => m.target === target);
-        const inherited = metas.filter((m) => m.target !== target);
-        return options.skipMissingProperties
-          ? isDefined(own) || (!isOptional(own) && isDefined(inherited))
-          : !(isOptional(own) || isOptional(inherited));
-      })
-      .map(([name]) => name)
-  );
-}

package/src/validator-json/defaultConverters.ts

@@ -1,402 +0,0 @@
-// tslint:disable:no-submodule-imports
-import * as cv from 'class-validator';
-import type { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
-import 'reflect-metadata';
-
-import { IOptions } from './options';
-
-export interface ISchemaConverters {
-  [validatorType: string]: any;
-}
-
-export type SchemaConverter = (
-  meta: ValidationMetadata,
-  options: IOptions,
-) => any;
-
-export const defaultConverters: ISchemaConverters = {
-  [cv.ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
-    if (typeof meta.target === 'function') {
-      const type = getPropType(meta.target.prototype, meta.propertyName);
-      return targetToSchema(type, options);
-    }
-  },
-  [cv.ValidationTypes.NESTED_VALIDATION]: (meta, options) => {
-    if (typeof meta.target === 'function') {
-      const typeMeta = options.classTransformerMetadataStorage
-        ? options.classTransformerMetadataStorage.findTypeMetadata(
-            meta.target,
-            meta.propertyName,
-          )
-        : null;
-      const childType = typeMeta
-        ? typeMeta.typeFunction()
-        : getPropType(meta.target.prototype, meta.propertyName);
-      return targetToSchema(childType, options);
-    }
-  },
-  [cv.ValidationTypes.WHITELIST]: {},
-  [cv.ValidationTypes.CONDITIONAL_VALIDATION]: {},
-  [cv.ValidationTypes.IS_DEFINED]: {
-    not: { type: 'null' },
-  },
-  [cv.EQUALS]: (meta) => {
-    const schema = constraintToSchema(meta.constraints[0]);
-    if (schema) {
-      return { ...schema, enum: [meta.constraints[0]] };
-    }
-  },
-  [cv.NOT_EQUALS]: (meta) => {
-    const schema = constraintToSchema(meta.constraints[0]);
-    if (schema) {
-      return { not: { ...schema, enum: [meta.constraints[0]] } };
-    }
-  },
-  [cv.IS_EMPTY]: {
-    type: 'string',
-    anyOf: [
-      { type: 'string', enum: [''] },
-      {
-        not: {
-          anyOf: [
-            { type: 'string' },
-            { type: 'number' },
-            { type: 'boolean' },
-            { type: 'integer' },
-            { type: 'array' },
-            { type: 'object' },
-          ],
-        },
-        nullable: true,
-      },
-    ],
-  },
-  [cv.IS_NOT_EMPTY]: {
-    minLength: 1,
-    type: 'string',
-  },
-  [cv.IS_IN]: (meta) => {
-    const [head, ...rest]: any[] = meta.constraints[0].map(constraintToSchema);
-    if (head && rest.every((item) => item.type === head.type)) {
-      return { ...head, enum: meta.constraints[0] };
-    }
-    return {
-      type: 'string',
-    };
-  },
-  [cv.IS_NOT_IN]: (meta) => {
-    const [head, ...rest]: any[] = meta.constraints[0].map(constraintToSchema);
-    if (head && rest.every((item) => item.type === head.type)) {
-      return { not: { ...head, enum: meta.constraints[0] } };
-    }
-    return {
-      type: 'string',
-    };
-  },
-  [cv.IS_BOOLEAN]: {
-    type: 'boolean',
-  },
-  [cv.IS_DATE]: {
-    type: 'string',
-    oneOf: [
-      { format: 'date', type: 'string' },
-      { format: 'date-time', type: 'string' },
-    ],
-  },
-  [cv.IS_NUMBER]: {
-    type: 'number',
-  },
-  [cv.IS_STRING]: {
-    type: 'string',
-  },
-  [cv.IS_DATE_STRING]: {
-    pattern: '\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d.\\d+Z?',
-    type: 'string',
-  },
-  [cv.IS_ARRAY]: {
-    items: {},
-    type: 'array',
-  },
-  [cv.IS_INT]: {
-    type: 'integer',
-  },
-  [cv.IS_ENUM]: (meta) => {
-    return {
-      enum: Object.values(meta.constraints[0]),
-      type: 'string',
-    };
-  },
-  [cv.IS_DIVISIBLE_BY]: (meta) => ({
-    multipleOf: meta.constraints[0],
-    type: 'number',
-  }),
-  [cv.IS_POSITIVE]: {
-    exclusiveMinimum: 0,
-    type: 'number',
-  },
-  [cv.IS_NEGATIVE]: {
-    exclusiveMaximum: 0,
-    type: 'number',
-  },
-  [cv.MIN]: (meta) => ({
-    minimum: meta.constraints[0],
-    type: 'number',
-  }),
-  [cv.MAX]: (meta) => ({
-    maximum: meta.constraints[0],
-    type: 'number',
-  }),
-  [cv.MIN_DATE]: (meta) => ({
-    description: `After ${meta.constraints[0].toJSON()}`,
-    oneOf: [
-      { format: 'date', type: 'string' },
-      { format: 'date-time', type: 'string' },
-    ],
-  }),
-  [cv.MAX_DATE]: (meta) => ({
-    description: `Before ${meta.constraints[0].toJSON()}`,
-    oneOf: [
-      { format: 'date', type: 'string' },
-      { format: 'date-time', type: 'string' },
-    ],
-  }),
-  [cv.IS_BOOLEAN_STRING]: {
-    enum: ['true', 'false'],
-    type: 'string',
-  },
-  [cv.IS_NUMBER_STRING]: {
-    pattern: '^[-+]?[0-9]+$',
-    type: 'string',
-  },
-  [cv.CONTAINS]: (meta) => ({
-    pattern: meta.constraints[0],
-    type: 'string',
-  }),
-  [cv.NOT_CONTAINS]: (meta) => ({
-    not: { pattern: meta.constraints[0] },
-    type: 'string',
-  }),
-  [cv.IS_ALPHA]: {
-    pattern: '^[a-zA-Z]+$',
-    type: 'string',
-  },
-  [cv.IS_ALPHANUMERIC]: {
-    pattern: '^[0-9a-zA-Z]+$',
-    type: 'string',
-  },
-  [cv.IS_ASCII]: {
-    pattern: '^[\\x00-\\x7F]+$',
-    type: 'string',
-  },
-  [cv.IS_BASE64]: {
-    format: 'base64',
-    type: 'string',
-  },
-  [cv.IS_BYTE_LENGTH]: {
-    type: 'string',
-  },
-  [cv.IS_CREDIT_CARD]: {
-    format: 'credit-card',
-    type: 'string',
-  },
-  [cv.IS_CURRENCY]: {
-    format: 'currency',
-    type: 'string',
-  },
-  [cv.IS_EMAIL]: {
-    format: 'email',
-    type: 'string',
-  },
-  [cv.IS_FQDN]: {
-    format: 'hostname',
-    type: 'string',
-  },
-  [cv.IS_FULL_WIDTH]: {
-    pattern:
-      '[^\\u0020-\\u007E\\uFF61-\\uFF9F\\uFFA0-\\uFFDC\\uFFE8-\\uFFEE0-9a-zA-Z]',
-    type: 'string',
-  },
-  [cv.IS_HALF_WIDTH]: {
-    pattern:
-      '[\\u0020-\\u007E\\uFF61-\\uFF9F\\uFFA0-\\uFFDC\\uFFE8-\\uFFEE0-9a-zA-Z]',
-    type: 'string',
-  },
-  [cv.IS_VARIABLE_WIDTH]: {
-    type: 'string',
-  },
-  [cv.IS_HEX_COLOR]: {
-    pattern: '^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$',
-    type: 'string',
-  },
-  [cv.IS_HEXADECIMAL]: {
-    pattern: '^[0-9a-fA-F]+$',
-    type: 'string',
-  },
-  [cv.IS_IP]: (meta) => ({
-    format: 'ipv' + (meta.constraints[0] === '6' ? 6 : 4),
-    type: 'string',
-  }),
-  [cv.IS_ISBN]: {
-    format: 'isbn',
-    type: 'string',
-  },
-  [cv.IS_ISIN]: {
-    format: 'isin',
-    type: 'string',
-  },
-  [cv.IS_ISO8601]: {
-    oneOf: [
-      { format: 'date', type: 'string' },
-      { format: 'date-time', type: 'string' },
-    ],
-  },
-  [cv.IS_JSON]: {
-    format: 'json',
-    type: 'string',
-  },
-  [cv.IS_LOWERCASE]: {
-    type: 'string',
-  },
-  [cv.IS_MOBILE_PHONE]: {
-    format: 'mobile-phone',
-    type: 'string',
-  },
-  [cv.IS_MONGO_ID]: {
-    pattern: '^[0-9a-fA-F]{24}$',
-    type: 'string',
-  },
-  [cv.IS_MULTIBYTE]: {
-    pattern: '[^\\x00-\\x7F]',
-    type: 'string',
-  },
-  [cv.IS_SURROGATE_PAIR]: {
-    pattern: '[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]',
-    type: 'string',
-  },
-  [cv.IS_URL]: {
-    format: 'url',
-    type: 'string',
-  },
-  [cv.IS_UUID]: {
-    format: 'uuid',
-    type: 'string',
-  },
-  [cv.IS_LENGTH]: (meta) => {
-    const [minLength, maxLength] = meta.constraints;
-    if (maxLength || maxLength === 0) {
-      return { min: minLength, max: maxLength, type: 'Range' };
-    }
-    return { min: minLength, type: 'Range' };
-  },
-  [cv.IS_UPPERCASE]: {
-    type: 'string',
-  },
-  [cv.IS_OBJECT]: {
-    type: 'object',
-  },
-  [cv.IS_NOT_EMPTY_OBJECT]: {
-    type: 'object',
-    minProperties: 1,
-  },
-  [cv.MIN_LENGTH]: (meta) => ({
-    minLength: meta.constraints[0],
-    type: 'string',
-  }),
-  [cv.MAX_LENGTH]: (meta) => ({
-    maxLength: meta.constraints[0],
-    type: 'string',
-  }),
-  [cv.MATCHES]: (meta) => ({
-    pattern: meta.constraints[0].source,
-    type: 'string',
-  }),
-  [cv.IS_MILITARY_TIME]: {
-    pattern: '^([01]\\d|2[0-3]):?([0-5]\\d)$',
-    type: 'string',
-  },
-  [cv.ARRAY_CONTAINS]: (meta) => {
-    const schemas: any[] = meta.constraints[0].map(constraintToSchema);
-    if (schemas.length > 0 && schemas.every((s) => s && s.type)) {
-      return {
-        not: {
-          anyOf: schemas.map((d, i) => ({
-            items: {
-              not: {
-                ...d,
-                enum: [meta.constraints[0][i]],
-              },
-            },
-          })),
-        },
-        type: 'array',
-      };
-    }
-    return { items: {}, type: 'array' };
-  },
-  [cv.ARRAY_NOT_CONTAINS]: (meta) => {
-    const schemas: any[] = meta.constraints[0].map(constraintToSchema);
-    if (schemas.length > 0 && schemas.every((s) => s && s.type)) {
-      return {
-        items: {
-          not: {
-            anyOf: schemas.map((d, i) => ({
-              ...d,
-              enum: [meta.constraints[0][i]],
-            })),
-          },
-        },
-        type: 'array',
-      };
-    }
-    return { items: {}, type: 'array' };
-  },
-  [cv.ARRAY_NOT_EMPTY]: {
-    items: {},
-    minItems: 1,
-    type: 'array',
-  },
-  [cv.ARRAY_MIN_SIZE]: (meta) => ({
-    items: {},
-    minItems: meta.constraints[0],
-    type: 'array',
-  }),
-  [cv.ARRAY_MAX_SIZE]: (meta) => ({
-    items: {},
-    maxItems: meta.constraints[0],
-    type: 'array',
-  }),
-  [cv.ARRAY_UNIQUE]: {
-    items: {},
-    type: 'array',
-    uniqueItems: true,
-  },
-};
-
-function getPropType(target: object, property: string) {
-  return Reflect.getMetadata('design:type', target, property);
-}
-
-function constraintToSchema(primitive: any): any | void {
-  const primitives = ['string', 'number', 'boolean'];
-  const type = typeof primitive;
-  if (primitives.includes(type)) {
-    return { type: type as 'string' | 'number' | 'boolean' };
-  }
-}
-
-function targetToSchema(type: any, options: IOptions): any {
-  if (typeof type === 'function') {
-    if (
-      type.prototype === String.prototype ||
-      type.prototype === Symbol.prototype
-    ) {
-      return { type: 'string' };
-    } else if (type.prototype === Number.prototype) {
-      return { type: 'number' };
-    } else if (type.prototype === Boolean.prototype) {
-      return { type: 'boolean' };
-    }
-
-    return { $ref: options.refPointerPrefix + type.name };
-  }
-}

package/src/validator-json/index.ts

@@ -1,4 +0,0 @@
-export * from './default';
-export * from './decorators';
-export * from './defaultConverters';
-export * from './options';

package/src/validator-json/options.ts

@@ -1,50 +0,0 @@
-import type { MetadataStorage as ClassTransformerMetadataStorage } from 'class-transformer/types/MetadataStorage'; // tslint:disable-line:no-submodule-imports
-import {
-  getMetadataStorage,
-  MetadataStorage,
-  ValidatorOptions,
-} from 'class-validator';
-
-import { ISchemaConverters } from './defaultConverters';
-
-export interface IOptions extends ValidatorOptions {
-  /**
-   * A map of additional metadata-to-schema converters that can be used to
-   * supplement or override the default ones. The key should correspond to the
-   * 'type' property of a ValidationMetadata object.
-   */
-  additionalConverters: ISchemaConverters;
-
-  /**
-   * Metadata storage instance of class-transformer. This value can be
-   * optionally defined in order for class-transformer's @Type decorators to
-   * have effect in JSON Schema generation.
-   */
-  classTransformerMetadataStorage?: ClassTransformerMetadataStorage;
-
-  /**
-   * Metadata storage instance of class-validator. This value can be
-   * optionally defined in order to override the default storage used
-   * to parse decorator metadata.
-   */
-  classValidatorMetadataStorage: MetadataStorage;
-
-  /**
-   * A prefix added to all `$ref` JSON pointers referencing other schemas.
-   * Defaults to '#/definitions/'.
-   */
-  refPointerPrefix: string;
-
-  /**
-   * Property used to group schemas.
-   * Defaults to `name`, i.e., class name.
-   */
-  schemaNameField: string;
-}
-
-export const defaultOptions: IOptions = {
-  additionalConverters: {},
-  classValidatorMetadataStorage: getMetadataStorage(),
-  refPointerPrefix: '#/definitions/',
-  schemaNameField: 'name',
-};