@mondart/nestjs-common-module 1.0.3

package/common/services/core-crud.service.ts

@@ -0,0 +1,457 @@
+import {
+  DeepPartial,
+  DeleteResult,
+  FindManyOptions,
+  FindOptionsWhere,
+  Repository,
+  UpdateResult,
+} from 'typeorm';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { ParentEntity } from '../entities/parent.entity';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { paginate, Paginated } from 'nestjs-paginate';
+import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
+import { ObjectId } from 'typeorm/driver/mongodb/typings';
+import { PaginationQueryCustom } from '../interface/pagination-query';
+import { SharedMessages } from '../enums/shared-messages.enum';
+import { InsertResult } from 'typeorm/query-builder/result/InsertResult';
+import { CoreCrudServiceOption } from '../interface';
+import { UpsertOptions } from 'typeorm/repository/UpsertOptions';
+import { MessageFormatter } from '../helper/message-formatter.helper';
+
+@Injectable()
+export abstract class CoreCrudService<
+  T extends ParentEntity,
+  CreateDto,
+  UpdateDto,
+> {
+  private readonly relationsPath: string[];
+
+  protected constructor(protected readonly repository: Repository<T>) {
+    const metadata = this.repository.metadata;
+    this.relationsPath = metadata.relations.map(
+      (relation) => relation.propertyPath,
+    );
+  }
+
+  async create(
+    createDto: CreateDto,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<T> {
+    const relationEntityName = Object.keys(createDto).filter(
+      (item) => this.relationsPath.includes(item) && createDto[item],
+    );
+
+    relationEntityName.map((item) => {
+      createDto[item] = createDto[item].map((id: number) => {
+        return { id };
+      });
+    });
+
+    const entity = this.repository.create(createDto as DeepPartial<T>);
+
+    if (options?.entityManager) {
+      return await options.entityManager.save(entity);
+    } else {
+      return await this.repository.save(entity);
+    }
+  }
+
+  async findAllWithPagination(
+    query: PaginationQueryCustom,
+    paginateConfig: PaginateConfig<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<Paginated<T>> {
+    return await paginate<T>(query, this.repository, {
+      ...paginateConfig,
+      relations: options?.relations ? options?.relations : this.relationsPath,
+    });
+  }
+
+  async findAll(
+    query: FindManyOptions<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<T[]> {
+    let result: T[] | PromiseLike<T[]>;
+    if (!options?.entityManager)
+      result = await this.repository.find({
+        relations: this.relationsPath,
+        ...query,
+      });
+    else
+      result = await options.entityManager.find(this.repository.target, {
+        relations: this.relationsPath,
+        ...query,
+      });
+    if (options?.existsCheck && !result) {
+      throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+    }
+    return result;
+  }
+
+  async findOneById(
+    id: number,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<T> {
+    let result: T;
+
+    if (options?.entityManager) {
+      result = await options.entityManager.findOne<T>(this.repository.target, {
+        where: {
+          id,
+        } as FindOptionsWhere<T>,
+        relations: options?.relations ? options?.relations : this.relationsPath,
+      });
+    } else {
+      result = await this.repository.findOne({
+        where: {
+          id,
+        } as FindOptionsWhere<T>,
+        relations: options?.relations ? options?.relations : this.relationsPath,
+      });
+    }
+    if (options?.existsCheck && !result) {
+      throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+    }
+    return result;
+  }
+
+  async findOne(
+    query: FindManyOptions<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<T> {
+    const whereQuery = this.validateWhereQuery(query.where);
+    if (!whereQuery) {
+      return undefined;
+    }
+    query.where = whereQuery;
+    let result: T;
+
+    if (options?.entityManager) {
+      result = await options?.entityManager.findOne<T>(this.repository.target, {
+        relations: this.relationsPath,
+        ...query,
+      });
+    } else {
+      result = await this.repository.findOne({
+        ...query,
+        relations: query?.relations ? query?.relations : this.relationsPath,
+      });
+    }
+
+    if (options?.existsCheck && !result) {
+      throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+    }
+    return result;
+  }
+
+  async isExists(
+    query: FindManyOptions<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<boolean> {
+    // const whereQuery = this.validateWhereQuery(query.where);
+    // if (!whereQuery) {
+    //   return undefined;
+    // }
+    // query.where = whereQuery;
+    let result: boolean;
+
+    if (options?.entityManager) {
+      result = await options?.entityManager.exists<T>(this.repository.target, {
+        relations: query?.relations ? query?.relations : this.relationsPath,
+        ...query,
+      });
+    } else {
+      result = await this.repository.exists({
+        ...query,
+        relations: query?.relations ? query?.relations : this.relationsPath,
+      });
+    }
+
+    return result;
+  }
+
+  async count(
+    query: FindManyOptions<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<number> {
+    const whereQuery = this.validateWhereQuery(query.where);
+    if (!whereQuery) {
+      return undefined;
+    }
+    query.where = whereQuery;
+    let result: number;
+
+    if (options?.entityManager) {
+      result = await options?.entityManager.count<T>(this.repository.target, {
+        relations: query?.relations ? query?.relations : this.relationsPath,
+        ...query,
+      });
+    } else {
+      result = await this.repository.count({
+        ...query,
+        relations: query?.relations ? query?.relations : this.relationsPath,
+      });
+    }
+
+    return result;
+  }
+
+  async upsert(
+    upsertDto: QueryDeepPartialEntity<T>,
+    upsertOptions: UpsertOptions<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<InsertResult> {
+    try {
+      let conflictPaths: string[] = [];
+
+      let findWhereQuery: FindOptionsWhere<T> = {};
+      if (this.isArray(upsertOptions.conflictPaths)) {
+        conflictPaths = (upsertOptions.conflictPaths as string[]) ?? [];
+      } else {
+        conflictPaths = Object.keys(
+          upsertOptions.conflictPaths as { [P in keyof T]?: true },
+        );
+      }
+      conflictPaths.map((path) => {
+        findWhereQuery = {
+          ...findWhereQuery,
+          [path]: upsertDto[path],
+        };
+      });
+      if (!options?.entityManager) {
+        const existEntity = await this.repository.findOne({
+          where: findWhereQuery,
+          select: ['id'],
+        });
+
+        return await this.repository.upsert(
+          { id: existEntity.id, ...upsertDto },
+          upsertOptions,
+        );
+      } else {
+        const existEntity = await options?.entityManager.findOne<T>(
+          this.repository.target,
+          {
+            where: findWhereQuery,
+            select: ['id'],
+          },
+        );
+        return await options?.entityManager.upsert(
+          this.repository.target,
+          { id: existEntity.id, ...upsertDto },
+          upsertOptions,
+        );
+      }
+      // Delete Cache
+    } catch (error) {
+      throw new BadRequestException(
+        MessageFormatter.replace(SharedMessages.UPSERT_FAILED, error),
+      );
+    }
+  }
+
+  async update(
+    id: number,
+    updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<UpdateResult> {
+    if (!options?.entityManager) {
+      const fetchedItem = await this.repository.findOne({
+        where: { id } as FindOptionsWhere<T>,
+        relations: this.relationsPath,
+      });
+
+      if (!fetchedItem)
+        throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+
+      const relationEntityName = Object.keys(updateDto).filter(
+        (item) => this.relationsPath.includes(item) && updateDto[item],
+      );
+      relationEntityName.map((item) => {
+        delete fetchedItem[item];
+        updateDto[item] = updateDto[item].map((id: number) => {
+          return { id };
+        });
+      });
+      const merged = this.repository.merge(
+        fetchedItem,
+        updateDto as unknown as DeepPartial<T>,
+      );
+      await this.repository.save(merged);
+
+      return {
+        generatedMaps: [],
+        raw: merged,
+        affected: 1,
+      } as UpdateResult;
+    } else {
+      // Transaction context: use the provided EntityManager
+      const fetchedItem = await options?.entityManager.findOne<T>(
+        this.repository.target,
+        {
+          where: { id } as FindOptionsWhere<T>,
+          relations: this.relationsPath,
+        },
+      );
+      if (!fetchedItem)
+        throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+
+      const relationEntityName = Object.keys(updateDto).filter(
+        (item) => this.relationsPath.includes(item) && updateDto[item],
+      );
+      relationEntityName.map((item) => {
+        delete fetchedItem[item];
+        updateDto[item] = updateDto[item].map((id: number) => {
+          return { id };
+        });
+      });
+
+      const merged = options?.entityManager.merge(
+        this.repository.target,
+        fetchedItem,
+        updateDto as unknown as DeepPartial<T>,
+      );
+      await options?.entityManager.save(merged);
+      // Delete Cache
+      return {
+        generatedMaps: [],
+        raw: merged,
+        affected: 1,
+      } as UpdateResult;
+    }
+  }
+
+  async softDelete(
+    criteria:
+      | string
+      | string[]
+      | number
+      | number[]
+      | Date
+      | Date[]
+      | ObjectId
+      | ObjectId[]
+      | FindOptionsWhere<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<UpdateResult> {
+    if (options?.entityManager) {
+      return await options?.entityManager.softDelete(
+        this.repository.target,
+        criteria,
+      );
+    } else {
+      return await this.repository.softDelete(criteria);
+    }
+  }
+
+  async softDeleteById(
+    id: number,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<UpdateResult> {
+    if (options?.entityManager) {
+      return await options?.entityManager.softDelete(
+        this.repository.target,
+        id,
+      );
+    } else {
+      return await this.repository.softDelete(id);
+    }
+  }
+
+  async delete(
+    criteria:
+      | string
+      | string[]
+      | number
+      | number[]
+      | Date
+      | Date[]
+      | ObjectId
+      | ObjectId[]
+      | FindOptionsWhere<T>,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<DeleteResult> {
+    if (options?.entityManager) {
+      return await options?.entityManager.delete(
+        this.repository.target,
+        criteria,
+      );
+    } else {
+      return await this.repository.delete(criteria);
+    }
+  }
+
+  async deleteById(
+    id: number,
+    options?: CoreCrudServiceOption<T>,
+  ): Promise<DeleteResult> {
+    if (options?.entityManager) {
+      return await options?.entityManager.delete(this.repository.target, id);
+    } else {
+      return await this.repository.delete(id);
+    }
+  }
+
+  private validateWhereQuery(
+    query: FindOptionsWhere<T> | FindOptionsWhere<T>[],
+  ) {
+    if (this.isArray(query)) {
+      const newArrayQuery: FindOptionsWhere<T>[] = [];
+
+      query = query as FindOptionsWhere<T>[];
+      if (query.length !== 0) {
+        query.map((key, index) => {
+          if (this.isArray(query[index])) {
+            return query[index].map((item) => this.validateWhereQuery(item));
+          }
+          if (this.isObject(query[index])) {
+            this.validateWhereQuery(query[index]);
+          }
+          if (query[index] !== undefined) {
+            newArrayQuery.push({
+              [index]: query[index],
+            } as FindOptionsWhere<T>);
+          }
+        });
+      }
+      if (Object.keys(newArrayQuery).length === 0) return undefined;
+      return newArrayQuery;
+    } else {
+      let newQuery: FindOptionsWhere<T> = {};
+
+      const queryKeys = Object.keys(query);
+
+      if (queryKeys.length !== 0) {
+        queryKeys.map((key) => {
+          if (this.isArray(query[key])) {
+            return query[key].map((item) => this.validateWhereQuery(item));
+          }
+          if (this.isObject(query[key])) {
+            this.validateWhereQuery(query[key]);
+          }
+          if (query[key] !== undefined) {
+            newQuery = {
+              ...newQuery,
+              [key]: query[key],
+            } as FindOptionsWhere<T>;
+          }
+        });
+      }
+      if (Object.keys(newQuery).length === 0) return undefined;
+      return newQuery;
+    }
+  }
+
+  private isObject(value: any): boolean {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+  }
+
+  private isArray(value: any): boolean {
+    return value !== null && typeof value === 'object' && Array.isArray(value);
+  }
+}

package/common/services/index.ts

@@ -0,0 +1 @@
+export * from './core-crud.service';

package/common/strategy/index.ts

@@ -0,0 +1 @@
+export * from './type-orm-naming.strategy';

package/common/strategy/type-orm-naming.strategy.ts

@@ -0,0 +1,17 @@
+import { DefaultNamingStrategy, NamingStrategyInterface } from 'typeorm';
+import { snakeCase } from 'typeorm/util/StringUtils';
+
+export class SnakeNamingStrategy
+  extends DefaultNamingStrategy
+  implements NamingStrategyInterface
+{
+  columnName(
+    propertyName: string,
+    customName: string,
+    embeddedPrefixes: string[],
+  ): string {
+    return snakeCase(
+      embeddedPrefixes.concat(customName || propertyName).join('_'),
+    );
+  }
+}

package/common/validators/does-exist.validator.ts

@@ -0,0 +1,42 @@
+import {
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+import { DataSource } from 'typeorm';
+import { ValidationArguments } from 'class-validator/types/validation/ValidationArguments';
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+
+type ValidationEntity =
+  | {
+      id?: number | string;
+    }
+  | undefined;
+
+@Injectable()
+@ValidatorConstraint({ name: 'DoesExist', async: true })
+export class DoesExist implements ValidatorConstraintInterface {
+  constructor(
+    @InjectDataSource()
+    private dataSource: DataSource,
+  ) {}
+
+  async validate(value: string, validationArguments: ValidationArguments) {
+    const repository = validationArguments.constraints[0] as string;
+    const pathToProperty = validationArguments.constraints[1];
+    const targetRepository = this.dataSource.getRepository(repository);
+    const entity = (await targetRepository.findOne({
+      where: {
+        [pathToProperty ? pathToProperty : validationArguments.property]: value
+          ? value
+          : value?.[pathToProperty],
+      },
+    })) as ValidationEntity;
+
+    if (entity?.id === value) {
+      return true;
+    }
+
+    return false;
+  }
+}

package/common/validators/env.validator.ts

@@ -0,0 +1,28 @@
+import { plainToClass } from 'class-transformer';
+import { validateSync } from 'class-validator';
+
+export function envValidator(configuration: Record<string, unknown>, EnvironmentSchema: any) {
+  const finalConfig: string = plainToClass(EnvironmentSchema, configuration, {
+    enableImplicitConversion: true,
+  });
+
+  const errors = validateSync(finalConfig, { skipMissingProperties: false });
+  if (errors.length > 0) {
+    throw new Error(errors.toString());
+  }
+
+  return finalConfig;
+}
+
+export function testEnvValidator(configuration: Record<string, unknown>, EnvironmentTestSchema: any) {
+  const finalConfig: string = plainToClass(EnvironmentTestSchema, configuration, {
+    enableImplicitConversion: true,
+  });
+
+  const errors = validateSync(finalConfig, { skipMissingProperties: false });
+  if (errors.length > 0) {
+    throw new Error(errors.toString());
+  }
+
+  return finalConfig;
+}

package/common/validators/index.ts

@@ -0,0 +1,4 @@
+export * from './does-exist.validator';
+export * from './env.validator';
+export * from './is-unique.validator';
+export * from './validation-options';

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

@@ -0,0 +1,70 @@
+import {
+  IsNotIn,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+import { DataSource, FindOptionsWhere } from 'typeorm';
+import { ValidationArguments } from 'class-validator/types/validation/ValidationArguments';
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import {
+  CustomConstraintsInterface,
+  CustomValidationArguments,
+  CustomValidatorConstraintInterface,
+} from '../interface/custom-validation-arguments.interface';
+
+type ValidationEntity =
+  | {
+      id?: number | string;
+    }
+  | undefined;
+
+@Injectable()
+@ValidatorConstraint({ name: 'IsUnique', async: true })
+export class IsUnique implements CustomValidatorConstraintInterface {
+  constructor(
+    @InjectDataSource()
+    private dataSource: DataSource,
+  ) {}
+
+  async validate(
+    value: string,
+    validationArguments: CustomValidationArguments,
+  ) {
+    const repository = validationArguments.constraints[0]?.repository;
+    const targetRepository = this.dataSource.getRepository(repository);
+
+    const pathToProperty =
+      validationArguments.constraints[0]?.pathToProperty ??
+      validationArguments.property;
+    const whereQuery =
+      (validationArguments?.constraints[0]?.whereQuery as FindOptionsWhere<
+        typeof targetRepository
+      >) ?? [];
+
+    let combineQuery = {};
+
+    validationArguments?.constraints[0]?.stringPropertyQuery?.map(
+      (condition: string) => {
+        combineQuery = {
+          ...combineQuery,
+          [condition]: validationArguments.object?.[condition],
+        };
+      },
+    );
+    const entity = (await targetRepository.findOne({
+      where: {
+        [pathToProperty ? pathToProperty : validationArguments.property]: value
+          ? value
+          : value?.[pathToProperty],
+        ...whereQuery,
+      },
+    })) as ValidationEntity;
+
+    if (entity?.id) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/common/validators/validation-options.ts

@@ -0,0 +1,38 @@
+import {
+  HttpException,
+  HttpStatus,
+  ValidationError,
+  ValidationPipeOptions,
+} from '@nestjs/common';
+import { MessageFormatter } from '../helper/message-formatter.helper';
+
+function mapValidationErrors(errors: ValidationError[]): any {
+  return errors.reduce((result, error) => {
+    const constraints = error.constraints
+      ? Object.values(error.constraints)
+          .map((message) => MessageFormatter.replace(message, error.property))
+          .join(', ')
+      : null;
+
+    result[error.property] =
+      constraints || mapValidationErrors(error.children || []);
+    return result;
+  }, {});
+}
+
+const validationOptions: ValidationPipeOptions = {
+  transform: true,
+  whitelist: true,
+  errorHttpStatusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+  exceptionFactory: (errors: ValidationError[]) =>
+    new HttpException(
+      {
+        status: HttpStatus.UNPROCESSABLE_ENTITY,
+        message: `Validation failed: ${errors.length} errors found`,
+        details: mapValidationErrors(errors),
+      },
+      HttpStatus.UNPROCESSABLE_ENTITY,
+    ),
+};
+
+export default validationOptions;

package/dist/caching/caching.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CachingModule {
+}