@koalarx/nest-cli 3.0.2 → 3.0.4

package/templates/startup-project/src/domain/dtos/read-many-person.dto.ts

@@ -0,0 +1,16 @@
+import { PaginatedRequestProps } from '@koalarx/nest/core/controllers/pagination.request'
+import { PaginationDto } from '@koalarx/nest/core/dtos/pagination.dto'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+
+export class ReadManyPersonDto extends PaginationDto {
+  @AutoMap()
+  name?: string
+
+  @AutoMap()
+  active?: boolean
+
+  constructor(props?: PaginatedRequestProps<ReadManyPersonDto>) {
+    super()
+    Object.assign(this, props)
+  }
+}

package/templates/startup-project/src/domain/entities/person/person-address.ts

@@ -0,0 +1,12 @@
+import { EntityBase } from '@koalarx/nest/core/database/entity.base'
+import { Entity } from '@koalarx/nest/core/database/entity.decorator'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+
+@Entity()
+export class PersonAddress extends EntityBase<PersonAddress> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  address: string
+}

package/templates/startup-project/src/domain/entities/person/person-phone.ts

@@ -0,0 +1,12 @@
+import { EntityBase } from '@koalarx/nest/core/database/entity.base'
+import { Entity } from '@koalarx/nest/core/database/entity.decorator'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+
+@Entity()
+export class PersonPhone extends EntityBase<PersonPhone> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  phone: string
+}

package/templates/startup-project/src/domain/entities/person/person.ts

@@ -0,0 +1,24 @@
+import { EntityBase } from '@koalarx/nest/core/database/entity.base'
+import { Entity } from '@koalarx/nest/core/database/entity.decorator'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { List } from '@koalarx/nest/core/utils/list'
+import { PersonAddress } from './person-address'
+import { PersonPhone } from './person-phone'
+
+@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
+}

package/templates/startup-project/src/domain/repositories/iperson.repository.ts

@@ -0,0 +1,10 @@
+import { ListResponseBase } from '@koalarx/nest/core/controllers/list-response.base'
+import { ReadManyPersonDto } from '../dtos/read-many-person.dto'
+import { Person } from '../entities/person/person'
+
+export abstract class IPersonRepository {
+  abstract save(person: Person): Promise<any>
+  abstract read(id: number): Promise<Person | null>
+  abstract readMany(query: ReadManyPersonDto): Promise<ListResponseBase<Person>>
+  abstract delete(id: number): Promise<void>
+}

package/templates/startup-project/src/host/app.module.ts

@@ -0,0 +1,19 @@
+import { CreatePersonJob } from '@/application/person/create-person-job/create-person-job'
+import { DeleteInactiveJob } from '@/application/person/delete-inative-job/delete-inactive-job'
+import { InactivePersonHandler } from '@/application/person/events/inactive-person/inactive-person-handler'
+import { env } from '@/core/env'
+import { KoalaNestModule } from '@koalarx/nest/core/koala-nest.module'
+import { Module } from '@nestjs/common'
+import { PersonModule } from './controllers/person/person.module'
+
+@Module({
+  imports: [
+    KoalaNestModule.register({
+      env,
+      controllers: [PersonModule],
+      cronJobs: [DeleteInactiveJob, CreatePersonJob],
+      eventJobs: [InactivePersonHandler],
+    }),
+  ],
+})
+export class AppModule {}

package/templates/startup-project/src/host/controllers/controller.module.ts

@@ -0,0 +1,16 @@
+import { MappingProfile } from '@/application/mapping/mapping.profile'
+import { InfraModule } from '@/infra/infra.module'
+import { KoalaNestHttpModule } from '@koalarx/nest/core/koala-nest-http.module'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [
+    KoalaNestHttpModule.register({
+      imports: [InfraModule],
+      automapperProfile: MappingProfile,
+      middlewares: [],
+    }),
+  ],
+  exports: [KoalaNestHttpModule],
+})
+export class ControllerModule {}

package/templates/startup-project/src/host/controllers/person/create-person.controller.ts

@@ -0,0 +1,30 @@
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler'
+import { CreatePersonRequest } from '@/application/person/create/create-person.request'
+import { CreatePersonResponse } from '@/application/person/create/create-person.response'
+import { IController } from '@koalarx/nest/core/controllers/base.controller'
+import { Controller } from '@koalarx/nest/core/controllers/controller.decorator'
+import { Body, HttpCode, HttpStatus, Post } from '@nestjs/common'
+import { ApiCreatedResponse } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@Controller(PERSON_ROUTER_CONFIG)
+export class CreatePersonController
+  implements IController<CreatePersonRequest, CreatePersonResponse>
+{
+  constructor(private readonly handler: CreatePersonHandler) {}
+
+  @Post()
+  @ApiCreatedResponse({ type: CreatePersonResponse })
+  @HttpCode(HttpStatus.CREATED)
+  async handle(
+    @Body() request: CreatePersonRequest,
+  ): Promise<CreatePersonResponse> {
+    const response = await this.handler.handle(request)
+
+    if (response.isFailure()) {
+      throw response.value
+    }
+
+    return response.value
+  }
+}

package/templates/startup-project/src/host/controllers/person/delete-person.controller.ts

@@ -0,0 +1,22 @@
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler'
+import { IController } from '@koalarx/nest/core/controllers/base.controller'
+import { Controller } from '@koalarx/nest/core/controllers/controller.decorator'
+import { Delete, HttpCode, HttpStatus, Param } from '@nestjs/common'
+import { ApiNoContentResponse } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@Controller(PERSON_ROUTER_CONFIG)
+export class DeletePersonController implements IController<null, void, string> {
+  constructor(private readonly handler: DeletePersonHandler) {}
+
+  @Delete(':id')
+  @ApiNoContentResponse()
+  @HttpCode(HttpStatus.NO_CONTENT)
+  async handle(_, @Param('id') id: string): Promise<void> {
+    const response = await this.handler.handle(+id)
+
+    if (response.isFailure()) {
+      throw response.value
+    }
+  }
+}

package/templates/startup-project/src/host/controllers/person/person.controller.e2e-spec.ts

@@ -0,0 +1,158 @@
+import { createE2ETestApp } from '@/test/create-e2e-test-app'
+import { INestApplication } from '@nestjs/common'
+import request from 'supertest'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+describe(`CRUD OF PERSON`, () => {
+  let app: INestApplication
+  let personId: number
+  let addressId: number
+
+  beforeAll(async () => {
+    app = await createE2ETestApp()
+  })
+
+  it('should create a person', async () => {
+    const response = await request(app.getHttpServer())
+      .post(PERSON_ROUTER_CONFIG.group)
+      .send({
+        name: 'John Doe',
+        phones: [],
+        address: {
+          address: 'Streat 1',
+        },
+      })
+
+    personId = response.body.id
+
+    expect(response.statusCode).toBe(201)
+    expect(response.body).toStrictEqual({
+      id: expect.any(Number),
+    })
+  })
+
+  it('should get the created person', async () => {
+    const response = await request(app.getHttpServer()).get(
+      `${PERSON_ROUTER_CONFIG.group}/${personId}`,
+    )
+
+    // Capturar o ID do endereço da resposta
+    addressId = response.body.address.id
+
+    expect(response.statusCode).toBe(200)
+    expect(response.body).toStrictEqual({
+      id: personId,
+      name: 'John Doe',
+      phones: [],
+      address: {
+        id: expect.any(Number),
+        address: 'Streat 1',
+      },
+      active: true,
+    })
+  })
+
+  it('should get all persons', async () => {
+    const response = await request(app.getHttpServer()).get(
+      PERSON_ROUTER_CONFIG.group,
+    )
+
+    expect(response.statusCode).toBe(200)
+    expect(response.body).toStrictEqual({
+      items: [
+        {
+          id: personId,
+          name: 'John Doe',
+          phones: [],
+          address: {
+            id: addressId,
+            address: 'Streat 1',
+          },
+          active: true,
+        },
+      ],
+      count: 1,
+    })
+  })
+
+  it('should get all inactive persons', async () => {
+    const response = await request(app.getHttpServer()).get(
+      `${PERSON_ROUTER_CONFIG.group}?active=false`,
+    )
+
+    expect(response.statusCode).toBe(200)
+    expect(response.body).toStrictEqual({
+      items: [],
+      count: 0,
+    })
+  })
+
+  it('should get persons by name', async () => {
+    const response = await request(app.getHttpServer()).get(
+      `${PERSON_ROUTER_CONFIG.group}?name=John`,
+    )
+
+    expect(response.statusCode).toBe(200)
+    expect(response.body).toStrictEqual({
+      items: [
+        {
+          id: personId,
+          name: 'John Doe',
+          phones: [],
+          address: {
+            id: addressId,
+            address: 'Streat 1',
+          },
+          active: true,
+        },
+      ],
+      count: 1,
+    })
+  })
+
+  it('should update the created person', async () => {
+    const updateResponse = await request(app.getHttpServer())
+      .put(`${PERSON_ROUTER_CONFIG.group}/${personId}`)
+      .send({
+        name: 'John Doe Updated',
+        phones: [],
+        address: {
+          id: addressId,
+          address: 'Streat 2',
+        },
+        active: true,
+      })
+
+    expect(updateResponse.statusCode).toBe(200)
+
+    const response = await request(app.getHttpServer()).get(
+      `${PERSON_ROUTER_CONFIG.group}/${personId}`,
+    )
+
+    expect(response.body).toStrictEqual({
+      id: personId,
+      name: 'John Doe Updated',
+      phones: [],
+      address: {
+        id: addressId,
+        address: 'Streat 2',
+      },
+      active: true,
+    })
+  })
+
+  it('should delete the created person', async () => {
+    const deleteResponse = await request(app.getHttpServer()).delete(
+      `${PERSON_ROUTER_CONFIG.group}/${personId}`,
+    )
+
+    expect(deleteResponse).toBeTruthy()
+    expect(deleteResponse.statusCode).toBe(204)
+
+    const response = await request(app.getHttpServer()).get(
+      `${PERSON_ROUTER_CONFIG.group}/${personId}`,
+    )
+
+    expect(response.statusCode).toBe(404)
+  })
+})

package/templates/startup-project/src/host/controllers/person/person.module.ts

@@ -0,0 +1,37 @@
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler'
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler'
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler'
+import { ReadPersonHandler } from '@/application/person/read/read-person.handler'
+import { UpdatePersonHandler } from '@/application/person/update/update-person.handler'
+import { Module } from '@nestjs/common'
+import { ControllerModule } from '../controller.module'
+import { CreatePersonController } from './create-person.controller'
+import { DeletePersonController } from './delete-person.controller'
+import { ReadManyPersonController } from './read-many-person.controller'
+import { ReadPersonController } from './read-person.controller'
+import { UpdatePersonController } from './update-person.controller'
+
+@Module({
+  imports: [ControllerModule],
+  controllers: [
+    CreatePersonController,
+    ReadPersonController,
+    ReadManyPersonController,
+    UpdatePersonController,
+    DeletePersonController,
+  ],
+  providers: [
+    CreatePersonHandler,
+    ReadPersonHandler,
+    ReadManyPersonHandler,
+    UpdatePersonHandler,
+    DeletePersonHandler,
+  ],
+  exports: [
+    ControllerModule,
+    CreatePersonHandler,
+    ReadManyPersonHandler,
+    DeletePersonHandler,
+  ],
+})
+export class PersonModule {}

package/templates/startup-project/src/host/controllers/person/read-many-person.controller.ts

@@ -0,0 +1,29 @@
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler'
+import { ReadManyPersonRequest } from '@/application/person/read-many/read-many-person.request'
+import { ReadManyPersonResponse } from '@/application/person/read-many/read-many-person.response'
+import { IController } from '@koalarx/nest/core/controllers/base.controller'
+import { Controller } from '@koalarx/nest/core/controllers/controller.decorator'
+import { Get, Query } from '@nestjs/common'
+import { ApiOkResponse } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@Controller(PERSON_ROUTER_CONFIG)
+export class ReadManyPersonController
+  implements IController<ReadManyPersonRequest, ReadManyPersonResponse>
+{
+  constructor(private readonly handler: ReadManyPersonHandler) {}
+
+  @Get()
+  @ApiOkResponse({ type: ReadManyPersonResponse })
+  async handle(
+    @Query() query: ReadManyPersonRequest,
+  ): Promise<ReadManyPersonResponse> {
+    const response = await this.handler.handle(query)
+
+    if (response.isFailure()) {
+      throw response.value
+    }
+
+    return response.value
+  }
+}

package/templates/startup-project/src/host/controllers/person/read-person.controller.ts

@@ -0,0 +1,26 @@
+import { ReadPersonHandler } from '@/application/person/read/read-person.handler'
+import { ReadPersonResponse } from '@/application/person/read/read-person.response'
+import { IController } from '@koalarx/nest/core/controllers/base.controller'
+import { Controller } from '@koalarx/nest/core/controllers/controller.decorator'
+import { Get, Param } from '@nestjs/common'
+import { ApiOkResponse } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@Controller(PERSON_ROUTER_CONFIG)
+export class ReadPersonController
+  implements IController<null, ReadPersonResponse, string>
+{
+  constructor(private readonly handler: ReadPersonHandler) {}
+
+  @Get(':id')
+  @ApiOkResponse({ type: ReadPersonResponse })
+  async handle(_, @Param('id') id: string): Promise<ReadPersonResponse> {
+    const response = await this.handler.handle(+id)
+
+    if (response.isFailure()) {
+      throw response.value
+    }
+
+    return response.value
+  }
+}

package/templates/startup-project/src/host/controllers/person/router.config.ts

@@ -0,0 +1,9 @@
+import { RouterConfigBase } from '@koalarx/nest/core/controllers/router-config.base'
+
+class PersonRouterConfig extends RouterConfigBase {
+  constructor() {
+    super('Person', '/person')
+  }
+}
+
+export const PERSON_ROUTER_CONFIG = new PersonRouterConfig()

package/templates/startup-project/src/host/controllers/person/update-person.controller.ts

@@ -0,0 +1,30 @@
+import { UpdatePersonHandler } from '@/application/person/update/update-person.handler'
+import { UpdatePersonRequest } from '@/application/person/update/update-person.request'
+import { IController } from '@koalarx/nest/core/controllers/base.controller'
+import { Controller } from '@koalarx/nest/core/controllers/controller.decorator'
+import { Body, Param, Put } from '@nestjs/common'
+import { ApiOkResponse } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@Controller(PERSON_ROUTER_CONFIG)
+export class UpdatePersonController
+  implements IController<UpdatePersonRequest, void>
+{
+  constructor(private readonly handler: UpdatePersonHandler) {}
+
+  @Put(':id')
+  @ApiOkResponse()
+  async handle(
+    @Body() request: UpdatePersonRequest,
+    @Param('id') id: string,
+  ): Promise<void> {
+    const response = await this.handler.handle({
+      id: +id,
+      data: request,
+    })
+
+    if (response.isFailure()) {
+      throw response.value
+    }
+  }
+}

package/templates/startup-project/src/host/main.ts

@@ -0,0 +1,38 @@
+import { CreatePersonJob } from '@/application/person/create-person-job/create-person-job'
+import { DeleteInactiveJob } from '@/application/person/delete-inative-job/delete-inactive-job'
+import { InactivePersonHandler } from '@/application/person/events/inactive-person/inactive-person-handler'
+import { DbTransactionContext } from '@/infra/database/db-transaction-context'
+import { setPrismaClientOptions } from '@koalarx/nest/core/database/prisma.service'
+import { KoalaApp } from '@koalarx/nest/core/koala-app'
+import { NestFactory } from '@nestjs/core'
+import { PrismaPg } from '@prisma/adapter-pg'
+import 'dotenv/config'
+import { Pool } from 'pg'
+import { AppModule } from './app.module'
+
+async function bootstrap() {
+  const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+  })
+  const adapter = new PrismaPg(pool)
+  setPrismaClientOptions({ adapter })
+
+  return NestFactory.create(AppModule).then((app) =>
+    new KoalaApp(app)
+      .useDoc({
+        ui: 'scalar',
+        endpoint: '/doc',
+        title: 'API de Demonstração',
+        version: '1.0',
+      })
+      .addCronJob(CreatePersonJob)
+      .addCronJob(DeleteInactiveJob)
+      .addEventJob(InactivePersonHandler)
+      .setAppName('example')
+      .setInternalUserName('integration.bot')
+      .setDbTransactionContext(DbTransactionContext)
+      .enableCors()
+      .buildAndServe(),
+  )
+}
+bootstrap()

package/templates/startup-project/src/infra/database/db-transaction-context.ts

@@ -0,0 +1,24 @@
+import { PrismaClientWithCustomTransaction } from '@koalarx/nest/core/database/prisma-client-with-custom-transaction.interface'
+import { PrismaTransactionalClient } from '@koalarx/nest/core/database/prisma-transactional-client'
+import { DefaultArgs } from '@prisma/client/runtime/client'
+import { Prisma } from 'prisma/generated/client'
+
+export class DbTransactionContext
+  extends PrismaTransactionalClient
+  implements PrismaClientWithCustomTransaction
+{
+  get person(): Prisma.PersonDelegate<DefaultArgs> {
+    return this.transactionalClient.person
+  }
+
+  get personPhone(): Prisma.PersonPhoneDelegate<DefaultArgs> {
+    return this.transactionalClient.personPhone
+  }
+
+  get personAddress(): Prisma.PersonAddressDelegate<
+    DefaultArgs,
+    Prisma.PrismaClientOptions
+  > {
+    return this.transactionalClient.personAddress
+  }
+}

package/templates/startup-project/src/infra/database/repositories/person.repository.ts

@@ -0,0 +1,54 @@
+import { ReadManyPersonDto } from '@/domain/dtos/read-many-person.dto'
+import { Person } from '@/domain/entities/person/person'
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { CreatedRegistreWithIdResponse } from '@koalarx/nest/core/controllers/created-registre-response.base'
+import { ListResponseBase } from '@koalarx/nest/core/controllers/list-response.base'
+import { RepositoryBase } from '@koalarx/nest/core/database/repository.base'
+import { PRISMA_TOKEN } from '@koalarx/nest/core/koala-nest-database.module'
+import { Inject, Injectable } from '@nestjs/common'
+import { Prisma } from 'prisma/generated/client'
+import { DbTransactionContext } from '../db-transaction-context'
+
+@Injectable()
+export class PersonRepository
+  extends RepositoryBase<Person>
+  implements IPersonRepository
+{
+  constructor(
+    @Inject(PRISMA_TOKEN)
+    prisma: DbTransactionContext,
+  ) {
+    super({
+      modelName: Person,
+      context: prisma,
+      include: {
+        phones: true,
+        address: true,
+      },
+    })
+  }
+
+  async save(person: Person): Promise<CreatedRegistreWithIdResponse | null> {
+    return this.saveChanges(person)
+  }
+
+  read(id: number): Promise<Person | null> {
+    return this.findById(id)
+  }
+
+  readMany(query: ReadManyPersonDto): Promise<ListResponseBase<Person>> {
+    return this.findManyAndCount<Prisma.PersonWhereInput>(
+      {
+        name: {
+          contains: query.name,
+        },
+        active: query.active,
+      },
+      query,
+    )
+  }
+
+  delete(id: number): Promise<void> {
+    return this.remove<Prisma.PersonWhereUniqueInput>({ id })
+  }
+}

package/templates/startup-project/src/infra/database/repositories/repositories.module.ts

@@ -0,0 +1,15 @@
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { KoalaNestDatabaseModule } from '@koalarx/nest/core/koala-nest-database.module'
+import { Module } from '@nestjs/common'
+import { PersonRepository } from './person.repository'
+
+@Module({
+  imports: [
+    KoalaNestDatabaseModule.register({
+      repositories: [{ interface: IPersonRepository, class: PersonRepository }],
+      services: [],
+    }),
+  ],
+  exports: [KoalaNestDatabaseModule],
+})
+export class RepositoriesModule {}

package/templates/startup-project/src/infra/infra.module.ts

@@ -0,0 +1,8 @@
+import { RepositoriesModule } from '@/infra/database/repositories/repositories.module'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [RepositoriesModule],
+  exports: [RepositoriesModule],
+})
+export class InfraModule {}

package/templates/startup-project/src/test/create-e2e-test-app.ts

@@ -0,0 +1,27 @@
+import { AppModule } from '@/host/app.module'
+import { DbTransactionContext } from '@/infra/database/db-transaction-context'
+import { setPrismaClientOptions } from '@koalarx/nest/core/database/prisma.service'
+import { KoalaAppTest } from '@koalarx/nest/test/koala-app-test'
+import { Test } from '@nestjs/testing'
+import { PrismaPg } from '@prisma/adapter-pg'
+import 'dotenv/config'
+import { Pool } from 'pg'
+
+export async function createE2ETestApp() {
+  const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+  })
+  const adapter = new PrismaPg(pool)
+  setPrismaClientOptions({ adapter })
+
+  return Test.createTestingModule({ imports: [AppModule] })
+    .compile()
+    .then((moduleRef) => moduleRef.createNestApplication())
+    .then((app) =>
+      new KoalaAppTest(app)
+        .setDbTransactionContext(DbTransactionContext)
+        .enableCors()
+        .build(),
+    )
+    .then((app) => app.init())
+}

package/templates/startup-project/src/test/create-unit-test-app.ts

@@ -0,0 +1,24 @@
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler'
+import { MappingProfile } from '@/application/mapping/mapping.profile'
+import { AutoMappingService } from '@koalarx/nest/core/mapping/auto-mapping.service'
+import { KoalaAppTestDependencies } from '@koalarx/nest/test/koala-app-test-dependencies'
+import { PersonRepository } from './repositories/person.repository'
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler'
+import { ReadPersonHandler } from '@/application/person/read/read-person.handler'
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler'
+import { UpdatePersonHandler } from '@/application/person/update/update-person.handler'
+
+export function createUnitTestApp() {
+  const automapService = new AutoMappingService(new MappingProfile())
+  const personRepository = new PersonRepository()
+
+  return new KoalaAppTestDependencies({
+    dependencies: [
+      new CreatePersonHandler(automapService, personRepository),
+      new ReadPersonHandler(automapService, personRepository),
+      new ReadManyPersonHandler(automapService, personRepository),
+      new UpdatePersonHandler(automapService, personRepository),
+      new DeletePersonHandler(personRepository),
+    ],
+  })
+}