@koalarx/nest-cli 3.0.2 → 3.0.4

package/templates/startup-project/src/application/person/create-person-job/create-person-job.ts

@@ -0,0 +1,58 @@
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import {
+  CronJobHandlerBase,
+  CronJobResponse,
+  CronJobSettings,
+} from '@koalarx/nest/core/backgroud-services/cron-service/cron-job.handler.base'
+import { EventQueue } from '@koalarx/nest/core/backgroud-services/event-service/event-queue'
+import { ok } from '@koalarx/nest/core/request-overflow/request-result'
+import { ILoggingService } from '@koalarx/nest/services/logging/ilogging.service'
+import { IRedLockService } from '@koalarx/nest/services/redlock/ired-lock.service'
+import { Injectable } from '@nestjs/common'
+import { CreatePersonHandler } from '../create/create-person.handler'
+import { InactivePersonEvent } from '../events/inactive-person/inactive-person-event'
+import { PersonEventJob } from '../events/person-event.job'
+
+@Injectable()
+export class CreatePersonJob extends CronJobHandlerBase {
+  constructor(
+    redlockService: IRedLockService,
+    loggingService: ILoggingService,
+    private readonly createPerson: CreatePersonHandler,
+    private readonly repository: IPersonRepository,
+  ) {
+    super(redlockService, loggingService)
+  }
+
+  protected async settings(): Promise<CronJobSettings> {
+    return {
+      isActive: true,
+      timeInMinutes: 1,
+    }
+  }
+
+  protected async run(): Promise<CronJobResponse> {
+    const result = await this.createPerson.handle({
+      name: 'John Doe',
+      phones: [{ phone: '22999999999' }],
+      address: { address: 'Street 1' },
+    })
+
+    if (result.isOk()) {
+      const person = await this.repository.read(result.value.id)
+
+      if (person) {
+        const jobs = new PersonEventJob()
+        jobs.addEvent(new InactivePersonEvent())
+
+        EventQueue.dispatchEventsForAggregate(jobs._id)
+      }
+
+      console.log('Person created with id:', result.value.id)
+    } else {
+      console.error('Error creating person:', result.value)
+    }
+
+    return ok(null)
+  }
+}

package/templates/startup-project/src/application/person/delete/delete-person.handler.spec.ts

@@ -0,0 +1,24 @@
+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 { DeletePersonHandler } from './delete-person.handler'
+
+describe('DeletePersonHandler', () => {
+  const app = createUnitTestApp()
+
+  it('should delete a person', async () => {
+    const createResult = await app
+      .get(CreatePersonHandler)
+      .handle(createPersonRequestMockup)
+
+    expect(createResult.isOk()).toBeTruthy()
+
+    if (createResult.isOk()) {
+      const result = await app
+        .get(DeletePersonHandler)
+        .handle(createResult.value.id)
+
+      expect(result.isOk()).toBeTruthy()
+    }
+  })
+})

package/templates/startup-project/src/application/person/delete/delete-person.handler.ts

@@ -0,0 +1,33 @@
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { ResourceNotFoundError } from '@koalarx/nest/core/errors/resource-not-found.error'
+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'
+
+@Injectable()
+export class DeletePersonHandler extends RequestHandlerBase<
+  number,
+  RequestResult<ResourceNotFoundError, null>
+> {
+  constructor(private readonly repository: IPersonRepository) {
+    super()
+  }
+
+  async handle(
+    id: number,
+  ): Promise<RequestResult<ResourceNotFoundError, null>> {
+    const person = await this.repository.read(id)
+
+    if (!person) {
+      return failure(new ResourceNotFoundError('Pessoa'))
+    }
+
+    await this.repository.delete(id)
+
+    return ok(null)
+  }
+}

package/templates/startup-project/src/application/person/delete-inative-job/delete-inactive-job.ts

@@ -0,0 +1,49 @@
+import { ReadManyPersonDto } from '@/domain/dtos/read-many-person.dto'
+import {
+  CronJobHandlerBase,
+  CronJobResponse,
+  CronJobSettings,
+} from '@koalarx/nest/core/backgroud-services/cron-service/cron-job.handler.base'
+import { ok } from '@koalarx/nest/core/request-overflow/request-result'
+import { ILoggingService } from '@koalarx/nest/services/logging/ilogging.service'
+import { IRedLockService } from '@koalarx/nest/services/redlock/ired-lock.service'
+import { Injectable } from '@nestjs/common'
+import { DeletePersonHandler } from '../delete/delete-person.handler'
+import { ReadManyPersonHandler } from '../read-many/read-many-person.handler'
+
+@Injectable()
+export class DeleteInactiveJob extends CronJobHandlerBase {
+  constructor(
+    redlockService: IRedLockService,
+    loggingService: ILoggingService,
+    private readonly readManyPerson: ReadManyPersonHandler,
+    private readonly deletePerson: DeletePersonHandler,
+  ) {
+    super(redlockService, loggingService)
+  }
+
+  protected async settings(): Promise<CronJobSettings> {
+    return {
+      isActive: true,
+      timeInMinutes: 1,
+    }
+  }
+
+  protected async run(): Promise<CronJobResponse> {
+    const result = await this.readManyPerson.handle(
+      new ReadManyPersonDto({ active: false }),
+    )
+
+    if (result.isOk()) {
+      for (const person of result.value.items) {
+        await this.deletePerson.handle(person.id)
+
+        console.log('Person with id was deleted:', person.id)
+      }
+    } else {
+      console.error('Error to search inactive people:', result.value)
+    }
+
+    return ok(null)
+  }
+}

package/templates/startup-project/src/application/person/events/inactive-person/inactive-person-event.ts

@@ -0,0 +1,3 @@
+import { EventClass } from '@koalarx/nest/core/backgroud-services/event-service/event-class'
+
+export class InactivePersonEvent extends EventClass {}

package/templates/startup-project/src/application/person/events/inactive-person/inactive-person-handler.ts

@@ -0,0 +1,27 @@
+import { ReadManyPersonDto } from '@/domain/dtos/read-many-person.dto'
+import { IPersonRepository } from '@/domain/repositories/iperson.repository'
+import { EventHandlerBase } from '@koalarx/nest/core/backgroud-services/event-service/event-handler.base'
+import { Injectable } from '@nestjs/common'
+import { InactivePersonEvent } from './inactive-person-event'
+
+@Injectable()
+export class InactivePersonHandler extends EventHandlerBase {
+  constructor(private readonly repository: IPersonRepository) {
+    super(InactivePersonEvent)
+  }
+
+  async handleEvent(): Promise<void> {
+    const result = await this.repository.readMany(
+      new ReadManyPersonDto({ active: true }),
+    )
+
+    for (const person of result.items) {
+      person.active = false
+      await this.repository.save(person)
+    }
+
+    console.log(
+      'InactivePersonHandler: Registros ativos inativados com sucesso!',
+    )
+  }
+}

package/templates/startup-project/src/application/person/events/person-event.job.ts

@@ -0,0 +1,11 @@
+import { Person } from '@/domain/entities/person/person'
+import { EventHandlerBase } from '@koalarx/nest/core/backgroud-services/event-service/event-handler.base'
+import { EventJob } from '@koalarx/nest/core/backgroud-services/event-service/event-job'
+import { Type } from '@nestjs/common'
+import { InactivePersonHandler } from './inactive-person/inactive-person-handler'
+
+export class PersonEventJob extends EventJob<Person> {
+  defineHandlers(): Type<EventHandlerBase>[] {
+    return [InactivePersonHandler]
+  }
+}

package/templates/startup-project/src/application/person/read/read-person.handler.spec.ts

@@ -0,0 +1,28 @@
+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-person.handler'
+
+describe('ReadPersonHandler', () => {
+  const app = createUnitTestApp()
+
+  it('should get a person by id', async () => {
+    const createResult = await app
+      .get(CreatePersonHandler)
+      .handle(createPersonRequestMockup)
+
+    expect(createResult.isOk()).toBeTruthy()
+
+    if (createResult.isOk()) {
+      const result = await app
+        .get(ReadPersonHandler)
+        .handle(createResult.value.id)
+
+      expect(result.isOk()).toBeTruthy()
+
+      if (result.isOk()) {
+        expect(result.value.id).toBe(createResult.value.id)
+      }
+    }
+  })
+})

package/templates/startup-project/src/application/person/read/read-person.handler.ts

@@ -0,0 +1,37 @@
+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 { ReadPersonResponse } from './read-person.response'
+
+@Injectable()
+export class ReadPersonHandler extends RequestHandlerBase<
+  number,
+  RequestResult<ResourceNotFoundError, ReadPersonResponse>
+> {
+  constructor(
+    private readonly mapper: AutoMappingService,
+    private readonly repository: IPersonRepository,
+  ) {
+    super()
+  }
+
+  async handle(
+    id: number,
+  ): Promise<RequestResult<ResourceNotFoundError, ReadPersonResponse>> {
+    const person = await this.repository.read(id)
+
+    if (!person) {
+      return failure(new ResourceNotFoundError('Pessoa'))
+    }
+
+    return ok(this.mapper.map(person, Person, ReadPersonResponse))
+  }
+}

package/templates/startup-project/src/application/person/read/read-person.response.ts

@@ -0,0 +1,44 @@
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { ApiProperty } from '@nestjs/swagger'
+
+export class ReadPersonAddressResponse {
+  @ApiProperty()
+  @AutoMap()
+  id: number
+
+  @ApiProperty({ example: 'Street 1' })
+  @AutoMap()
+  address: string
+}
+
+export class ReadPersonPhoneResponse {
+  @ApiProperty()
+  @AutoMap()
+  id: number
+
+  @ApiProperty({ example: '22999999999' })
+  @AutoMap()
+  phone: string
+}
+
+export class ReadPersonResponse {
+  @ApiProperty()
+  @AutoMap()
+  id: number
+
+  @ApiProperty({ example: 'John Doe' })
+  @AutoMap()
+  name: string
+
+  @ApiProperty({ type: [ReadPersonPhoneResponse] })
+  @AutoMap({ type: () => ReadPersonPhoneResponse, isArray: true })
+  phones: Array<ReadPersonPhoneResponse>
+
+  @ApiProperty({ type: ReadPersonAddressResponse })
+  @AutoMap({ type: () => ReadPersonAddressResponse })
+  address: ReadPersonAddressResponse
+
+  @ApiProperty()
+  @AutoMap()
+  active: boolean
+}

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

@@ -0,0 +1,67 @@
+import { createUnitTestApp } from '@/test/create-unit-test-app'
+import { createPersonRequestMockup } from '@/test/mockup/person/create-person-request.mockup'
+import { RequestResult } from '@koalarx/nest/core/request-overflow/request-result'
+import { CreatePersonHandler } from '../create/create-person.handler'
+import { CreatePersonResponse } from '../create/create-person.response'
+import { ReadManyPersonHandler } from './read-many-person.handler'
+import { ReadManyPersonRequest } from './read-many-person.request'
+
+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.isOk()).toBeTruthy()
+
+    if (result.isOk()) {
+      expect(result.value.items).toHaveLength(1)
+    }
+  })
+
+  it('should get persons by name', async () => {
+    const result = await app.get(ReadManyPersonHandler).handle(
+      new ReadManyPersonRequest({
+        name: person.name,
+      }),
+    )
+
+    expect(result.isOk()).toBeTruthy()
+
+    if (result.isOk()) {
+      expect(result.value.items[0].name).toBe(person.name)
+      expect(result.value.items).toHaveLength(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/templates/startup-project/src/application/person/read-many/read-many-person.handler.ts

@@ -0,0 +1,47 @@
+import { ReadManyPersonDto } from '@/domain/dtos/read-many-person.dto'
+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(
+      this.mapper.map(
+        new ReadManyPersonValidator(query).validate(),
+        ReadManyPersonRequest,
+        ReadManyPersonDto,
+      ),
+    )
+
+    return ok({
+      ...listOfPerson,
+      items: listOfPerson.items.map((person) =>
+        this.mapper.map(person, Person, ReadPersonResponse),
+      ),
+    })
+  }
+}

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

@@ -0,0 +1,21 @@
+import {
+  PaginatedRequestProps,
+  PaginationRequest,
+} from '@koalarx/nest/core/controllers/pagination.request'
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { ApiProperty } from '@nestjs/swagger'
+
+export class ReadManyPersonRequest extends PaginationRequest {
+  @ApiProperty({ required: false })
+  @AutoMap()
+  name?: string
+
+  @ApiProperty({ required: false })
+  @AutoMap()
+  active?: boolean
+
+  constructor(props?: PaginatedRequestProps<ReadManyPersonRequest>) {
+    super()
+    Object.assign(this, props)
+  }
+}

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

@@ -0,0 +1,16 @@
+import { ListResponse } from '@koalarx/nest/core'
+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/templates/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/templates/startup-project/src/application/person/update/update-person.handler.spec.ts

@@ -0,0 +1,47 @@
+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,
+          address: {
+            id: 1,
+            ...person.address,
+          },
+          active: true,
+        },
+      })
+
+      expect(updateResult.isOk()).toBeTruthy()
+
+      const result = await app
+        .get(ReadPersonHandler)
+        .handle(createResult.value.id)
+
+      expect(result.isOk()).toBeTruthy()
+
+      if (result.isOk()) {
+        expect(result.value.name).toEqual(person.name)
+        expect(result.value.active).toEqual(true)
+        expect(result.value.address.address).toEqual(person.address.address)
+        expect(result.value.phones[0].phone).toEqual(person.phones[0].phone)
+      }
+    }
+  })
+})

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

@@ -0,0 +1,57 @@
+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.address.address = person.address.address
+    personInBd.phones.update(person.phones.toArray())
+
+    await this.repository.save(personInBd)
+
+    return ok(null)
+  }
+}

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

@@ -0,0 +1,36 @@
+import { AutoMap } from '@koalarx/nest/core/mapping/auto-mapping.decorator'
+import { ApiProperty } from '@nestjs/swagger'
+import {
+  PersistPersonAddressRequest,
+  PersistPersonPhoneRequest,
+} from '../common/persist-person.request'
+
+export class UpdatePersonAddressRequest extends PersistPersonAddressRequest {
+  @ApiProperty()
+  @AutoMap()
+  id: number
+}
+
+export class UpdatePersonPhoneRequest extends PersistPersonPhoneRequest {
+  @ApiProperty({ required: false })
+  @AutoMap()
+  id?: number
+}
+
+export class UpdatePersonRequest {
+  @ApiProperty({ example: 'Mark Willians' })
+  @AutoMap()
+  name: string
+
+  @ApiProperty({ example: false })
+  @AutoMap()
+  active: boolean
+
+  @ApiProperty({ type: [UpdatePersonPhoneRequest] })
+  @AutoMap({ type: () => UpdatePersonPhoneRequest, isArray: true })
+  phones: Array<UpdatePersonPhoneRequest>
+
+  @ApiProperty({ type: UpdatePersonAddressRequest })
+  @AutoMap({ type: () => UpdatePersonAddressRequest })
+  address: UpdatePersonAddressRequest
+}

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

@@ -0,0 +1,21 @@
+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(),
+        }),
+      ),
+      address: z.object({
+        id: z.number(),
+        address: z.string(),
+      }),
+    })
+  }
+}

package/templates/startup-project/src/core/env.ts

@@ -0,0 +1,6 @@
+import { envSchema } from '@koalarx/nest/env/env'
+import { z } from 'zod'
+
+export const env = envSchema.merge(z.object({}))
+
+export type EnvType = z.infer<typeof env>