storemw-core-api 1.0.163 → 1.0.165

package/dist/lib/model_factory/ModelFactory.js

@@ -5,57 +5,159 @@ const default_1 = require("./default");
 const utils_1 = require("../../utils");
 const ModelFactory = ({ debug = false, 
 // prisma,
-modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperator = false,
-// isConsoleTable = false
+modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperator = false, tx, // ✅ ADD THIS LINE
  }) => {
     // load prisma from core configuration
     const { prisma: coreConfigPrisma } = (0, utils_1.getCoreConfiguration)();
-    const selectedPrisma = coreConfigPrisma;
+    // const selectedPrisma = coreConfigPrisma
+    const selectedPrisma = tx ?? coreConfigPrisma;
+    const getSelectedPrisma = () => tx ?? coreConfigPrisma;
+    const getModel = () => getSelectedPrisma()[modelName];
     // const delegate = prisma[modelName] as any;
-    const delegate = selectedPrisma[modelName];
+    // const delegate = selectedPrisma[modelName] as unknown as {
+    //     create: (args: any) => Promise<TModel>;
+    //     update: (args: any) => Promise<TModel>;
+    //     delete: (args: any) => Promise<TModel>;
+    //     findUnique: (args: any) => Promise<TModel | null>;
+    //     findFirst: (args: any) => Promise<TModel | null>;  // ✅ add this
+    //     findMany: (args: any) => Promise<TModel[]>;
+    //     updateMany: (args: any) => Promise<{ count: number }>; // ✅ useful for update
+    // };
+    // const getFields = async (
+    //     prefix?: string,
+    //     excludeKeywords: string[] = []
+    // ): Promise<Column[]> => {
+    //     // 👇 Tell TS exactly what comes back from selectedPrisma
+    //     const fields: ColumnInfo[] = await selectedPrisma.$queryRaw<ColumnInfo[]>`
+    //         SELECT column_name, data_type
+    //         FROM information_schema.columns 
+    //         WHERE table_name = ${String(modelName)}
+    //     `;
+    //     return fields
+    //         .map((f: ColumnInfo): Column => ({
+    //             name: f.column_name,
+    //             type: f.data_type,
+    //         }))
+    //         .filter((c: Column) => !prefix || c.name.startsWith(prefix))
+    //         .filter((c: Column) => !excludeKeywords.some((kw) => c.name.includes(kw)));
+    // };
     const getFields = async (prefix, excludeKeywords = []) => {
-        // 👇 Tell TS exactly what comes back from selectedPrisma
-        const fields = await selectedPrisma.$queryRaw `
+        const run = async (client) => {
+            const fields = await client.$queryRaw `
             SELECT column_name, data_type
             FROM information_schema.columns 
             WHERE table_name = ${String(modelName)}
         `;
-        return fields
-            .map((f) => ({
-            name: f.column_name,
-            type: f.data_type,
-        }))
-            .filter((c) => !prefix || c.name.startsWith(prefix))
-            .filter((c) => !excludeKeywords.some((kw) => c.name.includes(kw)));
+            return fields
+                .map((f) => ({
+                name: f.column_name,
+                type: f.data_type,
+            }))
+                .filter((c) => !prefix || c.name.startsWith(prefix))
+                .filter((c) => !excludeKeywords.some((kw) => c.name.includes(kw)));
+        };
+        // 🔥 external transaction support
+        if (tx) {
+            return run(tx);
+        }
+        // 🔥 fallback to global prisma
+        return run(selectedPrisma);
     };
-    // const getFields = async (
-    //     prefix?: string,
-    //     excludeKeywords?: string[]
-    // ): Promise<{ name: string; type: string }[]> => {
-    //     const fields = await selectedPrisma.$queryRaw<{ column_name: string; data_type: string }[]>`
-    //     SELECT column_name, data_type
-    //     FROM information_schema.columns 
-    //     WHERE table_name = ${String(modelName)}
-    // `;
-    //     let cols = fields.map(f => ({ name: f.column_name, type: f.data_type }));
-    //     if (prefix) {
-    //         cols = cols.filter(c => c.name.startsWith(prefix));
-    //     }
-    //     if (excludeKeywords && excludeKeywords.length > 0) {
-    //         cols = cols.filter(c => !excludeKeywords.some(kw => c.name.includes(kw)));
+    // const create = async ({ data }: { data: Omit<any, DefaultOmitFields> }): Promise<TModel> => {
+    //     // const model = selectedPrisma[modelName] as any;
+    //     // const model = selectedPrisma[modelName] as TDelegate;
+    //     const model = getModel() as TDelegate;
+    //     const _data = {
+    //         ...data,
+    //         ...getDefaultCreateFields(actionUserId, accountId),
+    //     };
+    //     // if (debug) {
+    //     //     console.log(`[ModelFactory(data)]: ${JSON.stringify(_data)}`)
+    //     //     console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     // }
+    //     if (debug) {
+    //         console.log(`[ModelFactory:create:${String(modelName)}]`, _data);
     //     }
-    //     return cols;
+    //     // return delegate.create({
+    //     //     data: _data,
+    //     // });
+    //     return model.create({
+    //         data: _data,
+    //     });
     // };
-    const create = async ({ data }) => {
-        const _data = { ...data, ...(0, default_1.getDefaultCreateFields)(actionUserId, accountId) };
-        if (debug) {
-            console.log(`[ModelFactory(data)]: ${JSON.stringify(_data)}`);
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    const create = async ({ data, }) => {
+        const run = async (client) => {
+            const model = client[modelName];
+            const _data = {
+                ...data,
+                ...(0, default_1.getDefaultCreateFields)(actionUserId, accountId),
+            };
+            if (debug) {
+                console.log(`[ModelFactory:create:${String(modelName)}]`, _data);
+            }
+            return model.create({
+                data: _data,
+            });
+        };
+        // 🔥 external transaction support
+        if (tx) {
+            return run(tx);
         }
-        return delegate.create({
-            data: _data,
-        });
+        // 🔥 internal transaction fallback (ensures rollback safety)
+        return selectedPrisma.$transaction(run);
     };
+    // const createMany = async ({
+    //     dataList,
+    //     disableRollback = false,
+    // }: {
+    //     dataList: Omit<any, DefaultOmitFields>[];
+    //     disableRollback?: boolean;
+    // }): Promise<TModel[]> => {
+    //     if (!Array.isArray(dataList) || dataList.length === 0) {
+    //         throw new Error("createMany: dataList cannot be empty.");
+    //     }
+    //     if (debug) {
+    //         console.log(`[ModelFactory(createMany)]: count=${dataList.length}`);
+    //     }
+    //     return selectedPrisma.$transaction(async (tx: typeof selectedPrisma) => {
+    //         const modelTx = (tx as any)[modelName] as {
+    //             createMany: (args: any) => Promise<{ count: number }>;
+    //             findMany: (args: any) => Promise<TModel[]>;
+    //         };
+    //         // inject system fields for each record
+    //         const records = dataList.map((d) => ({
+    //             ...d,
+    //             ...getDefaultCreateFields(actionUserId, accountId),
+    //         }));
+    //         const result = await modelTx.createMany({
+    //             data: records,
+    //         });
+    //         if (disableRollback === false) {
+    //             if (!result.count || result.count !== dataList.length) {
+    //                 throw new Error("Error: Not all records were inserted.");
+    //             }
+    //         }
+    //         // re-fetch the inserted records (if they have predictable keys)
+    //         // only works if they share identifiable property (like foreign key)
+    //         // or you can just return records if no need to verify
+    //         let inserted: TModel[] = [];
+    //         try {
+    //             inserted = await modelTx.findMany({
+    //                 where: {
+    //                     ...(isOperator === false ? { accountid: accountId } : {}),
+    //                     ...getDefaultGetWhere,
+    //                 },
+    //                 orderBy: {
+    //                     [primaryKey as string]: "desc",
+    //                 },
+    //                 take: dataList.length,
+    //             });
+    //         } catch (err) {
+    //             if (debug) console.warn("Could not re-fetch newly created records:", err);
+    //         }
+    //         return inserted;
+    //     });
+    // };
     const createMany = async ({ dataList, disableRollback = false, }) => {
         if (!Array.isArray(dataList) || dataList.length === 0) {
             throw new Error("createMany: dataList cannot be empty.");
@@ -63,27 +165,21 @@ modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperato
         if (debug) {
             console.log(`[ModelFactory(createMany)]: count=${dataList.length}`);
         }
-        return selectedPrisma.$transaction(async (tx) => {
-            const modelTx = tx[modelName];
-            // inject system fields for each record
+        const run = async (client) => {
+            const model = client[modelName];
             const records = dataList.map((d) => ({
                 ...d,
                 ...(0, default_1.getDefaultCreateFields)(actionUserId, accountId),
             }));
-            const result = await modelTx.createMany({
+            const result = await model.createMany({
                 data: records,
             });
-            if (disableRollback === false) {
-                if (!result.count || result.count !== dataList.length) {
-                    throw new Error("Error: Not all records were inserted.");
-                }
+            if (!disableRollback && result.count !== dataList.length) {
+                throw new Error("Error: Not all records were inserted.");
             }
-            // re-fetch the inserted records (if they have predictable keys)
-            // only works if they share identifiable property (like foreign key)
-            // or you can just return records if no need to verify
             let inserted = [];
             try {
-                inserted = await modelTx.findMany({
+                inserted = await model.findMany({
                     where: {
                         ...(isOperator === false ? { accountid: accountId } : {}),
                         ...default_1.getDefaultGetWhere,
@@ -99,126 +195,335 @@ modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperato
                     console.warn("Could not re-fetch newly created records:", err);
             }
             return inserted;
-        });
+        };
+        // 🔥 external transaction support
+        if (tx) {
+            return run(tx);
+        }
+        // 🔥 internal transaction fallback
+        return selectedPrisma.$transaction(run);
     };
+    // const get = async ({
+    //     id,
+    //     where,
+    //     include,
+    // }: {
+    //     id?: number;
+    //     where?: Record<string, any>;
+    //     include?: any;
+    // }): Promise<TModel | null> => {
+    //     const condition = id ? { [primaryKey]: id } : where ?? {};
+    //     const condition2 = isOperator === false ? { accountid: accountId } : {}
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return delegate.findFirst({
+    //         where: { ...condition, ...condition2, ...getDefaultGetWhere },
+    //         include,
+    //     });
+    // };
     const get = async ({ id, where, include, }) => {
         const condition = id ? { [primaryKey]: id } : where ?? {};
         const condition2 = isOperator === false ? { accountid: accountId } : {};
         if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+            console.log("[ModelFactory:get]", JSON.stringify(Object.keys(selectedPrisma)));
+        }
+        const run = async (client) => {
+            const model = client[modelName];
+            return model.findFirst({
+                where: {
+                    ...condition,
+                    ...condition2,
+                    ...default_1.getDefaultGetWhere,
+                },
+                include,
+            });
+        };
+        // 🔥 use external transaction if exists
+        if (tx) {
+            return run(tx);
         }
-        return delegate.findFirst({
-            where: { ...condition, ...condition2, ...default_1.getDefaultGetWhere },
-            include,
-        });
+        // 🔥 fallback to normal prisma
+        return run(selectedPrisma);
     };
-    const list = async ({ where, orderBy, offset, limit, include } = {}) => {
+    // const list = async ({ where, orderBy, offset, limit, include }: any = {}): Promise<TModel[]> => {
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return delegate.findMany({
+    //         where,
+    //         orderBy,
+    //         skip: offset,
+    //         take: limit,
+    //         include,
+    //     });
+    // };
+    const list = async ({ where, orderBy, offset, limit, include, } = {}) => {
         if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+            console.log("[ModelFactory:list]", JSON.stringify(Object.keys(selectedPrisma)));
+        }
+        const run = async (client) => {
+            const model = client[modelName];
+            return model.findMany({
+                where,
+                orderBy,
+                skip: offset,
+                take: limit,
+                include,
+            });
+        };
+        // 🔥 external transaction support
+        if (tx) {
+            return run(tx);
         }
-        return delegate.findMany({
-            where,
-            orderBy,
-            skip: offset,
-            take: limit,
-            include,
-        });
+        // 🔥 normal execution
+        return run(selectedPrisma);
     };
-    const count = async ({ where } = {}) => {
+    // const count = async ({ where }: { where?: Record<string, any> } = {}): Promise<number> => {
+    //     if (debug) {
+    //         console.log(`[ModelFactory:count:${String(modelName)}] where =`, where);
+    //     }
+    //     // Use Prisma's built-in count
+    //     const result = await (delegate as any).count({
+    //         where: {
+    //             ...where,
+    //             ...(isOperator === false ? { accountid: accountId } : {}),
+    //             ...getDefaultGetWhere,
+    //         },
+    //     });
+    //     return result ?? 0;
+    // };
+    const count = async ({ where, } = {}) => {
         if (debug) {
             console.log(`[ModelFactory:count:${String(modelName)}] where =`, where);
         }
-        // Use Prisma's built-in count
-        const result = await delegate.count({
-            where: {
-                ...where,
-                ...(isOperator === false ? { accountid: accountId } : {}),
-                ...default_1.getDefaultGetWhere,
-            },
-        });
-        return result ?? 0;
+        const run = async (client) => {
+            const model = client[modelName];
+            return model.count({
+                where: {
+                    ...where,
+                    ...(isOperator === false ? { accountid: accountId } : {}),
+                    ...default_1.getDefaultGetWhere,
+                },
+            });
+        };
+        // 🔥 external transaction case
+        if (tx) {
+            return run(tx);
+        }
+        // 🔥 normal case (no transaction needed for count)
+        return run(selectedPrisma);
     };
+    // const aggregate = async ({
+    //     field,
+    //     operation = "sum",
+    //     where = {},
+    // }: {
+    //     field: keyof TModel;
+    //     operation?: "sum" | "avg" | "min" | "max" | "count";
+    //     where?: Record<string, any>;
+    // }): Promise<number> => {
+    //     if (debug) {
+    //         console.log(`[ModelFactory:aggregate:${String(modelName)}] ${operation}(${String(field)})`, where);
+    //     }
+    //     // Build dynamic aggregation key
+    //     const aggregateKey = `_${operation}` as
+    //         | "_sum"
+    //         | "_avg"
+    //         | "_min"
+    //         | "_max"
+    //         | "_count";
+    //     // Build only the key you need
+    //     const aggregateInput: Record<string, any> = {
+    //         [aggregateKey]: { [field]: true },
+    //         where: {
+    //             ...where,
+    //             ...(isOperator === false ? { accountid: accountId } : {}),
+    //             ...getDefaultGetWhere,
+    //         },
+    //     };
+    //     // Run Prisma aggregate dynamically
+    //     const result = await (delegate as any).aggregate(aggregateInput);
+    //     // Extract inner value
+    //     const inner = result?.[aggregateKey] ?? {};
+    //     const value = inner?.[field as string] ?? (operation === "count" ? 0 : 0);
+    //     return Number(value) || 0;
+    // }
     const aggregate = async ({ field, operation = "sum", where = {}, }) => {
-        if (debug) {
-            console.log(`[ModelFactory:aggregate:${String(modelName)}] ${operation}(${String(field)})`, where);
-        }
-        // Build dynamic aggregation key
-        const aggregateKey = `_${operation}`;
-        // Build only the key you need
-        const aggregateInput = {
-            [aggregateKey]: { [field]: true },
-            where: {
-                ...where,
-                ...(isOperator === false ? { accountid: accountId } : {}),
-                ...default_1.getDefaultGetWhere,
-            },
+        const run = async (client) => {
+            const model = client[modelName];
+            const aggregateKey = `_${operation}`;
+            const aggregateInput = {
+                [aggregateKey]: { [field]: true },
+                where: {
+                    ...where,
+                    ...(isOperator === false ? { accountid: accountId } : {}),
+                    ...default_1.getDefaultGetWhere,
+                },
+            };
+            const result = await model.aggregate(aggregateInput);
+            const inner = result?.[aggregateKey] ?? {};
+            const value = inner?.[field] ?? 0;
+            return Number(value) || 0;
         };
-        // Run Prisma aggregate dynamically
-        const result = await delegate.aggregate(aggregateInput);
-        // Extract inner value
-        const inner = result?.[aggregateKey] ?? {};
-        const value = inner?.[field] ?? (operation === "count" ? 0 : 0);
-        return Number(value) || 0;
+        // 🔥 external tx support
+        if (tx) {
+            return run(tx);
+        }
+        // 🔥 internal fallback
+        return selectedPrisma.$transaction(run);
     };
+    // const update = async ({ id, where, data, disableRollback = false }: {
+    //     id?: number;
+    //     where?: Record<string, any>;
+    //     data: Partial<TModel>,
+    //     disableRollback?: Boolean
+    // }): Promise<TModel> => {
+    //     if (debug) {
+    //         console.log(`[ModelFactory(data)]: ${JSON.stringify(data)}`)
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return selectedPrisma.$transaction(async (tx: typeof selectedPrisma) => {
+    //         const modelTx = (tx as any)[modelName] as TxModel<TModel>;
+    //         // prefer primary key if provided, otherwise fall back to custom where
+    //         let finalWhere = id ?
+    //             {
+    //                 [primaryKey]: id,
+    //                 ...getDefaultUpdateWhere,
+    //                 ...(isOperator === false ? { accountid: accountId } : {}),
+    //             }
+    //             :
+    //             {
+    //                 ...where,
+    //                 ...getDefaultUpdateWhere,
+    //                 ...(isOperator === false ? { accountid: accountId } : {}),
+    //             };
+    //         const result = await modelTx.updateMany({
+    //             where: finalWhere,
+    //             data: { ...data, ...getDefaultUpdateFields(actionUserId) },
+    //         });
+    //         if (disableRollback === false) {
+    //             if (!result.count) {
+    //                 throw new Error(errorRecordNotFoundAlreadyDeleted);
+    //             }
+    //         }
+    //         // const updatedRecord = await modelTx.findUnique({ where: { [primaryKey]: id } });
+    //         let updatedRecord: TModel | null = null;
+    //         if (id) {
+    //             // use findUnique when updating by primary key
+    //             updatedRecord = await modelTx.findUnique({ where: { [primaryKey]: id } });
+    //         } else {
+    //             // use findFirst when updating by other field(s)
+    //             updatedRecord = await (modelTx as any).findFirst({ where: finalWhere });
+    //         }
+    //         if (disableRollback === false) {
+    //             if (!updatedRecord) {
+    //                 throw new Error(errorRecordNotFoundAfterUpdated);
+    //             }
+    //         }
+    //         return updatedRecord;
+    //     });
+    // };
     const update = async ({ id, where, data, disableRollback = false }) => {
-        if (debug) {
-            console.log(`[ModelFactory(data)]: ${JSON.stringify(data)}`);
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
-        }
-        return selectedPrisma.$transaction(async (tx) => {
-            const modelTx = tx[modelName];
-            // prefer primary key if provided, otherwise fall back to custom where
-            let finalWhere = id ?
-                {
+        const run = async (client) => {
+            const model = client[modelName];
+            const finalWhere = id
+                ? {
                     [primaryKey]: id,
                     ...default_1.getDefaultUpdateWhere,
                     ...(isOperator === false ? { accountid: accountId } : {}),
                 }
-                :
-                    {
-                        ...where,
-                        ...default_1.getDefaultUpdateWhere,
-                        ...(isOperator === false ? { accountid: accountId } : {}),
-                    };
-            const result = await modelTx.updateMany({
+                : {
+                    ...where,
+                    ...default_1.getDefaultUpdateWhere,
+                    ...(isOperator === false ? { accountid: accountId } : {}),
+                };
+            const result = await model.updateMany({
                 where: finalWhere,
-                data: { ...data, ...(0, default_1.getDefaultUpdateFields)(actionUserId) },
+                data: {
+                    ...data,
+                    ...(0, default_1.getDefaultUpdateFields)(actionUserId),
+                },
             });
-            if (disableRollback === false) {
-                if (!result.count) {
-                    throw new Error(default_1.errorRecordNotFoundAlreadyDeleted);
-                }
-            }
-            // const updatedRecord = await modelTx.findUnique({ where: { [primaryKey]: id } });
-            let updatedRecord = null;
-            if (id) {
-                // use findUnique when updating by primary key
-                updatedRecord = await modelTx.findUnique({ where: { [primaryKey]: id } });
-            }
-            else {
-                // use findFirst when updating by other field(s)
-                updatedRecord = await modelTx.findFirst({ where: finalWhere });
+            if (!disableRollback && result.count === 0) {
+                throw new Error(default_1.errorRecordNotFoundAlreadyDeleted);
             }
-            if (disableRollback === false) {
-                if (!updatedRecord) {
-                    throw new Error(default_1.errorRecordNotFoundAfterUpdated);
-                }
+            const updated = id
+                ? await model.findUnique({ where: { [primaryKey]: id } })
+                : await model.findFirst({ where: finalWhere });
+            if (!disableRollback && !updated) {
+                throw new Error(default_1.errorRecordNotFoundAfterUpdated);
             }
-            return updatedRecord;
-        });
+            return updated;
+        };
+        // ✅ external transaction support
+        if (tx) {
+            return run(tx);
+        }
+        // ✅ internal transaction fallback
+        return selectedPrisma.$transaction(run);
     };
+    // const updateMany = async ({
+    //     dataList,
+    //     disableRollback = false,
+    // }: {
+    //     dataList: { where: Record<string, any>; data: Partial<TModel> }[];
+    //     disableRollback?: boolean;
+    // }): Promise<TModel[]> => {
+    //     if (!Array.isArray(dataList) || dataList.length === 0) {
+    //         throw new Error("updateMany: dataList cannot be empty.");
+    //     }
+    //     if (debug) {
+    //         console.log(`[ModelFactory(updateMany)]: count=${dataList.length}`);
+    //     }
+    //     return selectedPrisma.$transaction(async (tx: typeof selectedPrisma) => {
+    //         const modelTx = (tx as any)[modelName] as TxModel<TModel> & {
+    //             findMany: (args: any) => Promise<TModel[]>;
+    //         };
+    //         let totalUpdated = 0;
+    //         for (const { where, data } of dataList) {
+    //             const result = await modelTx.updateMany({
+    //                 where: {
+    //                     ...where,
+    //                     ...getDefaultUpdateWhere,
+    //                 },
+    //                 data: {
+    //                     ...data,
+    //                     ...getDefaultUpdateFields(actionUserId),
+    //                 },
+    //             });
+    //             totalUpdated += result.count;
+    //         }
+    //         if (disableRollback === false && totalUpdated === 0) {
+    //             throw new Error(errorRecordNotFoundAlreadyDeleted);
+    //         }
+    //         // Attempt to refetch updated records for confirmation
+    //         let updatedRecords: TModel[] = [];
+    //         try {
+    //             const allWhere = dataList.map(d => d.where);
+    //             // Combine OR condition if Prisma supports OR for this table
+    //             updatedRecords = await modelTx.findMany({
+    //                 where: {
+    //                     OR: allWhere,
+    //                     ...(isOperator === false ? { accountid: accountId } : {}),
+    //                     ...getDefaultGetWhere,
+    //                 },
+    //             });
+    //         } catch (err) {
+    //             if (debug) console.warn("Could not re-fetch updated records:", err);
+    //         }
+    //         return updatedRecords;
+    //     });
+    // };
     const updateMany = async ({ dataList, disableRollback = false, }) => {
         if (!Array.isArray(dataList) || dataList.length === 0) {
             throw new Error("updateMany: dataList cannot be empty.");
         }
-        if (debug) {
-            console.log(`[ModelFactory(updateMany)]: count=${dataList.length}`);
-        }
-        return selectedPrisma.$transaction(async (tx) => {
-            const modelTx = tx[modelName];
+        const run = async (txClient) => {
+            const model = txClient[modelName];
             let totalUpdated = 0;
             for (const { where, data } of dataList) {
-                const result = await modelTx.updateMany({
+                const result = await model.updateMany({
                     where: {
                         ...where,
                         ...default_1.getDefaultUpdateWhere,
@@ -230,96 +535,189 @@ modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperato
                 });
                 totalUpdated += result.count;
             }
-            if (disableRollback === false && totalUpdated === 0) {
+            if (!disableRollback && totalUpdated === 0) {
                 throw new Error(default_1.errorRecordNotFoundAlreadyDeleted);
             }
-            // Attempt to refetch updated records for confirmation
-            let updatedRecords = [];
-            try {
-                const allWhere = dataList.map(d => d.where);
-                // Combine OR condition if Prisma supports OR for this table
-                updatedRecords = await modelTx.findMany({
-                    where: {
-                        OR: allWhere,
-                        ...(isOperator === false ? { accountid: accountId } : {}),
-                        ...default_1.getDefaultGetWhere,
-                    },
-                });
-            }
-            catch (err) {
-                if (debug)
-                    console.warn("Could not re-fetch updated records:", err);
-            }
-            return updatedRecords;
-        });
+            return model.findMany({
+                where: {
+                    OR: dataList.map(d => d.where),
+                    ...(isOperator === false ? { accountid: accountId } : {}),
+                    ...default_1.getDefaultGetWhere,
+                },
+            });
+        };
+        // 🔥 transaction boundary ONLY here
+        if (tx) {
+            return run(tx);
+        }
+        return selectedPrisma.$transaction(run);
     };
+    // const trash = async ({ ids }: { ids: number[] }): Promise<TModel[]> => {
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return selectedPrisma.$transaction(async (tx: typeof selectedPrisma) => {
+    //         const modelTx = (tx as any)[modelName] as TxModel<TModel>;
+    //         const result = await modelTx.updateMany({
+    //             where: { [primaryKey]: { in: ids }, ...getDefaultTrashWhere },
+    //             data: { ...getDefaultTrashFields(actionUserId) },
+    //         });
+    //         if (!result.count || result.count !== ids.length)
+    //             throw new Error(errorRecordNotFoundAlreadyDeleted);
+    //         const updated = await modelTx.findMany!({ where: { [primaryKey]: { in: ids } } });
+    //         if (!updated.length) throw new Error(errorRecordNotFoundAfterTrashed);
+    //         return updated;
+    //     });
+    // };
     const trash = async ({ ids }) => {
         if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+            console.log("[ModelFactory:trash]", JSON.stringify(Object.keys(selectedPrisma)));
         }
-        return selectedPrisma.$transaction(async (tx) => {
-            const modelTx = tx[modelName];
-            const result = await modelTx.updateMany({
-                where: { [primaryKey]: { in: ids }, ...default_1.getDefaultTrashWhere },
-                data: { ...(0, default_1.getDefaultTrashFields)(actionUserId) },
+        const run = async (client) => {
+            const model = client[modelName];
+            const result = await model.updateMany({
+                where: {
+                    [primaryKey]: { in: ids },
+                    ...default_1.getDefaultTrashWhere,
+                },
+                data: {
+                    ...(0, default_1.getDefaultTrashFields)(actionUserId),
+                },
             });
-            if (!result.count || result.count !== ids.length)
+            if (!result.count || result.count !== ids.length) {
                 throw new Error(default_1.errorRecordNotFoundAlreadyDeleted);
-            const updated = await modelTx.findMany({ where: { [primaryKey]: { in: ids } } });
-            if (!updated.length)
+            }
+            const updated = await model.findMany({
+                where: { [primaryKey]: { in: ids } },
+            });
+            if (!updated.length) {
                 throw new Error(default_1.errorRecordNotFoundAfterTrashed);
+            }
             return updated;
-        });
+        };
+        // ✅ external transaction support
+        if (tx) {
+            return run(tx);
+        }
+        // ✅ internal fallback transaction
+        return selectedPrisma.$transaction(run);
     };
+    // const remove = async ({ ids, where }: { ids?: number[], where?: Record<string, any>; }): Promise<TModel[]> => {
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return selectedPrisma.$transaction(async (tx: typeof selectedPrisma) => {
+    //         const modelTx = (tx as any)[modelName] as TxModel<TModel>;
+    //         // prefer primary ids if provided, otherwise fall back to custom where
+    //         const finalWhere = ids
+    //             ? { [primaryKey]: { in: ids }, ...getDefaultRemoveWhere }
+    //             : { ...where, ...getDefaultRemoveWhere };
+    //         const result = await modelTx.updateMany({
+    //             where: finalWhere,
+    //             data: { ...getDefaultRemoveFields(actionUserId) },
+    //         });
+    //         // if (!result.count) throw new Error(errorRecordNotFoundAlreadyDeleted);
+    //         if (!result.count) {
+    //             // no rows touched → just return []
+    //             return [];
+    //         }
+    //         let updated: TModel[] | null;
+    //         if (ids) {
+    //             updated = await modelTx.findMany!({ where: { [primaryKey]: { in: ids } } });
+    //         } else {
+    //             updated = await modelTx.findMany!({ where });
+    //         }
+    //         if (!updated || updated.length === 0) {
+    //             throw new Error(errorRecordNotFoundAfterRemoved);
+    //         }
+    //         return updated;
+    //     });
+    // };
     const remove = async ({ ids, where }) => {
         if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+            console.log("[ModelFactory:remove]", JSON.stringify(Object.keys(selectedPrisma)));
         }
-        return selectedPrisma.$transaction(async (tx) => {
-            const modelTx = tx[modelName];
-            // prefer primary ids if provided, otherwise fall back to custom where
+        const run = async (client) => {
+            const model = client[modelName];
             const finalWhere = ids
-                ? { [primaryKey]: { in: ids }, ...default_1.getDefaultRemoveWhere }
-                : { ...where, ...default_1.getDefaultRemoveWhere };
-            const result = await modelTx.updateMany({
+                ? {
+                    [primaryKey]: { in: ids },
+                    ...default_1.getDefaultRemoveWhere,
+                }
+                : {
+                    ...where,
+                    ...default_1.getDefaultRemoveWhere,
+                };
+            const result = await model.updateMany({
                 where: finalWhere,
-                data: { ...(0, default_1.getDefaultRemoveFields)(actionUserId) },
+                data: {
+                    ...(0, default_1.getDefaultRemoveFields)(actionUserId),
+                },
             });
-            // if (!result.count) throw new Error(errorRecordNotFoundAlreadyDeleted);
             if (!result.count) {
-                // no rows touched → just return []
                 return [];
             }
-            let updated;
-            if (ids) {
-                updated = await modelTx.findMany({ where: { [primaryKey]: { in: ids } } });
-            }
-            else {
-                updated = await modelTx.findMany({ where });
-            }
+            const updated = ids
+                ? await model.findMany({
+                    where: { [primaryKey]: { in: ids } },
+                })
+                : await model.findMany({
+                    where,
+                });
             if (!updated || updated.length === 0) {
                 throw new Error(default_1.errorRecordNotFoundAfterRemoved);
             }
             return updated;
-        });
+        };
+        // 🔥 external transaction support
+        if (tx) {
+            return run(tx);
+        }
+        // 🔥 internal transaction fallback
+        return selectedPrisma.$transaction(run);
     };
     // Used for SELECT queries (read operations)
+    // const raw = async <T = any>(query: string, params: any[] = []): Promise<T[]> => {
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     // const client = prisma as unknown as PrismaClient;
+    //     const client = selectedPrisma as unknown as PrismaClient;
+    //     // return prisma.$queryRawUnsafe<T[]>(query, ...params);
+    //     return client.$queryRawUnsafe<T[]>(query, ...params);
+    // };
     const raw = async (query, params = []) => {
-        if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+        const run = async (client) => {
+            return client.$queryRawUnsafe(query, ...params);
+        };
+        // 🔥 use tx if exists
+        if (tx) {
+            return run(tx);
         }
-        // const client = prisma as unknown as PrismaClient;
-        const client = selectedPrisma;
-        // return prisma.$queryRawUnsafe<T[]>(query, ...params);
-        return client.$queryRawUnsafe(query, ...params);
+        // 🔥 fallback to global prisma
+        return run(selectedPrisma);
     };
     // Used for mutations (INSERT, UPDATE, DELETE, DDL like CREATE TABLE etc.)
-    const rawExec = async (query, params = []) => {
-        if (debug) {
-            console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
-        }
-        return selectedPrisma.$executeRawUnsafe(query, ...params); // returns number of affected rows
-    };
+    // const rawExec = async (query: string, params: any[] = []): Promise<number> => {
+    //     if (debug) {
+    //         console.log("[ModelFactory:delegate]", JSON.stringify(Object.keys(selectedPrisma)));
+    //     }
+    //     return selectedPrisma.$executeRawUnsafe(query, ...params); // returns number of affected rows
+    // };
+    // const rawExec = async (
+    //     query: string,
+    //     params: any[] = []
+    // ): Promise<number> => {
+    //     const run = async (client: any) => {
+    //         return client.$executeRawUnsafe(query, ...params);
+    //     };
+    //     // 🔥 if external tx exists → use it
+    //     if (tx) {
+    //         return run(tx);
+    //     }
+    //     // 🔥 otherwise use global prisma (no transaction wrapper needed for raw exec)
+    //     return run(selectedPrisma);
+    // };
     return {
         selectedPrisma,
         primaryKey,
@@ -335,7 +733,7 @@ modelName, primaryKey = "id", accountId, actionUserId, authToken = '', isOperato
         trash,
         remove,
         raw,
-        rawExec
+        // rawExec
     };
 };
 exports.ModelFactory = ModelFactory;