@nest-omni/core 1.0.56 → 2.0.1-0

package/src/validator-json/default.ts

@@ -0,0 +1,257 @@
+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

@@ -0,0 +1,402 @@
+// 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

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

package/src/validator-json/options.ts

@@ -0,0 +1,50 @@
+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',
+};