@koalarx/nest 4.0.6 → 4.1.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/setup-e2e.ts

@@ -1,60 +1,23 @@
 import 'reflect-metadata';
-import { delay } from '@koalarx/utils/KlDelay';
 import { createE2EDatabase } from '@/test/utils/create-e2e-database';
 import { E2EDatabaseClient } from '@/test/utils/e2e-database-client';
 import { Pool } from 'pg';
 
 class E2EPostgresClient extends E2EDatabaseClient {
-  private baseUrl: URL;
-
   public pool: Pool;
 
   constructor(url: string, schemaName: string) {
     super(url, schemaName);
-
-    this.baseUrl = new URL(this.url);
-    this.baseUrl.pathname = `/${this.schemaName}`;
-
-    this.pool = this.createSession();
+    this.pool = new Pool({ connectionString: url });
   }
 
-  private createSession(idleTimeout?: number) {
-    return new Pool({
-      connectionString: this.baseUrl.toString(),
-      ...(idleTimeout ? { idleTimeoutMillis: idleTimeout } : {}),
-    });
+  async createSchema(schemaName: string): Promise<void> {
+    await this.pool.query(`CREATE SCHEMA "${schemaName}"`);
   }
 
-  async createDatabase(schemaName: string): Promise<void> {
-    this.baseUrl.pathname = '/postgres';
-
-    const pool = this.createSession();
-
-    await pool.query(`CREATE DATABASE "${schemaName}"`);
-    await pool.end();
-
-    this.baseUrl.pathname = `/${schemaName}`;
-  }
-
-  async dropDatabase(): Promise<void> {
+  async dropSchema(): Promise<void> {
+    await this.pool.query(`DROP SCHEMA IF EXISTS "${this.schemaName}" CASCADE`);
     await this.pool.end();
-
-    await delay(1000);
-
-    this.baseUrl.pathname = '/postgres';
-    const pool = this.createSession(100);
-
-    await pool.query(`
-      SELECT pg_terminate_backend(pg_stat_activity.pid)
-      FROM pg_stat_activity
-      WHERE pg_stat_activity.datname = '${this.schemaName}'
-      AND pid <> pg_backend_pid()
-    `);
-
-    await delay(500);
-
-    await pool.query(`DROP DATABASE IF EXISTS "${this.schemaName}"`);
-    await pool.end();
   }
 }
 
@@ -62,5 +25,5 @@ const { client } = await createE2EDatabase(E2EPostgresClient);
 export const pgClient = client;
 
 afterAll(async () => {
-  await pgClient.dropDatabase();
+  await pgClient.dropSchema();
 });

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

@@ -2,7 +2,7 @@ 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 { setE2EDatabaseContext } from '../e2e-context';
 import { E2EDatabaseClient } from './e2e-database-client';
 
 function resolveMigrationRunner(): string {
@@ -19,35 +19,37 @@ function resolveMigrationRunner(): string {
   return 'node --import ts-node/register/transpile-only';
 }
 
-function generateUniqueDatabaseURL() {
-  const schemaId = randomUUID();
+function generateUniqueSchemaConfig() {
+  const schemaName = `e2e_${randomUUID().replace(/-/g, '_')}`;
 
   if (!process.env.DATABASE_URL) {
     throw new Error('Please provide a DATABASE_URL environment variable');
   }
 
-  const url = new URL(process.env.DATABASE_URL);
-  url.pathname = `/${schemaId}`;
-
   return {
-    url: url.toString(),
-    schemaId,
+    url: process.env.DATABASE_URL,
+    schemaName,
   };
 }
 
 export async function createE2EDatabase<T extends E2EDatabaseClient>(
   clientInstance: Type<T>,
 ) {
-  const { url, schemaId } = generateUniqueDatabaseURL();
+  const { url, schemaName } = generateUniqueSchemaConfig();
 
-  setE2EDatabaseUrl(url);
+  setE2EDatabaseContext(url, schemaName);
 
-  try {
-    const client = new clientInstance(url, schemaId);
+  const client = new clientInstance(url, schemaName);
 
-    await client.createDatabase(schemaId);
+  try {
+    await client.createSchema(schemaName);
 
-    const env = { ...process.env, DATABASE_URL: url, NODE_ENV: 'test' };
+    const env = {
+      ...process.env,
+      DATABASE_URL: url,
+      DATABASE_SCHEMA: schemaName,
+      NODE_ENV: 'test',
+    };
     const migrationRunner = resolveMigrationRunner();
     execSync(
       `${migrationRunner} ./node_modules/typeorm/cli.js migration:run -d ./src/infra/database/migrations/migration-datasource.ts`,
@@ -58,9 +60,15 @@ export async function createE2EDatabase<T extends E2EDatabaseClient>(
       },
     );
 
-    return { client, schemaId };
+    return { client, schemaName };
   } catch (error) {
-    console.error('Erro ao criar banco de dados e2e:', error);
+    try {
+      await client.dropSchema();
+    } catch {
+      // schema pode não ter sido criado
+    }
+
+    console.error('Erro ao preparar schema e2e:', error);
     throw error;
   }
 }

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

@@ -4,6 +4,6 @@ export abstract class E2EDatabaseClient {
     protected readonly schemaName: string,
   ) {}
 
-  abstract createDatabase(schemaName: string): Promise<void>;
-  abstract dropDatabase(): Promise<void>;
+  abstract createSchema(schemaName: string): Promise<void>;
+  abstract dropSchema(): Promise<void>;
 }

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.1.0",
   "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;