@koalarx/nest-cli 1.0.1

package/code-base/startup-project/src/application/person/read-many/read-many-person.handler.spec.ts

@@ -0,0 +1,72 @@
+import { createUnitTestApp } from "@/test/create-unit-test-app"
+import { createPersonRequestMockup } from "@/test/mockup/person/create-person-request.mockup"
+import { CreatePersonHandler } from "../create/create-person.handler"
+import { ReadManyPersonHandler } from "./read-many-person.handler"
+import { ReadManyPersonRequest } from "./read-many-person.request"
+import { RequestResult } from "@koalarx/nest/core/request-overflow/request-result"
+import { CreatePersonResponse } from "../create/create-person.response"
+
+describe('ReadManyPersonHandler', () => {
+  const app = createUnitTestApp()
+  const person = createPersonRequestMockup
+
+  let personId: number
+  let createResult: RequestResult<Error, CreatePersonResponse>
+
+  beforeAll(async () => {    
+    createResult = await app
+      .get(CreatePersonHandler)
+      .handle(createPersonRequestMockup)
+    
+    expect(createResult.isOk()).toBeTruthy()
+
+    if (createResult.isOk()) {
+      personId = createResult.value.id
+    }
+  })
+
+  it('should get all persons', async () => {
+    const result = await app
+      .get(ReadManyPersonHandler)
+      .handle(new ReadManyPersonRequest())
+
+    expect(result.value).toEqual({
+      items: [{
+        ...person,
+        id: personId,
+        status: 'inactive'
+      }],
+      count: 1
+    })
+  })
+
+  it('should get persons by name', async () => {
+    const result = await app
+      .get(ReadManyPersonHandler)
+      .handle(new ReadManyPersonRequest({
+        name: person.name
+      }))
+
+    expect(result.value).toEqual({
+      items: [{
+        ...person,
+        id: personId,
+        status: 'inactive'
+      }],
+      count: 1
+    })
+  })  
+
+  it('should get persons by status', async () => {
+    const result = await app
+      .get(ReadManyPersonHandler)
+      .handle(new ReadManyPersonRequest({
+        active: true
+      }))
+
+    expect(result.value).toEqual({
+      items: [],
+      count: 0
+    })
+  })
+})

package/code-base/startup-project/src/application/person/read-many/read-many-person.handler.ts

@@ -0,0 +1,42 @@
+import { Person } from '@/domain/entities/person/person'
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { ResourceNotFoundError } from '@koalarx/nest/core/errors/resource-not-found.error'
+import { AutoMappingService } from '@koalarx/nest/core/mapping/auto-mapping.service'
+import { RequestHandlerBase } from '@koalarx/nest/core/request-overflow/request-handler.base'
+import {
+  ok,
+  RequestResult,
+} from '@koalarx/nest/core/request-overflow/request-result'
+import { Injectable } from '@nestjs/common'
+import { ReadPersonResponse } from '../read/read-person.response'
+import { ReadManyPersonRequest } from './read-many-person.request'
+import { ReadManyPersonResponse } from './read-many-person.response'
+import { ReadManyPersonValidator } from './read-many.validator'
+
+@Injectable()
+export class ReadManyPersonHandler extends RequestHandlerBase<
+  ReadManyPersonRequest,
+  RequestResult<ResourceNotFoundError, ReadManyPersonResponse>
+> {
+  constructor(
+    private readonly mapper: AutoMappingService,
+    private readonly repository: IPersonRepository,
+  ) {
+    super()
+  }
+
+  async handle(
+    query: ReadManyPersonRequest,
+  ): Promise<RequestResult<ResourceNotFoundError, ReadManyPersonResponse>> {
+    const listOfPerson = await this.repository.readMany(
+      new ReadManyPersonValidator(query).validate(),
+    )
+
+    return ok({
+      ...listOfPerson,
+      items: listOfPerson.items.map((person) =>
+        this.mapper.map(person, Person, ReadPersonResponse),
+      )
+    })
+  }
+}

package/code-base/startup-project/src/application/person/read-many/read-many-person.request.ts

@@ -0,0 +1,15 @@
+import { PaginatedRequestProps, PaginationParams } from '@koalarx/nest/core/models/pagination-params'
+import { ApiProperty } from '@nestjs/swagger'
+
+export class ReadManyPersonRequest extends PaginationParams {
+  @ApiProperty({ required: false })
+  name?: string
+
+  @ApiProperty({ required: false })
+  active?: boolean
+
+  constructor(props?: PaginatedRequestProps<ReadManyPersonRequest>) {
+    super()
+    Object.assign(this, props)
+  }
+}

package/code-base/startup-project/src/application/person/read-many/read-many-person.response.ts

@@ -0,0 +1,16 @@
+import { ListResponse } from '@koalarx/nest/core/@types'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { ApiProperty } from '@nestjs/swagger'
+import { ReadPersonResponse } from '../read/read-person.response'
+
+export class ReadManyPersonResponse
+  implements ListResponse<ReadPersonResponse>
+{
+  @ApiProperty({ type: [ReadPersonResponse] })
+  @AutoMap()
+  items: ReadPersonResponse[]
+
+  @ApiProperty()
+  @AutoMap()
+  count: number
+}

package/code-base/startup-project/src/application/person/read-many/read-many.validator.ts

@@ -0,0 +1,16 @@
+import { booleanSchema } from '@koalarx/nest/core/controllers/schemas/boolean.schema'
+import { LIST_QUERY_SCHEMA } from '@koalarx/nest/core/controllers/schemas/list-query.schema'
+import { RequestValidatorBase } from '@koalarx/nest/core/request-overflow/request-validator.base'
+import { z, ZodType, ZodTypeDef } from 'zod'
+import { ReadManyPersonRequest } from './read-many-person.request'
+
+export class ReadManyPersonValidator extends RequestValidatorBase<ReadManyPersonRequest> {
+  protected get schema(): ZodType<any, ZodTypeDef, any> {
+    return LIST_QUERY_SCHEMA.merge(
+      z.object({
+        name: z.string().optional().nullable(),
+        active: booleanSchema().optional().nullable(),
+      }),
+    )
+  }
+}

package/code-base/startup-project/src/application/person/update/update-person.handler.spec.ts

@@ -0,0 +1,42 @@
+import { createUnitTestApp } from "@/test/create-unit-test-app"
+import { createPersonRequestMockup } from "@/test/mockup/person/create-person-request.mockup"
+import { CreatePersonHandler } from "../create/create-person.handler"
+import { ReadPersonHandler } from "../read/read-person.handler"
+import { UpdatePersonHandler } from "./update-person.handler"
+
+describe('UpdatePersonHandler', () => {
+  const app = createUnitTestApp()
+
+  it('should update a person by id', async () => {
+    const person = createPersonRequestMockup
+    const createResult = await app
+      .get(CreatePersonHandler)
+      .handle(createPersonRequestMockup)
+    
+    expect(createResult.isOk()).toBeTruthy()
+
+    if (createResult.isOk()) {
+      const updateResult = await app
+        .get(UpdatePersonHandler)
+        .handle({
+          id: createResult.value.id,
+          data: {
+            ...person,
+            active: true
+          }
+        })
+      
+      expect(updateResult.isOk()).toBeTruthy()
+
+      const result = await app
+        .get(ReadPersonHandler)
+        .handle(createResult.value.id)
+
+      expect(result.value).toEqual({
+        ...person,
+        id: createResult.value.id,
+        status: 'active'
+      })
+    }
+  })
+})

package/code-base/startup-project/src/application/person/update/update-person.handler.ts

@@ -0,0 +1,56 @@
+import { Person } from '@/domain/entities/person/person'
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { ResourceNotFoundError } from '@koalarx/nest/core/errors/resource-not-found.error'
+import { AutoMappingService } from '@koalarx/nest/core/mapping/auto-mapping.service'
+import { RequestHandlerBase } from '@koalarx/nest/core/request-overflow/request-handler.base'
+import {
+  failure,
+  ok,
+  RequestResult,
+} from '@koalarx/nest/core/request-overflow/request-result'
+import { Injectable } from '@nestjs/common'
+import { UpdatePersonRequest } from './update-person.request'
+import { UpdatePersonValidator } from './update-person.validator'
+
+type UpdatePersonHandleRequest = {
+  id: number
+  data: UpdatePersonRequest
+}
+
+@Injectable()
+export class UpdatePersonHandler extends RequestHandlerBase<
+  UpdatePersonHandleRequest,
+  RequestResult<ResourceNotFoundError, null>
+> {
+  constructor(
+    private readonly mapper: AutoMappingService,
+    private readonly repository: IPersonRepository,
+  ) {
+    super()
+  }
+
+  async handle({
+    id,
+    data,
+  }: UpdatePersonHandleRequest): Promise<RequestResult<Error, null>> {
+    const personInBd = await this.repository.read(id)
+
+    if (!personInBd) {
+      return failure(new ResourceNotFoundError('Person'))
+    }
+
+    const person = this.mapper.map(
+      new UpdatePersonValidator(data).validate(),
+      UpdatePersonRequest,
+      Person,
+    )
+
+    personInBd.name = person.name
+    personInBd.active = person.active
+    personInBd.phones.update(person.phones.toArray())
+
+    await this.repository.save(personInBd)
+
+    return ok(null)
+  }
+}

package/code-base/startup-project/src/application/person/update/update-person.request.ts

@@ -0,0 +1,26 @@
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { ApiProperty } from '@nestjs/swagger'
+
+export class UpdatePersonPhoneRequest {
+  @ApiProperty({required: false})
+  @AutoMap()
+  id?: number
+
+  @ApiProperty()
+  @AutoMap()
+  phone: string
+}
+
+export class UpdatePersonRequest {
+  @ApiProperty()
+  @AutoMap()
+  name: string
+
+  @ApiProperty()
+  @AutoMap()
+  active: boolean
+
+  @ApiProperty({ type: [UpdatePersonPhoneRequest] })
+  @AutoMap({ type: UpdatePersonPhoneRequest, isArray: true })
+  phones: Array<UpdatePersonPhoneRequest>
+}

package/code-base/startup-project/src/application/person/update/update-person.validator.ts

@@ -0,0 +1,17 @@
+import { RequestValidatorBase } from '@koalarx/nest/core/request-overflow/request-validator.base'
+import { z, ZodType, ZodTypeDef } from 'zod'
+import { UpdatePersonRequest } from './update-person.request'
+
+export class UpdatePersonValidator extends RequestValidatorBase<UpdatePersonRequest> {
+  protected get schema(): ZodType<any, ZodTypeDef, any> {
+    return z.object({
+      name: z.string(),
+      phones: z.array(
+        z.object({
+          id: z.number().nullable().optional(),
+          phone: z.string(),
+        }),
+      ),
+    })
+  }
+}

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

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

package/code-base/startup-project/src/domain/entities/person/person.ts

@@ -0,0 +1,18 @@
+import { EntityBase } from '@koalarx/nest/core/database/entity.base'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { List } from '@koalarx/nest/core/utils/list'
+import { PersonPhone } from './person-phone'
+
+export class Person extends EntityBase<Person> {
+  @AutoMap()
+  id: number
+
+  @AutoMap()
+  name: string
+
+  @AutoMap({ type: List })
+  phones = new List(PersonPhone)
+
+  @AutoMap()
+  active: boolean
+}

package/code-base/startup-project/src/domain/mapping/mapping.profile.ts

@@ -0,0 +1,10 @@
+import { AutoMappingProfile } from '@koalarx/nest/core/mapping/auto-mapping-profile'
+import { Injectable } from '@nestjs/common'
+import { PersonMapping } from './person.mapping'
+
+@Injectable()
+export class MappingProfile implements AutoMappingProfile {
+  profile(): void {
+    PersonMapping.createMap()
+  }
+}

package/code-base/startup-project/src/domain/mapping/person.mapping.ts

@@ -0,0 +1,24 @@
+import { CreatePersonPhoneRequest, CreatePersonRequest } from '@/application/person/create/create-person.request'
+import { ReadPersonPhoneResponse, ReadPersonResponse } from '@/application/person/read/read-person.response'
+import { UpdatePersonPhoneRequest, UpdatePersonRequest } from '@/application/person/update/update-person.request'
+import { createMap } from '@koalarx/nest/core/mapping/create-map'
+import { forMember } from '@koalarx/nest/core/mapping/for-member'
+import { Person } from '../entities/person/person'
+import { PersonPhone } from '../entities/person/person-phone'
+
+export class PersonMapping {
+  static createMap() {
+    createMap(CreatePersonPhoneRequest, PersonPhone)
+    createMap(CreatePersonRequest, Person)
+
+    createMap(PersonPhone, ReadPersonPhoneResponse)
+    createMap(
+      Person,
+      ReadPersonResponse,
+      forMember('status', (s) => (s.active === true ? 'active' : 'inactive')),
+    )
+
+    createMap(UpdatePersonPhoneRequest, PersonPhone)
+    createMap(UpdatePersonRequest, Person)
+  }
+}

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

@@ -0,0 +1,14 @@
+import { CreatedRegistreResponseBase } from '@koalarx/nest/core/controllers/created-registre-response.base'
+import { ListResponseBase } from '@koalarx/nest/core/controllers/list-response.base'
+import { Person } from '../entities/person/person'
+import { ReadManyPersonRequest } from '@/application/person/read-many/read-many-person.request'
+
+export abstract class IPersonRepository {
+  abstract save(person: Person): Promise<CreatedRegistreResponseBase<number>>
+  abstract read(id: number): Promise<Person | null>
+  abstract readMany(
+    query: ReadManyPersonRequest,
+  ): Promise<ListResponseBase<Person>>
+
+  abstract delete(id: number): Promise<void>
+}

package/code-base/startup-project/src/infra/app.module.ts

@@ -0,0 +1,27 @@
+import { CreatePersonJob } from '@/application/person/create-person-job/create-person-job'
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler'
+import { DeleteInactiveJob } from '@/application/person/delete-inative-job/delete-inactive-job'
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler'
+import { InactivePersonHandler } from '@/application/person/events/inactive-person/inactive-person-handler'
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler'
+import { KoalaNestModule } from '@koalarx/nest/core/koala-nest.module'
+import { Module } from '@nestjs/common'
+import { ControllersModule } from './controllers/controllers.module'
+import { RepositoriesModule } from './database/repositories/repositories.module'
+
+@Module({
+  imports: [
+    KoalaNestModule.register(), 
+    RepositoriesModule, 
+    ControllersModule
+  ],
+  providers: [
+    CreatePersonHandler,
+    ReadManyPersonHandler,
+    DeletePersonHandler,
+    DeleteInactiveJob,
+    CreatePersonJob,
+    InactivePersonHandler,
+  ],
+})
+export class AppModule {}

package/code-base/startup-project/src/infra/controllers/controller.module.ts

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

package/code-base/startup-project/src/infra/controllers/controllers.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common'
+import { ControllerModule } from './controller.module'
+import { PersonModule } from './person/person.module'
+
+@Module({
+  imports: [
+    ControllerModule,
+    PersonModule,
+  ],
+  exports: [ControllerModule],
+})
+export class ControllersModule {}

package/code-base/startup-project/src/infra/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 { Body, Controller, HttpCode, HttpStatus, Post } from '@nestjs/common'
+import { ApiCreatedResponse, ApiTags } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@ApiTags(PERSON_ROUTER_CONFIG.tag)
+@Controller(PERSON_ROUTER_CONFIG.group)
+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/code-base/startup-project/src/infra/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, Delete, HttpCode, HttpStatus, Param } from '@nestjs/common'
+import { ApiNoContentResponse, ApiTags } from '@nestjs/swagger'
+import { PERSON_ROUTER_CONFIG } from './router.config'
+
+@ApiTags(PERSON_ROUTER_CONFIG.tag)
+@Controller(PERSON_ROUTER_CONFIG.group)
+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/code-base/startup-project/src/infra/controllers/person/person.controller.e2e-spec.ts

@@ -0,0 +1,120 @@
+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
+
+  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: []
+      })
+    
+    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}`)
+    
+    expect(response.statusCode).toBe(200)
+    expect(response.body).toStrictEqual({
+      id: personId,
+      name: 'John Doe',
+      phones: [],
+      status: 'active'
+    })
+  })
+
+  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: [],
+        status: 'active'
+      }],
+      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: [],
+        status: 'active'
+      }],
+      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: [],
+        status: 'active'
+      })
+    
+    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: [],
+      status: 'active'
+    })
+  })
+
+  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/code-base/startup-project/src/infra/controllers/person/person.module.ts

@@ -0,0 +1,31 @@
+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,
+  ],
+})
+export class PersonModule {}