@koalarx/nest 1.19.0 → 3.0.1

package/src/core/database/repository.base.ts

@@ -0,0 +1,548 @@
+import { toCamelCase } from '@koalarx/utils/KlString'
+import { Type } from '@nestjs/common'
+import { ListResponse } from '..'
+import { PaginationDto } from '../dtos/pagination.dto'
+import { KoalaGlobalVars } from '../koala-global-vars'
+import { IComparableId } from '../utils/interfaces/icomparable'
+import { List } from '../utils/list'
+import { EntityActionType, EntityBase } from './entity.base'
+import { PrismaTransactionalClient } from './prisma-transactional-client'
+import { AutoMappingList } from '../mapping/auto-mapping-list'
+
+type RepositoryInclude<TEntity> = Omit<
+  {
+    [K in keyof TEntity as TEntity[K] extends Function ? never : K]?:
+      | boolean
+      | (TEntity[K] extends List<infer U>
+          ? RepositoryInclude<U>
+          : RepositoryInclude<TEntity[K]>)
+  },
+  '_id' | '_action'
+>
+
+interface RepositoryInitProps<
+  TEntity extends EntityBase<TEntity>,
+  TContext extends PrismaTransactionalClient,
+> {
+  context: TContext
+  modelName: Type<TEntity>
+  transactionContext?: Type<TContext>
+  include?: RepositoryInclude<TEntity>
+}
+
+export abstract class RepositoryBase<
+  TEntity extends EntityBase<TEntity>,
+  TContext extends PrismaTransactionalClient = PrismaTransactionalClient,
+  TModelKey extends keyof TContext = keyof TContext,
+> {
+  protected _context: TContext
+  private readonly _modelName: Type<TEntity>
+  private readonly _include?: RepositoryInclude<TEntity>
+
+  constructor({
+    context,
+    modelName,
+    include,
+  }: RepositoryInitProps<TEntity, TContext>) {
+    this._context = context
+    this._modelName = modelName
+    this._include = include
+  }
+
+  private listRelationEntities(entity: TEntity) {
+    const relationEntities: TEntity[] = []
+
+    Object.keys(entity).forEach((key) => {
+      if (entity[key] instanceof List) {
+        const list = entity[key]
+
+        list.toArray('added').forEach((item) => {
+          relationEntities.push(item)
+          relationEntities.push(...this.listRelationEntities(item))
+        })
+
+        list.toArray('updated').forEach((item) => {
+          relationEntities.push(item)
+          relationEntities.push(...this.listRelationEntities(item))
+        })
+      } else if (entity[key] instanceof EntityBase) {
+        relationEntities.push(entity[key] as any)
+        relationEntities.push(...this.listRelationEntities(entity[key] as any))
+      }
+    })
+
+    return relationEntities
+  }
+
+  private listToRelationActionList(entity: TEntity) {
+    type RelationActionList = Array<{
+      modelName: string
+      entityInstance: Type<TEntity>
+      schema: any
+      relations: TEntity[]
+    }>
+
+    const relationCreates: RelationActionList = []
+    const relationUpdates: RelationActionList = []
+    const relationDeletes: RelationActionList = []
+
+    Object.keys(entity).forEach((key) => {
+      if (entity[key] instanceof List) {
+        const list = entity[key]
+        const entityInstance = list.entityType! as any
+        const modelName = entityInstance.name
+        const parentModelName = entity.constructor.name
+
+        if (modelName) {
+          list.toArray('removed').forEach((item) => {
+            relationDeletes.push({
+              modelName: toCamelCase(modelName),
+              entityInstance,
+              schema: { where: { id: item._id } },
+              relations: [],
+            })
+          })
+
+          list.toArray('added').forEach((item) => {
+            relationCreates.push({
+              modelName: toCamelCase(modelName),
+              entityInstance,
+              schema: {
+                data: {
+                  ...this.entityToPrisma(item),
+                  [toCamelCase(parentModelName)]: {
+                    connect: {
+                      [this.getIdPropName(entity)]:
+                        entity[this.getIdPropName(entity)],
+                    },
+                  },
+                },
+              },
+              relations: this.listRelationEntities(item),
+            })
+          })
+
+          list.toArray('updated').forEach((item) => {
+            relationUpdates.push({
+              modelName: toCamelCase(modelName),
+              entityInstance,
+              schema: {
+                where: { id: item._id },
+                data: this.entityToPrisma(item),
+              },
+              relations: this.listRelationEntities(item),
+            })
+          })
+        }
+      }
+    })
+
+    return { relationCreates, relationUpdates, relationDeletes }
+  }
+
+  private entityToPrisma(entity: TEntity) {
+    const prismaSchema = {}
+
+    Object.keys(entity)
+      .filter((key) => !['id', '_id', '_action'].includes(key))
+      .filter(
+        (key) =>
+          !(entity[key] instanceof Function || entity[key] instanceof List),
+      )
+      .forEach((key) => {
+        if (entity[key] instanceof EntityBase) {
+          if (entity[key]._action === EntityActionType.create) {
+            if (entity[key][this.getIdPropName(entity)]) {
+              prismaSchema[key] = {
+                connectOrCreate: {
+                  where: {
+                    [this.getIdPropName(entity)]:
+                      entity[key][this.getIdPropName(entity)],
+                  },
+                  create: this.entityToPrisma(entity[key] as any),
+                },
+              }
+            } else {
+              prismaSchema[key] = {
+                create: this.entityToPrisma(entity[key] as any),
+              }
+            }
+          } else {
+            prismaSchema[key] = {
+              update: this.entityToPrisma(entity[key] as any),
+            }
+          }
+        } else {
+          prismaSchema[key] = entity[key]
+        }
+      })
+
+    return prismaSchema
+  }
+
+  private findManySchema<T>(where: T, pagination?: PaginationDto) {
+    return {
+      include: this.getInclude(),
+      where,
+      orderBy: pagination?.generateOrderBy(),
+      skip: pagination?.skip(),
+      take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
+    }
+  }
+
+  private createEntity(data: any, entityClass?: Type<TEntity>) {
+    const entity = new (entityClass || this._modelName)()
+    entity._action = EntityActionType.update
+    entity.automap(data)
+
+    return entity
+  }
+
+  private orphanRemoval(
+    client: PrismaTransactionalClient,
+    entity: EntityBase<TEntity>,
+  ) {
+    const where = {}
+
+    Object.keys(entity)
+      .filter((key: string) => key === 'id' || key.includes('Id'))
+      .forEach((key) => (where[key] = entity[key]))
+
+    return client[toCamelCase(entity.constructor.name)].delete({ where })
+  }
+
+  private getIdPropName(entity?: TEntity) {
+    return (
+      Reflect.getMetadata(
+        'entity:id',
+        entity ? entity.constructor.prototype : this._modelName.prototype,
+      ) ?? 'id'
+    )
+  }
+
+  private getInclude(include?: RepositoryInclude<TEntity>) {
+    include = include ?? this._include ?? {}
+
+    const result = {}
+
+    Object.keys(include).forEach((key) => {
+      if (typeof include[key] === 'boolean') {
+        result[key] = include[key]
+      } else {
+        result[key] = {
+          include: this.getInclude(include[key]),
+        }
+      }
+    })
+
+    return result
+  }
+
+  private getPropNameFromEntitySource(source: TEntity, entity: Type<TEntity>) {
+    return Object.keys(source).find((key) => {
+      const propDefinitions = AutoMappingList.getPropDefinitions(
+        source.constructor as any,
+        key,
+      )
+
+      if (propDefinitions) {
+        if (propDefinitions.type === entity.name) {
+          return true
+        } else if (source[key] instanceof List) {
+          const list = source[key] as List<any>
+          return list.entityType?.name === entity.name
+        }
+      }
+
+      return false
+    })
+  }
+
+  private persistRelations(
+    transaction: PrismaTransactionalClient,
+    entity: TEntity,
+  ) {
+    const { relationCreates, relationUpdates, relationDeletes } =
+      this.listToRelationActionList(entity)
+
+    return Promise.all([
+      ...relationCreates.map((relationCreate) =>
+        transaction[relationCreate.modelName]
+          .create(relationCreate.schema)
+          .then((response) => {
+            return Promise.all(
+              relationCreate.relations.map((relation) => {
+                const relationPropName = this.getPropNameFromEntitySource(
+                  relation,
+                  relationCreate.entityInstance,
+                )
+
+                if (!relationPropName) {
+                  throw new Error(
+                    `Propname not found for relation entity ${relation.constructor.name} on entity ${relationCreate.entityInstance.constructor.name}`,
+                  )
+                }
+
+                const relationEntity = this.createEntity(
+                  response,
+                  relationCreate.entityInstance as any,
+                )
+                relationEntity._action = EntityActionType.create
+
+                relation[relationPropName] = relationEntity
+
+                return transaction[toCamelCase(relation.constructor.name)]
+                  .create({
+                    data: this.entityToPrisma(relation),
+                  })
+                  .then((response: TEntity) => {
+                    entity[this.getIdPropName(relation)] =
+                      response[this.getIdPropName(relation)]
+                    return this.persistRelations(transaction, relation)
+                  })
+              }),
+            )
+          }),
+      ),
+      ...relationUpdates.map((relation) =>
+        transaction[relation.modelName].update(relation.schema),
+      ),
+      ...relationDeletes.map((relation) => this.removeMany(relation.schema)),
+    ])
+  }
+
+  protected context(transactionalClient?: TContext): TContext[TModelKey] {
+    const modelName = this._modelName.name
+
+    if (!modelName)
+      throw new Error('modelName não informado no contrutor do repositorio')
+
+    const contextKey = toCamelCase(modelName) as TModelKey
+
+    if (transactionalClient) {
+      return transactionalClient[contextKey] as any
+    }
+
+    return this._context[contextKey] as any
+  }
+
+  protected async findById(id: IComparableId): Promise<TEntity | null> {
+    return (this.context() as any)
+      .findFirst({
+        include: this.getInclude(),
+        where: { [this.getIdPropName()]: id },
+      })
+      .then((response: TEntity) => {
+        if (response) {
+          return this.createEntity(response)
+        }
+
+        return null
+      })
+  }
+
+  protected async findFirst<T>(where: T): Promise<TEntity | null> {
+    return (this.context() as any)
+      .findFirst({
+        include: this.getInclude(),
+        where,
+      })
+      .then((response: TEntity) => {
+        if (response) {
+          return this.createEntity(response)
+        }
+
+        return null
+      })
+  }
+
+  protected async findUnique<T>(where: T): Promise<TEntity | null> {
+    return (this.context() as any)
+      .findUnique({
+        include: this.getInclude(),
+        where,
+      })
+      .then((response: TEntity) => {
+        if (response) {
+          return this.createEntity(response)
+        }
+
+        return null
+      })
+  }
+
+  protected async findMany<T>(
+    where: T,
+    pagination?: PaginationDto,
+  ): Promise<TEntity[]> {
+    return (this.context() as any)
+      .findMany(this.findManySchema(where, pagination))
+      .then((result: TEntity[]) =>
+        result.map((response) => this.createEntity(response)),
+      )
+  }
+
+  protected async findManyAndCount<T>(
+    where: T,
+    pagination?: PaginationDto,
+  ): Promise<ListResponse<TEntity>> {
+    const count = await (this.context() as any).count({ where })
+
+    if (count > 0) {
+      const items = await this.findMany(
+        where,
+        Object.assign(new PaginationDto(), pagination),
+      )
+
+      return { items, count }
+    }
+
+    return { items: [], count }
+  }
+
+  protected async saveChanges<TWhere = any>(
+    entity: TEntity,
+    updateWhere?: TWhere,
+  ): Promise<TEntity> {
+    const prismaEntity = this.entityToPrisma(entity)
+
+    if (entity._action === EntityActionType.create) {
+      return this.withTransaction((client) =>
+        (this.context(client) as any)
+          .create({
+            data: prismaEntity,
+            include: this.getInclude(),
+          })
+          .then((response: TEntity) => {
+            entity[this.getIdPropName()] = response[this.getIdPropName()]
+            return this.persistRelations(client, entity).then(() => entity)
+          }),
+      )
+    } else {
+      const where = updateWhere ?? { id: entity._id }
+
+      return this.withTransaction((client) =>
+        (this.context(client) as any)
+          .update({
+            where,
+            data: prismaEntity,
+          })
+          .then(() => this.persistRelations(client, entity)),
+      ).then(() => this.findUnique(where) as Promise<TEntity>)
+    }
+  }
+
+  protected async saveMany<TWhere = any>(
+    entities: TEntity[],
+    updateWhere?: TWhere,
+  ): Promise<void> {
+    await this.withTransaction(async (client) => {
+      const prismaEntities = entities.map((entity) =>
+        this.entityToPrisma(entity),
+      )
+
+      return Promise.all([
+        (this.context(client) as any).createMany({
+          data: prismaEntities,
+          skipDuplicates: true,
+        }),
+        ...entities
+          .filter((entity) => !!entity._id)
+          .map((entity) =>
+            (this.context(client) as any).update({
+              data: entity,
+              where: updateWhere ?? { id: entity._id },
+            }),
+          ),
+      ])
+    })
+  }
+
+  protected async remove<TWhere = any>(
+    where: TWhere,
+    notCascadeEntityProps?: Array<keyof TEntity>,
+    externalServices?: Promise<any>,
+  ) {
+    const entity = await this.findUnique(where)
+
+    if (!entity) {
+      throw new Error(`Entity not found for where: ${JSON.stringify(where)}`)
+    }
+
+    const relationEntity: EntityBase<TEntity>[] = []
+
+    Object.keys(entity).forEach((key) => {
+      if (
+        entity[key] instanceof EntityBase &&
+        !notCascadeEntityProps?.includes(key as keyof TEntity)
+      ) {
+        relationEntity.push(entity[key])
+      }
+    })
+
+    return this.withTransaction((client) =>
+      (externalServices
+        ? externalServices.then(() => client)
+        : Promise.resolve(client)
+      ).then((client) =>
+        (this.context(client) as any)
+          .delete({ where })
+          .then((response) =>
+            Promise.all(
+              relationEntity.map((entity) =>
+                this.orphanRemoval(client, entity),
+              ),
+            ).then(() => response),
+          ),
+      ),
+    )
+  }
+
+  protected async removeMany<TWhere = any>(
+    where: TWhere,
+    notCascadeEntityProps?: Array<keyof TEntity>,
+    externalServices?: Promise<any>,
+  ): Promise<void> {
+    const entities = await this.findMany(where)
+
+    if (entities.length === 0) {
+      throw new Error(`Entities not found for where: ${JSON.stringify(where)}`)
+    }
+
+    return this.withTransaction((client) =>
+      (externalServices
+        ? externalServices.then(() => client)
+        : Promise.resolve(client)
+      ).then(async (client) => {
+        const relationEntity: EntityBase<TEntity>[] = []
+
+        for (const entity of entities) {
+          Object.keys(entity).forEach((key) => {
+            if (
+              entity[key] instanceof EntityBase &&
+              !notCascadeEntityProps?.includes(key as keyof TEntity)
+            ) {
+              relationEntity.push(entity[key])
+            }
+          })
+        }
+
+        return (this.context(client) as any)
+          .deleteMany({ where })
+          .then((response) =>
+            Promise.all(
+              relationEntity.map((entity) =>
+                this.orphanRemoval(client, entity),
+              ),
+            ).then(() => response),
+          )
+      }),
+    )
+  }
+
+  withTransaction(fn: (prisma: TContext) => Promise<any>) {
+    return this._context.withTransaction(async (client) => {
+      return fn(new (KoalaGlobalVars.dbTransactionContext as any)(client))
+    })
+  }
+}

package/src/core/dtos/pagination.dto.ts

@@ -0,0 +1,35 @@
+import type { QueryDirectionType } from '..'
+import { QUERY_FILTER_PARAMS } from '../constants/query-params'
+import { AutoMap } from '../mapping/auto-mapping.decorator'
+
+export class PaginationDto {
+  @AutoMap()
+  page?: number = 0
+
+  @AutoMap()
+  limit?: number = QUERY_FILTER_PARAMS.limit
+
+  @AutoMap()
+  orderBy?: string = ''
+
+  @AutoMap()
+  direction?: QueryDirectionType = 'asc'
+
+  skip() {
+    return (this.limit ?? 0) * (this.page ?? QUERY_FILTER_PARAMS.page)
+  }
+
+  generateOrderBy() {
+    if (this.orderBy) {
+      const orderByField = this.orderBy.split('.')
+      return orderByField.reduceRight(
+        (acc, item, index) => ({
+          [item]: index === orderByField.length - 1 ? this.direction : acc,
+        }),
+        {},
+      )
+    }
+
+    return undefined
+  }
+}

package/src/core/errors/bad-request.error.ts

@@ -0,0 +1,8 @@
+import { ErrorBase } from './error.base'
+import { UseCaseError } from './use-case-error'
+
+export class BadRequestError extends ErrorBase implements UseCaseError {
+  constructor(message?: string, data?: any) {
+    super(message ?? 'Bad Request', data)
+  }
+}

package/src/core/errors/conflict.error.ts

@@ -0,0 +1,7 @@
+import { ErrorBase } from './error.base'
+
+export class ConflictError extends ErrorBase {
+  constructor(identifier: string, data?: any) {
+    super(`O registro ${identifier} já existe.`, data)
+  }
+}

package/src/core/errors/error.base.ts

@@ -0,0 +1,5 @@
+export abstract class ErrorBase extends Error {
+  constructor(message: string, public readonly data?: any) {
+    super(message)
+  }
+}

package/src/core/errors/no-content.error.ts

@@ -0,0 +1,8 @@
+import { ErrorBase } from './error.base'
+import { UseCaseError } from './use-case-error'
+
+export class NoContentError extends ErrorBase implements UseCaseError {
+  constructor(message?: string, data?: any) {
+    super(message ?? 'No Content', data)
+  }
+}

package/src/core/errors/not-allowed.error.ts

@@ -0,0 +1,8 @@
+import { ErrorBase } from './error.base'
+import { UseCaseError } from './use-case-error'
+
+export class NotAllowedError extends ErrorBase implements UseCaseError {
+  constructor(message?: string, data?: any) {
+    super(message ?? 'Você não tem permissão para utilizar esse recurso.', data)
+  }
+}

package/src/core/errors/resource-not-found.error.ts

@@ -0,0 +1,8 @@
+import { ErrorBase } from './error.base'
+import { UseCaseError } from './use-case-error'
+
+export class ResourceNotFoundError extends ErrorBase implements UseCaseError {
+  constructor(name = 'Recurso', data?: any) {
+    super(`${name} não encontrado(a).`, data)
+  }
+}

package/{core/errors/use-case-error.d.ts → src/core/errors/use-case-error.ts}

@@ -1,3 +1,3 @@
 export interface UseCaseError {
-    message: string;
+  message: string
 }

package/src/core/errors/user-already-exist.error.ts

@@ -0,0 +1,7 @@
+import { ErrorBase } from './error.base'
+
+export class UserAlreadyExist extends ErrorBase {
+  constructor(identifier: string, data?: any) {
+    super(`User ${identifier} already exists`, data)
+  }
+}

package/src/core/errors/wrong-credentials.error.ts

@@ -0,0 +1,7 @@
+import { ErrorBase } from './error.base'
+
+export class WrongCredentialsError extends ErrorBase {
+  constructor(data?: any) {
+    super('Credentials are not valid', data)
+  }
+}

package/src/core/health-check/health-check.controller.ts

@@ -0,0 +1,13 @@
+import { IsPublic } from '@koalarx/nest/decorators/is-public.decorator'
+import { Controller, Get } from '@nestjs/common'
+import { ApiExcludeEndpoint } from '@nestjs/swagger'
+
+@Controller('health')
+export class HealthCheckController {
+  @Get()
+  @IsPublic()
+  @ApiExcludeEndpoint()
+  healthCheck() {
+    return { status: 'ok' }
+  }
+}

package/src/core/health-check/health-check.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common'
+import { HealthCheckController } from './health-check.controller'
+
+@Module({
+  controllers: [HealthCheckController],
+})
+export class HealthCheckModule {}