@koalarx/nest 3.0.3 → 3.0.4

package/src/core/utils/instanciate-class-with-dependencies-injection.ts

@@ -1,12 +0,0 @@
-import { INestApplication } from '@nestjs/common'
-
-export function instanciateClassWithDependenciesInjection(
-  app: INestApplication,
-  Target: any,
-) {
-  const dependencies = Reflect.getMetadata('design:paramtypes', Target) ?? []
-  const injections = dependencies.map((dependency: any) => {
-    return app.get(dependency)
-  })
-  return new Target(...injections)
-}

package/src/core/utils/interfaces/icomparable.ts

@@ -1,6 +0,0 @@
-export type IComparableId = string | number
-
-export abstract class IComparable<T = any> {
-  abstract _id: IComparableId
-  abstract equals(obj: IComparable<T>): boolean
-}

package/src/core/utils/list.spec.ts

@@ -1,81 +0,0 @@
-import { EntityBase } from '../database/entity.base'
-import { Entity } from '../database/entity.decorator'
-import { AutoMap } from '../mapping/auto-mapping.decorator'
-import { List } from './list'
-
-@Entity()
-class EntityTest extends EntityBase<EntityTest> {
-  @AutoMap()
-  id: number
-
-  @AutoMap()
-  value: number
-}
-
-describe('List test', () => {
-  let entity: EntityTest
-
-  beforeEach(() => {
-    entity = new EntityTest({ id: 1, value: 1 })
-  })
-
-  it('should add item on list', () => {
-    const list = new List<number>()
-    list.add(1)
-
-    expect(list.toArray('added').length).toBe(1)
-    expect(list.toArray('added')[0]).toEqual(1)
-  })
-
-  it('should update item on list', () => {
-    const list = new List(EntityTest).setList([entity])
-
-    entity.value = 2
-
-    list.add(entity)
-
-    expect(list.toArray('updated').length).toBe(1)
-    expect(list.toArray('updated')[0].value).toEqual(2)
-  })
-
-  it('should remove item on list', () => {
-    const list = new List(EntityTest).setList([entity])
-
-    list.remove(entity)
-
-    expect(list.toArray().length).toBe(0)
-    expect(list.toArray('removed').length).toBe(1)
-    expect(list.toArray('removed')[0].value).toEqual(1)
-  })
-
-  it('should get item by id', () => {
-    const list = new List(EntityTest).setList([entity])
-
-    expect(list.findById(entity.id)).toEqual(entity)
-  })
-
-  it('should order items', () => {
-    const list = new List(EntityTest).setList([
-      new EntityTest({ id: 1, value: 3 }),
-      new EntityTest({ id: 2, value: 1 }),
-      new EntityTest({ id: 3, value: 2 }),
-    ])
-
-    list.orderBy('value', 'asc')
-
-    const orderedValues = list.toArray().map((item) => item.value)
-
-    expect(orderedValues).toEqual([1, 2, 3])
-  })
-
-  it('should get first and last items', () => {
-    const list = new List(EntityTest).setList([
-      new EntityTest({ id: 1, value: 1 }),
-      new EntityTest({ id: 2, value: 2 }),
-      new EntityTest({ id: 3, value: 3 }),
-    ])
-
-    expect(list.first()!.value).toBe(1)
-    expect(list.last()!.value).toBe(3)
-  })
-})

package/src/core/utils/list.ts

@@ -1,223 +0,0 @@
-import { Type } from '@nestjs/common'
-import 'reflect-metadata'
-import { EntityBase } from '../database/entity.base'
-import { IComparableId } from './interfaces/icomparable'
-
-export type OrderDirection = 'asc' | 'desc'
-export type ListActionType = 'added' | 'updated' | 'removed'
-export interface ListProps<T> {
-  list?: T[]
-  entityType?: Type<T>
-}
-
-export class List<T> {
-  private _list: T[] = []
-  private _addedItemsList: T[] = []
-  private _updatedItemsList: T[] = []
-  private _removedItemsList: T[] = []
-
-  constructor(public readonly entityType?: Type<T>) {}
-
-  private indexOf(item: T, list = this._list) {
-    if (item instanceof EntityBase) {
-      return list
-        .filter((i) => i instanceof EntityBase)
-        .filter((i) => !!i._id)
-        .findIndex(
-          (i) =>
-            (item as any)._id === (i as any)._id ||
-            (item as any).id === (i as any).id,
-        )
-    }
-
-    return list
-      .filter((i) => !(i instanceof EntityBase))
-      .findIndex((i) => item === i)
-  }
-
-  private contains(item: T, list = this._list): boolean {
-    return this.indexOf(item, list) > -1
-  }
-
-  private mapInternalIdIfIsEmpty(list: T[]) {
-    return list.map((item) => {
-      if (item instanceof EntityBase && !item._id) {
-        item._id = (item as any).id
-      }
-
-      return item
-    })
-  }
-
-  get length() {
-    return this._list.length
-  }
-
-  orderBy(by: keyof T, direction: OrderDirection = 'asc') {
-    const inverse = direction === 'desc'
-
-    this._list.sort((a: any, b: any) => {
-      if (typeof a !== 'string' && typeof b !== 'string') {
-        if ((!inverse && a[by] > b[by]) || (inverse && a[by] < b[by])) {
-          return 1
-        } else if ((!inverse && a[by] < b[by]) || (inverse && a[by] > b[by])) {
-          return -1
-        } else {
-          return 0
-        }
-      } else {
-        return 0
-      }
-    })
-
-    return this
-  }
-
-  first() {
-    return this._list[0] ?? null
-  }
-
-  last() {
-    return this._list[this._list.length - 1] ?? null
-  }
-
-  findById(id: IComparableId): T | null {
-    return (
-      this._list
-        .filter((item) => item instanceof EntityBase)
-        .find((item) => (item as any)._id === id || (item as any).id === id) ??
-      null
-    )
-  }
-
-  findByValue(value: any): T | null {
-    return this._list.find((item) => item === value) ?? null
-  }
-
-  setList(list: T[]) {
-    this._list = this.mapInternalIdIfIsEmpty(list)
-    return this
-  }
-
-  add(item: T) {
-    if (this.contains(item)) {
-      this._list[this.indexOf(item)] = item
-
-      if (!this.contains(item, this._updatedItemsList)) {
-        this._updatedItemsList.push(item)
-      }
-
-      return
-    }
-
-    this._list.push(item)
-    this._addedItemsList.push(item)
-
-    return this
-  }
-
-  remove(item: T) {
-    const index = this.indexOf(item)
-
-    if (index > -1) {
-      this._list.splice(index, 1)
-
-      if (!this.contains(item, this._removedItemsList)) {
-        this._removedItemsList.push(item)
-      }
-    }
-
-    return this
-  }
-
-  update(items: T[]) {
-    items = this.mapInternalIdIfIsEmpty(items)
-
-    items.forEach((item) => this.add(item))
-
-    this._list
-      .filter((item) => !this.contains(item, items))
-      .forEach((item) => this.remove(item))
-
-    return this
-  }
-
-  clear() {
-    this._addedItemsList = []
-    this._updatedItemsList = []
-    this._removedItemsList = this._list
-    this._list = []
-
-    return this
-  }
-
-  forEach(callback: (item: T, index: number) => void) {
-    this._list.forEach(callback)
-    return this
-  }
-
-  async forEachAsync(callback: (item: T, index: number) => Promise<void>) {
-    return Promise.all(this._list.map(callback)).then(() => this)
-  }
-
-  map<U>(callback: (item: T, index: number) => U): List<U> {
-    const mappedItems = this._list.map(callback)
-    const list = new List<U>()
-
-    list.setList(mappedItems)
-
-    return list
-  }
-
-  async mapAsync<U>(
-    callback: (item: T, index: number) => Promise<U>,
-  ): Promise<List<U>> {
-    return Promise.all(this._list.map(callback)).then((mappedItems) => {
-      const mappedList = new List<U>()
-
-      mappedList.setList(mappedItems)
-
-      return mappedList
-    })
-  }
-
-  filter(callback: (item: T, index: number) => boolean): List<T> {
-    const filteredItems = this._list.filter(callback)
-    const list = new List<T>()
-
-    list.setList(filteredItems)
-
-    return list
-  }
-
-  async filterAsync(
-    callback: (item: T, index: number) => Promise<boolean>,
-  ): Promise<List<T>> {
-    return Promise.all(this._list.filter(callback))
-      .then((list) => list.filter((item) => item))
-      .then((filteredItems) => {
-        const list = new List<T>()
-
-        list.setList(filteredItems)
-
-        return list
-      })
-  }
-
-  find(callback: (item: T, index: number) => boolean): T | null {
-    return this._list.find(callback) ?? null
-  }
-
-  toArray(type?: ListActionType): T[] {
-    switch (type) {
-      case 'added':
-        return this._addedItemsList
-      case 'updated':
-        return this._updatedItemsList
-      case 'removed':
-        return this._removedItemsList
-      default:
-        return this._list
-    }
-  }
-}

package/src/core/utils/promise-all.ts

@@ -1,24 +0,0 @@
-type PromisesResponseType<T> = {
-  [K in keyof T]: Awaited<T[K]>
-}
-
-export class Promises {
-  static async result<T>(requests: T): Promise<PromisesResponseType<T>> {
-    const promises: Array<any> = []
-
-    Object.values(requests as any).forEach((promise) => promises.push(promise))
-
-    return Promise.all(promises).then((result) => {
-      let currentIndex = 0
-
-      const response = {} as PromisesResponseType<T>
-
-      Object.keys(requests as any).forEach((propName) => {
-        response[propName] = result[currentIndex]
-        currentIndex++
-      })
-
-      return response
-    })
-  }
-}

package/src/core/utils/set-mask-document-number.ts

@@ -1,13 +0,0 @@
-import { maskCnpj, maskCpf } from '@koalarx/utils/KlString'
-
-export function setMaskDocumentNumber(document?: string) {
-  if (!document) {
-    return ''
-  }
-
-  const documentWithoutMask = document.replace(/[^0-9]/g, '')
-
-  return documentWithoutMask.length === 11
-    ? maskCpf(documentWithoutMask)
-    : maskCnpj(documentWithoutMask)
-}

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

@@ -1,113 +0,0 @@
-import { FileValidator } from '@nestjs/common'
-import { FileType } from '..'
-
-type FileTypeInternal = FileType | FileType[] | Record<string, FileType[]>
-type Result = { errorFileName?: string; isValid: boolean }
-
-const runFileValidation = async (args: {
-  multiple: boolean
-  file: FileTypeInternal
-  validator: (file: FileType) => Promise<boolean> | boolean
-}): Promise<Result> => {
-  if (args.multiple) {
-    const fileFields = Object.keys(args.file)
-    for (const field of fileFields) {
-      const fieldFile = args.file[field]
-      if (Array.isArray(fieldFile)) {
-        for (const f of fieldFile) {
-          if (!args.validator(f)) {
-            return { errorFileName: f.originalname, isValid: false }
-          }
-        }
-      } else {
-        if (!args.validator(fieldFile)) {
-          return { errorFileName: fieldFile.originalname, isValid: false }
-        }
-      }
-    }
-    return { isValid: true }
-  }
-
-  if (Array.isArray(args.file)) {
-    for (const f of args.file) {
-      if (!args.validator(f)) {
-        return { errorFileName: f.originalname, isValid: false }
-      }
-    }
-    return { isValid: true }
-  }
-
-  if (args.validator(args.file as any)) {
-    return { errorFileName: args.file.originalname as string, isValid: false }
-  }
-
-  return { isValid: true }
-}
-
-export class FileSizeValidator extends FileValidator {
-  private maxSizeBytes: number
-  private multiple: boolean
-  private errorFileName: string
-
-  constructor(args: { maxSizeBytes: number; multiple: boolean }) {
-    super({})
-    this.maxSizeBytes = args.maxSizeBytes
-    this.multiple = args.multiple
-  }
-
-  async isValid(file?: FileTypeInternal): Promise<boolean> {
-    if (!file) {
-      return true
-    }
-
-    const result = await runFileValidation({
-      file,
-      multiple: this.multiple,
-      validator: (f) => f.size < this.maxSizeBytes,
-    })
-    this.errorFileName = result.errorFileName ?? ''
-    return result.isValid
-  }
-
-  buildErrorMessage(file: any): string {
-    return (
-      `file ${this.errorFileName || ''} exceeded the size limit ` +
-      parseFloat((this.maxSizeBytes / 1024 / 1024).toFixed(2)) +
-      'MB'
-    )
-  }
-}
-
-export class FileTypeValidator extends FileValidator {
-  private multiple: boolean
-  private errorFileName: string
-  private filetype: RegExp | string
-
-  constructor(args: { multiple: boolean; filetype: RegExp | string }) {
-    super({})
-    this.multiple = args.multiple
-    this.filetype = args.filetype
-  }
-
-  isMimeTypeValid(file: FileType) {
-    return file.mimetype.search(this.filetype) === 0
-  }
-
-  async isValid(file?: FileTypeInternal): Promise<boolean> {
-    if (!file) {
-      return true
-    }
-
-    const result = await runFileValidation({
-      multiple: this.multiple,
-      file,
-      validator: (f) => this.isMimeTypeValid(f),
-    })
-    this.errorFileName = result.errorFileName ?? ''
-    return result.isValid
-  }
-
-  buildErrorMessage(file: any): string {
-    return `file ${this.errorFileName || ''} must be of type ${this.filetype}`
-  }
-}

package/src/decorators/api-exclude-endpoint-diff-develop.decorator.ts

@@ -1,15 +0,0 @@
-import { ApiExcludeEndpoint } from '@nestjs/swagger'
-import { EnvConfig } from '../core/utils/env.config'
-
-/**
- * Um decorator personalizado que utiliza o `ApiExcludeEndpoint` do NestJS Swagger
- * para excluir endpoints da documentação da API com base no ambiente de execução.
- *
- * Este decorator verifica se o ambiente atual não é de desenvolvimento (`!EnvConfig.isEnvDevelop`).
- * Se o ambiente não for de desenvolvimento, o endpoint será excluído da documentação.
- *
- * @returns Um decorator que aplica a exclusão condicional do endpoint na documentação da API.
- */
-export const ApiExcludeEndpointDiffDevelop = () => {
-  return ApiExcludeEndpoint(!EnvConfig.isEnvDevelop)
-}

package/src/decorators/api-property-enum.decorator.ts

@@ -1,58 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger'
-import { EnumAllowedTypes } from '@nestjs/swagger/dist/interfaces/schema-object-metadata.interface'
-
-interface ApiPropertyEnumOptions {
-  enum: EnumAllowedTypes
-  isArray?: boolean
-  required?: boolean
-}
-
-/**
- * Um decorator personalizado para documentar propriedades de enumeração em classes do NestJS
- * usando o Swagger.
- *
- * @param options - As opções para configurar o decorator.
- * @param options.enum - O enum que será documentado. Deve ser um tipo permitido pelo Swagger.
- * @param options.isArray - Indica se a propriedade é um array de enums. Por padrão, é falso.
- * @param options.required - Indica se a propriedade é obrigatória. Por padrão, é opcional.
- *
- * @description
- * Este decorator é usado para gerar automaticamente a documentação de propriedades
- * que utilizam enums. Ele cria uma descrição detalhada com os valores e suas respectivas
- * descrições, formatada em Markdown para exibição no Swagger UI.
- *
- * @example
- * ```typescript
- * import { ApiPropertyEnum } from './api-property-enum.decorator';
- *
- * enum Status {
- *   ACTIVE = 1,
- *   INACTIVE = 2,
- * }
- *
- * class ExampleDto {
- *   \@ApiPropertyEnum({ enum: Status, required: true })
- *   status: Status;
- * }
- * ```
- *
- * No exemplo acima, o Swagger exibirá a propriedade `status` com uma descrição detalhada
- * dos valores possíveis do enum `Status` (e.g., "ACTIVE: 1\nINACTIVE: 2").
- */
-export function ApiPropertyEnum(options: ApiPropertyEnumOptions) {
-  return function (target: any, propertyKey: string) {
-    const enumValues = Object.values(options.enum)
-      .filter((value) => typeof value === 'number')
-      .map((value) => ({
-        value,
-        description: options.enum[value],
-      }))
-    const description = enumValues
-      .map((enumValue) => `${enumValue.description}: ${enumValue.value}`)
-      .join('\n')
-    ApiProperty({
-      ...options,
-      description: ['```', description, '```'].join('\n'),
-    })(target, propertyKey)
-  }
-}

package/src/decorators/api-property-only-develop.decorator.ts

@@ -1,6 +0,0 @@
-import { ApiProperty, ApiPropertyOptions } from '@nestjs/swagger'
-import { EnvConfig } from '../core/utils/env.config'
-
-export const ApiPropertyOnlyDevelop = (propertyOptions: ApiPropertyOptions) => {
-  return EnvConfig.isEnvDevelop ? ApiProperty(propertyOptions) : () => {}
-}

package/src/decorators/cookies.decorator.ts

@@ -1,8 +0,0 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common'
-
-export const Cookies = createParamDecorator(
-  (data: string, ctx: ExecutionContext) => {
-    const request = ctx.switchToHttp().getRequest()
-    return data ? request.cookies?.[data] : request.cookies
-  },
-)

package/src/decorators/is-public.decorator.ts

@@ -1,5 +0,0 @@
-import { SetMetadata } from '@nestjs/common'
-import { ApiBearerAuth, ApiSecurity } from '@nestjs/swagger'
-
-export const IS_PUBLIC_KEY = 'isPublic'
-export const IsPublic = () => SetMetadata(IS_PUBLIC_KEY, true)

package/src/decorators/upload.decorator.ts

@@ -1,31 +0,0 @@
-import { ParseFilePipe, UploadedFiles } from '@nestjs/common'
-import {
-  FileSizeValidator,
-  FileTypeValidator,
-} from '../core/validators/file-validator'
-
-/**
- * Um decorator personalizado para lidar com o upload de arquivos em um controlador NestJS.
- *
- * @param {number} maxSizeInKb - O tamanho máximo permitido para os arquivos em kilobytes.
- * @param {RegExp} filetype - Um padrão de expressão regular para validar os tipos de arquivo permitidos.
- *
- * Este decorator utiliza o `UploadedFiles` do NestJS para processar múltiplos arquivos enviados em uma requisição.
- * Ele valida os arquivos com base no tamanho máximo permitido e no tipo de arquivo especificado.
- */
-export function UploadDecorator(maxSizeInKb: number, filetype: RegExp) {
-  const maxSizeBytes = maxSizeInKb * 1024
-
-  return UploadedFiles(
-    new ParseFilePipe({
-      validators: [
-        new FileSizeValidator({ maxSizeBytes, multiple: true }),
-        new FileTypeValidator({
-          filetype,
-          multiple: true,
-        }),
-      ],
-      fileIsRequired: false,
-    }),
-  )
-}

package/src/env/env.module.ts

@@ -1,8 +0,0 @@
-import { Module } from '@nestjs/common'
-import { EnvService } from './env.service'
-
-@Module({
-  providers: [EnvService],
-  exports: [EnvService],
-})
-export class EnvModule {}

package/src/env/env.service.ts

@@ -1,12 +0,0 @@
-import { Injectable } from '@nestjs/common'
-import { ConfigService } from '@nestjs/config'
-import { Env } from './env'
-
-@Injectable()
-export class EnvService<TEnv extends Env = Env> {
-  constructor(private readonly configService: ConfigService<TEnv, true>) {}
-
-  get<T extends keyof TEnv>(key: T) {
-    return this.configService.get(key as any, { infer: true })
-  }
-}

package/src/env/env.ts

@@ -1,14 +0,0 @@
-import 'dotenv/config'
-import { z } from 'zod'
-import { booleanSchema } from '../core/controllers/schemas/boolean.schema'
-
-export const envSchema = z.object({
-  PORT: z.coerce.number().default(3000),
-  NODE_ENV: z.enum(['test', 'develop', 'staging', 'production']),
-  PRISMA_QUERY_LOG: booleanSchema().optional(),
-  SWAGGER_USERNAME: z.string().optional(),
-  SWAGGER_PASSWORD: z.string().optional(),
-  REDIS_CONNECTION_STRING: z.string().optional(),
-})
-
-export type Env = z.infer<typeof envSchema>