@nest-omni/core 1.0.56 → 2.0.1-0

package/src/.hygen.js

@@ -0,0 +1,116 @@
+module.exports = {
+  templates: `${__dirname}/.hygen`,
+  helpers: {
+    ControllerName(name) {
+      return `${this.ClassName(name)}Controller`;
+    },
+    ServiceName(name) {
+      return `${this.ClassName(name)}Service`;
+    },
+    ModuleName(name) {
+      return `${this.ClassName(name)}Module`;
+    },
+    DtoName(name) {
+      return `${this.ClassName(name)}Dto`;
+    },
+    TranslationDtoName(name) {
+      return `${this.ClassName(name)}TranslationDto`;
+    },
+    UpdateDtoName(name) {
+      return `Update${this.DtoName(name)}`;
+    },
+    DtoOptionName(name) {
+      return `I${this.DtoName(name)}Options`;
+    },
+    CreateDtoName(name) {
+      return `Create${this.DtoName(name)}`;
+    },
+    EntityName(name) {
+      return `${this.ClassName(name)}Entity`;
+    },
+    TranslationEntityName(name) {
+      return `${this.ClassName(name)}TranslationEntity`;
+    },
+    CreateCommandName(name) {
+      return `Create${this.ClassName(name)}Command`;
+    },
+    CreateHandlerName(name) {
+      return `Create${this.ClassName(name)}Handler`;
+    },
+    GetHandlerName(name) {
+      return `Get${this.ClassName(name)}Handler`;
+    },
+    GetQueryName(name) {
+      return `Get${this.ClassName(name)}Query`;
+    },
+    PageOptionsDtoName(name) {
+      return this.ClassName(name) + 'PageOptionsDto';
+    },
+    NotFoundExceptionName(name) {
+      return this.ClassName(name) + 'NotFoundException';
+    },
+    entityFileName(name) {
+      return `${this.fileName(name)}.entity`;
+    },
+    translationEntityFileName(name) {
+      return `${this.fileName(name)}-translation.entity`;
+    },
+    translationDtoFileName(name) {
+      return `${this.fileName(name)}-translation.dto`;
+    },
+    repositoryFileName(name) {
+      return `${this.fileName(name)}.repository`;
+    },
+    translationRepositoryFileName(name) {
+      return `${this.fileName(name)}-translation.repository`;
+    },
+    createCommandFileName(name) {
+      return `create-${this.fileName(name)}.command`;
+    },
+    getQueryFileName(name) {
+      return `get-${this.fileName(name)}.query`;
+    },
+    controllerFileName(name) {
+      return `${this.fileName(name)}.controller`;
+    },
+    dtoFileName(name) {
+      return `${this.fileName(name)}.dto`;
+    },
+    notFoundExceptionFileName(name) {
+      return `${this.fileName(name)}-not-found.exception`;
+    },
+    createDtoFileName(name) {
+      return `create-${this.fileName(name)}.dto`;
+    },
+    updateDtoFileName(name) {
+      return `update-${this.fileName(name)}.dto`;
+    },
+    pageOptionsDtoFileName(name) {
+      return `${this.fileName(name)}-page-options.dto`;
+    },
+    serviceFileName(name) {
+      return `${this.fileName(name)}.service`;
+    },
+    moduleFileName(name) {
+      return `${this.fileName(name)}.module`;
+    },
+    ClassName(name) {
+      return this.changeCase.pascal(name);
+    },
+    TableName(name) {
+      return this.inflection.underscore(this.ClassName(name));
+    },
+    RepositoryName(name) {
+      return `${this.ClassName(name)}Repository`;
+    },
+    TranslationRepositoryName(name) {
+      return `${this.ClassName(name)}TranslationRepository`;
+    },
+    moduleName(name) {
+      return this.changeCase.camel(name);
+    },
+    fileName(name) {
+      return this.inflection.dasherize(name).toLowerCase();
+    },
+  },
+}

package/src/common/abstract-client.service.ts

@@ -0,0 +1,56 @@
+import type { ClientProxy } from '@nestjs/microservices';
+import { plainToInstance } from 'class-transformer';
+import { firstValueFrom } from 'rxjs';
+
+import { PageTypeException } from '../exceptions/page-type.exception';
+import type { Constructor } from './types';
+import type { PageDto } from './dto/page.dto';
+import type { PageMetaDto } from './dto/page-meta.dto';
+
+/**
+ * Fixme: This class designed to use with @nestjs/microservices by extending and creating a new class.
+ * TODO: Create Implementation and usage of it
+ */
+export class AbstractClientService<ActionType> {
+  constructor(private client: ClientProxy) {}
+
+  public async send(pattern: ActionType, data: unknown): Promise<void>;
+
+  public async send<R>(
+    pattern: ActionType,
+    data: unknown,
+    returnDataOptions: { class: Constructor<R>; isPage: true },
+  ): Promise<PageDto<R>>;
+
+  public async send<R>(
+    pattern: ActionType,
+    data: unknown,
+    returnDataOptions?: { class: Constructor<R>; isPage?: false },
+  ): Promise<R>;
+
+  public async send<R, I>(
+    pattern: ActionType,
+    data: I,
+    returnDataOptions?: Partial<{
+      class?: Constructor<R>;
+      isPage?: boolean;
+    }>,
+  ): Promise<R | PageDto<R> | void> {
+    const returnData = await firstValueFrom(
+      this.client.send<{ data?: R; meta?: PageMetaDto }>(pattern, data),
+      {
+        defaultValue: undefined,
+      },
+    );
+
+    if (returnDataOptions?.isPage && (!returnData?.data || !returnData.meta)) {
+      throw new PageTypeException();
+    }
+
+    if (!returnDataOptions?.class || returnDataOptions.isPage) {
+      return returnData as R;
+    }
+
+    return plainToInstance(returnDataOptions.class, returnData);
+  }
+}

package/src/common/abstract.entity.ts

@@ -0,0 +1,82 @@
+import {
+  BeforeInsert,
+  Column,
+  CreateDateColumn,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import type { AbstractDto, AbstractTranslationDto } from './dto/abstract.dto';
+import { NumberFieldOptional, StringFieldOptional } from '../decorators';
+import { LanguageCode } from '../constants';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Abstract Entity
+ *
+ * @description This class is an abstract class for all entities.
+ * It's experimental and recommended using it only in microservice architecture,
+ * otherwise just delete and use your own entity.
+ */
+export abstract class AbstractBaseEntity<DTO, O> {
+  @CreateDateColumn({
+    type: 'timestamp',
+  })
+  createdAt: Date;
+
+  @UpdateDateColumn({
+    type: 'timestamp',
+  })
+  updatedAt: Date;
+
+  translations?: AbstractTranslationEntity[];
+
+  toDto(options?: O): DTO {
+    const dtoClass = Object.getPrototypeOf(this).dtoClass;
+
+    if (!dtoClass) {
+      throw new Error(
+        `You need to use @UseDto on class (${this.constructor.name}) be able to call toDto function`,
+      );
+    }
+
+    return new dtoClass(this, options);
+  }
+}
+
+export class AbstractEntity<
+  DTO extends AbstractDto = AbstractDto,
+  O = never,
+> extends AbstractBaseEntity<DTO, O> {
+  @PrimaryGeneratedColumn('increment')
+  @NumberFieldOptional({ swagger: false })
+  id: number;
+}
+
+export class AbstractTranslationEntity<
+  DTO extends AbstractTranslationDto = AbstractTranslationDto,
+  O = never,
+> extends AbstractEntity<DTO, O> {
+  @Column({ type: 'enum', enum: LanguageCode })
+  languageCode: LanguageCode;
+}
+
+export class AbstractUuidPrimaryEntity<
+  DTO extends AbstractDto = AbstractDto,
+  O = never,
+> extends AbstractBaseEntity<DTO, O> {
+  @PrimaryGeneratedColumn('uuid')
+  @StringFieldOptional({
+    maxLength: 36,
+    minLength: 2,
+    example: '23247899-c237-4ab1-9639-3322029d2e1c',
+    swagger: false,
+  })
+  id: string;
+
+  @BeforeInsert()
+  generateId() {
+    if (!this.id || this.id?.length < 2) {
+      this.id = uuidv4();
+    }
+  }
+}

package/src/common/boilerplate.polyfill.ts

@@ -0,0 +1,202 @@
+import 'source-map-support/register';
+
+import { compact, map } from 'lodash';
+import type { ObjectLiteral } from 'typeorm';
+import { Brackets, SelectQueryBuilder } from 'typeorm';
+
+import type { AbstractEntity } from './abstract.entity';
+import type { AbstractDto } from './dto/abstract.dto';
+import type { CreateTranslationDto } from './dto/create-translation.dto';
+import { PageDto } from './dto/page.dto';
+import { PageMetaDto } from './dto/page-meta.dto';
+import type { PageOptionsDto } from './dto/page-options.dto';
+import type { LanguageCode } from '../constants/language-code';
+import type { KeyOfType } from './types';
+import { ContextProvider } from '../providers';
+
+declare global {
+  export type Uuid = string & { _uuidBrand: undefined };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-redundant-type-constituents
+  export type Todo = any & { _todoBrand: undefined };
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  interface Array<T> {
+    toDtos<Dto extends AbstractDto>(this: T[], options?: unknown): Dto[];
+
+    getByLanguage(
+      this: CreateTranslationDto[],
+      languageCode: LanguageCode,
+    ): string;
+
+    toPageDto<Dto extends AbstractDto>(
+      this: T[],
+      pageMetaDto: PageMetaDto,
+      // FIXME make option type visible from entity
+      options?: unknown,
+    ): PageDto<Dto>;
+  }
+}
+
+declare module 'typeorm' {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  interface SelectQueryBuilder<Entity> {
+    searchByString(
+      q: string,
+      columnNames: string[],
+      options?: {
+        formStart: boolean;
+      },
+    ): this;
+
+    withTenant(tenantId?: string | number, tenantFieldName?: string): this;
+
+    paginate(
+      this: SelectQueryBuilder<Entity>,
+      pageOptionsDto: PageOptionsDto,
+      options?: Partial<{ takeAll: boolean; skipCount: boolean }>,
+    ): Promise<[Entity[], PageMetaDto]>;
+
+    leftJoinAndSelect<AliasEntity extends AbstractEntity, A extends string>(
+      this: SelectQueryBuilder<Entity>,
+      property: `${A}.${Exclude<
+        KeyOfType<AliasEntity, AbstractEntity>,
+        symbol
+      >}`,
+      alias: string,
+      condition?: string,
+      parameters?: ObjectLiteral,
+    ): this;
+
+    leftJoin<AliasEntity extends AbstractEntity, A extends string>(
+      this: SelectQueryBuilder<Entity>,
+      property: `${A}.${Exclude<
+        KeyOfType<AliasEntity, AbstractEntity>,
+        symbol
+      >}`,
+      alias: string,
+      condition?: string,
+      parameters?: ObjectLiteral,
+    ): this;
+
+    innerJoinAndSelect<AliasEntity extends AbstractEntity, A extends string>(
+      this: SelectQueryBuilder<Entity>,
+      property: `${A}.${Exclude<
+        KeyOfType<AliasEntity, AbstractEntity>,
+        symbol
+      >}`,
+      alias: string,
+      condition?: string,
+      parameters?: ObjectLiteral,
+    ): this;
+
+    innerJoin<AliasEntity extends AbstractEntity, A extends string>(
+      this: SelectQueryBuilder<Entity>,
+      property: `${A}.${Exclude<
+        KeyOfType<AliasEntity, AbstractEntity>,
+        symbol
+      >}`,
+      alias: string,
+      condition?: string,
+      parameters?: ObjectLiteral,
+    ): this;
+  }
+}
+
+Array.prototype.toDtos = function <
+  Entity extends AbstractEntity<Dto>,
+  Dto extends AbstractDto,
+>(options?: unknown): Dto[] {
+  return compact(
+    map<Entity, Dto>(this as Entity[], (item) => item.toDto(options as never)),
+  );
+};
+
+Array.prototype.getByLanguage = function (languageCode: LanguageCode): string {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return this.find((translation) => languageCode === translation.languageCode)!
+    .text;
+};
+
+Array.prototype.toPageDto = function (
+  pageMetaDto: PageMetaDto,
+  options?: unknown,
+) {
+  return new PageDto(this.toDtos(options), pageMetaDto);
+};
+
+SelectQueryBuilder.prototype.searchByString = function (
+  q,
+  columnNames,
+  options,
+) {
+  if (!q) {
+    return this;
+  }
+
+  this.andWhere(
+    new Brackets((qb) => {
+      for (const item of columnNames) {
+        qb.orWhere(`${item} ILIKE :q`);
+      }
+    }),
+  );
+
+  if (options?.formStart) {
+    this.setParameter('q', `${q}%`);
+  } else {
+    this.setParameter('q', `%${q}%`);
+  }
+
+  return this;
+};
+
+SelectQueryBuilder.prototype.paginate = async function (
+  pageOptionsDto: PageOptionsDto,
+  options?: Partial<{
+    skipCount: boolean;
+    takeAll: boolean;
+  }>,
+) {
+  if (!options?.takeAll) {
+    this.skip(pageOptionsDto.skip).take(pageOptionsDto.pageSize);
+  }
+
+  const entities = await this.getMany();
+
+  let itemCount = -1;
+
+  if (!options?.skipCount) {
+    itemCount = await this.getCount();
+  }
+
+  const pageMetaDto = new PageMetaDto({
+    itemCount,
+    pageOptionsDto,
+  });
+
+  return [entities, pageMetaDto];
+};
+
+SelectQueryBuilder.prototype.withTenant = function (
+  tenantId?: number | string,
+  tenantFieldName: string = 'tenantId',
+) {
+  if (!tenantId) {
+    tenantId = ContextProvider.getTenantId();
+  }
+
+  if (this.expressionMap.mainAlias.hasMetadata) {
+    const entityMetadata = this.expressionMap.mainAlias.metadata;
+    const columnName = entityMetadata.columns.find(
+      (column: any) => column.propertyName === tenantFieldName,
+    )?.databaseName;
+
+    if (columnName) {
+      return this.andWhere(`${this.alias}.${columnName} = :tenantId`, {
+        tenantId,
+      });
+    }
+  }
+
+  return this;
+};

package/src/common/dto/abstract.dto.ts

@@ -0,0 +1,61 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+import { DYNAMIC_TRANSLATION_DECORATOR_KEY } from '../../decorators';
+import { ContextProvider } from '../../providers';
+import { AbstractEntity, AbstractUuidPrimaryEntity } from '../abstract.entity';
+
+export class AbstractDto {
+  @ApiProperty()
+  id: number | string;
+
+  @ApiProperty()
+  createdAt: Date;
+
+  @ApiProperty()
+  updatedAt: Date;
+
+  translations?: AbstractTranslationDto[];
+
+  constructor(
+    entity: AbstractEntity | AbstractUuidPrimaryEntity,
+    options?: { excludeFields?: boolean },
+  ) {
+    if (!options?.excludeFields) {
+      this.id = entity.id;
+      this.createdAt = entity.createdAt;
+      this.updatedAt = entity.updatedAt;
+    }
+
+    const languageCode = ContextProvider.getLanguage();
+
+    if (languageCode && entity.translations) {
+      const translationEntity = entity.translations.find(
+        (titleTranslation) => titleTranslation.languageCode === languageCode,
+      )!;
+
+      const fields: Record<string, string> = {};
+
+      for (const key of Object.keys(translationEntity)) {
+        const metadata = Reflect.getMetadata(
+          DYNAMIC_TRANSLATION_DECORATOR_KEY,
+          this,
+          key,
+        );
+
+        if (metadata) {
+          fields[key] = translationEntity[key];
+        }
+      }
+
+      Object.assign(this, fields);
+    } else {
+      this.translations = entity.translations?.toDtos();
+    }
+  }
+}
+
+export class AbstractTranslationDto extends AbstractDto {
+  constructor(entity: AbstractEntity | AbstractUuidPrimaryEntity) {
+    super(entity, { excludeFields: true });
+  }
+}

package/src/common/dto/bulk-id.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsArray } from 'class-validator';
+
+export class BulkIdDto {
+  @ApiProperty({
+    type: 'string',
+    description: 'ID',
+    isArray: true,
+    required: true,
+  })
+  @IsArray()
+  id: number[] | string[];
+}

package/src/common/dto/create-translation.dto.ts

@@ -0,0 +1,10 @@
+import { LanguageCode } from '../../constants';
+import { EnumField, StringField } from '../../decorators';
+
+export class CreateTranslationDto {
+  @EnumField(() => LanguageCode)
+  languageCode: LanguageCode;
+
+  @StringField()
+  text: string;
+}

package/src/common/dto/index.ts

@@ -0,0 +1,6 @@
+export * from './abstract.dto';
+export * from './bulk-id.dto';
+export * from './create-translation.dto';
+export * from './page.dto';
+export * from './page-meta.dto';
+export * from './page-options.dto';

package/src/common/dto/page-meta.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+import type { PageOptionsDto } from './page-options.dto';
+
+interface IPageMetaDtoParameters {
+  pageOptionsDto: PageOptionsDto;
+  itemCount: number;
+}
+
+export class PageMetaDto {
+  @ApiProperty()
+  readonly page: number;
+
+  @ApiProperty()
+  readonly pageSize: number;
+
+  @ApiProperty()
+  readonly itemCount: number;
+
+  @ApiProperty()
+  readonly pageCount: number;
+
+  @ApiProperty()
+  readonly hasPreviousPage: boolean;
+
+  @ApiProperty()
+  readonly hasNextPage: boolean;
+
+  constructor({ pageOptionsDto, itemCount }: IPageMetaDtoParameters) {
+    this.page = pageOptionsDto.page;
+    this.pageSize = pageOptionsDto.pageSize;
+    this.itemCount = itemCount;
+    this.pageCount = Math.ceil(this.itemCount / this.pageSize);
+    this.hasPreviousPage = this.page > 1;
+    this.hasNextPage = this.page < this.pageCount;
+  }
+}

package/src/common/dto/page-options.dto.ts

@@ -0,0 +1,35 @@
+import { Order } from '../../constants';
+import {
+  EnumFieldOptional,
+  NumberFieldOptional,
+  StringFieldOptional,
+} from '../../decorators';
+
+export class PageOptionsDto {
+  @EnumFieldOptional(() => Order, {
+    default: Order.ASC,
+  })
+  readonly order: Order = Order.ASC;
+
+  @NumberFieldOptional({
+    minimum: 1,
+    default: 1,
+    int: true,
+  })
+  readonly page: number = 1;
+
+  @NumberFieldOptional({
+    minimum: 1,
+    maximum: 50,
+    default: 10,
+    int: true,
+  })
+  readonly pageSize: number = 10;
+
+  get skip(): number {
+    return (this.page - 1) * this.pageSize;
+  }
+
+  @StringFieldOptional()
+  readonly q?: string;
+}

package/src/common/dto/page.dto.ts

@@ -0,0 +1,36 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+import { PageMetaDto } from './page-meta.dto';
+
+export class PageDto<T> {
+  @ApiProperty({ isArray: true })
+  readonly data: T[];
+
+  @ApiProperty()
+  count: number;
+
+  @ApiProperty()
+  total: number;
+
+  @ApiProperty()
+  page: number;
+
+  @ApiProperty()
+  pageCount: number;
+
+  @ApiProperty()
+  hasPreviousPage: boolean;
+
+  @ApiProperty()
+  hasNextPage: boolean;
+
+  constructor(data: T[], meta: PageMetaDto) {
+    this.data = data;
+    this.count = meta.pageSize;
+    this.pageCount = meta.pageCount;
+    this.page = meta.page;
+    this.total = meta.itemCount;
+    this.hasPreviousPage = meta.hasPreviousPage;
+    this.hasNextPage = meta.hasNextPage;
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,7 @@
+export * from './abstract.entity';
+export * from './abstract-client.service';
+export * from './utils';
+export * from './dto';
+export * from './types';
+export * from './snake-naming.strategy';
+export * from './boilerplate.polyfill';