@koalarx/nest 4.0.8 → 4.1.0

package/cli/utils/install-module.js

@@ -1,12 +1,3 @@
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync
-} from "node:fs";
-import path from "node:path";
 import {
   AUTH_DEV_PACKAGES,
   AUTH_PACKAGES,
@@ -18,13 +9,24 @@ import {
   HEALTH_PACKAGES
 } from "../constants/core-packages.js";
 import {
-  AuthChoice,
   AuthStrategy,
   ExtraFeature,
   InstallModule as Modules,
   Template
 } from "../constants/domain.js";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { getPackageManager } from "./get-package-manager.js";
 import { getSourceCodePath } from "./get-source-code-path.js";
+import { patchAuthInstall } from "./patch-auth-install.js";
+import { restoreDefineDocumentationWithAuth } from "./patch-define-documentation.js";
 import {
   patchAppModuleForHealth,
   patchHealthCheckWithoutRedis
@@ -34,24 +36,19 @@ import {
   patchInfraModuleForCache,
   stripInfraModuleCache
 } from "./patch-infra-module.js";
-import { patchAuthInstall } from "./patch-auth-install.js";
-import {
-  patchMainForAuth
-} from "./patch-main.js";
-import { restoreDefineDocumentationWithAuth } from "./patch-define-documentation.js";
+import { patchMainForAuth } from "./patch-main.js";
 import { pruneCoreAuthForSlimTemplate } from "./prune-core-auth.js";
 import { removeSampleParts } from "./remove-sample-parts.js";
 import { resolveProjectPath } from "./resolve-project-path.js";
 import { runCommand } from "./run-command.js";
-import { getPackageManager } from "./get-package-manager.js";
 export {
   AuthChoice,
   AuthStrategy,
   CRUD_BUNDLED_FEATURES,
   ExtraFeature,
-  InstallModule as Modules,
   mapExtraFeatureToModule,
   mergeCrudSampleFeatures,
+  InstallModule as Modules,
   resolveNewProjectOptions,
   Template
 } from "../constants/domain.js";

package/cli/utils/patch-app-test-module.js

@@ -5,7 +5,7 @@ const defaultAppTestModule = `import { envSchema } from '@/core/env';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { InfraModule } from '@/infra/infra.module';
-import { e2eDatabaseUrl } from '@/test/e2e-context';
+import { e2eDatabaseUrl, e2eSchemaName } from '@/test/e2e-context';
 
 @Module({
   imports: [
@@ -17,6 +17,7 @@ import { e2eDatabaseUrl } from '@/test/e2e-context';
           PORT: 3000,
           NODE_ENV: 'test',
           DATABASE_URL: e2eDatabaseUrl,
+          DATABASE_SCHEMA: e2eSchemaName,
         }),
     }),
     InfraModule,

package/cli/utils/patch-env.js

@@ -11,6 +11,7 @@ export const envSchema = z.object({
   HOST: z.string().default('0.0.0.0'),
   NODE_ENV: z.enum(['test', 'develop', 'staging', 'production']),
   DATABASE_URL: z.string(),
+  DATABASE_SCHEMA: z.string().optional(),
   REDIS_CONNECTION_STRING: z.string().optional(),
   CACHE_KEY_PREFIX: z.string().optional(),
   CRON_JOBS_ENABLED: envBooleanSchema(false),
@@ -73,6 +74,7 @@ export const envSchema = z.object({
   HOST: z.string().default('0.0.0.0'),
   NODE_ENV: z.enum(['test', 'develop', 'staging', 'production']),
   DATABASE_URL: z.string(),
+  DATABASE_SCHEMA: z.string().optional(),
   REDIS_CONNECTION_STRING: z.string().optional(),
   CACHE_KEY_PREFIX: z.string().optional(),
   CRON_JOBS_ENABLED: envBooleanSchema(false),

package/koala-nest/src/core/database/db-context.ts

@@ -0,0 +1,3 @@
+export class DbContext {
+  static entities: Set<Function> = new Set();
+}

package/koala-nest/src/core/database/entity.ts

@@ -0,0 +1,9 @@
+import { Entity as TypeOrmEntity } from 'typeorm';
+import { DbContext } from './db-context';
+
+export function Entity(tableName: string) {
+  return function (target: Function) {
+    TypeOrmEntity(tableName)(target);
+    DbContext.entities.add(target);
+  };
+}

package/koala-nest/src/core/env.ts

@@ -11,6 +11,7 @@ export const envSchema = z.object({
   HOST: z.string().default('0.0.0.0'),
   NODE_ENV: z.enum(['test', 'develop', 'staging', 'production']),
   DATABASE_URL: z.string(),
+  DATABASE_SCHEMA: z.string().optional(),
   REDIS_CONNECTION_STRING: z.string().optional(),
   CACHE_KEY_PREFIX: z.string().optional(),
   CRON_JOBS_ENABLED: envBooleanSchema(false),

package/koala-nest/src/domain/entities/person/person-address.ts

@@ -1,6 +1,7 @@
 import { EntityBase } from '@/core/base/entity.base';
+import { Entity } from '@/core/database/entity';
 import { AutoMap } from '@/core/tools/mapping';
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity('person_address')
 export class PersonAddress extends EntityBase<PersonAddress> {

package/koala-nest/src/domain/entities/person/person-contact.ts

@@ -1,13 +1,13 @@
+import { EntityBase } from '@/core/base/entity.base';
+import { Entity } from '@/core/database/entity';
 import { AutoMap } from '@/core/tools/mapping';
 import {
   Column,
-  Entity,
   ManyToOne,
   PrimaryGeneratedColumn,
   type Relation,
 } from 'typeorm';
 import type { Person } from './person';
-import { EntityBase } from '@/core/base/entity.base';
 
 @Entity('person_contact')
 export class PersonContact extends EntityBase<PersonContact> {

package/koala-nest/src/domain/entities/person/person.ts

@@ -1,7 +1,8 @@
+import { EntityBase } from '@/core/base/entity.base';
+import { Entity } from '@/core/database/entity';
 import { AutoMap } from '@/core/tools/mapping';
 import {
   Column,
-  Entity,
   JoinColumn,
   OneToMany,
   OneToOne,
@@ -9,7 +10,6 @@ import {
 } from 'typeorm';
 import { PersonAddress } from './person-address';
 import { PersonContact } from './person-contact';
-import { EntityBase } from '@/core/base/entity.base';
 
 @Entity('person')
 export class Person extends EntityBase<Person> {

package/koala-nest/src/domain/entities/user/user.ts

@@ -1,11 +1,11 @@
 import { AuthProfile } from '@/core/auth/auth-profile.enum';
 import { EntityBase } from '@/core/base/entity.base';
+import { Entity } from '@/core/database/entity';
 import { AutoMap } from '@/core/tools/mapping';
 import { UserStatus } from '@/domain/entities/user/enums/user-status.enum';
 import {
   Column,
   CreateDateColumn,
-  Entity,
   PrimaryGeneratedColumn,
   UpdateDateColumn,
 } from 'typeorm';

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

@@ -1,9 +1,6 @@
-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 { DbContext } from '@/core/database/db-context';
 import { EnvService } from '@/infra/common/env.service';
+import { DataSource } from 'typeorm';
 
 export const DATA_SOURCE_PROVIDER_TOKEN = 'DATA_SOURCE';
 
@@ -11,7 +8,8 @@ export async function dataSourceFactory(env: EnvService) {
   const dataSource = new DataSource({
     type: 'postgres',
     url: env.get('DATABASE_URL'),
-    entities: [Person, PersonAddress, PersonContact, User],
+    schema: env.get('DATABASE_SCHEMA'),
+    entities: Array.from(DbContext.entities.values()),
     invalidWhereValuesBehavior: {
       undefined: 'ignore',
     },

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

@@ -3,10 +3,17 @@ import path from 'node:path';
 import { DataSource } from 'typeorm';
 
 const root = process.cwd();
+const schema = process.env.DATABASE_SCHEMA;
 
 export default new DataSource({
   type: 'postgres',
   url: process.env.DATABASE_URL,
+  ...(schema
+    ? {
+        schema,
+        extra: { options: `-c search_path=${schema},public` },
+      }
+    : {}),
   entities: [path.join(root, 'src/domain/entities/**/*.{js,ts}')],
   migrations: [path.join(root, 'src/infra/database/migrations/[0-9]*.{js,ts}')],
   migrationsTableName: 'migrations',

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

@@ -3,7 +3,7 @@ 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 { e2eDatabaseUrl, e2eSchemaName } from '@/test/e2e-context';
 import { getJwtTestKeys } from '@/test/utils/jwt-test-keys';
 
 const jwtKeys = getJwtTestKeys();
@@ -18,6 +18,7 @@ const jwtKeys = getJwtTestKeys();
           PORT: 3000,
           NODE_ENV: 'test',
           DATABASE_URL: e2eDatabaseUrl,
+          DATABASE_SCHEMA: e2eSchemaName,
           JWT_PRIVATE_KEY: jwtKeys.privateKey,
           JWT_PUBLIC_KEY: jwtKeys.publicKey,
           JWT_ACCESS_TOKEN_EXPIRES_IN: '15m',

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

@@ -2,7 +2,7 @@ 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';
+import { e2eDatabaseUrl, e2eSchemaName } from '@/test/e2e-context';
 
 @Module({
   imports: [
@@ -14,6 +14,7 @@ import { e2eDatabaseUrl } from '@/test/e2e-context';
           PORT: 3000,
           NODE_ENV: 'test',
           DATABASE_URL: e2eDatabaseUrl,
+          DATABASE_SCHEMA: e2eSchemaName,
         }),
     }),
     PersonModule,

package/koala-nest/src/test/e2e-context.ts

@@ -1,7 +1,10 @@
 export let e2eDatabaseUrl: string | undefined;
+export let e2eSchemaName: string | undefined;
 
-export function setE2EDatabaseUrl(url: string) {
+export function setE2EDatabaseContext(url: string, schemaName: string) {
   e2eDatabaseUrl = url;
+  e2eSchemaName = schemaName;
   process.env.DATABASE_URL = url;
+  process.env.DATABASE_SCHEMA = schemaName;
   process.env.NODE_ENV = 'test';
 }

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

@@ -10,11 +10,13 @@ import { IPersonRepository } from '@/domain/repositories/iperson.repository';
 import { Test, TestingModule } from '@nestjs/testing';
 
 /**
- * Valida carregamento explícito de relacionamentos no repositório.
- * - findById: relations { address, contacts }
- * - findMany: sem relations (listagem leve; contacts normalizado como [])
+ * Testes E2E do RepositoryBase - Lazy Loading
+ *
+ * Valida o carregamento de relacionamentos por cenário:
+ * - findById: carrega address e contacts (detalhe da entidade)
+ * - findMany: retorna apenas dados escalares (performance em listagens)
  */
-describe('PersonRepository - Relations (E2E)', () => {
+describe('RepositoryBase - Lazy Loading (E2E)', () => {
   let moduleRef: TestingModule;
 
   beforeAll(async () => {
@@ -23,8 +25,8 @@ describe('PersonRepository - Relations (E2E)', () => {
     }).compile();
   });
 
-  describe('findById - relations explícitas', () => {
-    it('should load person with address and contacts using findById', async () => {
+  describe('findById - Carregamento de Relacionamentos', () => {
+    it('should load person with all relationships using findById', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
       const created = await createHandler.handle({
         name: 'João Silva',
@@ -51,10 +53,30 @@ describe('PersonRepository - Relations (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 - listagem sem relations', () => {
-    it('should return persons without loading relations in findMany', async () => {
+  describe('findMany - Listagem sem Relacionamentos', () => {
+    it('should return persons without loading relationships in findMany', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
 
       for (let i = 0; i < 2; i++) {
@@ -76,11 +98,12 @@ describe('PersonRepository - Relations (E2E)', () => {
       const person = items[0];
       expect(person.id).toBeDefined();
       expect(person.name).toBeDefined();
+      expect(person.active).toBeDefined();
       expect(person.address).toBeUndefined();
-      expect(person.contacts ?? []).toHaveLength(0);
+      expect(person.contacts).toBeUndefined();
     });
 
-    it('should list via handler without requiring relations on entities', async () => {
+    it('should load multiple persons efficiently', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
 
       const createdIds: number[] = [];
@@ -95,6 +118,8 @@ describe('PersonRepository - Relations (E2E)', () => {
         createdIds.push(result.id);
       }
 
+      expect(createdIds.length).toBe(3);
+
       const readManyHandler = moduleRef.get(ReadManyPersonHandler);
       const result = await readManyHandler.handle(new ReadManyPersonRequest());
 
@@ -105,15 +130,24 @@ describe('PersonRepository - Relations (E2E)', () => {
       createdIds.forEach((id) => {
         expect(returnedIds).toContain(id);
       });
+
+      result.items.forEach((person) => {
+        expect(person.id).toBeDefined();
+        expect(person.name).toBeDefined();
+        expect(person.active).toBeDefined();
+      });
     });
   });
 
-  describe('findById vs findMany', () => {
-    it('findById carrega relations; findMany retorna entidade leve', async () => {
+  describe('Comparação entre findById e findMany', () => {
+    it('should load relationships only in findById', async () => {
       const createHandler = moduleRef.get(CreatePersonHandler);
       const created = await createHandler.handle({
         name: 'Comparação Test',
-        contacts: [{ contact: 'first@example.com' }],
+        contacts: [
+          { contact: 'first@example.com' },
+          { contact: 'second@example.com' },
+        ],
         address: {
           address: 'Rua Comparação, 789',
         },
@@ -131,11 +165,13 @@ describe('PersonRepository - Relations (E2E)', () => {
       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).toBeUndefined();
-      expect(personFromFindMany?.contacts ?? []).toHaveLength(0);
+      expect(personFromFindMany?.contacts).toBeUndefined();
     });
   });
 });

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

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