public readonly prisma = new PrismaClient({ log: process.env.NODE_ENV === SharedTypes.NODE_ENV.PRODUCTION ? ["error"] : ["query", "info", "warn", "error"] }).$extends({ 

import { Injectable, Logger, OnModuleInit } from "@nestjs/common";
import { Prisma, PrismaClient } from "@prisma/client";
import { DynamicClientExtensionThis, InternalArgs } from "@prisma/client/runtime/library";

export type PrismaFlatTransactionClient = Prisma.TransactionClient & {
    $commit: () => Promise<void>;
    $rollback: () => Promise<void>;
};

export type ExtendedPrismaClient = DynamicClientExtensionThis<
    Prisma.TypeMap<
        InternalArgs & {
            result: object;
            model: object;
            query: object;
            client: {
                $begin: () => () => Promise<PrismaFlatTransactionClient>;
            };
        }
    >,
    Prisma.TypeMapCb,
    {
        result: object;
        model: object;
        query: object;
        client: {
            $begin: () => () => Promise<PrismaFlatTransactionClient>;
        };
    }
>;

@Injectable()
export class PrismaService extends PrismaClient<Prisma.PrismaClientOptions, "query" | "info" | "warn" | "error"> implements OnModuleInit {
    public readonly logger: Logger;

    readonly rollback = {
        [Symbol.for("prisma.client.extension.rollback")]: true,
    };

    constructor() {
        super();
        this.logger = new Logger("PrismaService");

        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.prisma.$on("query", (event: any) => {
            this.logger.debug(`Query - [${event.query}}] \n with Parameters ${event.params}} \n time-taken ${event.duration}ms \n`);
        });
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.prisma.$on("error", (event: any) => {
            this.logger.error(`Prisma ERROR :- \n ${JSON.stringify(event, null, 2)} \n `);
        });
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.prisma.$on("info", (event: any) => {
            this.logger.log(`Prisma INFO :- ${JSON.stringify(event, null, 2)} \n `);
        });
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.prisma.$on("warn", (event: any) => {
            this.logger.warn(`Prisma WARNING :- ${JSON.stringify(event, null, 2)} \n`);
        });
    }

    public readonly prisma = new PrismaClient({
        log: [
            {
                emit: "event",
                level: "query",
            },
            {
                emit: "stdout",
                level: "error",
            },
            {
                emit: "stdout",
                level: "info",
            },
            {
                emit: "stdout",
                level: "warn",
            },
        ],
    }).$extends({
        client: (() => {
            // eslint-disable-next-line @typescript-eslint/no-this-alias
            const self = this; // Capture the `this` value from the outer scope

            return {
                async $begin() {
                    const prisma = Prisma.getExtensionContext(this);
                    let setTxClient: (txClient: Prisma.TransactionClient) => void;
                    let commit: () => void;
                    let rollback: () => void;

                    // a promise for getting the tx inner client
                    const txClient = new Promise<Prisma.TransactionClient>((res) => {
                        // eslint-disable-next-line jsdoc/require-returns
                        /**
                         * Sets the transaction client.
                         * @param txClient - The transaction client.
                         */
                        // eslint-disable-next-line @typescript-eslint/no-shadow
                        setTxClient = (txClient) => res(txClient);
                    });

                    // a promise for controlling the transaction
                    const txPromise = new Promise((res, rej) => {
                        /**
                         * Commits the transaction.
                         * @returns - A promise that resolves when the transaction is committed.
                         */
                        commit = () => {
                            return res(undefined);
                        };

                        /**
                         * Rolls back the transaction.
                         * @returns - A promise that rejects with the rollback symbol.
                         */
                        rollback = () => {
                            return rej(self.rollback);
                        };
                    });

                    // opening a transaction to control externally
                    if ("$transaction" in prisma && typeof prisma.$transaction === "function") {
                        const tx = prisma
                            .$transaction((newTxClient) => {
                                // Should be avoided, but we need to set the txClient
                                const localClient = newTxClient as Prisma.TransactionClient;
                                setTxClient(localClient);

                                return txPromise;
                            })
                            .catch((e) => {
                                if (e === self.rollback) return;
                                throw e;
                            });

                        // return a proxy TransactionClient with `$commit` and `$rollback` methods
                        return new Proxy(await txClient, {
                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
                            get(target, prop: any) {
                                if (prop === "$commit") {
                                    return () => {
                                        commit();
                                        return tx;
                                    };
                                }
                                if (prop === "$rollback") {
                                    return () => {
                                        rollback();
                                        return tx;
                                    };
                                }
                                return target[prop];
                                // return target[prop as keyof typeof target];
                            },
                        }) as PrismaFlatTransactionClient;
                    }

                    throw new Error("Transactions are not supported by this client");
                },
            };
        })(),
    });

    async onModuleInit() {
        await this.connect();
    }
}