@koalarx/nest 4.0.5 → 4.0.8

package/koala-nest/src/test/core/pagination-typeorm.spec.ts

@@ -0,0 +1,74 @@
+/// <reference types="bun-types/test-globals" />
+
+import { PaginationDto } from '@/domain/dtos/pagination.dto';
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { describe, expect, it } from 'bun:test';
+
+describe('PaginationDto TypeORM', () => {
+  it('toFindOptionsOrder normaliza direction para ASC/DESC', () => {
+    const query = PaginationDto.from({ orderBy: 'name', direction: 'desc' });
+
+    expect(query.toFindOptionsOrder()).toEqual({ name: 'DESC' });
+  });
+
+  it('toFindOptionsOrder suporta ordenação aninhada', () => {
+    const query = PaginationDto.from({
+      orderBy: 'address.city',
+      direction: 'asc',
+    });
+
+    expect(query.toFindOptionsOrder()).toEqual({
+      address: { city: 'ASC' },
+    });
+  });
+
+  it('applyQueryBuilderPagination aplica order, skip e take', () => {
+    const qb = {
+      expressionMap: {
+        orderBys: {} as Record<string, string>,
+        skip: 0,
+        take: 0,
+      },
+      addOrderBy(path: string, direction: string) {
+        this.expressionMap.orderBys[path] = direction;
+        return this;
+      },
+      skip(value: number) {
+        this.expressionMap.skip = value;
+        return this;
+      },
+      take(value: number) {
+        this.expressionMap.take = value;
+        return this;
+      },
+    };
+    const query = PaginationDto.from({
+      page: 1,
+      limit: 10,
+      orderBy: 'name',
+      direction: 'desc',
+    });
+
+    const result = query.applyQueryBuilderPagination(qb as never, 'entity');
+
+    expect(result.expressionMap.orderBys).toEqual({ 'entity.name': 'DESC' });
+    expect(result.expressionMap.skip).toBe(10);
+    expect(result.expressionMap.take).toBe(10);
+  });
+});
+
+describe('PersonQueryDto default sort', () => {
+  it('usa id asc quando orderBy não é informado', () => {
+    const query = PersonQueryDto.from({ name: 'Jane' });
+
+    expect(query.generateOrderBy()).toEqual({ id: 'asc' });
+    expect(query.toFindOptionsOrder()).toEqual({ id: 'ASC' });
+  });
+
+  it('delega para PaginationDto quando orderBy é informado', () => {
+    const query = PersonQueryDto.from({ orderBy: 'name', direction: 'desc' });
+
+    expect(query.generateOrderBy()).toEqual({ name: 'desc' });
+    expect(query.toFindOptionsOrder()).toEqual({ name: 'DESC' });
+  });
+});

package/koala-nest/src/test/core/resolve-cors-origins.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test';
+import { resolveCorsOrigin } from '@/core/utils/resolve-cors-origins';
+
+describe('resolveCorsOrigin', () => {
+  it('permite qualquer origin quando CORS_ORIGINS não está definido', () => {
+    expect(resolveCorsOrigin(undefined)).toBe(true);
+    expect(resolveCorsOrigin('')).toBe(true);
+    expect(resolveCorsOrigin('   ')).toBe(true);
+  });
+
+  it('aceita lista de origens separadas por vírgula', () => {
+    expect(
+      resolveCorsOrigin('http://localhost:4200, https://app.example.com'),
+    ).toEqual(['http://localhost:4200', 'https://app.example.com']);
+  });
+
+  it('retorna string única quando há uma origem', () => {
+    expect(resolveCorsOrigin('https://app.example.com')).toBe(
+      'https://app.example.com',
+    );
+  });
+});

package/koala-nest/src/test/core/sync-improvements.spec.ts

@@ -0,0 +1,39 @@
+/// <reference types="bun-types/test-globals" />
+
+import { ListResponseBase } from '@/core/common/list-response.base';
+import { PaginationDto } from '@/domain/dtos/pagination.dto';
+import { describe, expect, it } from 'bun:test';
+
+class QueryPersonDto extends PaginationDto {
+  name?: string;
+}
+
+class PersonListItem {
+  id!: number;
+  name!: string;
+}
+
+class PersonListResponse extends ListResponseBase<PersonListItem> {}
+
+describe('PaginationDto.from', () => {
+  it('cria instância com props parciais herdando defaults', () => {
+    const query = QueryPersonDto.from({ name: 'Jane', limit: 50 });
+
+    expect(query).toBeInstanceOf(QueryPersonDto);
+    expect(query.name).toBe('Jane');
+    expect(query.limit).toBe(50);
+    expect(query.page).toBe(0);
+  });
+});
+
+describe('ListResponseBase.from', () => {
+  it('cria resposta paginada via ObjectClass.from', () => {
+    const response = PersonListResponse.from({
+      items: [{ id: 1, name: 'Jane' }],
+      count: 1,
+    });
+
+    expect(response.items).toHaveLength(1);
+    expect(response.count).toBe(1);
+  });
+});

package/koala-nest/src/test/host/controllers/app/app.e2e.spec.ts

@@ -0,0 +1,24 @@
+/// <reference types="bun-types/test-globals" />
+
+import { createE2ETestApp } from '@/test/create-e2e-test-app';
+import type { INestApplication } from '@nestjs/common';
+
+/**
+ * Estrutura mínima de E2E — use como ponto de partida no template Padrão.
+ * No exemplo CRUD, veja `person.controller.e2e.spec.ts` e `auth.controller.e2e.spec.ts`.
+ */
+describe('App (E2E)', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    app = await createE2ETestApp();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('should bootstrap the application', () => {
+    expect(app.getHttpServer()).toBeDefined();
+  });
+});

package/koala-nest/src/test/host/controllers/person/lazy-loading.e2e.spec.ts

@@ -10,13 +10,11 @@ import { IPersonRepository } from '@/domain/repositories/iperson.repository';
 import { Test, TestingModule } from '@nestjs/testing';
 
 /**
- * Testes E2E do RepositoryBase - Lazy Loading
- *
- * Valida o carregamento efetivo de relacionamentos em diferentes cenários:
- * - findById: carrega recursivamente todos os relacionamentos
- * - findMany: carrega com otimização para listas
+ * Valida carregamento explícito de relacionamentos no repositório.
+ * - findById: relations { address, contacts }
+ * - findMany: sem relations (listagem leve; contacts normalizado como [])
  */
-describe('RepositoryBase - Lazy Loading (E2E)', () => {
+describe('PersonRepository - Relations (E2E)', () => {
   let moduleRef: TestingModule;
 
   beforeAll(async () => {
@@ -25,8 +23,8 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
     }).compile();
   });
 
-  describe('findById - Carregamento de Relacionamentos', () => {
-    it('should load person with all relationships using findById', async () => {
+  describe('findById - relations explícitas', () => {
+    it('should load person with address and contacts using findById', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
       const created = await createHandler.handle({
         name: 'João Silva',
@@ -53,30 +51,10 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
         'joao@example.com',
       ]);
     });
-
-    it('should have all relationships loaded and accessible', async () => {
-      const createHandler = moduleRef.get(CreatePersonHandler);
-      const created = await createHandler.handle({
-        name: 'Test Person',
-        contacts: [{ contact: 'test@example.com' }],
-        address: {
-          address: 'Test Address',
-        },
-      });
-
-      const readHandler = moduleRef.get(ReadPersonHandler);
-      const person = await readHandler.handle(created.id);
-
-      expect(person.id).toBe(created.id);
-      expect(person.address).toBeDefined();
-      expect(person.address.address).toBeDefined();
-      expect(person.contacts).toBeDefined();
-      expect(person.contacts.length).toBeGreaterThan(0);
-    });
   });
 
-  describe('findMany - Carregamento Otimizado para Listas', () => {
-    it('should load persons with relationships in findMany', async () => {
+  describe('findMany - listagem sem relations', () => {
+    it('should return persons without loading relations in findMany', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
 
       for (let i = 0; i < 2; i++) {
@@ -90,10 +68,7 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
       }
 
       const repository = moduleRef.get(IPersonRepository);
-      const query = Object.assign(new PersonQueryDto(), {
-        limit: 100,
-        page: 0,
-      });
+      const query = PersonQueryDto.from({ limit: 100, page: 0 });
       const { items } = await repository.findMany(query);
 
       expect(items.length).toBeGreaterThan(0);
@@ -101,11 +76,11 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
       const person = items[0];
       expect(person.id).toBeDefined();
       expect(person.name).toBeDefined();
-      expect(person.address).toBeDefined();
-      expect(person.contacts).toBeDefined();
+      expect(person.address).toBeUndefined();
+      expect(person.contacts ?? []).toHaveLength(0);
     });
 
-    it('should load multiple persons efficiently', async () => {
+    it('should list via handler without requiring relations on entities', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
 
       const createdIds: number[] = [];
@@ -120,8 +95,6 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
         createdIds.push(result.id);
       }
 
-      expect(createdIds.length).toBe(3);
-
       const readManyHandler = moduleRef.get(ReadManyPersonHandler);
       const result = await readManyHandler.handle(new ReadManyPersonRequest());
 
@@ -132,23 +105,15 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
       createdIds.forEach((id) => {
         expect(returnedIds).toContain(id);
       });
-
-      result.items.forEach((person) => {
-        expect(person.id).toBeDefined();
-        expect(person.name).toBeDefined();
-      });
     });
   });
 
-  describe('Comparação entre findById e findMany', () => {
-    it('should load relationships in both methods', async () => {
+  describe('findById vs findMany', () => {
+    it('findById carrega relations; findMany retorna entidade leve', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
       const created = await createHandler.handle({
         name: 'Comparação Test',
-        contacts: [
-          { contact: 'first@example.com' },
-          { contact: 'second@example.com' },
-        ],
+        contacts: [{ contact: 'first@example.com' }],
         address: {
           address: 'Rua Comparação, 789',
         },
@@ -158,24 +123,19 @@ describe('RepositoryBase - Lazy Loading (E2E)', () => {
       const personFromFindById = await readHandler.handle(created.id);
 
       const repository = moduleRef.get(IPersonRepository);
-      const query = Object.assign(new PersonQueryDto(), {
-        limit: 100,
-        page: 0,
-      });
-      const { items } = await repository.findMany(query);
+      const { items } = await repository.findMany(
+        PersonQueryDto.from({ limit: 100, page: 0 }),
+      );
       const personFromFindMany = items.find((p) => p.id === created.id);
 
       expect(personFromFindMany).toBeDefined();
       expect(personFromFindById.id).toBe(personFromFindMany!.id);
       expect(personFromFindById.name).toBe(personFromFindMany!.name);
-
       expect(personFromFindById.address).toBeDefined();
       expect(personFromFindById.contacts).toBeDefined();
       expect(personFromFindById.contacts.length).toBeGreaterThan(0);
-
-      expect(personFromFindMany?.address).toBeDefined();
-      expect(personFromFindMany?.contacts).toBeDefined();
-      expect(personFromFindMany?.contacts.length).toBeGreaterThan(0);
+      expect(personFromFindMany?.address).toBeUndefined();
+      expect(personFromFindMany?.contacts ?? []).toHaveLength(0);
     });
   });
 });

package/koala-nest/src/test/infra/redis-cache.service.spec.ts

@@ -35,6 +35,14 @@ class RedisStub {
     );
   }
 
+  scan(cursor: string, ...args: unknown[]) {
+    const pattern = String(args[1] ?? '');
+    const prefix = pattern.replace(/\*$/, '');
+    const keys = [...this.store.keys()].filter((key) => key.startsWith(prefix));
+
+    return Promise.resolve(['0', keys]);
+  }
+
   disconnect() {}
 }
 

package/koala-nest/src/test/utils/configure-test-app.ts

@@ -1,17 +1,11 @@
+import { applyHttpMiddleware } from '@/host/bootstrap/apply-http-middleware';
 import { ErrorsFilter } from '@/host/filters/errors.filter';
 import { ILoggingService } from '@/domain/common/ilogging.service';
 import { INestApplication } from '@nestjs/common';
 import { HttpAdapterHost } from '@nestjs/core';
-import cookieParser from 'cookie-parser';
 
 export function setupTestApp(app: INestApplication) {
-  app.use(cookieParser());
-
-  app.enableCors({
-    credentials: true,
-    origin: true,
-    optionsSuccessStatus: 200,
-  });
+  applyHttpMiddleware(app);
 
   const { httpAdapter } = app.get(HttpAdapterHost);
   const loggingService = app.get(ILoggingService);

package/koala-nest/src/test/utils/create-e2e-database.ts

@@ -1,9 +1,24 @@
 import { Type } from '@nestjs/common';
 import { execSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { setE2EDatabaseUrl } from '../e2e-context';
 import { E2EDatabaseClient } from './e2e-database-client';
 
+function resolveMigrationRunner(): string {
+  const packageJson = JSON.parse(readFileSync('package.json', 'utf8')) as {
+    packageManager?: string;
+  };
+
+  const packageManager = packageJson.packageManager ?? 'bun';
+
+  if (packageManager === 'bun') {
+    return 'bun';
+  }
+
+  return 'node --import ts-node/register/transpile-only';
+}
+
 function generateUniqueDatabaseURL() {
   const schemaId = randomUUID();
 
@@ -33,8 +48,9 @@ export async function createE2EDatabase<T extends E2EDatabaseClient>(
     await client.createDatabase(schemaId);
 
     const env = { ...process.env, DATABASE_URL: url, NODE_ENV: 'test' };
+    const migrationRunner = resolveMigrationRunner();
     execSync(
-      'bun ./node_modules/typeorm/cli.js migration:run -d ./src/infra/database/migrations/migration-datasource.ts',
+      `${migrationRunner} ./node_modules/typeorm/cli.js migration:run -d ./src/infra/database/migrations/migration-datasource.ts`,
       {
         cwd: process.cwd(),
         env,

package/koala-nest/src/test/utils/in-memory-base.repository.ts

@@ -0,0 +1,80 @@
+import { PaginationDto } from '@/domain/dtos/pagination.dto';
+import { ListResponseBase } from '@/core/common/list-response.base';
+import { QUERY_FILTER_PARAMS } from '@/core/constants/query-params';
+import { KlArray } from '@koalarx/utils/KlArray';
+import { randomUUID } from 'node:crypto';
+
+export abstract class InMemoryBaseRepository<
+  TClass extends { id?: number | string | null },
+> {
+  protected items: TClass[] = [];
+
+  constructor(private readonly typeId: 'number' | 'string' = 'number') {}
+
+  protected async findById(id: number | string) {
+    return this.items.find((item) => item.id === id) ?? null;
+  }
+
+  protected async findMany<T extends PaginationDto>(
+    query: T,
+    predicate?: (value: TClass, index: number, array: TClass[]) => unknown,
+  ) {
+    const page = query.page ?? QUERY_FILTER_PARAMS.page;
+    const limit = query.limit ?? QUERY_FILTER_PARAMS.limit;
+
+    return new KlArray(predicate ? this.items.filter(predicate) : this.items)
+      .orderBy(query.orderBy ?? '', query.direction)
+      .slice(page * limit, (page + 1) * limit);
+  }
+
+  protected async findManyAndCount<T extends PaginationDto>(
+    query: T,
+    predicate?: (value: TClass, index: number, array: TClass[]) => unknown,
+  ): Promise<ListResponseBase<TClass>> {
+    const filtered = predicate ? this.items.filter(predicate) : this.items;
+    const page = query.page ?? QUERY_FILTER_PARAMS.page;
+    const limit = query.limit ?? QUERY_FILTER_PARAMS.limit;
+    const items = new KlArray(filtered)
+      .orderBy(query.orderBy ?? '', query.direction)
+      .slice(page * limit, (page + 1) * limit);
+
+    return ListResponseBase.from({ items, count: filtered.length });
+  }
+
+  protected async saveChanges(
+    item: TClass,
+    updateWhere?: (item: TClass) => boolean,
+  ) {
+    if (!item.id) {
+      const id = this.typeId === 'number' ? this.getNewId() : randomUUID();
+      (item as { id: number | string }).id = id;
+      this.items.push(item);
+      return { id };
+    }
+
+    const predicate = updateWhere ?? ((stored) => stored.id === item.id);
+    const itemIndex = this.items.findIndex(predicate);
+
+    if (itemIndex > -1) {
+      this.items[itemIndex] = item;
+    } else {
+      this.items.push(item);
+    }
+  }
+
+  protected async remove(
+    predicate: (value: TClass, index: number, obj: TClass[]) => unknown,
+  ) {
+    const itemIndex = this.items.findIndex(predicate);
+    if (itemIndex > -1) this.items.splice(itemIndex, 1);
+  }
+
+  private getNewId() {
+    if (this.typeId === 'number') {
+      const lastId = new KlArray(this.items).orderBy('id', 'desc')[0]?.id;
+      return lastId ? (lastId as number) + 1 : 1;
+    }
+
+    return randomUUID();
+  }
+}

package/koala-nest/vitest.config.e2e.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    include: ['src/test/**/*.e2e.spec.ts'],
+    setupFiles: ['src/test/setup-e2e.ts'],
+    environment: 'node',
+    testTimeout: 60_000,
+    hookTimeout: 60_000,
+  },
+});

package/koala-nest/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    include: ['src/test/**/*.spec.ts'],
+    exclude: ['src/test/**/*.e2e.spec.ts'],
+    setupFiles: ['src/test/setup.ts'],
+    environment: 'node',
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "4.0.5",
+  "version": "4.0.8",
   "description": "CLI para criar APIs NestJS com arquitetura DDD — copia módulos prontos para o seu repositório.",
   "license": "MIT",
   "type": "module",

package/koala-nest/src/core/utils/icomparable.ts

@@ -1 +0,0 @@
-export type IComparableId = string | number;