@koalarx/nest 1.19.0 → 3.0.1

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

@@ -0,0 +1,95 @@
+import { KlArray, KlDate, KlTime } from '@koalarx/utils'
+import { Type } from '@nestjs/common'
+import { Overwrite } from '..'
+import { AutoMappingList } from '../mapping/auto-mapping-list'
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable'
+import { List } from '../utils/list'
+
+export enum EntityActionType {
+  create = 1,
+  update,
+}
+
+export type EntityProps<T extends IComparable<T>> = Overwrite<
+  Omit<
+    {
+      [K in keyof T as T[K] extends Function ? never : K]: T[K]
+    },
+    '_id' | '_action'
+  >,
+  { id?: T extends { id: infer U } ? U : never }
+>
+
+export abstract class EntityBase<T extends IComparable<T>>
+  implements IComparable<T>
+{
+  _id: IComparableId
+  _action: EntityActionType = EntityActionType.create
+
+  constructor(props?: EntityProps<T>) {
+    if (props) {
+      this.automap(props)
+    }
+  }
+
+  automap(props?: EntityProps<T>) {
+    if (props) {
+      for (const key of Object.keys(props)) {
+        if (props[key] === undefined) {
+          continue
+        }
+
+        const propDefinitions = AutoMappingList.getPropDefinitions(
+          this.constructor.prototype.constructor,
+          key,
+        )
+        const EntityOnPropKey = AutoMappingList.getSourceByName(
+          propDefinitions?.type ?? '',
+        )
+
+        if (Array.isArray(props[key]) && this[key] instanceof List) {
+          let value: any = props[key]
+
+          if (this[key].entityType) {
+            value = value.map((item) => {
+              const entity = new (this[key].entityType as Type<any>)()
+              entity._action = this._action
+              entity.automap(item)
+
+              return entity
+            })
+          }
+
+          this[key].setList(value)
+        } else if (
+          propDefinitions?.type === 'KlArray' &&
+          (props[key] instanceof Array || Array.isArray(props[key]))
+        ) {
+          this[key] = new KlArray(props[key])
+        } else if (propDefinitions?.type === 'KlDate' && props[key] instanceof Date) {
+          this[key] = new KlDate(props[key])
+        } else if (propDefinitions?.type === 'KlTime' && props[key] instanceof Date) {
+          this[key] = new KlTime(props[key].getHours(), props[key].getMinutes(), props[key].getSeconds(), props[key].getMilliseconds())
+        } else if (EntityOnPropKey) {
+          if (props[key]) {
+            const entity = new EntityOnPropKey()
+            entity._action = this._action
+            entity.automap(props[key])
+
+            this[key] = entity
+          }
+        } else if (propDefinitions) {
+          if (key === 'id') {
+            this._id = props[key] as IComparableId
+          }
+
+          this[key] = props[key]
+        }
+      }
+    }
+  }
+
+  public equals(obj: EntityBase<T>): boolean {
+    return obj._id === this._id
+  }
+}

package/src/core/database/entity.decorator.spec.ts

@@ -0,0 +1,71 @@
+import { faker } from '@faker-js/faker'
+import { AutoMap } from '../mapping/auto-mapping.decorator'
+import { List } from '../utils/list'
+import { EntityBase } from './entity.base'
+import { Entity } from './entity.decorator'
+
+@Entity()
+export class PersonAddress extends EntityBase<PersonAddress> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  address: string
+}
+
+@Entity()
+export class PersonPhone extends EntityBase<PersonPhone> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  phone: string
+}
+
+@Entity()
+export class Person extends EntityBase<Person> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  name: string
+
+  @AutoMap({ type: List })
+  phones = new List(PersonPhone)
+
+  @AutoMap({ type: PersonAddress })
+  address: PersonAddress
+
+  @AutoMap()
+  active: boolean
+}
+
+describe('Entity decorator', () => {
+  it('should create an instance of Person', () => {
+    const person = new Person({
+      name: faker.person.fullName(),
+      phones: [
+        { phone: faker.phone.number() },
+        { phone: faker.phone.number() },
+      ],
+      address: { address: faker.location.streetAddress() },
+      active: true,
+    } as any)
+
+    expect(person).toBeInstanceOf(Person)
+    expect(person).toBeInstanceOf(EntityBase)
+    expect(person.constructor.name).toBe('Person')
+
+    expect(person.phones).toBeInstanceOf(List)
+    expect(person.phones.toArray()[0]).toBeInstanceOf(PersonPhone)
+    expect(person.phones.toArray()[1]).toBeInstanceOf(PersonPhone)
+    expect(person.phones.toArray()[0].phone).toBeDefined()
+    expect(person.phones.toArray()[1].phone).toBeDefined()
+
+    expect(person.address.constructor.name).toBe(PersonAddress.name)
+    expect(person.address.address).toBeDefined()
+
+    expect(person.name).toBeDefined()
+    expect(person.active).toBe(true)
+  })
+})

package/src/core/database/entity.decorator.ts

@@ -0,0 +1,39 @@
+import { EntityBase } from './entity.base'
+
+type EntityProps<T> = Omit<
+  {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K]
+  },
+  '_id' | '_action'
+>
+
+export function Entity<T extends new (...args: any[]) => EntityBase<any>>(
+  id?: keyof EntityProps<InstanceType<T>>,
+) {
+  return function (target: T) {
+    class NewConstructor extends target {
+      constructor(...args: any[]) {
+        super(...args) // Chama o construtor original
+
+        // Chama o método `automap` se ele existir
+        if (typeof this.automap === 'function') {
+          this.automap(args[0])
+        }
+      }
+    }
+
+    // Copia o protótipo e propriedades estáticas para o novo construtor
+    Object.setPrototypeOf(NewConstructor.prototype, target.prototype)
+    Object.setPrototypeOf(NewConstructor, target)
+
+    // Define o nome do novo construtor para corresponder ao nome da classe original
+    Object.defineProperty(NewConstructor, 'name', {
+      value: target.name,
+      writable: false,
+    })
+
+    Reflect.defineMetadata('entity:id', id, NewConstructor.prototype)
+
+    return NewConstructor
+  }
+}

package/src/core/database/prisma-client-with-custom-transaction.interface.ts

@@ -0,0 +1,13 @@
+import { Prisma } from 'prisma/generated/client'
+
+export interface PrismaClientWithCustomTransaction
+  extends Readonly<Prisma.TransactionClient> {
+  withTransaction<F>(
+    fn: (prisma: Prisma.TransactionClient) => Promise<F>,
+    options?: {
+      maxWait?: number | undefined
+      timeout?: number | undefined
+      isolationLevel?: Prisma.TransactionIsolationLevel | undefined
+    },
+  ): Promise<F>
+}

package/src/core/database/prisma-resolver.ts

@@ -0,0 +1,99 @@
+/**
+ * Resolver automático para o Prisma Client do projeto consumidor
+ * Tenta múltiplos caminhos para encontrar o cliente gerado
+ */
+import * as path from 'path'
+import * as fs from 'fs'
+
+let cachedPrismaClient: any = null
+
+function findPrismaClient(): string | null {
+  // Lista de caminhos possíveis onde o Prisma pode estar
+  const possiblePaths = [
+    path.join(process.cwd(), 'prisma/generated/client.js'),
+    path.join(__dirname, '../../../../../prisma/generated/client.js'),
+    path.join(process.cwd(), 'prisma/generated/client.ts'),
+    path.join(__dirname, '../../../../../prisma/generated/client.ts'),
+    ...(require.main?.filename
+      ? [
+          path.join(
+            path.dirname(require.main.filename),
+            '../prisma/generated/client.js',
+          ),
+          path.join(
+            path.dirname(require.main.filename),
+            '../prisma/generated/client.ts',
+          ),
+        ]
+      : []),
+  ]
+
+  for (const prismaPath of possiblePaths) {
+    if (fs.existsSync(prismaPath)) {
+      return prismaPath
+    }
+  }
+
+  return null
+}
+
+async function resolvePrismaClient() {
+  if (cachedPrismaClient) {
+    return cachedPrismaClient
+  }
+
+  const prismaPath = findPrismaClient()
+
+  if (!prismaPath) {
+    throw new Error(
+      `
+      Não foi possível carregar o Prisma Client automaticamente.
+      
+      Certifique-se de que você:
+      1. Executou 'bunx prisma generate' no seu projeto
+      2. Tem a pasta 'prisma/generated/client' no seu projeto
+      3. A lib @koalarx/nest está instalada como dependência
+      
+      Se o problema persistir, você pode registrar manualmente o Prisma Client:
+      
+      import { setPrismaClient } from '@koalarx/nest'
+      import { PrismaClient } from './prisma/generated/client'
+      
+      setPrismaClient(PrismaClient)
+      `.trim(),
+    )
+  }
+
+  try {
+    // Carrega dinamicamente o módulo
+    const module = await import(prismaPath)
+    // Extrai PrismaClient do módulo (pode ser default export ou named export)
+    cachedPrismaClient = module.PrismaClient || module.default || module
+    return cachedPrismaClient
+  } catch (error) {
+    throw new Error(
+      `
+      Erro ao carregar o Prisma Client de ${prismaPath}:
+      ${error instanceof Error ? error.message : String(error)}
+      
+      Certifique-se de que 'bunx prisma generate' foi executado com sucesso.
+      `.trim(),
+    )
+  }
+}
+
+// Variável global para registro manual
+let manualPrismaClient: any = null
+
+export function setPrismaClient(prismaClientClass: any) {
+  manualPrismaClient = prismaClientClass
+  cachedPrismaClient = null // Limpa cache
+}
+
+export function getPrismaClientClass() {
+  if (manualPrismaClient) {
+    return manualPrismaClient
+  }
+  // Retorna uma função que resolve o cliente quando necessário
+  return resolvePrismaClient()
+}

package/src/core/database/prisma-transactional-client.ts

@@ -0,0 +1,43 @@
+import { Prisma } from 'prisma/generated/client'
+
+export abstract class PrismaTransactionalClient {
+  [key: symbol]: any
+
+  constructor(
+    protected readonly transactionalClient: Prisma.TransactionClient,
+  ) {}
+
+  async withTransaction<F>(
+    fn: (prisma: Prisma.TransactionClient) => Promise<F>,
+  ): Promise<F> {
+    return await fn(this.transactionalClient)
+  }
+
+  $executeRaw(
+    query: TemplateStringsArray | Prisma.Sql,
+    ...values: any[]
+  ): Prisma.PrismaPromise<number> {
+    return this.transactionalClient.$executeRaw(query, ...values)
+  }
+
+  $executeRawUnsafe(
+    query: string,
+    ...values: any[]
+  ): Prisma.PrismaPromise<number> {
+    return this.transactionalClient.$executeRawUnsafe(query, ...values)
+  }
+
+  $queryRaw<T = unknown>(
+    query: TemplateStringsArray | Prisma.Sql,
+    ...values: any[]
+  ): Prisma.PrismaPromise<T> {
+    return this.transactionalClient.$queryRaw(query, ...values)
+  }
+
+  $queryRawUnsafe<T = unknown>(
+    query: string,
+    ...values: any[]
+  ): Prisma.PrismaPromise<T> {
+    return this.transactionalClient.$queryRawUnsafe(query, ...values)
+  }
+}

package/src/core/database/prisma.service.ts

@@ -0,0 +1,136 @@
+import { EnvService } from '@koalarx/nest/env/env.service'
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common'
+import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface'
+import { getPrismaClientClass } from './prisma-resolver'
+import type { Prisma } from 'prisma/generated/client'
+
+/**
+ * Configure opções padrão do PrismaClient (ex: adapter).
+ * Use isso na sua aplicação antes de inicializar o módulo Nest.
+ */
+let globalPrismaOptions = {} as Prisma.PrismaClientOptions
+
+export function setPrismaClientOptions(options: Prisma.PrismaClientOptions) {
+  globalPrismaOptions = options
+}
+
+// Wrapper para carregar o PrismaClient dinamicamente
+let PrismaClientClass: any = null
+
+async function loadPrismaClient() {
+  if (!PrismaClientClass) {
+    PrismaClientClass = await getPrismaClientClass()
+  }
+  return PrismaClientClass
+}
+
+@Injectable()
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+export class PrismaService
+  implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction
+{
+  private prismaInstance: any
+
+  constructor(private readonly env: EnvService) {
+    // Retorna um proxy para permitir acesso transparente às models
+    // Isso é necessário porque repository.base.ts tenta acessar this._context[modelName]
+    return new Proxy(this, {
+      get: (target, prop, receiver) => {
+        // Propriedades e métodos da instância têm prioridade
+        if (prop in target) {
+          const value = Reflect.get(target, prop, receiver)
+          if (typeof value === 'function') {
+            return value.bind(target)
+          }
+          return value
+        }
+
+        // Caso a propriedade não exista, tenta acessar no prismaInstance
+        // Isso permite acessar models (person, user, etc.) e métodos como $queryRaw
+        if (target.prismaInstance && typeof prop === 'string') {
+          const value = target.prismaInstance[prop]
+          if (typeof value === 'function') {
+            return value.bind(target.prismaInstance)
+          }
+          return value
+        }
+
+        return Reflect.get(target, prop, receiver)
+      },
+    }) as any
+  }
+
+  async initialize() {
+    const PrismaClientType = await loadPrismaClient()
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.prismaInstance = new PrismaClientType({
+      log: [{ emit: 'event', level: 'query' }],
+      ...globalPrismaOptions,
+    } as Prisma.PrismaClientOptions)
+  }
+
+  async onModuleInit() {
+    await this.initialize()
+    if (this.env.get('PRISMA_QUERY_LOG')) {
+      this.prismaInstance?.$on?.('query', async (e: any) => {
+        console.log(`${e.query} ${e.params}`)
+      })
+    }
+    return this.prismaInstance?.$connect?.()
+  }
+
+  onModuleDestroy() {
+    return this.prismaInstance?.$disconnect?.()
+  }
+
+  async withTransaction<F>(
+    fn: (prisma: Prisma.TransactionClient) => Promise<F>,
+    options?: {
+      maxWait?: number
+      timeout?: number
+      isolationLevel?: Prisma.TransactionIsolationLevel
+    },
+  ): Promise<F> {
+    return this.prismaInstance?.$transaction?.(
+      fn,
+      options ?? {
+        maxWait: 20000,
+        timeout: 20000,
+      },
+    )
+  }
+
+  // Expõe métodos e properties do PrismaClient dynamicamente
+  // Isso permite que o repositório acesse models (person, user, etc.) via Proxy
+  [Symbol.toPrimitive]() {
+    return this.prismaInstance
+  }
+
+  toString() {
+    return '[PrismaService]'
+  }
+
+  // Métodos úteis do PrismaClient
+  get $connect() {
+    return this.prismaInstance?.$connect?.bind(this.prismaInstance)
+  }
+
+  get $disconnect() {
+    return this.prismaInstance?.$disconnect?.bind(this.prismaInstance)
+  }
+
+  get $transaction() {
+    return this.prismaInstance?.$transaction?.bind(this.prismaInstance)
+  }
+
+  get $on() {
+    return this.prismaInstance?.$on?.bind(this.prismaInstance)
+  }
+
+  // Proxy transparente para acessar models e qualquer outro property do PrismaClient
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return this.prismaInstance
+  }
+}