@koalarx/nest 3.1.50 → 4.0.1

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

@@ -0,0 +1,66 @@
+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();
+  }
+
+  private createSession(idleTimeout?: number) {
+    return new Pool({
+      connectionString: this.baseUrl.toString(),
+      ...(idleTimeout ? { idleTimeoutMillis: idleTimeout } : {}),
+    });
+  }
+
+  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> {
+    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();
+  }
+}
+
+const { client } = await createE2EDatabase(E2EPostgresClient);
+export const pgClient = client;
+
+afterAll(async () => {
+  await pgClient.dropDatabase();
+});

package/koala-nest/src/test/setup.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

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

@@ -0,0 +1,24 @@
+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,
+  });
+
+  const { httpAdapter } = app.get(HttpAdapterHost);
+  const loggingService = app.get(ILoggingService);
+  app.useGlobalFilters(new ErrorsFilter(httpAdapter, loggingService));
+}
+
+export async function initTestApp(app: INestApplication) {
+  await app.init();
+  return app;
+}

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

@@ -0,0 +1,50 @@
+import { Type } from '@nestjs/common';
+import { execSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { setE2EDatabaseUrl } from '../e2e-context';
+import { E2EDatabaseClient } from './e2e-database-client';
+
+function generateUniqueDatabaseURL() {
+  const schemaId = randomUUID();
+
+  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,
+  };
+}
+
+export async function createE2EDatabase<T extends E2EDatabaseClient>(
+  clientInstance: Type<T>,
+) {
+  const { url, schemaId } = generateUniqueDatabaseURL();
+
+  setE2EDatabaseUrl(url);
+
+  try {
+    const client = new clientInstance(url, schemaId);
+
+    await client.createDatabase(schemaId);
+
+    const env = { ...process.env, DATABASE_URL: url, NODE_ENV: 'test' };
+    execSync(
+      'bun ./node_modules/typeorm/cli.js migration:run -d ./src/infra/database/migrations/migration-datasource.ts',
+      {
+        cwd: process.cwd(),
+        env,
+        stdio: 'inherit',
+      },
+    );
+
+    return { client, schemaId };
+  } catch (error) {
+    console.error('Erro ao criar banco de dados e2e:', error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,9 @@
+export abstract class E2EDatabaseClient {
+  constructor(
+    protected readonly url: string,
+    protected readonly schemaName: string,
+  ) {}
+
+  abstract createDatabase(schemaName: string): Promise<void>;
+  abstract dropDatabase(): Promise<void>;
+}

package/koala-nest/src/test/utils/guard-test-context.ts

@@ -0,0 +1,28 @@
+import { ExecutionContext } from '@nestjs/common';
+
+export function createGuardContext<TUser extends object>(options: {
+  user?: TUser;
+  metadata?: Record<string, unknown>;
+  metadataKey?: string;
+}) {
+  const handler = () => undefined;
+
+  if (options.metadataKey && options.metadata) {
+    Reflect.defineMetadata(
+      options.metadataKey,
+      options.metadata[options.metadataKey],
+      handler,
+    );
+  }
+
+  return {
+    handler,
+    context: {
+      getHandler: () => handler,
+      getClass: () => class {},
+      switchToHttp: () => ({
+        getRequest: () => ({ user: options.user }),
+      }),
+    } as unknown as ExecutionContext,
+  };
+}

package/koala-nest/src/test/utils/jwt-test-keys.ts

@@ -0,0 +1,27 @@
+import { generateKeyPairSync } from 'node:crypto';
+
+type JwtTestKeys = {
+  privateKey: string;
+  publicKey: string;
+};
+
+let cachedKeys: JwtTestKeys | null = null;
+
+export function getJwtTestKeys(): JwtTestKeys {
+  if (cachedKeys) {
+    return cachedKeys;
+  }
+
+  const pair = generateKeyPairSync('rsa', {
+    modulusLength: 2048,
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+  });
+
+  cachedKeys = {
+    privateKey: Buffer.from(pair.privateKey).toString('base64'),
+    publicKey: Buffer.from(pair.publicKey).toString('base64'),
+  };
+
+  return cachedKeys;
+}

package/koala-nest/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "exclude": ["node_modules", "dist", "**/*spec.ts", "src/test"]
+}

package/koala-nest/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false,
+    "types": ["bun-types"],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@cli/*": [
+        "../cli/*"
+      ]
+    }
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/koala-nest/tsconfig.spec.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["bun-types"]
+  },
+  "include": [
+    "src/test/bun-test-globals.d.ts",
+    "src/test/**/*.ts"
+  ],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -1,36 +1,26 @@
 {
   "name": "@koalarx/nest",
-  "version": "3.1.50",
-  "description": "",
-  "author": "Igor D. Rangel",
+  "version": "4.0.1",
+  "description": "CLI para criar APIs NestJS com arquitetura DDD — copia módulos prontos para o seu repositório.",
   "license": "MIT",
-  "engines": {
-    "bun": ">=1.0.0"
+  "type": "module",
+  "bin": {
+    "kl-nest": "./cli/index.js"
   },
-  "peerDependencies": {
-    "@nestjs/common": "^11.0.12",
-    "@nestjs/core": "^11.0.12",
-    "@nestjs/platform-express": "^11.0.12",
-    "reflect-metadata": "^0.1.13"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/igordrangel/koala-nest.git"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "cli",
+    "koala-nest",
+    "README.md"
+  ],
   "dependencies": {
-    "@koalarx/utils": "^4.2.1",
-    "@nestjs/config": "^4.0.1",
-    "@nestjs/mapped-types": "^2.1.0",
-    "@nestjs/passport": "^11.0.5",
-    "@nestjs/swagger": "^11.0.7",
-    "@prisma/adapter-pg": "^7.2.0",
-    "@prisma/client": "^7.2.0",
-    "@scalar/nestjs-api-reference": "^1.0.24",
-    "consola": "^3.4.2",
-    "dotenv": "^16.0.3",
-    "express-basic-auth": "^1.2.1",
-    "ioredis": "^5.3.2",
-    "passport": "^0.7.0",
-    "passport-custom": "^1.1.1",
-    "pg": "^8.11.3",
-    "rimraf": "^3.0.2",
-    "zod": "^3.22.4",
-    "zod-validation-error": "^1.5.0"
+    "@clack/prompts": "^1.5.1",
+    "picocolors": "^1.1.1"
   }
-}
+}

package/core/backgroud-services/cron-service/cron-job.handler.base.d.ts

@@ -1,16 +0,0 @@
-import { ILoggingService } from '../../../services/logging/ilogging.service';
-import { IRedLockService } from '../../../services/redlock/ired-lock.service';
-import { RequestResult } from '../../request-overflow/request-result';
-export type CronJobResponse = RequestResult<Error, null>;
-export interface CronJobSettings {
-    isActive: boolean;
-    timeInMinutes: number;
-}
-export declare abstract class CronJobHandlerBase {
-    private readonly redlockService;
-    private readonly loggingService;
-    constructor(redlockService: IRedLockService, loggingService: ILoggingService);
-    protected abstract run(): Promise<CronJobResponse>;
-    protected abstract settings(): Promise<CronJobSettings>;
-    start(): Promise<void>;
-}

package/core/backgroud-services/cron-service/cron-job.handler.base.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CronJobHandlerBase = void 0;
-const KlDelay_1 = require("@koalarx/utils/KlDelay");
-const koala_global_vars_1 = require("../../koala-global-vars");
-class CronJobHandlerBase {
-    redlockService;
-    loggingService;
-    constructor(redlockService, loggingService) {
-        this.redlockService = redlockService;
-        this.loggingService = loggingService;
-    }
-    async start() {
-        const name = this.constructor.name;
-        while (true) {
-            const settings = await this.settings();
-            const timeout = settings.timeInMinutes * 60 * 1000;
-            if (settings.isActive) {
-                const ttlSecondsLock = timeout / 1000;
-                const acquiredLock = await this.redlockService.acquiredLock(name, ttlSecondsLock);
-                if (acquiredLock) {
-                    const error = await this.run()
-                        .then((result) => {
-                        if (result.isFailure()) {
-                            return result.value;
-                        }
-                        return null;
-                    })
-                        .catch((error) => error);
-                    if (error) {
-                        try {
-                            await this.loggingService.report({
-                                error,
-                                packageName: koala_global_vars_1.KoalaGlobalVars.appName,
-                                loggedUsername: koala_global_vars_1.KoalaGlobalVars.internalUserName,
-                            });
-                        }
-                        catch {
-                            console.error(error);
-                        }
-                    }
-                }
-            }
-            await (0, KlDelay_1.delay)(timeout);
-            await this.redlockService.releaseLock(name);
-        }
-    }
-}
-exports.CronJobHandlerBase = CronJobHandlerBase;

package/core/backgroud-services/event-service/event-class.d.ts

@@ -1,5 +0,0 @@
-export declare abstract class EventClass<TEntity = any> {
-    data?: TEntity | undefined;
-    ocurredAt: Date;
-    constructor(data?: TEntity | undefined);
-}

package/core/backgroud-services/event-service/event-class.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventClass = void 0;
-class EventClass {
-    data;
-    ocurredAt = new Date();
-    constructor(data) {
-        this.data = data;
-    }
-}
-exports.EventClass = EventClass;

package/core/backgroud-services/event-service/event-handler.base.d.ts

@@ -1,8 +0,0 @@
-import { Type } from '@nestjs/common';
-import { EventClass } from './event-class';
-export declare abstract class EventHandlerBase {
-    readonly event: Type<EventClass>;
-    constructor(event: Type<EventClass>);
-    setupSubscriptions(): void;
-    abstract handleEvent(event: InstanceType<this['event']>): Promise<void>;
-}

package/core/backgroud-services/event-service/event-handler.base.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventHandlerBase = void 0;
-const event_queue_1 = require("./event-queue");
-class EventHandlerBase {
-    event;
-    constructor(event) {
-        this.event = event;
-    }
-    setupSubscriptions() {
-        event_queue_1.EventQueue.register(this.handleEvent.bind(this), this.constructor.name, this.event.name);
-    }
-}
-exports.EventHandlerBase = EventHandlerBase;

package/core/backgroud-services/event-service/event-is-trigger.d.ts

@@ -1,3 +0,0 @@
-export declare class EventIsTrigger {
-    isTrigger(): void;
-}

package/core/backgroud-services/event-service/event-is-trigger.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventIsTrigger = void 0;
-class EventIsTrigger {
-    isTrigger() { }
-}
-exports.EventIsTrigger = EventIsTrigger;

package/core/backgroud-services/event-service/event-job.d.ts

@@ -1,13 +0,0 @@
-import { Type } from '@nestjs/common';
-import { EventClass } from './event-class';
-import { EventHandlerBase } from './event-handler.base';
-import { EventQueue } from './event-queue';
-export declare abstract class EventJob<TEntity> {
-    _id: `${string}-${string}-${string}-${string}-${string}`;
-    private _eventQueue;
-    constructor();
-    abstract defineHandlers(): Array<Type<EventHandlerBase>>;
-    get eventQueue(): EventQueue[];
-    clearQueue(): void;
-    addEvent(event: EventClass<TEntity>): void;
-}

package/core/backgroud-services/event-service/event-job.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventJob = void 0;
-const event_queue_1 = require("./event-queue");
-const node_crypto_1 = require("node:crypto");
-class EventJob {
-    _id = (0, node_crypto_1.randomUUID)();
-    _eventQueue = [];
-    constructor() { }
-    get eventQueue() {
-        return this._eventQueue;
-    }
-    clearQueue() {
-        this._eventQueue = [];
-    }
-    addEvent(event) {
-        this.eventQueue.push(event);
-        event_queue_1.EventQueue.markAggregateForDispatch(this);
-    }
-}
-exports.EventJob = EventJob;

package/core/backgroud-services/event-service/event-queue.d.ts

@@ -1,18 +0,0 @@
-import { IComparableId } from '../../../core/utils/interfaces/icomparable';
-import { EventJob } from './event-job';
-type EventJobCallback = (event: any) => void;
-export declare class EventQueue {
-    private static handlersMap;
-    private static markedAggregates;
-    static markAggregateForDispatch(aggregate: EventJob<any>): void;
-    static dispatchEventsForAggregate(id: IComparableId): void;
-    static register(callback: EventJobCallback, handlerClassName: string, eventClassName: string): void;
-    static clearHandlers(): void;
-    static clearMarkedAggregates(): void;
-    static findMarkedAggregateByID(id: IComparableId): EventJob<any> | undefined;
-    static getMarkedAggregates(): EventJob<any>[];
-    private static dispatchAggregateEvents;
-    private static removeAggregateFromMarkedDispatchList;
-    private static dispatch;
-}
-export {};

package/core/backgroud-services/event-service/event-queue.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventQueue = void 0;
-class EventQueue {
-    static handlersMap = {};
-    static markedAggregates = [];
-    static markAggregateForDispatch(aggregate) {
-        const aggregateFound = !!this.findMarkedAggregateByID(aggregate._id);
-        if (!aggregateFound) {
-            this.markedAggregates.push(aggregate);
-        }
-    }
-    static dispatchEventsForAggregate(id) {
-        const aggregate = this.findMarkedAggregateByID(id);
-        if (aggregate) {
-            this.dispatchAggregateEvents(aggregate);
-            aggregate.clearQueue();
-            this.removeAggregateFromMarkedDispatchList(aggregate);
-        }
-    }
-    static register(callback, handlerClassName, eventClassName) {
-        const wasEventRegisteredBefore = handlerClassName in this.handlersMap;
-        if (!wasEventRegisteredBefore) {
-            this.handlersMap[handlerClassName] = [];
-        }
-        this.handlersMap[handlerClassName].push({
-            eventClassName,
-            callback,
-        });
-    }
-    static clearHandlers() {
-        this.handlersMap = {};
-    }
-    static clearMarkedAggregates() {
-        this.markedAggregates = [];
-    }
-    static findMarkedAggregateByID(id) {
-        return this.markedAggregates.find((aggregate) => aggregate._id === id);
-    }
-    static getMarkedAggregates() {
-        return this.markedAggregates;
-    }
-    static dispatchAggregateEvents(aggregate) {
-        aggregate.eventQueue.forEach((event) => this.dispatch(event));
-    }
-    static removeAggregateFromMarkedDispatchList(aggregate) {
-        const index = this.markedAggregates.findIndex((a) => a._id === aggregate._id);
-        this.markedAggregates.splice(index, 1);
-    }
-    static dispatch(event) {
-        const eventJobHandlers = this.markedAggregates.find((a) => a.eventQueue.find((e) => e === event));
-        const eventHandler = Object.keys(this.handlersMap).find((handlerName) => eventJobHandlers
-            ?.defineHandlers()
-            .find((handler) => handler.name === handlerName &&
-            this.handlersMap[handler.name].some((job) => job.eventClassName === event.constructor.name)));
-        const isEventRegistered = !!eventHandler;
-        if (isEventRegistered) {
-            const jobs = this.handlersMap[eventHandler];
-            for (const job of jobs) {
-                job.callback(event);
-            }
-        }
-    }
-}
-exports.EventQueue = EventQueue;

package/core/constants/query-params.d.ts

@@ -1,6 +0,0 @@
-import type { QueryDirectionType } from '..';
-export declare const QUERY_FILTER_PARAMS: {
-    direction: QueryDirectionType;
-    page: number;
-    limit: number;
-};

package/core/constants/query-params.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUERY_FILTER_PARAMS = void 0;
-exports.QUERY_FILTER_PARAMS = {
-    direction: 'asc',
-    page: 0,
-    limit: 30,
-};

package/core/controllers/base.controller.d.ts

@@ -1,4 +0,0 @@
-import { Response as HttpResponse } from 'express';
-export declare abstract class IController<Request, Response, Params = any> {
-    abstract handle(request: Request, params?: Params, response?: HttpResponse): Promise<Response>;
-}

package/core/controllers/base.controller.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IController = void 0;
-class IController {
-}
-exports.IController = IController;

package/core/controllers/controller.decorator.d.ts

@@ -1,2 +0,0 @@
-import { RouterConfigBase } from './router-config.base';
-export declare function Controller(config: RouterConfigBase): (target: any) => void;

package/core/controllers/controller.decorator.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = Controller;
-const common_1 = require("@nestjs/common");
-const swagger_1 = require("@nestjs/swagger");
-function Controller(config) {
-    return function (target) {
-        (0, common_1.Controller)(config.group)(target);
-        (0, swagger_1.ApiTags)(config.tag)(target);
-    };
-}

package/core/controllers/created-registre-response.base.d.ts

@@ -1,10 +0,0 @@
-import { IComparableId } from '../../core/utils/interfaces/icomparable';
-export declare abstract class CreatedRegistreResponseBase<TId = IComparableId> {
-    id: TId;
-}
-export declare abstract class CreatedRegistreWithUUIDResponse extends CreatedRegistreResponseBase<string> {
-    id: string;
-}
-export declare abstract class CreatedRegistreWithIdResponse extends CreatedRegistreResponseBase<number> {
-    id: number;
-}