@koalarx/nest 1.19.0 → 3.0.1

package/src/filters/domain-errors.filter.ts

@@ -0,0 +1,97 @@
+import { ArgumentsHost, Catch, HttpStatus } from '@nestjs/common'
+import { BaseExceptionFilter } from '@nestjs/core'
+import { BadRequestError } from '../core/errors/bad-request.error'
+import { ConflictError } from '../core/errors/conflict.error'
+import { NoContentError } from '../core/errors/no-content.error'
+import { NotAllowedError } from '../core/errors/not-allowed.error'
+import { ResourceNotFoundError } from '../core/errors/resource-not-found.error'
+import { UserAlreadyExist } from '../core/errors/user-already-exist.error'
+import { WrongCredentialsError } from '../core/errors/wrong-credentials.error'
+import { KoalaGlobalVars } from '../core/koala-global-vars'
+import { EnvConfig } from '../core/utils/env.config'
+import { FilterRequestParams } from '../core/utils/filter-request-params'
+import { ILoggingService } from '../services/logging/ilogging.service'
+
+type DomainErrors =
+  | NotAllowedError
+  | ResourceNotFoundError
+  | UserAlreadyExist
+  | WrongCredentialsError
+  | ConflictError
+  | BadRequestError
+  | NoContentError
+
+@Catch(
+  NotAllowedError,
+  ResourceNotFoundError,
+  UserAlreadyExist,
+  WrongCredentialsError,
+  ConflictError,
+  BadRequestError,
+  NoContentError,
+)
+export class DomainErrorsFilter extends BaseExceptionFilter {
+  constructor(private readonly loggingService: ILoggingService) {
+    super()
+  }
+
+  public catch(exception: DomainErrors, host: ArgumentsHost) {
+    const mappedException = this.map(exception)
+    const filterRequestParams = FilterRequestParams.get(host)
+
+    if (mappedException.statusCode !== HttpStatus.UNAUTHORIZED) {
+      if (!EnvConfig.isEnvTest) {
+        this.loggingService
+          .report({
+            error: exception,
+            packageName: KoalaGlobalVars.appName,
+            loggedUsername: filterRequestParams.loggedUserName,
+            httpRequest: {
+              ...filterRequestParams.filterParams,
+              statusCode: mappedException.statusCode,
+              response: mappedException,
+            },
+          })
+          .catch((err) => console.error(err))
+      } else {
+        console.error(exception)
+      }
+    }
+
+    return filterRequestParams.response
+      .status(mappedException.statusCode)
+      .json(mappedException)
+  }
+
+  private map(exception: DomainErrors) {
+    const mappedException = {
+      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+      message: exception.message,
+      data: exception.data,
+    }
+
+    switch (exception.constructor) {
+      case UserAlreadyExist:
+      case NotAllowedError:
+      case BadRequestError:
+        mappedException.statusCode = HttpStatus.BAD_REQUEST
+        break
+      case ResourceNotFoundError:
+        mappedException.statusCode = HttpStatus.NOT_FOUND
+        break
+      case WrongCredentialsError:
+        mappedException.statusCode = HttpStatus.UNAUTHORIZED
+        break
+      case ConflictError:
+        mappedException.statusCode = HttpStatus.CONFLICT
+        break
+      case NoContentError:
+        mappedException.statusCode = HttpStatus.NO_CONTENT
+        break
+      default:
+        console.error(exception)
+    }
+
+    return mappedException
+  }
+}

package/src/filters/global-exception.filter.ts

@@ -0,0 +1,60 @@
+import { ArgumentsHost, Catch, HttpException, HttpStatus } from '@nestjs/common'
+import { BaseExceptionFilter } from '@nestjs/core'
+import { IncomingMessage } from 'node:http'
+import { KoalaGlobalVars } from '../core/koala-global-vars'
+import { EnvConfig } from '../core/utils/env.config'
+import { FilterRequestParams } from '../core/utils/filter-request-params'
+import { ILoggingService } from '../services/logging/ilogging.service'
+
+@Catch()
+export class GlobalExceptionsFilter extends BaseExceptionFilter {
+  constructor(private readonly loggingService: ILoggingService) {
+    super()
+  }
+
+  catch(exception: Error, host: ArgumentsHost) {
+    const filterRequestParams = FilterRequestParams.get(host)
+    const request: IncomingMessage | null =
+      host.getArgs().find((arg) => arg instanceof IncomingMessage) ?? null
+
+    const statusCode =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR
+
+    const responseBody =
+      exception instanceof HttpException
+        ? exception.getResponse()
+        : {
+            statusCode,
+            timestamp: new Date().toISOString(),
+            path: filterRequestParams.filterParams.endpoint,
+          }
+
+    if (
+      !exception.message?.includes('Cannot GET /socket.io') &&
+      !exception.message?.includes('Cannot GET /favicon.ico') &&
+      !['/'].includes(request?.url ?? '') &&
+      statusCode !== HttpStatus.UNAUTHORIZED
+    ) {
+      if (!EnvConfig.isEnvTest) {
+        this.loggingService
+          .report({
+            error: exception,
+            packageName: KoalaGlobalVars.appName,
+            loggedUsername: filterRequestParams.loggedUserName,
+            httpRequest: {
+              ...filterRequestParams.filterParams,
+              statusCode,
+              response: responseBody as any,
+            },
+          })
+          .catch((err) => console.error(err))
+      } else {
+        console.error(exception)
+      }
+    }
+
+    return filterRequestParams.response.status(statusCode).json(responseBody)
+  }
+}

package/src/filters/prisma-validation-exception.filter.ts

@@ -0,0 +1,73 @@
+import { ArgumentsHost, Catch, HttpStatus } from '@nestjs/common'
+import { BaseExceptionFilter } from '@nestjs/core'
+import { Prisma } from 'prisma/generated/client'
+import { KoalaGlobalVars } from '../core/koala-global-vars'
+import { EnvConfig } from '../core/utils/env.config'
+import { FilterRequestParams } from '../core/utils/filter-request-params'
+import { ILoggingService } from '../services/logging/ilogging.service'
+
+@Catch(Prisma.PrismaClientKnownRequestError)
+export class PrismaValidationExceptionFilter extends BaseExceptionFilter {
+  constructor(private readonly loggingService: ILoggingService) {
+    super()
+  }
+
+  public catch(
+    exception: Prisma.PrismaClientKnownRequestError,
+    host: ArgumentsHost,
+  ) {
+    const translatedResponse = this.translate(exception)
+    const filterRequestParams = FilterRequestParams.get(host)
+
+    if (translatedResponse.statusCode !== HttpStatus.UNAUTHORIZED) {
+      if (!EnvConfig.isEnvTest) {
+        this.loggingService
+          .report({
+            error: exception,
+            packageName: KoalaGlobalVars.appName,
+            loggedUsername: filterRequestParams.loggedUserName,
+            httpRequest: {
+              ...filterRequestParams.filterParams,
+              statusCode: translatedResponse.statusCode,
+              response: translatedResponse,
+            },
+          })
+          .catch((err) => console.error(err))
+      } else {
+        console.error(exception)
+      }
+    }
+
+    return filterRequestParams.response
+      .status(translatedResponse.statusCode)
+      .json(translatedResponse)
+  }
+
+  private translate(exception: Prisma.PrismaClientKnownRequestError) {
+    switch (exception.code) {
+      case 'P2002':
+        return {
+          statusCode: HttpStatus.CONFLICT,
+          message: 'Registro já existente.',
+        }
+      case 'P2003':
+        return {
+          statusCode: HttpStatus.BAD_REQUEST,
+          message:
+            'Falha devido a relacionamento. Verifique se o relacionamento existe ou é valido.',
+        }
+      case 'P2025':
+        return {
+          statusCode: HttpStatus.NOT_FOUND,
+          message: 'Registro não encontrado.',
+        }
+      default:
+        console.error(exception)
+        return {
+          statusCode: HttpStatus.BAD_REQUEST,
+          message:
+            'Ocorreu um erro desconhecido relacionado aos dados enviados.',
+        }
+    }
+  }
+}

package/src/filters/zod-errors.filter.ts

@@ -0,0 +1,48 @@
+import { ArgumentsHost, Catch, HttpStatus } from '@nestjs/common'
+import { BaseExceptionFilter } from '@nestjs/core'
+import { ZodError } from 'zod'
+import { fromZodError } from 'zod-validation-error'
+import { KoalaGlobalVars } from '../core/koala-global-vars'
+import { EnvConfig } from '../core/utils/env.config'
+import { FilterRequestParams } from '../core/utils/filter-request-params'
+import { ILoggingService } from '../services/logging/ilogging.service'
+
+@Catch(ZodError)
+export class ZodErrorsFilter extends BaseExceptionFilter {
+  constructor(private readonly loggingService: ILoggingService) {
+    super()
+  }
+
+  public catch(exception: ZodError, host: ArgumentsHost) {
+    const filterRequestParams = FilterRequestParams.get(host)
+
+    const zodResponse = {
+      errors: fromZodError(exception).details.map(
+        (detail) => `${detail.path} ${detail.message.toLowerCase()}`,
+      ),
+      statusCode: HttpStatus.BAD_REQUEST,
+      message: 'Dados enviados inválidos',
+    }
+
+    if (!EnvConfig.isEnvTest) {
+      this.loggingService
+        .report({
+          error: exception,
+          packageName: KoalaGlobalVars.appName,
+          loggedUsername: filterRequestParams.loggedUserName,
+          httpRequest: {
+            ...filterRequestParams.filterParams,
+            statusCode: HttpStatus.BAD_REQUEST,
+            response: zodResponse,
+          },
+        })
+        .catch((err) => console.error(err))
+    } else {
+      console.error(exception)
+    }
+
+    return filterRequestParams.response
+      .status(HttpStatus.BAD_REQUEST)
+      .send(zodResponse)
+  }
+}

package/src/services/logging/ilogging.service.ts

@@ -0,0 +1,17 @@
+export interface LoggingReportProps {
+  loggedUsername: string
+  packageName: string
+  error: Error
+  httpRequest?: {
+    method: string
+    endpoint: string
+    queryParams?: string
+    payload?: object
+    statusCode: number
+    response?: object
+  }
+}
+
+export abstract class ILoggingService {
+  abstract report(data: LoggingReportProps): Promise<void>
+}

package/src/services/logging/logging.service.ts

@@ -0,0 +1,10 @@
+import { Injectable } from '@nestjs/common'
+import { ILoggingService, LoggingReportProps } from './ilogging.service'
+import consola from 'consola'
+
+@Injectable()
+export class LoggingService implements ILoggingService {
+  async report(data: LoggingReportProps): Promise<void> {
+    consola.error(data.error)
+  }
+}

package/src/services/redis/iredis.service.ts

@@ -0,0 +1,11 @@
+export abstract class IRedisService {
+  abstract isConnected: boolean
+  abstract getCache(key: string): Promise<string | null>
+  abstract setCache(
+    key: string,
+    ttlSecondsCache: number,
+    payload: any,
+  ): Promise<void>
+
+  abstract deleteCache(key: string): Promise<void>
+}

package/src/services/redis/redis.service.ts

@@ -0,0 +1,70 @@
+import { Injectable, OnModuleDestroy } from '@nestjs/common'
+import Redis from 'ioredis'
+import { EnvConfig } from '../../core/utils/env.config'
+import { EnvService } from '../../env/env.service'
+import { IRedisService } from './iredis.service'
+
+@Injectable()
+export class RedisService implements IRedisService, OnModuleDestroy {
+  private readonly redisClient: Redis
+  private readonly environment: string
+
+  get isConnected(): boolean {
+    return !!this.redisClient
+  }
+
+  constructor(env: EnvService) {
+    if (!EnvConfig.isEnvTest) {
+      const redisUrl = env.get('REDIS_CONNECTION_STRING')
+
+      if (redisUrl) {
+        const url = new URL(redisUrl)
+        this.environment = env.get('NODE_ENV')
+
+        this.redisClient = new Redis({
+          host: url.hostname,
+          port: Number(url.port),
+          password: url.password,
+          username: url.username,
+        })
+      }
+    }
+  }
+
+  onModuleDestroy() {
+    this.redisClient.disconnect()
+  }
+
+  async getCache(key: string): Promise<string | null> {
+    if (EnvConfig.isEnvTest) {
+      return ''
+    }
+
+    return await this.redisClient.get(this.getKeyCache(key))
+  }
+
+  async setCache(
+    key: string,
+    ttlSecondsCache: number,
+    payload: any,
+  ): Promise<void> {
+    if (!EnvConfig.isEnvTest) {
+      await this.redisClient.set(
+        this.getKeyCache(key),
+        JSON.stringify(payload),
+        'EX',
+        ttlSecondsCache,
+      )
+    }
+  }
+
+  async deleteCache(key: string): Promise<void> {
+    if (!EnvConfig.isEnvTest) {
+      await this.redisClient.del(this.getKeyCache(key))
+    }
+  }
+
+  private getKeyCache(key: string) {
+    return `${this.environment}:app:${key}`
+  }
+}

package/src/services/redlock/ired-lock.service.ts

@@ -0,0 +1,4 @@
+export abstract class IRedLockService {
+  abstract acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean>
+  abstract releaseLock(key: string): Promise<void>
+}

package/src/services/redlock/red-lock.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common'
+import { EnvConfig } from '../../core/utils/env.config'
+import { IRedisService } from '../redis/iredis.service'
+import { IRedLockService } from './ired-lock.service'
+
+@Injectable()
+export class RedLockService implements IRedLockService {
+  constructor(private readonly redisService: IRedisService) {}
+
+  async acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean> {
+    if (EnvConfig.isEnvTest || !this.redisService.isConnected) {
+      return true
+    }
+
+    const lockKey = this.getLockKey(key)
+    const canLock = await this.redisService.getCache(lockKey)
+
+    if (canLock) {
+      return false
+    }
+
+    await this.redisService.setCache(lockKey, ttlSecondsLock, 'RedLockService')
+
+    return true
+  }
+
+  async releaseLock(key: string): Promise<void> {
+    if (!EnvConfig.isEnvTest && this.redisService.isConnected) {
+      await this.redisService.deleteCache(this.getLockKey(key))
+    }
+  }
+
+  private getLockKey(key: string) {
+    return `redLock:${key}`
+  }
+}

package/src/test/koala-app-test-dependencies.ts

@@ -0,0 +1,15 @@
+import { Type } from '@nestjs/common'
+
+interface KoalaAppTestDependenciesConfig {
+  dependencies: any[]
+}
+
+export class KoalaAppTestDependencies {
+  constructor(private readonly _config: KoalaAppTestDependenciesConfig) {}
+
+  get<T>(objectType: Type<T>): T {
+    return this._config.dependencies.find(
+      (dependency) => dependency instanceof objectType,
+    )
+  }
+}

package/src/test/koala-app-test.ts

@@ -0,0 +1,103 @@
+import { CanActivate, INestApplication, Type } from '@nestjs/common'
+import { BaseExceptionFilter } from '@nestjs/core'
+import { PrismaTransactionalClient } from '../core/database/prisma-transactional-client'
+import { KoalaGlobalVars } from '../core/koala-global-vars'
+import { instanciateClassWithDependenciesInjection } from '../core/utils/instanciate-class-with-dependencies-injection'
+import { DomainErrorsFilter } from '../filters/domain-errors.filter'
+import { GlobalExceptionsFilter } from '../filters/global-exception.filter'
+import { PrismaValidationExceptionFilter } from '../filters/prisma-validation-exception.filter'
+import { ZodErrorsFilter } from '../filters/zod-errors.filter'
+import { ILoggingService } from '../services/logging/ilogging.service'
+
+export class KoalaAppTest {
+  private _guards: CanActivate[] = []
+  private _globalExceptionFilter: BaseExceptionFilter
+  private _prismaValidationExceptionFilter: BaseExceptionFilter
+  private _domainExceptionFilter: BaseExceptionFilter
+  private _zodExceptionFilter: BaseExceptionFilter
+
+  constructor(private readonly app: INestApplication<any>) {
+    let loggingService = app.get(ILoggingService)
+
+    if (!loggingService.report) {
+      loggingService = instanciateClassWithDependenciesInjection(
+        this.app,
+        loggingService,
+      )
+    }
+
+    this._globalExceptionFilter = new GlobalExceptionsFilter(loggingService)
+    this._prismaValidationExceptionFilter = new PrismaValidationExceptionFilter(
+      loggingService,
+    )
+    this._domainExceptionFilter = new DomainErrorsFilter(loggingService)
+    this._zodExceptionFilter = new ZodErrorsFilter(loggingService)
+  }
+
+  addGlobalGuard(Guard: Type<CanActivate>) {
+    this._guards.push(
+      instanciateClassWithDependenciesInjection(this.app, Guard),
+    )
+    return this
+  }
+
+  addCustomGlobalExceptionFilter(filter: BaseExceptionFilter) {
+    this._globalExceptionFilter = filter
+    return this
+  }
+
+  addCustomPrismaValidationExceptionFilter(filter: BaseExceptionFilter) {
+    this._prismaValidationExceptionFilter = filter
+    return this
+  }
+
+  addCustomDomainExceptionFilter(filter: BaseExceptionFilter) {
+    this._domainExceptionFilter = filter
+    return this
+  }
+
+  addCustomZodExceptionFilter(filter: BaseExceptionFilter) {
+    this._zodExceptionFilter = filter
+    return this
+  }
+
+  enableCors() {
+    this.app.enableCors({
+      credentials: true,
+      origin: true,
+      optionsSuccessStatus: 200,
+    })
+
+    return this
+  }
+
+  setAppName(name: string) {
+    KoalaGlobalVars.appName = name
+    return this
+  }
+
+  setInternalUserName(name: string) {
+    KoalaGlobalVars.internalUserName = name
+    return this
+  }
+
+  setDbTransactionContext(transactionContext: Type<PrismaTransactionalClient>) {
+    KoalaGlobalVars.dbTransactionContext = transactionContext
+    return this
+  }
+
+  build() {
+    this.app.useGlobalFilters(
+      this._globalExceptionFilter,
+      this._prismaValidationExceptionFilter,
+      this._domainExceptionFilter,
+      this._zodExceptionFilter,
+    )
+
+    for (const guard of this._guards) {
+      this.app.useGlobalGuards(guard)
+    }
+
+    return this.app
+  }
+}

package/src/test/repositories/in-memory-base.repository.ts

@@ -0,0 +1,90 @@
+import { QUERY_FILTER_PARAMS } from '@koalarx/nest/core/constants/query-params'
+import { PaginationDto } from '@koalarx/nest/core/dtos/pagination.dto'
+import { KlArray } from '@koalarx/utils/KlArray'
+import { randomUUID } from 'node:crypto'
+import { ListResponseBase } from '../../core/controllers/list-response.base'
+import { EntityActionType, EntityBase } from '../../core/database/entity.base'
+import { IComparableId } from '../../core/utils/interfaces/icomparable'
+
+export abstract class InMemoryBaseRepository<TClass extends EntityBase<any>> {
+  protected items: TClass[] = []
+
+  constructor(private readonly typeId: 'number' | 'string' = 'number') {}
+
+  protected async findById(id: IComparableId): Promise<TClass | null> {
+    const entity = this.items.find((item) => item._id === id) ?? null
+
+    if (entity) {
+      entity._action = EntityActionType.update
+    }
+
+    return entity
+  }
+
+  protected async findMany<T extends PaginationDto>(
+    query: T,
+    predicate?: (value: TClass, index: number, array: TClass[]) => unknown,
+  ) {
+    const page = query.page ?? QUERY_FILTER_PARAMS.page
+    const limit = query.limit ?? QUERY_FILTER_PARAMS.limit
+
+    return new KlArray(predicate ? this.items.filter(predicate) : this.items)
+      .orderBy(query.orderBy ?? '', query.direction)
+      .slice(page * limit, (page + 1) * limit)
+      .map((item) => {
+        item._action = EntityActionType.update
+        return item
+      })
+  }
+
+  protected async findManyAndCount<T extends PaginationDto>(
+    query: T,
+    predicate?: (value: TClass, index: number, array: TClass[]) => unknown,
+  ): Promise<ListResponseBase<TClass>> {
+    const items = await this.findMany(query, predicate)
+
+    return {
+      items,
+      count: items.length,
+    }
+  }
+
+  protected async saveChanges(
+    item: TClass,
+    updateWhere?: (item: TClass) => boolean,
+  ) {
+    if (item._action === EntityActionType.create) {
+      const id = this.typeId === 'number' ? this.getNewId() : randomUUID()
+
+      item.automap({ ...item, id })
+
+      this.items.push(item)
+
+      return { id: item._id }
+    }
+
+    const predicate = updateWhere ?? ((itemDB) => itemDB.equals(item))
+    const itemIndex = this.items.findIndex(predicate)
+
+    if (itemIndex > -1) {
+      this.items[itemIndex] = item
+    }
+  }
+
+  protected async remove(
+    predicate: (value: TClass, index: number, obj: TClass[]) => unknown,
+  ) {
+    const itemIndex = this.items.findIndex(predicate)
+
+    if (itemIndex > -1) {
+      this.items.splice(itemIndex, 1)
+    }
+  }
+
+  private getNewId(): IComparableId {
+    return this.typeId === 'number'
+      ? (new KlArray(this.items).orderBy('_id', 'desc')[0]?._id as number) ??
+          0 + 1
+      : randomUUID()
+  }
+}

package/src/test/services/fake-logging.service.ts

@@ -0,0 +1,7 @@
+import { ILoggingService } from '../../services/logging/ilogging.service'
+
+export class FakeLoggingService implements ILoggingService {
+  async report(data) {
+    console.log('FakeLoggingService.report', data)
+  }
+}

package/src/test/services/fake-red-lock.service.ts

@@ -0,0 +1,11 @@
+import { IRedLockService } from '../../services/redlock/ired-lock.service'
+
+export class FakeRedLockService implements IRedLockService {
+  async acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean> {
+    return true
+  }
+
+  async releaseLock(key: string): Promise<void> {
+    //
+  }
+}