@koalarx/nest 1.18.3 → 1.18.4

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

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