@nest-omni/core 1.0.57 → 2.0.1-0

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

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

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+{
+  "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

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

package/setup/bootstrap.setup.d.ts

@@ -1,2 +0,0 @@
-import type { NestExpressApplication } from '@nestjs/platform-express';
-export declare function bootstrapSetup(AppModule: any, SetupSwagger: any): Promise<NestExpressApplication<import("http").Server>>;

package/shared/services/aws-s3.service.d.ts

@@ -1,10 +0,0 @@
-import type { IFile } from '../../interfaces';
-import { ApiConfigService } from './api-config.service';
-import { GeneratorService } from './generator.service';
-export declare class AwsS3Service {
-    configService: ApiConfigService;
-    generatorService: GeneratorService;
-    private readonly s3;
-    constructor(configService: ApiConfigService, generatorService: GeneratorService);
-    uploadImage(file: IFile): Promise<string>;
-}

package/shared/services/aws-s3.service.js

@@ -1,56 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AwsS3Service = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const common_1 = require("@nestjs/common");
-const mime_types_1 = require("mime-types");
-const api_config_service_1 = require("./api-config.service");
-const generator_service_1 = require("./generator.service");
-let AwsS3Service = class AwsS3Service {
-    constructor(configService, generatorService) {
-        this.configService = configService;
-        this.generatorService = generatorService;
-        const awsS3Config = configService.awsS3Config;
-        this.s3 = new client_s3_1.S3({
-            apiVersion: awsS3Config.bucketApiVersion,
-            region: awsS3Config.bucketRegion,
-        });
-    }
-    uploadImage(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fileName = this.generatorService.fileName(mime_types_1.default.extension(file.mimetype));
-            const key = 'images/' + fileName;
-            yield this.s3.putObject({
-                Bucket: this.configService.awsS3Config.bucketName,
-                Body: file.buffer,
-                ACL: 'public-read',
-                Key: key,
-            });
-            return key;
-        });
-    }
-};
-exports.AwsS3Service = AwsS3Service;
-exports.AwsS3Service = AwsS3Service = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [api_config_service_1.ApiConfigService,
-        generator_service_1.GeneratorService])
-], AwsS3Service);