@koalarx/nest 3.1.50 → 4.0.1

package/koala-nest/src/infra/database/data-source-factory.ts

@@ -0,0 +1,23 @@
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import { PersonContact } from '@/domain/entities/person/person-contact';
+import { User } from '@/domain/entities/user/user';
+import { DataSource } from 'typeorm';
+import { EnvService } from '@/infra/common/env.service';
+
+export const DATA_SOURCE_PROVIDER_TOKEN = 'DATA_SOURCE';
+
+export async function dataSourceFactory(env: EnvService) {
+  const dataSource = new DataSource({
+    type: 'postgres',
+    url: env.get('DATABASE_URL'),
+    entities: [Person, PersonAddress, PersonContact, User],
+    invalidWhereValuesBehavior: {
+      undefined: 'ignore',
+    },
+  });
+
+  await dataSource.initialize();
+
+  return dataSource;
+}

package/koala-nest/src/infra/database/database.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { EnvService } from '@/infra/common/env.service';
+import {
+  DATA_SOURCE_PROVIDER_TOKEN,
+  dataSourceFactory,
+} from '@/infra/database/data-source-factory';
+
+@Module({
+  providers: [
+    EnvService,
+    {
+      provide: DATA_SOURCE_PROVIDER_TOKEN,
+      useFactory: dataSourceFactory,
+      inject: [EnvService],
+    },
+  ],
+  exports: [EnvService, DATA_SOURCE_PROVIDER_TOKEN],
+})
+export class DatabaseModule {}

package/koala-nest/src/infra/database/migrations/1781281330533-Init.ts

@@ -0,0 +1,67 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class Init1781281330533 implements MigrationInterface {
+  name = 'Init1781281330533';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "person_address" ("id" SERIAL NOT NULL, "address" character varying NOT NULL, CONSTRAINT "PK_cd587348ca3fec07931de208299" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "person" ("id" SERIAL NOT NULL, "name" character varying NOT NULL, "active" boolean NOT NULL DEFAULT true, "addressId" integer, CONSTRAINT "PK_5fdaf670315c4b7e70cce85daa3" PRIMARY KEY ("id"), CONSTRAINT "UQ_a793ed25458ce9bc1584889cb13" UNIQUE ("addressId"))`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "person_contact" ("id" SERIAL NOT NULL, "contact" character varying NOT NULL, "personId" integer, CONSTRAINT "PK_1094fd036d694f9949ef1c19e39" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "person_contact" ADD CONSTRAINT "FK_df8723423f0c007013d5b8574d3" FOREIGN KEY ("personId") REFERENCES "person"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "person" ADD CONSTRAINT "FK_a793ed25458ce9bc1584889cb13" FOREIGN KEY ("addressId") REFERENCES "person_address"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+
+    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
+
+    await queryRunner.query(`
+      CREATE TABLE "users" (
+        "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+        "name" character varying NOT NULL,
+        "email" character varying NOT NULL,
+        "login" character varying NOT NULL,
+        "password" character varying NOT NULL,
+        "profile" character varying NOT NULL,
+        "status" character varying NOT NULL DEFAULT 'active',
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "UQ_users_email" UNIQUE ("email"),
+        CONSTRAINT "UQ_users_login" UNIQUE ("login"),
+        CONSTRAINT "PK_users_id" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO "users" ("name", "email", "login", "password", "profile", "status")
+      VALUES (
+        'Admin Demo',
+        'admin@example.com',
+        'admin.demo',
+        '$2b$06$eyA412UuUAPsAOBREzXPue1AJW.GLAwjenHRSBVCc1.gB1AcASWo6',
+        'admin',
+        'active'
+      )
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "users"`);
+    await queryRunner.query(
+      `ALTER TABLE "person" DROP CONSTRAINT "FK_a793ed25458ce9bc1584889cb13"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "person_contact" DROP CONSTRAINT "FK_df8723423f0c007013d5b8574d3"`,
+    );
+    await queryRunner.query(`DROP TABLE "person_contact"`);
+    await queryRunner.query(`DROP TABLE "person"`);
+    await queryRunner.query(`DROP TABLE "person_address"`);
+  }
+}

package/koala-nest/src/infra/database/migrations/generate-migration.ts

@@ -0,0 +1,26 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+
+const isAutoName = !process.argv[2];
+const timestamp = String(Date.now());
+const name = process.argv[2] ?? `Migration-${timestamp}`;
+
+const migrationPath = path.join('src/infra/database/migrations', name);
+const command = [
+  './node_modules/typeorm/cli.js',
+  'migration:generate',
+  migrationPath,
+  '-d',
+  './src/infra/database/migrations/migration-datasource.ts',
+];
+
+if (isAutoName) {
+  command.push('-t', timestamp);
+}
+
+const result = spawnSync(process.execPath, command, {
+  stdio: 'inherit',
+  cwd: process.cwd(),
+});
+
+process.exit(result.status ?? 1);

package/koala-nest/src/infra/database/migrations/migration-datasource.ts

@@ -0,0 +1,14 @@
+import 'dotenv/config';
+import path from 'node:path';
+import { DataSource } from 'typeorm';
+
+const root = process.cwd();
+
+export default new DataSource({
+  type: 'postgres',
+  url: process.env.DATABASE_URL,
+  entities: [path.join(root, 'src/domain/entities/**/*.{js,ts}')],
+  migrations: [path.join(root, 'src/infra/database/migrations/[0-9]*.{js,ts}')],
+  migrationsTableName: 'migrations',
+  migrationsTransactionMode: 'all',
+});

package/koala-nest/src/infra/infra.module.ts

@@ -0,0 +1,29 @@
+import { ICacheService } from '@/domain/common/icache.service';
+import { ILoggingService } from '@/domain/common/ilogging.service';
+import { IRedLockService } from '@/domain/common/ired-lock.service';
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';
+import { Module } from '@nestjs/common';
+import { CacheServiceProvider } from '@/infra/common/cache-service.provider';
+import { LoggingService } from '@/infra/common/logging.service';
+import { RedLockService } from '@/infra/common/red-lock.service';
+import { LoggedUserInfoService } from '@/infra/services/logged-user-info.service';
+import { RepositoryModule } from '@/infra/repositories/repository.module';
+
+@Module({
+  imports: [RepositoryModule],
+  providers: [
+    CacheServiceProvider,
+    { provide: ICacheService, useExisting: CacheServiceProvider },
+    { provide: ILoggingService, useClass: LoggingService },
+    { provide: IRedLockService, useClass: RedLockService },
+    { provide: ILoggedUserInfoService, useClass: LoggedUserInfoService },
+  ],
+  exports: [
+    RepositoryModule,
+    ICacheService,
+    ILoggingService,
+    IRedLockService,
+    ILoggedUserInfoService,
+  ],
+})
+export class InfraModule {}

package/koala-nest/src/infra/repositories/person.repository.ts

@@ -0,0 +1,49 @@
+import { RepositoryBase } from '@/infra/repositories/repository.base';
+import { Person } from '@/domain/entities/person/person';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Inject, Injectable } from '@nestjs/common';
+import { DATA_SOURCE_PROVIDER_TOKEN } from '@/infra/database/data-source-factory';
+import { DataSource, FindOptionsWhere, Like } from 'typeorm';
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { ListResponse } from '@/core/types';
+
+@Injectable()
+export class PersonRepository
+  extends RepositoryBase<Person>
+  implements IPersonRepository
+{
+  constructor(@Inject(DATA_SOURCE_PROVIDER_TOKEN) dataSource: DataSource) {
+    super(dataSource, Person);
+  }
+
+  findMany(query: PersonQueryDto): Promise<ListResponse<Person>> {
+    const where: FindOptionsWhere<Person> = {};
+
+    if (query.name) {
+      where.name = Like<string>(`%${query.name}%`);
+    }
+
+    if (query.active !== undefined) {
+      where.active = query.active;
+    }
+
+    return this.repository
+      .findAndCount({
+        where,
+        order: query.generateOrderBy(),
+        skip: query.skip(),
+        take: query.limit,
+      })
+      .then(([items, count]) => ({
+        items,
+        count,
+      }));
+  }
+
+  findById(id: number): Promise<Person | null> {
+    return this.repository.findOne({
+      where: { id },
+      relations: { address: true, contacts: true },
+    });
+  }
+}

package/koala-nest/src/infra/repositories/repository.base.ts

@@ -0,0 +1,20 @@
+import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
+
+export class RepositoryBase<T extends ObjectLiteral> {
+  protected readonly repository: Repository<T>;
+
+  constructor(
+    protected readonly dataSource: DataSource,
+    protected readonly entity: EntityTarget<T>,
+  ) {
+    this.repository = this.dataSource.getRepository<T>(entity);
+  }
+
+  save(entity: T) {
+    return this.repository.save(entity);
+  }
+
+  async delete(entity: T) {
+    await this.repository.remove(entity);
+  }
+}

package/koala-nest/src/infra/repositories/repository.module.ts

@@ -0,0 +1,16 @@
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { IUserRepository } from '@/domain/repositories/iuser.repository';
+import { Module } from '@nestjs/common';
+import { DatabaseModule } from '@/infra/database/database.module';
+import { PersonRepository } from '@/infra/repositories/person.repository';
+import { UserRepository } from '@/infra/repositories/user.repository';
+
+@Module({
+  imports: [DatabaseModule],
+  providers: [
+    { provide: IPersonRepository, useClass: PersonRepository },
+    { provide: IUserRepository, useClass: UserRepository },
+  ],
+  exports: [DatabaseModule, IPersonRepository, IUserRepository],
+})
+export class RepositoryModule {}

package/koala-nest/src/infra/repositories/user.repository.ts

@@ -0,0 +1,38 @@
+import { User } from '@/domain/entities/user/user';
+import { IUserRepository } from '@/domain/repositories/iuser.repository';
+import { DATA_SOURCE_PROVIDER_TOKEN } from '@/infra/database/data-source-factory';
+import { RepositoryBase } from '@/infra/repositories/repository.base';
+import { Inject, Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class UserRepository
+  extends RepositoryBase<User>
+  implements IUserRepository
+{
+  constructor(@Inject(DATA_SOURCE_PROVIDER_TOKEN) dataSource: DataSource) {
+    super(dataSource, User);
+  }
+
+  getById(id: string): Promise<User | null> {
+    return this.repository.findOne({ where: { id } });
+  }
+
+  getByEmail(email: string): Promise<User | null> {
+    return this.repository.findOne({
+      where: { email: email.toLowerCase() },
+    });
+  }
+
+  getByLogin(login: string): Promise<User | null> {
+    return this.repository.findOne({ where: { login } });
+  }
+
+  save(user: User): Promise<User> {
+    if (user.email) {
+      user.email = user.email.toLowerCase();
+    }
+
+    return this.repository.save(user);
+  }
+}

package/koala-nest/src/infra/services/database.indicator.service.ts

@@ -0,0 +1,17 @@
+import { DATA_SOURCE_PROVIDER_TOKEN } from '@/infra/database/data-source-factory';
+import { Inject, Injectable } from '@nestjs/common';
+import { TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class DatabaseIndicator {
+  constructor(
+    private readonly typeOrm: TypeOrmHealthIndicator,
+    @Inject(DATA_SOURCE_PROVIDER_TOKEN)
+    private readonly dataSource: DataSource,
+  ) {}
+
+  isHealthy() {
+    return this.typeOrm.pingCheck('db', { connection: this.dataSource });
+  }
+}

package/koala-nest/src/infra/services/logged-user-info.service.ts

@@ -0,0 +1,32 @@
+import { AuthenticatedUser } from '@/core/auth/jwt-claims';
+import { LoggedUserInfoDto } from '@/domain/dtos/logged-user-info.dto';
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';
+import {
+  Inject,
+  Injectable,
+  Scope,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import type { Request } from 'express';
+
+export type AuthenticatedRequest = Request & {
+  user?: AuthenticatedUser;
+};
+
+@Injectable({ scope: Scope.REQUEST })
+export class LoggedUserInfoService implements ILoggedUserInfoService {
+  constructor(
+    @Inject(REQUEST) private readonly request: AuthenticatedRequest,
+  ) {}
+
+  getUser(): LoggedUserInfoDto {
+    if (!this.request?.user) {
+      throw new UnauthorizedException(
+        'Não foi possível recuperar suas credenciais de acesso. Gentileza reautenticar.',
+      );
+    }
+
+    return LoggedUserInfoDto.fromAuthenticatedUser(this.request.user);
+  }
+}

package/koala-nest/src/infra/services/redis.indicator.service.ts

@@ -0,0 +1,66 @@
+import { EnvService } from '@/infra/common/env.service';
+import { Injectable } from '@nestjs/common';
+import {
+  HealthIndicatorResult,
+  HealthIndicatorService,
+} from '@nestjs/terminus';
+
+@Injectable()
+export class RedisIndicator {
+  constructor(
+    private readonly env: EnvService,
+    private readonly healthIndicatorService: HealthIndicatorService,
+  ) {}
+
+  isConfigured() {
+    return Boolean(this.env.get('REDIS_CONNECTION_STRING'));
+  }
+
+  async isHealthy(): Promise<HealthIndicatorResult> {
+    const indicator = this.healthIndicatorService.check('redis');
+    const url = this.env.get('REDIS_CONNECTION_STRING');
+
+    if (!url) {
+      return indicator.up();
+    }
+
+    try {
+      const { Redis } = await import('ioredis');
+      const client = new Redis(url, {
+        connectTimeout: 2_000,
+        maxRetriesPerRequest: 1,
+        lazyConnect: true,
+      });
+
+      await client.connect();
+      await client.ping();
+      await client.quit();
+
+      return indicator.up();
+    } catch (error) {
+      if (isMissingIoredisModule(error)) {
+        return indicator.up({
+          message:
+            'REDIS_CONNECTION_STRING definido, mas ioredis não está instalado',
+        });
+      }
+
+      const message = error instanceof Error ? error.message : String(error);
+
+      return indicator.down({ message });
+    }
+  }
+}
+
+export function isMissingIoredisModule(error: unknown) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  const code = 'code' in error ? String(error.code) : '';
+  return (
+    code === 'ERR_MODULE_NOT_FOUND' ||
+    code === 'MODULE_NOT_FOUND' ||
+    /Cannot find module 'ioredis'/.test(error.message)
+  );
+}

package/koala-nest/src/test/app-auth-test.module.ts

@@ -0,0 +1,32 @@
+import { envSchema } from '@/core/env';
+import { AuthModule } from '@/host/controllers/auth/auth.module';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { PersonModule } from '@/host/controllers/person/person.module';
+import { e2eDatabaseUrl } from '@/test/e2e-context';
+import { getJwtTestKeys } from '@/test/utils/jwt-test-keys';
+
+const jwtKeys = getJwtTestKeys();
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      ignoreEnvFile: true,
+      validate: () =>
+        envSchema.parse({
+          PORT: 3000,
+          NODE_ENV: 'test',
+          DATABASE_URL: e2eDatabaseUrl,
+          JWT_PRIVATE_KEY: jwtKeys.privateKey,
+          JWT_PUBLIC_KEY: jwtKeys.publicKey,
+          JWT_ACCESS_TOKEN_EXPIRES_IN: '15m',
+          JWT_REFRESH_TOKEN_EXPIRES_IN: '7d',
+          API_HOST: 'http://localhost:3000',
+        }),
+    }),
+    PersonModule,
+    AuthModule,
+  ],
+})
+export class AppAuthTestModule {}

package/koala-nest/src/test/app-test.module.ts

@@ -0,0 +1,22 @@
+import { envSchema } from '@/core/env';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { PersonModule } from '@/host/controllers/person/person.module';
+import { e2eDatabaseUrl } from '@/test/e2e-context';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      ignoreEnvFile: true,
+      validate: () =>
+        envSchema.parse({
+          PORT: 3000,
+          NODE_ENV: 'test',
+          DATABASE_URL: e2eDatabaseUrl,
+        }),
+    }),
+    PersonModule,
+  ],
+})
+export class AppTestModule {}

package/koala-nest/src/test/application/auth-link.handler.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test';
+import { OAuthAuthLinkHandler } from '@/application/auth/oauth2/auth-link/auth-link.handler';
+import type { IOAuth2Service } from '@/domain/auth/services/iauth.service';
+
+describe('OAuthAuthLinkHandler', () => {
+  it('retorna URL de autorização do provider', async () => {
+    const oauth2Service = {
+      authLink: async (provider: string, redirectUri?: string) =>
+        `https://oauth.example.com/${provider}?redirect=${redirectUri ?? ''}`,
+    } as IOAuth2Service;
+
+    const handler = new OAuthAuthLinkHandler(oauth2Service);
+    const result = await handler.handle({
+      provider: 'google',
+      redirectUri: 'http://localhost/callback',
+    });
+
+    expect(result.url).toBe(
+      'https://oauth.example.com/google?redirect=http://localhost/callback',
+    );
+  });
+});

package/koala-nest/src/test/application/create-person.handler.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, beforeAll } from 'bun:test';
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler';
+import { PersonMapper } from '@/application/mapping/person.mapper';
+import { Person } from '@/domain/entities/person/person';
+import { PERSON_LIST_CACHE_PREFIX } from '@/core/utils/person-list-cache';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { CacheStub } from '@/test/services/cache.stub';
+
+describe('CreatePersonHandler', () => {
+  beforeAll(() => {
+    PersonMapper.createMap();
+  });
+
+  it('valida, persiste, invalida cache e retorna o id da pessoa criada', async () => {
+    const saved: Person[] = [];
+    const cache = new CacheStub();
+
+    const repository = {
+      save: async (person: Person) => {
+        const created = Person.from({ ...person, id: 42 });
+        saved.push(created);
+        return created;
+      },
+    } as unknown as IPersonRepository;
+
+    const handler = new CreatePersonHandler(repository, cache);
+
+    const result = await handler.handle({
+      name: 'John Doe',
+      address: { address: 'Street 1' },
+      contacts: [{ contact: 'john@example.com' }],
+    });
+
+    expect(result.id).toBe(42);
+    expect(saved).toHaveLength(1);
+    expect(saved[0].name).toBe('John Doe');
+    expect(cache.invalidateByPrefixCalls).toEqual([PERSON_LIST_CACHE_PREFIX]);
+  });
+});

package/koala-nest/src/test/application/create-person.job.spec.ts

@@ -0,0 +1,55 @@
+/// <reference types="bun-types/test-globals" />
+
+import { CreatePersonJob } from '@/application/person/jobs/cron/create-person.job';
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler';
+import { InactivePersonHandler } from '@/application/person/jobs/events/person/inactive-person/inactive-person.handler';
+import { EventQueue } from '@/core/background-services/event-service/event-queue';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { FakeLoggingService } from '@/test/services/fake-logging.service';
+import { FakeRedLockService } from '@/test/services/fake-red-lock.service';
+import { afterEach, describe, expect, it, spyOn } from 'bun:test';
+
+describe('CreatePersonJob', () => {
+  afterEach(() => {
+    EventQueue.clearHandlers();
+    EventQueue.clearMarkedAggregates();
+  });
+
+  it('cria pessoa e dispara evento de inativação', async () => {
+    const person = Person.from({
+      id: 10,
+      name: 'John Doe',
+      active: true,
+      address: PersonAddress.from({ id: 1, address: 'Street 1' }),
+      contacts: [],
+    });
+
+    const createPerson = {
+      handle: async () => ({ id: 10 }),
+    } as unknown as CreatePersonHandler;
+
+    const repository = {
+      findById: async () => person,
+      findMany: async () => ({ items: [], count: 0 }),
+      save: async () => person,
+      delete: async () => undefined,
+    } as unknown as IPersonRepository;
+
+    new InactivePersonHandler(repository).setupSubscriptions();
+
+    const dispatchSpy = spyOn(EventQueue, 'dispatchEventsForAggregate');
+    const job = new CreatePersonJob(
+      new FakeRedLockService(),
+      new FakeLoggingService(),
+      createPerson,
+      repository,
+    );
+
+    await job['run']();
+
+    expect(dispatchSpy).toHaveBeenCalled();
+    expect(dispatchSpy.mock.calls[0]?.[0]).toEqual(expect.any(String));
+  });
+});

package/koala-nest/src/test/application/delete-inactive.job.spec.ts

@@ -0,0 +1,35 @@
+import { DeleteInactiveJob } from '@/application/person/jobs/cron/delete-inactive.job';
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler';
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler';
+import { FakeLoggingService } from '@/test/services/fake-logging.service';
+import { FakeRedLockService } from '@/test/services/fake-red-lock.service';
+
+describe('DeleteInactiveJob', () => {
+  it('remove pessoas inativas retornadas pela listagem', async () => {
+    const deletedIds: number[] = [];
+
+    const readManyPerson = {
+      handle: async () => ({
+        items: [{ id: 1, name: 'Inactive', active: false }],
+        count: 1,
+      }),
+    } as unknown as ReadManyPersonHandler;
+
+    const deletePerson = {
+      handle: async (id: number) => {
+        deletedIds.push(id);
+      },
+    } as unknown as DeletePersonHandler;
+
+    const job = new DeleteInactiveJob(
+      new FakeRedLockService(),
+      new FakeLoggingService(),
+      readManyPerson,
+      deletePerson,
+    );
+
+    await job['run']();
+
+    expect(deletedIds).toEqual([1]);
+  });
+});