@nest-omni/core 1.0.0

package/src/decorators/field.decorators.ts

@@ -0,0 +1,773 @@
+import { applyDecorators } from '@nestjs/common';
+import type { ApiPropertyOptions } from '@nestjs/swagger';
+import { ApiProperty } from '@nestjs/swagger';
+import { i18nValidationMessage } from 'nestjs-i18n';
+import { Type } from 'class-transformer';
+import {
+  ArrayMaxSize,
+  ArrayMinSize,
+  IsBoolean,
+  IsDate,
+  IsDefined,
+  IsEmail,
+  IsEnum,
+  IsFQDN,
+  IsInt,
+  IsIP,
+  IsNumber,
+  IsObject,
+  IsPositive,
+  IsString,
+  IsUrl,
+  IsUUID,
+  Max,
+  MaxDate,
+  MaxLength,
+  Min,
+  MinDate,
+  MinLength,
+  NotEquals,
+  ValidateNested,
+} from 'class-validator';
+
+import { supportedLanguageCount } from '../constants';
+import { ApiEnumProperty, ApiUUIDProperty } from './property.decorators';
+import {
+  PhoneNumberSerializer,
+  ToArray,
+  ToBoolean,
+  ToLowerCase,
+  ToUpperCase,
+} from './transform.decorators';
+import {
+  IsEmptyable,
+  IsNullable,
+  IsPhoneNumber,
+  IsTmpKey as IsTemporaryKey,
+} from './validator.decorators';
+import ValidatorJS from 'validator';
+
+type RequireField<T, K extends keyof T> = T & Required<Pick<T, K>>;
+
+interface IFieldOptions {
+  each?: boolean;
+  swagger?: boolean;
+  nullable?: boolean;
+  group?: string[];
+  message?: string;
+}
+
+interface INumberFieldOptions extends IFieldOptions {
+  min?: number;
+  max?: number;
+  int?: boolean;
+  isPositive?: boolean;
+}
+
+interface IDateFieldOptions extends IFieldOptions {
+  minDate?: Date | (() => Date);
+  maxDate?: Date | (() => Date);
+}
+
+interface IStringFieldOptions extends IFieldOptions {
+  minLength?: number;
+  maxLength?: number;
+  toLowerCase?: boolean;
+  toUpperCase?: boolean;
+}
+
+interface IEmailFieldOptions {
+  emailOptions?: ValidatorJS.IsEmailOptions;
+}
+
+interface IIPFieldOptions {
+  version?: ValidatorJS.IPVersion;
+}
+
+interface IFQDNFieldOptions extends ValidatorJS.IsFQDNOptions {}
+
+type IClassFieldOptions = IFieldOptions;
+type IBooleanFieldOptions = IFieldOptions;
+type IEnumFieldOptions = IFieldOptions;
+
+export function NumberField(
+  options: Omit<ApiPropertyOptions, 'type'> & INumberFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [Type(() => Number)];
+
+  if (options.nullable) {
+    decorators.push(
+      IsNullable({
+        each: options.each,
+      }),
+    );
+  } else {
+    decorators.push(
+      NotEquals(null, {
+        each: options.each,
+        message: i18nValidationMessage('validation.NOT_EQUALS'),
+      }),
+    );
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ type: Number, ...options }));
+  }
+
+  if (options.each) {
+    decorators.push(ToArray());
+  }
+
+  if (options.int) {
+    decorators.push(
+      IsInt({
+        each: options.each,
+        message: i18nValidationMessage('validation.IS_INT'),
+      }),
+    );
+  } else {
+    decorators.push(
+      IsNumber(
+        {},
+        {
+          each: options.each,
+          message: i18nValidationMessage('validation.IS_NUMBER'),
+        },
+      ),
+    );
+  }
+
+  if (typeof options.min === 'number') {
+    decorators.push(
+      Min(options.min, {
+        each: options.each,
+        message: i18nValidationMessage('validation.MIN'),
+      }),
+    );
+  }
+
+  if (typeof options.max === 'number') {
+    decorators.push(
+      Max(options.max, {
+        each: options.each,
+        message: i18nValidationMessage('validation.MAX'),
+      }),
+    );
+  }
+
+  if (options.isPositive) {
+    decorators.push(
+      IsPositive({
+        each: options.each,
+        message: i18nValidationMessage('validation.IS_POSITIVE'),
+      }),
+    );
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function NumberFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    INumberFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    NumberField({ required: false, ...options }),
+  );
+}
+
+export function StringField(
+  options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    Type(() => String),
+    IsString({
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_STRING'),
+    }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable({ each: options.each }));
+  } else {
+    decorators.push(
+      NotEquals(null, {
+        each: options.each,
+        message: i18nValidationMessage('validation.NOT_EQUALS'),
+      }),
+    );
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(
+      ApiProperty({ type: String, ...options, isArray: options.each }),
+    );
+  }
+
+  const minLength = options.minLength ?? 1;
+
+  decorators.push(
+    MinLength(minLength, {
+      each: options.each,
+      message: i18nValidationMessage('validation.MIN_LENGTH'),
+    }),
+  );
+
+  if (options.maxLength) {
+    decorators.push(
+      MaxLength(options.maxLength, {
+        each: options.each,
+        message: i18nValidationMessage('validation.MAX_LENGTH'),
+      }),
+    );
+  }
+
+  if (options.toLowerCase) {
+    decorators.push(ToLowerCase());
+  }
+
+  if (options.toUpperCase) {
+    decorators.push(ToUpperCase());
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function StringFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    StringField({ required: false, ...options }),
+  );
+}
+
+export function PasswordField(
+  options: Omit<ApiPropertyOptions, 'type' | 'minLength'> &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    StringField({ ...options, minLength: 6 }) /*IsPassword()*/,
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function PasswordFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required' | 'minLength'> &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    PasswordField({ required: false, ...options }),
+  );
+}
+
+export function BooleanField(
+  options: Omit<ApiPropertyOptions, 'type'> & IBooleanFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    ToBoolean(),
+    IsBoolean({ message: 'validation.INVALID_BOOLEAN' }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ type: Boolean, ...options }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function BooleanFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    IBooleanFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    BooleanField({ required: false, ...options }),
+  );
+}
+
+export function TranslationsField(
+  options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> &
+    IFieldOptions,
+): PropertyDecorator {
+  const decorators = [
+    ArrayMinSize(supportedLanguageCount),
+    ArrayMaxSize(supportedLanguageCount),
+    ValidateNested({
+      each: true,
+    }),
+    Type(() => options.type as FunctionConstructor),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ isArray: true, ...options }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function TranslationsFieldOptional(
+  options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> &
+    IFieldOptions,
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    TranslationsField({ required: false, ...options }),
+  );
+}
+
+export function TmpKeyField(
+  options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    StringField(options),
+    IsTemporaryKey({ each: options.each }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(
+      ApiProperty({ type: String, ...options, isArray: options.each }),
+    );
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function TmpKeyFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    TmpKeyField({ required: false, ...options }),
+  );
+}
+
+export function getEnumDescription(enumType: any): string {
+  const keys = Object.keys(enumType).filter(
+    (k) => typeof enumType[k as any] === 'number',
+  );
+  return keys.map((k) => `${enumType[k]}: ${k}`).join(', ');
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function EnumField<TEnum extends object>(
+  getEnum: () => TEnum,
+  options: Omit<ApiPropertyOptions, 'type' | 'enum' | 'enumName' | 'isArray'> &
+    IEnumFieldOptions = {},
+): PropertyDecorator {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types
+  const enumValue = getEnum();
+  const decorators = [
+    IsEnum(enumValue, {
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_ENUM'),
+    }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.each) {
+    decorators.push(ToArray());
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(
+      ApiEnumProperty(getEnum, {
+        ...options,
+        isArray: options.each,
+      }),
+    );
+  }
+
+  return applyDecorators(...decorators);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function ClassField<TClass extends object>(
+  getClass: () => TClass,
+  options: Omit<ApiPropertyOptions, 'type'> & IClassFieldOptions = {},
+): PropertyDecorator {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const classValue = getClass() as any;
+
+  if (!classValue) {
+    throw new Error('ClassField: recursive class definition');
+  }
+
+  const decorators = [
+    Type(() => classValue),
+    ValidateNested({ each: options.each }),
+  ];
+
+  if (options.required !== false) {
+    decorators.push(IsDefined());
+  }
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(
+      ApiProperty({
+        type: () => classValue,
+        ...options,
+      }),
+    );
+  }
+
+  if (options.each) {
+    decorators.push(ToArray());
+  }
+
+  return applyDecorators(...decorators);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function EnumFieldOptional<TEnum extends object>(
+  getEnum: () => TEnum,
+  options: Omit<ApiPropertyOptions, 'type' | 'required' | 'enum' | 'enumName'> &
+    IEnumFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    EnumField(getEnum, { required: false, ...options }),
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function ClassFieldOptional<TClass extends object>(
+  getClass: () => TClass,
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    IClassFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    ClassField(getClass, { required: false, ...options }),
+  );
+}
+
+export function EmailField(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IStringFieldOptions &
+    IEmailFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    IsEmail(options.emailOptions, {
+      message:
+        options.message ?? i18nValidationMessage('validation.INVALID_EMAIL'),
+    }),
+    StringField({ toLowerCase: true, ...options }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ type: String, ...options }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function EmailFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IStringFieldOptions &
+    IEmailFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    EmailField({ required: false, ...options }),
+  );
+}
+
+export function PhoneField(
+  options: Omit<ApiPropertyOptions, 'type'> & IFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [IsPhoneNumber(), PhoneNumberSerializer()];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ type: String, ...options }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function PhoneFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> & IFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    PhoneField({ required: false, ...options }),
+  );
+}
+
+export function UUIDField(
+  options: Omit<ApiPropertyOptions, 'type' | 'format' | 'isArray'> &
+    IFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    Type(() => String),
+    IsUUID('4', {
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_UUID'),
+    }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(
+      IsNullable({ message: i18nValidationMessage('validation.IS_NULLABLE') }),
+    );
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiUUIDProperty(options));
+  }
+
+  if (options.each) {
+    decorators.push(ToArray());
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function UUIDFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required' | 'isArray'> &
+    IFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    UUIDField({ required: false, ...options }),
+  );
+}
+
+export function URLField(
+  options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    IsUrl(
+      {},
+      {
+        each: options.each,
+        message: i18nValidationMessage('validation.IS_URL'),
+      },
+    ),
+    StringField({ toLowerCase: true, ...options }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable({ each: options.each }));
+  } else {
+    decorators.push(NotEquals(null, { each: options.each }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function URLFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    URLField({ required: false, ...options }),
+  );
+}
+
+export function FQDNField(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IFQDNFieldOptions &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    IsFQDN(options, {
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_FQDN'),
+    }),
+    StringField({ toLowerCase: true, ...options }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable({ each: options.each }));
+  } else {
+    decorators.push(NotEquals(null, { each: options.each }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function FQDNFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IFQDNFieldOptions &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    FQDNField({ required: false, ...options }),
+  );
+}
+
+export function DateField(
+  options: Omit<ApiPropertyOptions, 'type'> & IDateFieldOptions = {},
+): PropertyDecorator {
+  const decorators = [
+    Type(() => Date),
+    IsDate({ message: i18nValidationMessage('validation.IS_DATE') }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable());
+  } else {
+    decorators.push(NotEquals(null));
+  }
+
+  if (options.minDate) {
+    decorators.push(
+      MinDate(options.minDate, {
+        each: options.each,
+        message: i18nValidationMessage('validation.MIN_DATE'),
+      }),
+    );
+  }
+
+  if (options.maxDate) {
+    decorators.push(
+      MaxDate(options.maxDate, {
+        each: options.each,
+        message: i18nValidationMessage('validation.MAX_DATE'),
+      }),
+    );
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(ApiProperty({ type: Date, ...options }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function DateFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> &
+    IDateFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    DateField({ ...options, required: false }),
+  );
+}
+
+export function IpFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IIPFieldOptions &
+    IStringFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    IpField({ required: false, ...options }),
+  );
+}
+
+export function IpField(
+  options: Omit<ApiPropertyOptions, 'type'> &
+    IStringFieldOptions &
+    IIPFieldOptions,
+): PropertyDecorator {
+  const decorators = [
+    IsIP(options.version || 4, {
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_IP'),
+    }),
+    StringField({ toLowerCase: true, ...options }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable({ each: options.each }));
+  } else {
+    decorators.push(NotEquals(null, { each: options.each }));
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function ObjectField(
+  options: Omit<ApiPropertyOptions, 'type'> & IFieldOptions,
+): PropertyDecorator {
+  const decorators = [
+    Type(() => Object),
+    IsObject({
+      each: options.each,
+      message: i18nValidationMessage('validation.IS_OBJECT'),
+    }),
+  ];
+
+  if (options.nullable) {
+    decorators.push(IsNullable({ each: options.each }));
+  } else {
+    decorators.push(NotEquals(null, { each: options.each }));
+  }
+
+  if (options.swagger !== false) {
+    decorators.push(
+      ApiProperty({
+        type: 'object',
+        ...options,
+      }),
+    );
+  }
+
+  return applyDecorators(...decorators);
+}
+
+export function ObjectFieldOptional(
+  options: Omit<ApiPropertyOptions, 'type'> & IFieldOptions = {},
+): PropertyDecorator {
+  return applyDecorators(
+    IsEmptyable(),
+    ObjectField({ required: false, ...options }),
+  );
+}