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

package/src/validators/file-mimetype.validator.ts

@@ -1,34 +0,0 @@
-import { FileValidator } from '@nestjs/common/pipes/file/file-validator.interface';
-import { IFile } from '@nestjs/common/pipes/file/interfaces';
-
-export type FileMimetypeValidatorOptions = {
-  allowedMimetypes: string[];
-  message?: string;
-};
-
-export class FileMimetypeValidator extends FileValidator<
-  FileMimetypeValidatorOptions,
-  IFile
-> {
-  private allowedMimetypes: string[];
-  private message: string;
-
-  constructor(options: FileMimetypeValidatorOptions) {
-    super(options);
-    this.allowedMimetypes = options.allowedMimetypes;
-    this.message = options.message;
-  }
-
-  buildErrorMessage(): string {
-    if (this.message) {
-      return this.message;
-    }
-    return `Invalid file type. Only ${this.allowedMimetypes.join(
-      ', ',
-    )} are allowed.`;
-  }
-
-  isValid(file?: IFile): boolean {
-    return this.allowedMimetypes.includes(file.mimetype);
-  }
-}

package/src/validators/index.ts

@@ -1,6 +0,0 @@
-export * from './phone-country-code.validator';
-export * from './skip-empty.validator';
-export * from './file-mimetype.validator';
-export * from './is-exists.validator';
-export * from './is-unique.validator';
-export * from './same-as.validator';

package/src/validators/is-exists.validator.ts

@@ -1,60 +0,0 @@
-import type {
-  ValidationArguments,
-  ValidationOptions,
-  ValidatorConstraintInterface,
-} from 'class-validator';
-import { registerDecorator, ValidatorConstraint } from 'class-validator';
-import type { EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
-import { DataSource } from 'typeorm';
-import { getDataSourceByName } from 'typeorm-transactional';
-import { i18nValidationMessage } from 'nestjs-i18n';
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-@ValidatorConstraint({ name: 'isExists', async: true })
-export class IsExistsValidator implements ValidatorConstraintInterface {
-  constructor(private readonly dataSource: DataSource) {
-    this.dataSource = getDataSourceByName('default');
-  }
-
-  public async validate<E>(
-    value: string,
-    args: IExistsValidationArguments<E>,
-  ): Promise<boolean> {
-    const [entityClass, findCondition] = args.constraints;
-    args.value = value;
-    return (
-      (await this.dataSource.getRepository(entityClass).count({
-        where: findCondition(args),
-      })) > 0
-    );
-  }
-
-  defaultMessage(args: ValidationArguments): string {
-    return i18nValidationMessage('validation.IS_EXISTS')(args);
-  }
-}
-
-type ExistsValidationConstraints<E> = [
-  ObjectType<E> | EntitySchema<E> | string,
-  (validationArguments: ValidationArguments) => FindOptionsWhere<E>,
-];
-
-interface IExistsValidationArguments<E> extends ValidationArguments {
-  constraints: ExistsValidationConstraints<E>;
-}
-
-export function IsExists<E>(
-  constraints: Partial<ExistsValidationConstraints<E>>,
-  validationOptions?: ValidationOptions,
-): PropertyDecorator {
-  return (object, propertyName: string) => {
-    registerDecorator({
-      target: object.constructor,
-      propertyName,
-      options: validationOptions,
-      constraints,
-      validator: IsExistsValidator,
-    });
-  };
-}

package/src/validators/is-unique.validator.ts

@@ -1,93 +0,0 @@
-import type {
-  ValidationArguments,
-  ValidationOptions,
-  ValidatorConstraintInterface,
-} from 'class-validator';
-import { registerDecorator, ValidatorConstraint } from 'class-validator';
-import {
-  DataSource,
-  EntitySchema,
-  FindOptionsWhere,
-  ObjectType,
-} from 'typeorm';
-import { getDataSourceByName } from 'typeorm-transactional';
-import { i18nValidationMessage } from 'nestjs-i18n';
-
-@ValidatorConstraint({ name: 'isUnique', async: true })
-export class IsUniqueValidator implements ValidatorConstraintInterface {
-  constructor(private readonly dataSource: DataSource) {
-    this.dataSource = getDataSourceByName('default');
-  }
-
-  public async validate<E>(
-    value: string,
-    args: IUniqueValidationArguments<E>,
-  ): Promise<boolean> {
-    const [entityClass, findCondition] = args.constraints;
-    args.value = value;
-    let exists: boolean;
-    const defCon = findCondition(args);
-    const pkCols = this.dataSource
-      .getMetadata(entityClass)
-      .primaryColumns.map((column) => column.propertyName);
-
-    const isNew = pkCols.some((pk) => args.object[pk]);
-    if (!isNew) {
-      exists =
-        (await this.dataSource
-          .getRepository(entityClass)
-          .count({ where: defCon })) < 1;
-    } else {
-      const entities = await this.dataSource
-        .getRepository(entityClass)
-        .createQueryBuilder()
-        .where(defCon)
-        .select(pkCols)
-        .limit(2)
-        .execute();
-
-      const entityCount = entities.length;
-      if (entityCount === 1) {
-        const entity = entities[0];
-        const oldPk = {};
-        const newPk = {};
-        pkCols.map((pk) => {
-          oldPk[pk] = entity[pk];
-          newPk[pk] = args.object[pk];
-        });
-        exists = JSON.stringify(oldPk) === JSON.stringify(newPk);
-      } else {
-        exists = entityCount < 1;
-      }
-    }
-    return exists;
-  }
-
-  defaultMessage(args: ValidationArguments): string {
-    return i18nValidationMessage('validation.IS_UNIQUE')(args);
-  }
-}
-
-type UniqueValidationConstraints<E> = [
-  ObjectType<E> | EntitySchema<E> | string,
-  (validationArguments: ValidationArguments) => FindOptionsWhere<E>,
-];
-
-interface IUniqueValidationArguments<E> extends ValidationArguments {
-  constraints: UniqueValidationConstraints<E>;
-}
-
-export function IsUnique<E>(
-  constraints: Partial<UniqueValidationConstraints<E>>,
-  validationOptions?: ValidationOptions,
-): PropertyDecorator {
-  return function (object, propertyName: string) {
-    registerDecorator({
-      target: object.constructor,
-      propertyName,
-      options: validationOptions,
-      constraints,
-      validator: IsUniqueValidator,
-    });
-  };
-}

package/src/validators/phone-country-code.validator.ts

@@ -1,36 +0,0 @@
-import {
-  isPhoneNumber,
-  registerDecorator,
-  ValidateIf,
-  ValidationArguments,
-  ValidationOptions,
-} from 'class-validator';
-
-export function IsPhoneNumberWithCountryCode(
-  validationOptions?: ValidationOptions,
-) {
-  return function (object: NonNullable<unknown>, propertyName: string) {
-    ValidateIf((_, value) => !!value)(object, propertyName);
-    const countryCodePropertyName = 'countryCode';
-
-    registerDecorator({
-      name: 'isPhoneNumberWithCountryCode',
-      target: object.constructor,
-      propertyName: propertyName,
-      constraints: [countryCodePropertyName],
-      options: validationOptions,
-      validator: {
-        validate(value: any, args: ValidationArguments) {
-          const [countryCodePropertyName] = args.constraints;
-          const countryCode = args.object[countryCodePropertyName];
-          return isPhoneNumber(value, countryCode);
-        },
-        defaultMessage(args: ValidationArguments) {
-          const [countryCodePropertyName] = args.constraints;
-          const countryCode = args.object[countryCodePropertyName];
-          return `$property must be a valid phone number in the country code ${countryCode}`;
-        },
-      },
-    });
-  };
-}

package/src/validators/same-as.validator.ts

@@ -1,27 +0,0 @@
-import type { ValidationOptions } from 'class-validator';
-import { registerDecorator } from 'class-validator';
-
-export function SameAs(
-  property: string,
-  validationOptions?: ValidationOptions,
-): PropertyDecorator {
-  return function (object, propertyName: string) {
-    registerDecorator({
-      name: 'sameAs',
-      target: object.constructor,
-      propertyName,
-      options: validationOptions,
-      constraints: [property],
-      validator: {
-        validate(value, args) {
-          const [relatedPropertyName] = args!.constraints;
-
-          return args?.object[relatedPropertyName] === value;
-        },
-        defaultMessage() {
-          return '$property must match $constraint1';
-        },
-      },
-    });
-  };
-}

package/src/validators/skip-empty.validator.ts

@@ -1,25 +0,0 @@
-import { applyDecorators } from '@nestjs/common';
-import { ApiProperty } from '@nestjs/swagger';
-import { ValidateIf } from 'class-validator';
-import { isString } from 'lodash';
-
-/**
- * When the value is emtpy, validation is skipped
- * @param field
- * @constructor
- */
-export function SkipEmpty(field?: string) {
-  return applyDecorators(
-    ApiProperty({ required: false }),
-    ValidateIf((obj, value) => {
-      if (field) {
-        value = obj[field];
-      }
-      return !(
-        value === null ||
-        value === undefined ||
-        (isString(value) && value.trim() === '')
-      );
-    }),
-  );
-}

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "es6",
-    "sourceMap": false,
-    "outDir": "./dist",
-    "baseUrl": "./dist",
-    "incremental": true,
-    "skipLibCheck": true,
-    "strictNullChecks": false,
-    "noImplicitAny": false,
-    "strictBindCallApply": false,
-    "forceConsistentCasingInFileNames": false,
-    "noFallthroughCasesInSwitch": false,
-    "resolveJsonModule": true
-  },
-  "include": [
-    "./src/**/*.ts",
-    "./src/i18n/**/*.json"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/*.spec.ts",
-    "tests"
-  ]
-}

package/tsconfig.lib.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "outDir": "../../dist/libs/core"
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "test",
-    "**/*spec.ts"
-  ]
-}