@koalarx/nest 1.18.3 → 1.18.5

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

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

package/core/controllers/pagination.request.d.ts

@@ -1,4 +1,4 @@
-import { QueryDirectionType } from '..';
+import type { QueryDirectionType } from '..';
 export type PaginatedRequestProps<T extends PaginationRequest> = Omit<{
     [K in keyof T as T[K] extends Function ? never : K]: T[K];
 }, '_id'>;

package/core/database/prisma-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function setPrismaClient(prismaClientClass: any): void;
+export declare function getPrismaClientClass(): any;

package/core/database/prisma-resolver.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrismaClient = setPrismaClient;
+exports.getPrismaClientClass = getPrismaClientClass;
+const path = require("path");
+const fs = require("fs");
+let cachedPrismaClient = null;
+function findPrismaClient() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'prisma/generated/client.js'),
+        path.join(__dirname, '../../../../../prisma/generated/client.js'),
+        path.join(process.cwd(), 'prisma/generated/client.ts'),
+        path.join(__dirname, '../../../../../prisma/generated/client.ts'),
+        ...(require.main?.filename
+            ? [
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.js'),
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.ts'),
+            ]
+            : []),
+    ];
+    for (const prismaPath of possiblePaths) {
+        if (fs.existsSync(prismaPath)) {
+            return prismaPath;
+        }
+    }
+    return null;
+}
+async function resolvePrismaClient() {
+    if (cachedPrismaClient) {
+        return cachedPrismaClient;
+    }
+    const prismaPath = findPrismaClient();
+    if (!prismaPath) {
+        throw new Error(`
+      Não foi possível carregar o Prisma Client automaticamente.
+      
+      Certifique-se de que você:
+      1. Executou 'bunx prisma generate' no seu projeto
+      2. Tem a pasta 'prisma/generated/client' no seu projeto
+      3. A lib @koalarx/nest está instalada como dependência
+      
+      Se o problema persistir, você pode registrar manualmente o Prisma Client:
+      
+      import { setPrismaClient } from '@koalarx/nest'
+      import { PrismaClient } from './prisma/generated/client'
+      
+      setPrismaClient(PrismaClient)
+      `.trim());
+    }
+    try {
+        const module = await Promise.resolve(`${prismaPath}`).then(s => require(s));
+        cachedPrismaClient = module.PrismaClient || module.default || module;
+        return cachedPrismaClient;
+    }
+    catch (error) {
+        throw new Error(`
+      Erro ao carregar o Prisma Client de ${prismaPath}:
+      ${error instanceof Error ? error.message : String(error)}
+      
+      Certifique-se de que 'bunx prisma generate' foi executado com sucesso.
+      `.trim());
+    }
+}
+let manualPrismaClient = null;
+function setPrismaClient(prismaClientClass) {
+    manualPrismaClient = prismaClientClass;
+    cachedPrismaClient = null;
+}
+function getPrismaClientClass() {
+    if (manualPrismaClient) {
+        return manualPrismaClient;
+    }
+    return resolvePrismaClient();
+}

package/core/database/prisma.service.d.ts

@@ -1,17 +1,25 @@
 import { EnvService } from '@koalarx/nest/env/env.service';
 import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
 import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
-import { Prisma, PrismaClient } from 'prisma/generated/client';
-import { PrismaClientOptions } from 'prisma/generated/internal/prismaNamespace';
+import type { Prisma } from 'prisma/generated/client';
+import type { PrismaClientOptions } from 'prisma/generated/internal/prismaNamespace';
 export declare function setPrismaClientOptions(options: PrismaClientOptions): void;
-export declare class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction {
+export declare class PrismaService implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction {
     private readonly env;
+    private prismaInstance;
     constructor(env: EnvService);
-    onModuleInit(): Promise<void>;
-    onModuleDestroy(): Promise<void>;
+    initialize(): Promise<void>;
+    onModuleInit(): Promise<any>;
+    onModuleDestroy(): any;
     withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
         maxWait?: number;
         timeout?: number;
         isolationLevel?: Prisma.TransactionIsolationLevel;
     }): Promise<F>;
+    [Symbol.toPrimitive](): any;
+    toString(): string;
+    get $connect(): any;
+    get $disconnect(): any;
+    get $transaction(): any;
+    get $on(): any;
 }

package/core/database/prisma.service.js

@@ -13,37 +13,89 @@ exports.PrismaService = void 0;
 exports.setPrismaClientOptions = setPrismaClientOptions;
 const env_service_1 = require("../../env/env.service");
 const common_1 = require("@nestjs/common");
-const client_1 = require("../../../../../prisma/generated/client");
+const prisma_resolver_1 = require("./prisma-resolver");
 let globalPrismaOptions = {};
 function setPrismaClientOptions(options) {
     globalPrismaOptions = options;
 }
-let PrismaService = class PrismaService extends client_1.PrismaClient {
+let PrismaClientClass = null;
+async function loadPrismaClient() {
+    if (!PrismaClientClass) {
+        PrismaClientClass = await (0, prisma_resolver_1.getPrismaClientClass)();
+    }
+    return PrismaClientClass;
+}
+let PrismaService = class PrismaService {
     env;
+    prismaInstance;
     constructor(env) {
-        super({
+        this.env = env;
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (prop in target) {
+                    const value = Reflect.get(target, prop, receiver);
+                    if (typeof value === 'function') {
+                        return value.bind(target);
+                    }
+                    return value;
+                }
+                if (target.prismaInstance && typeof prop === 'string') {
+                    const value = target.prismaInstance[prop];
+                    if (typeof value === 'function') {
+                        return value.bind(target.prismaInstance);
+                    }
+                    return value;
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    async initialize() {
+        const PrismaClientType = await loadPrismaClient();
+        this.prismaInstance = new PrismaClientType({
             log: [{ emit: 'event', level: 'query' }],
             ...globalPrismaOptions,
         });
-        this.env = env;
     }
     async onModuleInit() {
+        await this.initialize();
         if (this.env.get('PRISMA_QUERY_LOG')) {
-            this.$on('query', async (e) => {
+            this.prismaInstance?.$on?.('query', async (e) => {
                 console.log(`${e.query} ${e.params}`);
             });
         }
-        return this.$connect();
+        return this.prismaInstance?.$connect?.();
     }
     onModuleDestroy() {
-        return this.$disconnect();
+        return this.prismaInstance?.$disconnect?.();
     }
-    withTransaction(fn, options) {
-        return this.$transaction(fn, options ?? {
+    async withTransaction(fn, options) {
+        return this.prismaInstance?.$transaction?.(fn, options ?? {
             maxWait: 20000,
             timeout: 20000,
         });
     }
+    [Symbol.toPrimitive]() {
+        return this.prismaInstance;
+    }
+    toString() {
+        return '[PrismaService]';
+    }
+    get $connect() {
+        return this.prismaInstance?.$connect?.bind(this.prismaInstance);
+    }
+    get $disconnect() {
+        return this.prismaInstance?.$disconnect?.bind(this.prismaInstance);
+    }
+    get $transaction() {
+        return this.prismaInstance?.$transaction?.bind(this.prismaInstance);
+    }
+    get $on() {
+        return this.prismaInstance?.$on?.bind(this.prismaInstance);
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.prismaInstance;
+    }
 };
 exports.PrismaService = PrismaService;
 exports.PrismaService = PrismaService = __decorate([

package/core/dtos/pagination.dto.d.ts

@@ -1,4 +1,4 @@
-import { QueryDirectionType } from '..';
+import type { QueryDirectionType } from '..';
 export declare class PaginationDto {
     page?: number;
     limit?: number;

package/core/index.d.ts

@@ -14,3 +14,5 @@ export type FileResponse = {
     base64: string;
 };
 export type QueryDirectionType = 'asc' | 'desc';
+export { setPrismaClient } from './database/prisma-resolver';
+export { setPrismaClientOptions } from './database/prisma.service';

package/core/index.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrismaClientOptions = exports.setPrismaClient = void 0;
+var prisma_resolver_1 = require("./database/prisma-resolver");
+Object.defineProperty(exports, "setPrismaClient", { enumerable: true, get: function () { return prisma_resolver_1.setPrismaClient; } });
+var prisma_service_1 = require("./database/prisma.service");
+Object.defineProperty(exports, "setPrismaClientOptions", { enumerable: true, get: function () { return prisma_service_1.setPrismaClientOptions; } });

package/core/koala-app.d.ts

@@ -42,6 +42,8 @@ export declare class KoalaApp {
     private _ngrokKey;
     private _ngrokUrl;
     constructor(app: INestApplication<any>);
+    private showListeningMessage;
+    private startJobs;
     addGlobalGuard(Guard: Type<CanActivate>): this;
     addCronJob(job: CronJobClass): this;
     addEventJob(eventJob: EventJobClass): this;
@@ -58,6 +60,5 @@ export declare class KoalaApp {
     build(): Promise<INestApplication<any>>;
     serve(host?: string): Promise<void>;
     buildAndServe(host?: string): Promise<void>;
-    private showListeningMessage;
 }
 export {};

package/core/koala-app.js

@@ -16,6 +16,7 @@ const ilogging_service_1 = require("../services/logging/ilogging.service");
 const koala_global_vars_1 = require("./koala-global-vars");
 const env_config_1 = require("./utils/env.config");
 const instanciate_class_with_dependencies_injection_1 = require("./utils/instanciate-class-with-dependencies-injection");
+const utils_1 = require("@koalarx/utils");
 class KoalaApp {
     app;
     _globalExceptionFilter;
@@ -39,6 +40,32 @@ class KoalaApp {
         this._domainExceptionFilter = new domain_errors_filter_1.DomainErrorsFilter(loggingService);
         this._zodExceptionFilter = new zod_errors_filter_1.ZodErrorsFilter(loggingService);
     }
+    showListeningMessage(port, host = 'localhost') {
+        const envService = this.app.get(env_service_1.EnvService);
+        console.log('------------------------------');
+        if (this._apiReferenceEndpoint) {
+            consola.info('API Reference:', `http://${host}:${port}${this._apiReferenceEndpoint}`);
+        }
+        consola.info('Health Check:', `http://${host}:${port}/health`);
+        consola.info('Internal Host:', `http://${host}:${port}`);
+        if (this._ngrokUrl) {
+            consola.info('External Host:', this._ngrokUrl);
+            consola.info('External Inspect:', `http://${host}:4040/inspect/http`);
+        }
+        consola.box('Environment:', envService.get('NODE_ENV'));
+        console.log('------------------------------');
+    }
+    async startJobs() {
+        await (0, utils_1.delay)(5000);
+        const cronJobs = await Promise.all(this._cronJobs.map((job) => this.app.resolve(job)));
+        for (const cronJob of cronJobs) {
+            cronJob.start();
+        }
+        const eventJobs = await Promise.all(this._eventJobs.map((job) => this.app.resolve(job)));
+        for (const eventJob of eventJobs) {
+            eventJob.setupSubscriptions();
+        }
+    }
     addGlobalGuard(Guard) {
         this._guards.push((0, instanciate_class_with_dependencies_injection_1.instanciateClassWithDependenciesInjection)(this.app, Guard));
         return this;
@@ -194,14 +221,6 @@ class KoalaApp {
             this.app.useGlobalFilters(this._prismaValidationExceptionFilter);
         }
         this.app.useGlobalFilters(this._globalExceptionFilter, this._domainExceptionFilter, this._zodExceptionFilter);
-        const cronJobs = await Promise.all(this._cronJobs.map((job) => this.app.resolve(job)));
-        for (const cronJob of cronJobs) {
-            cronJob.start();
-        }
-        const eventJobs = await Promise.all(this._eventJobs.map((job) => this.app.resolve(job)));
-        for (const eventJob of eventJobs) {
-            eventJob.setupSubscriptions();
-        }
         for (const guard of this._guards) {
             this.app.useGlobalGuards(guard);
         }
@@ -217,6 +236,7 @@ class KoalaApp {
                 this._ngrokUrl = url;
             });
         }
+        this.startJobs();
         return this.app;
     }
     async serve(host) {
@@ -228,20 +248,5 @@ class KoalaApp {
         await this.build();
         await this.serve(host);
     }
-    showListeningMessage(port, host = 'localhost') {
-        const envService = this.app.get(env_service_1.EnvService);
-        console.log('------------------------------');
-        if (this._apiReferenceEndpoint) {
-            consola.info('API Reference:', `http://${host}:${port}${this._apiReferenceEndpoint}`);
-        }
-        consola.info('Health Check:', `http://${host}:${port}/health`);
-        consola.info('Internal Host:', `http://${host}:${port}`);
-        if (this._ngrokUrl) {
-            consola.info('External Host:', this._ngrokUrl);
-            consola.info('External Inspect:', `http://${host}:4040/inspect/http`);
-        }
-        consola.box('Environment:', envService.get('NODE_ENV'));
-        console.log('------------------------------');
-    }
 }
 exports.KoalaApp = KoalaApp;

package/core/mapping/auto-mapping-list.d.ts

@@ -10,6 +10,7 @@ interface AutoMappingGetContext {
 export declare class AutoMappingList {
     private static _mappedPropList;
     private static _mappingProfileList;
+    private static initializeLists;
     static add(source: Type<any>, target: Type<any>, ...forMember: ForMemberDefinition<any, any>): void;
     static get(source: Type<any>, target: Type<any>): AutoMappingGetContext;
     static getSourceByName(sourceName: string): Type<any> | undefined;

package/core/mapping/auto-mapping-list.js

@@ -6,9 +6,18 @@ const auto_mapping_class_context_1 = require("./auto-mapping-class-context");
 const auto_mapping_context_1 = require("./auto-mapping-context");
 const find_on_list_1 = require("../utils/find-on-list");
 class AutoMappingList {
-    static _mappedPropList = new list_1.List(auto_mapping_class_context_1.AutoMappingClassContext);
-    static _mappingProfileList = new list_1.List(auto_mapping_context_1.AutoMappingContext);
+    static _mappedPropList;
+    static _mappingProfileList;
+    static initializeLists() {
+        if (!this._mappedPropList) {
+            this._mappedPropList = new list_1.List(auto_mapping_class_context_1.AutoMappingClassContext);
+        }
+        if (!this._mappingProfileList) {
+            this._mappingProfileList = new list_1.List(auto_mapping_context_1.AutoMappingContext);
+        }
+    }
     static add(source, target, ...forMember) {
+        this.initializeLists();
         this._mappingProfileList.add(new auto_mapping_context_1.AutoMappingContext(source, target, forMember));
         this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(source));
         this._mappedPropList.add(new auto_mapping_class_context_1.AutoMappingClassContext(target));
@@ -16,6 +25,7 @@ class AutoMappingList {
         this.addExtendedPropsIntoSubClass(target);
     }
     static get(source, target) {
+        this.initializeLists();
         return {
             mapContext: (0, find_on_list_1.findOnList)(this._mappingProfileList, (mp) => mp.source.name === source.name && mp.target.name === target.name, (mp) => Object.getPrototypeOf(mp.source.prototype.constructor) === source &&
                 mp.target.name === target.name),
@@ -24,22 +34,23 @@ class AutoMappingList {
         };
     }
     static getSourceByName(sourceName) {
+        this.initializeLists();
         return this._mappedPropList.find((mp) => mp.source.name === sourceName)
             ?.source;
     }
     static getPropDefinitions(source, propName) {
-        return this._mappedPropList
-            .find((mp) => mp.source.name === source.name)
-            ?.props.find((prop) => prop.name === propName);
+        this.initializeLists();
+        return this._mappedPropList.find((mp) => mp.source.name === source.name)?.props.find((prop) => prop.name === propName);
     }
     static getTargets(source) {
-        return this._mappingProfileList
-            .filter((mp) => mp.source.name === source.name ||
+        this.initializeLists();
+        return this._mappingProfileList.filter((mp) => mp.source.name === source.name ||
             Object.getPrototypeOf(mp.source.prototype.constructor) === source)
             .map((mp) => mp.target)
             .toArray();
     }
     static addMappedProp(source, propName) {
+        this.initializeLists();
         let mappedClass = this._mappedPropList.find((mp) => mp.source.name === source.name);
         if (!mappedClass) {
             mappedClass = new auto_mapping_class_context_1.AutoMappingClassContext(source);
@@ -61,6 +72,7 @@ class AutoMappingList {
         });
     }
     static addExtendedPropsIntoSubClass(source) {
+        this.initializeLists();
         const mappedExtendedClass = this._mappedPropList.find((mp) => mp.source === Object.getPrototypeOf(source.prototype.constructor));
         if (mappedExtendedClass) {
             const mappedClass = this._mappedPropList.find((mp) => mp.source.name === source.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "1.18.3",
+  "version": "1.18.5",
   "description": "",
   "repository": {
     "type": "git",

package/test/utils/create-e2e-database.d.ts

@@ -1,2 +1,2 @@
 import 'dotenv/config';
-export declare function createE2EDatabase(): `${string}-${string}-${string}-${string}-${string}`;
+export declare function createE2EDatabase(runtime?: 'node' | 'bun'): Promise<`${string}-${string}-${string}-${string}-${string}`>;

package/test/utils/create-e2e-database.js

@@ -4,6 +4,7 @@ exports.createE2EDatabase = createE2EDatabase;
 require("dotenv/config");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
+const pg_1 = require("pg");
 function generateUniqueDatabaseURL() {
     const schemaId = (0, node_crypto_1.randomUUID)();
     if (!process.env.DATABASE_URL) {
@@ -16,11 +17,31 @@ function generateUniqueDatabaseURL() {
         schemaId,
     };
 }
-function createE2EDatabase() {
+async function createE2EDatabase(runtime = 'node') {
     const { url, schemaId } = generateUniqueDatabaseURL();
     process.env.DATABASE_URL = url;
     process.env.DIRECT_URL = url;
     process.env.PRISMA_SCHEMA_DISABLE_ADVISORY_LOCK = 'true';
-    (0, node_child_process_1.execSync)('npx prisma migrate deploy', {});
+    try {
+        const baseUrl = new URL(process.env.DATABASE_URL);
+        baseUrl.pathname = '/postgres';
+        const pool = new pg_1.Pool({ connectionString: baseUrl.toString() });
+        try {
+            await pool.query(`CREATE DATABASE "${schemaId}"`);
+        }
+        finally {
+            await pool.end();
+        }
+        const env = { ...process.env, DATABASE_URL: url, DIRECT_URL: url };
+        (0, node_child_process_1.execSync)(`${runtime}x prisma migrate deploy`, {
+            cwd: process.cwd(),
+            env,
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        console.error('Erro ao criar banco de dados e2e:', error);
+        throw error;
+    }
     return schemaId;
 }

package/test/utils/drop-e2e-database.d.ts

@@ -1,2 +1,2 @@
 import 'dotenv/config';
-export declare function dropE2EDatabase(schemaId: string): Promise<number>;
+export declare function dropE2EDatabase(schemaId: string): Promise<void>;

package/test/utils/drop-e2e-database.js

@@ -1,17 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dropE2EDatabase = dropE2EDatabase;
-const adapter_pg_1 = require("@prisma/adapter-pg");
 require("dotenv/config");
 const pg_1 = require("pg");
-const client_1 = require("../../../../../prisma/generated/client");
-function dropE2EDatabase(schemaId) {
+async function dropE2EDatabase(schemaId) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const baseUrl = new URL(process.env.DATABASE_URL || '');
+    baseUrl.pathname = '/postgres';
     const pool = new pg_1.Pool({
-        connectionString: process.env.DATABASE_URL,
+        connectionString: baseUrl.toString(),
+        idleTimeoutMillis: 100,
     });
-    const adapter = new adapter_pg_1.PrismaPg(pool);
-    const prisma = new client_1.PrismaClient({ adapter });
-    return prisma
-        .$executeRawUnsafe(`DROP SCHEMA IF EXISTS "${schemaId}" CASCADE`)
-        .finally(() => prisma.$disconnect());
+    try {
+        await pool.query(`
+      SELECT pg_terminate_backend(pg_stat_activity.pid)
+      FROM pg_stat_activity
+      WHERE pg_stat_activity.datname = '${schemaId}'
+      AND pid <> pg_backend_pid()
+    `);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        await pool.query(`DROP DATABASE IF EXISTS "${schemaId}"`);
+    }
+    catch {
+    }
+    finally {
+        try {
+            await pool.end();
+        }
+        catch {
+        }
+    }
 }