@mondart/nestjs-common-module 1.0.3 → 1.0.4

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

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

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

package/common/strategy/index.ts

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

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

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

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

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

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

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

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