@koalarx/nest 4.0.6 → 4.0.8

package/koala-nest/src/test/core/http/rate-limit.middleware.spec.ts

@@ -0,0 +1,62 @@
+/// <reference types="bun-types/test-globals" />
+
+import { createRateLimitMiddleware } from '@/core/http/rate-limit.middleware';
+import { describe, expect, it } from 'bun:test';
+
+function createMockResponse() {
+  const response = {
+    statusCode: 200,
+    body: undefined as unknown,
+    status(code: number) {
+      this.statusCode = code;
+      return this;
+    },
+    json(payload: unknown) {
+      this.body = payload;
+      return this;
+    },
+  };
+
+  return response;
+}
+
+describe('createRateLimitMiddleware', () => {
+  it('permite requisições quando rate limit está desabilitado', () => {
+    const middleware = createRateLimitMiddleware({
+      windowMs: 60_000,
+      maxRequests: 0,
+    });
+    let called = false;
+    const next = () => {
+      called = true;
+    };
+
+    middleware(
+      { ip: '127.0.0.1' } as never,
+      createMockResponse() as never,
+      next,
+    );
+
+    expect(called).toBe(true);
+  });
+
+  it('bloqueia requisições após atingir maxRequests', () => {
+    const middleware = createRateLimitMiddleware({
+      windowMs: 60_000,
+      maxRequests: 2,
+    });
+    const req = { ip: '127.0.0.1' } as never;
+    const next = () => {};
+
+    middleware(req, createMockResponse() as never, next);
+    middleware(req, createMockResponse() as never, next);
+    const blockedResponse = createMockResponse();
+
+    middleware(req, blockedResponse as never, next);
+
+    expect(blockedResponse.statusCode).toBe(429);
+    expect(blockedResponse.body).toMatchObject({
+      statusCode: 429,
+    });
+  });
+});

package/koala-nest/src/test/core/initialize-undefined-array-props.spec.ts

@@ -0,0 +1,63 @@
+/// <reference types="bun-types/test-globals" />
+
+import { initializeUndefinedArrayProps } from '@/core/utils/initialize-undefined-array-props';
+import { AutoMap } from '@/core/tools/mapping';
+import { MappingStore } from '@/core/tools/mapping/mapping-store';
+import { describe, expect, it } from 'bun:test';
+
+class ChildItem {
+  @AutoMap()
+  name!: string;
+}
+
+class EntityWithArrays {
+  @AutoMap()
+  title!: string;
+
+  @AutoMap({ type: () => ChildItem })
+  children!: ChildItem[];
+}
+
+describe('initializeUndefinedArrayProps', () => {
+  it('inicializa props de array mapeadas como [] quando undefined', () => {
+    const target = { title: 'Test' } as Record<string, unknown>;
+
+    initializeUndefinedArrayProps(target, EntityWithArrays);
+
+    expect(target.children).toEqual([]);
+  });
+
+  it('respeita onlyProps quando informado', () => {
+    const target = { title: 'Test' } as Record<string, unknown>;
+
+    initializeUndefinedArrayProps(target, EntityWithArrays, ['title']);
+
+    expect(target.children).toBeUndefined();
+  });
+
+  it('não sobrescreve array já definido', () => {
+    const existing: ChildItem[] = [];
+    const target = { title: 'Test', children: existing } as Record<
+      string,
+      unknown
+    >;
+
+    initializeUndefinedArrayProps(target, EntityWithArrays);
+
+    expect(target.children).toBe(existing);
+  });
+
+  it('detecta arrays via metadata composition:type', () => {
+    class DtoWithExplicitArray {
+      @AutoMap({ type: () => ChildItem, isArray: true })
+      items!: ChildItem[];
+    }
+
+    MappingStore.getAllProps(DtoWithExplicitArray);
+
+    const target = {} as Record<string, unknown>;
+    initializeUndefinedArrayProps(target, DtoWithExplicitArray);
+
+    expect(target.items).toEqual([]);
+  });
+});

package/koala-nest/src/test/core/mapping.spec.ts

@@ -104,6 +104,21 @@ describe('AutoMapper', () => {
     expect(person.contacts[0].contact).toBe(personRequest.contacts[0].contact);
   });
 
+  it('inicializa arrays undefined no destino após o map', () => {
+    createMap(PersonRequest, Person);
+
+    const personRequest = PersonRequest.from({
+      name: 'John Doe',
+      address: {
+        address: '123 Main St',
+      },
+    });
+
+    const person = AutoMapper.map(personRequest, PersonRequest, Person);
+
+    expect(person.contacts).toEqual([]);
+  });
+
   it('should apply forMember custom mappings', () => {
     class SourceRequest {
       @AutoMap()

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "4.0.6",
+  "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;