@nestjs-mod/prisma/src/lib/prisma_client-factory.service.js

Next-generation Node.js and TypeScript ORM for NestJS-mod (preview version only for Postgres)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PrismaClientFactoryService = void 0;
const tslib_1 = require("tslib");
/* eslint-disable @typescript-eslint/no-explicit-any */
const common_1 = require("@nestjs/common");
const timers_1 = require("timers");
const prisma_errors_1 = require("./prisma-errors");
const prisma_configuration_1 = require("./prisma.configuration");
const prisma_environments_1 = require("./prisma.environments");
let PrismaClientFactoryService = class PrismaClientFactoryService {
    constructor(prismaConfiguration, prismaEnvironments) {
        this.prismaConfiguration = prismaConfiguration;
        this.prismaEnvironments = prismaEnvironments;
        this.logger = new common_1.Logger('PrismaClient');
        this.dbPingers = [];
        this.prismaClients = [];
    }
    async createPrismaClient() {
        if (this.prismaConfiguration?.prismaClientFactory) {
            const prismaClientAsPromise = this.prismaConfiguration?.prismaClientFactory({
                url: this.prismaEnvironments.databaseUrl,
                log: [
                    {
                        emit: 'event',
                        level: 'query',
                    },
                    {
                        emit: 'event',
                        level: 'error',
                    },
                ],
            });
            if (prismaClientAsPromise && prismaClientAsPromise.then) {
                const prismaClient = await prismaClientAsPromise;
                this.prismaClients.push(prismaClient);
                return prismaClient;
            }
            this.prismaClients.push(prismaClientAsPromise);
            return prismaClientAsPromise;
        }
        if (!this.prismaConfiguration?.prismaModule) {
            throw new prisma_errors_1.PrismaError(`prismaModule not set`);
        }
        const prismaModule = await this.prismaConfiguration?.prismaModule;
        if (!prismaModule.PrismaClient) {
            throw new prisma_errors_1.PrismaError(`PrismaClient not found`);
        }
        const prismaClient = new prismaModule.PrismaClient({
            datasources: {
                db: {
                    url: this.prismaEnvironments.databaseUrl,
                },
            },
            log: [
                {
                    emit: 'event',
                    level: 'query',
                },
                {
                    emit: 'event',
                    level: 'error',
                },
            ],
        });
        this.prismaClients.push(prismaClient);
        return prismaClient;
    }
    getLogger() {
        // todo: add info about feature name and context name
        return this.prismaConfiguration.defaultLogger ?? this.logger;
    }
    async onModuleInit() {
        for (const prismaClient of this.prismaClients) {
            try {
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                prismaClient.$on('query', (e) => {
                    if (this.prismaConfiguration.logging === 'all_queries') {
                        if (e.query !== 'SELECT 1') {
                            this.getLogger().log(`query: ${e.query}, params: ${e.params}, duration: ${e.duration}`);
                        }
                    }
                    if (this.prismaConfiguration.logging === 'long_queries') {
                        if (e.duration >= this.prismaConfiguration.maxQueryExecutionTime) {
                            this.getLogger().warn(`query is slow: ${e.query}, params: ${e.params}, execution time: ${e.duration}`);
                        }
                    }
                });
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                prismaClient.$on('error', (e) => {
                    if (this.prismaConfiguration.logging === 'all_queries') {
                        if (e.query !== 'SELECT 1') {
                            this.getLogger().log(`query: ${e.query}, params: ${e.params}, duration: ${e.duration}`);
                        }
                    }
                    if (this.prismaConfiguration.logging === 'long_queries') {
                        if (e.duration >= this.prismaConfiguration.maxQueryExecutionTime) {
                            this.getLogger().warn(`query is slow: ${e.query}, params: ${e.params}, execution time: ${e.duration}`);
                        }
                    }
                });
                await prismaClient.$connect();
                this.getLogger().log('Connected to database!');
                const logger = this.getLogger();
                if ((this.prismaConfiguration?.pingDatabaseIntervalMs ?? 0) > 0) {
                    this.dbPingers.push((0, timers_1.setInterval)(function () {
                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                        prismaClient.$queryRaw `SELECT 1`.catch((err) => logger.error(err, err.stack));
                    }, this.prismaConfiguration.pingDatabaseIntervalMs));
                }
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
            }
            catch (err) {
                if (!String(err).includes('fake')) {
                    this.getLogger().error(err, err.stack);
                }
            }
        }
    }
    async onModuleDestroy() {
        for (const dbPinger of this.dbPingers) {
            clearInterval(dbPinger);
        }
    }
};
exports.PrismaClientFactoryService = PrismaClientFactoryService;
exports.PrismaClientFactoryService = PrismaClientFactoryService = tslib_1.__decorate([
    (0, common_1.Injectable)(),
    tslib_1.__metadata("design:paramtypes", [prisma_configuration_1.PrismaConfiguration,
        prisma_environments_1.PrismaEnvironments])
], PrismaClientFactoryService);
//# sourceMappingURL=prisma_client-factory.service.js.map