arkos 1.3.3-canary.2 → 1.3.4-beta

package/dist/esm/modules/base/base.service.js

@@ -1,4 +1,4 @@
-import { camelCase, kebabCase } from "../../utils/helpers/change-case.helpers.js";
+import { camelCase, kebabCase, pascalCase, } from "../../utils/helpers/change-case.helpers.js";
 import { getModuleComponents } from "../../utils/dynamic-loader.js";
 import deepmerge from "../../utils/helpers/deepmerge.helper.js";
 import { handleRelationFieldsInBody, } from "./utils/helpers/base.service.helpers.js";
@@ -8,6 +8,61 @@ import serviceHooksManager from "./utils/service-hooks-manager.js";
 import prismaSchemaParser from "../../utils/prisma/prisma-schema-parser.js";
 export class BaseService {
     constructor(modelName) {
+        this.executeOperation = (config) => {
+            return async (...args) => {
+                const context = args[args.length - 1];
+                try {
+                    await this.executeHooks("before", config.operationType, this.buildHookParams(args, config), context);
+                    if (config.hooks?.beforeOperation)
+                        await config.hooks.beforeOperation(this.buildHookParams(args, config));
+                    let processedArgs = await this.processArguments(args, config);
+                    if (config.hooks?.beforePrisma) {
+                        processedArgs = await config.hooks.beforePrisma(processedArgs, this.buildHookParams(args, config));
+                    }
+                    const prisma = getPrismaInstance();
+                    let result;
+                    if (config.customPrismaLogic) {
+                        result = await config.customPrismaLogic(processedArgs, prisma, config, this);
+                    }
+                    else {
+                        const prismaArgs = this.buildPrismaArgs(processedArgs, config);
+                        result = await prisma[this.modelName][config.prismaMethod](prismaArgs);
+                    }
+                    if (config.hooks?.afterPrisma) {
+                        result = await config.hooks.afterPrisma(result, this.buildHookParams(args, config));
+                    }
+                    await this.executeHooks("after", config.operationType, { ...this.buildHookParams(args, config), result }, context);
+                    if (config.hooks?.afterOperation) {
+                        await config.hooks.afterOperation(result, this.buildHookParams(args, config));
+                    }
+                    return result;
+                }
+                catch (err) {
+                    await this.executeHooks("error", config.operationType, { ...this.buildHookParams(args, config), error: err }, context);
+                    if (context?.throwOnError !== false)
+                        throw err;
+                    return config.returnsFallback;
+                }
+            };
+        };
+        this.executeTransactionOperation = (config) => {
+            return async (...args) => {
+                const context = args[args.length - 1];
+                try {
+                    await this.executeHooks("before", config.operationType, this.buildTransactionHookParams(args, config), context);
+                    const prisma = getPrismaInstance();
+                    const results = await this.executeTransactionLogic(args, config, prisma);
+                    await this.executeHooks("after", config.operationType, { ...this.buildTransactionHookParams(args, config), results }, context);
+                    return results;
+                }
+                catch (err) {
+                    await this.executeHooks("error", config.operationType, { ...this.buildTransactionHookParams(args, config), error: err }, context);
+                    if (context?.throwOnError !== false)
+                        throw err;
+                    return config.returnsFallback;
+                }
+            };
+        };
         this.modelName = camelCase(modelName);
         const modelFields = prismaSchemaParser.getModelRelations(modelName);
         this.relationFields = {
@@ -16,485 +71,328 @@ export class BaseService {
             list: modelFields?.filter((field) => field.isRelation && field.isArray) || [],
         };
     }
-    async createOne(data, queryOptions, context) {
+    async executeHooks(hookType, operationType, params, context) {
         const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeCreateOne &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before"))
-                await serviceHooksManager.handleHook(serviceHooks.beforeCreateOne, {
-                    data,
-                    queryOptions,
+        if (!serviceHooks)
+            return;
+        const skipCondition = context?.skip === hookType ||
+            context?.skip === "all" ||
+            (Array.isArray(context?.skip) && context.skip.includes(hookType));
+        if (skipCondition)
+            return;
+        const hookName = `${hookType === "error" ? "on" : hookType}${operationType.charAt(0).toUpperCase()}${operationType.slice(1)}${hookType === "error" ? "Error" : ""}`;
+        const hook = serviceHooks[hookName];
+        if (hook && typeof hook === "function") {
+            await serviceHooksManager.handleHook(hook, params);
+        }
+    }
+    buildHookParams(args, config) {
+        const context = args[args.length - 1];
+        switch (config.operationType) {
+            case "createOne":
+            case "createMany":
+                return { data: args[0], queryOptions: args[1], context };
+            case "findMany":
+                return { filters: args[0], queryOptions: args[1], context };
+            case "findById":
+                return { id: args[0], queryOptions: args[1], context };
+            case "findOne":
+                return { filters: args[0], queryOptions: args[1], context };
+            case "updateOne":
+                return {
+                    filters: args[0],
+                    data: args[1],
+                    queryOptions: args[2],
                     context,
-                });
-            if (kebabCase(this.modelName) === "user" && data.password)
-                if (!authService.isPasswordHashed(data.password))
-                    data.password = await authService.hashPassword(data.password);
-            const prisma = getPrismaInstance();
-            const dataWithRelationFieldsHandled = handleRelationFieldsInBody(data, {
-                ...this.relationFields,
-            }, ["delete", "disconnect", "update"]);
-            const result = await prisma[this.modelName].create(deepmerge({
-                data: dataWithRelationFieldsHandled,
-            }, queryOptions || {}));
-            if (serviceHooks?.afterCreateOne &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterCreateOne, {
-                    result,
-                    data,
-                    queryOptions,
+                };
+            case "updateMany":
+                return {
+                    filters: args[0],
+                    data: args[1],
+                    queryOptions: args[2],
                     context,
-                });
-            return result;
+                };
+            case "deleteOne":
+                return { filters: args[0], context };
+            case "deleteMany":
+                return { filters: args[0], context };
+            case "count":
+                return { filters: args[0], context };
+            default:
+                return { context };
         }
-        catch (err) {
-            if (serviceHooks?.onCreateOneError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onCreateOneError, {
-                    error: err,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
+    }
+    buildTransactionHookParams(args, config) {
+        const context = args[args.length - 1];
+        switch (config.operationType) {
+            case "batchUpdate":
+                return { data: args[0], queryOptions: args[1], context };
+            case "batchDelete":
+                return { batchFilters: args[0], context };
+            default:
+                return { context };
         }
     }
-    async createMany(data, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeCreateMany &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before")) {
-                await serviceHooksManager.handleHook(serviceHooks.beforeCreateMany, {
-                    data,
-                    queryOptions,
-                    context,
-                });
-            }
-            const prisma = getPrismaInstance();
-            const dataWithRelationFieldsHandled = [];
-            if (Array.isArray(data)) {
-                for (let i = 0; i < data.length; i++) {
-                    const curr = data[i];
-                    if ("password" in curr && this.modelName === "user") {
-                        if (!authService.isPasswordHashed(curr.password)) {
-                            data[i].password = await authService.hashPassword(curr?.password);
-                        }
-                    }
-                    dataWithRelationFieldsHandled[i] = handleRelationFieldsInBody(data[i], { ...this.relationFields }, ["delete", "disconnect", "update"]);
-                }
+    async processArguments(args, config) {
+        let processedArgs = [...args];
+        if (config.requiresPasswordHashing) {
+            const dataIndex = config.operationType.includes("update") &&
+                config.operationType !== "updateMany"
+                ? 1
+                : 0;
+            const data = processedArgs[dataIndex];
+            if (this.shouldHashPassword(data)) {
+                processedArgs[dataIndex] = await this.processPasswordHashing(data);
             }
-            const result = await prisma[this.modelName].createMany(deepmerge({ data: dataWithRelationFieldsHandled }, queryOptions || {}));
-            if (serviceHooks?.afterCreateMany &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterCreateMany, {
-                    result,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            return result;
         }
-        catch (err) {
-            if (serviceHooks?.onCreateManyError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onCreateManyError, {
-                    error: err,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
+        return processedArgs;
+    }
+    buildPrismaArgs(args, config) {
+        switch (config.operationType) {
+            case "createOne":
+            case "createMany":
+                const data = config.relationFieldsHandling
+                    ? handleRelationFieldsInBody(args[0], this.relationFields, config.relationFieldsHandling)
+                    : args[0];
+                return deepmerge({ data }, args[1] || {});
+            case "findMany":
+                return deepmerge({ where: args[0] }, args[1] || {});
+            case "findById":
+                return deepmerge({ where: { id: args[0] } }, args[1] || {});
+            case "findOne":
+                return deepmerge({ where: args[0] }, args[1] || {});
+            case "updateOne":
+                const updateData = config.relationFieldsHandling
+                    ? handleRelationFieldsInBody(args[1], this.relationFields)
+                    : args[1];
+                return deepmerge({ where: args[0], data: updateData }, args[2] || {});
+            case "updateMany":
+                const firstMerge = deepmerge({ data: args[1] }, args[2] || {});
+                return deepmerge({ where: args[0] }, firstMerge);
+            case "deleteOne":
+            case "deleteMany":
+                return { where: args[0] };
+            case "count":
+                return { where: args[0] };
+            default:
+                return {};
         }
     }
-    async count(filters, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeCount &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before")) {
-                await serviceHooksManager.handleHook(serviceHooks.beforeCount, {
-                    filters,
-                    context,
+    async executeTransactionLogic(args, config, prisma) {
+        if (config.operationType === "batchUpdate") {
+            const dataArray = args[0];
+            const queryOptions = args[1];
+            return await prisma.$transaction(async (tx) => {
+                const updatePromises = dataArray.map(async (data) => {
+                    let processedData = data;
+                    if (this.shouldHashPassword(data)) {
+                        processedData = await this.processPasswordHashing(data);
+                    }
+                    const finalPrismaQueryParams = handleRelationFieldsInBody({
+                        batchedData: {
+                            ...processedData,
+                            apiAction: "update",
+                        },
+                    }, {
+                        singular: [
+                            {
+                                ...prismaSchemaParser.getField({
+                                    type: pascalCase(this.modelName),
+                                }),
+                                name: "batchedData",
+                            },
+                        ],
+                        list: [],
+                    });
+                    return await tx[this.modelName].update(deepmerge(finalPrismaQueryParams.batchedData?.update, queryOptions || {}));
                 });
-            }
-            const prisma = getPrismaInstance();
-            const result = await prisma[this.modelName].count({
-                where: filters,
+                return await Promise.all(updatePromises);
             });
-            if (serviceHooks?.afterCount &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after")) {
-                await serviceHooksManager.handleHook(serviceHooks.afterCount, {
-                    result,
-                    filters,
-                    context,
-                });
-            }
-            return result;
         }
-        catch (err) {
-            if (serviceHooks?.onCountError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onCountError, {
-                    error: err,
-                    filters,
-                    context,
+        if (config.operationType === "batchDelete") {
+            const batchFilters = args[0];
+            return await prisma.$transaction(async (tx) => {
+                const deletePromises = batchFilters.map(async (filters) => {
+                    const filtersWithRelationFieldsHandled = handleRelationFieldsInBody(filters, this.relationFields);
+                    return await tx[this.modelName].delete({
+                        where: filtersWithRelationFieldsHandled,
+                    });
                 });
-            if (context?.throwOnError !== false)
-                throw err;
-            return 0;
+                return await Promise.all(deletePromises);
+            });
         }
+        throw new Error(`Unknown transaction operation: ${config.operationType}`);
     }
-    async findMany(filters, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeFindMany &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before")) {
-                await serviceHooksManager.handleHook(serviceHooks.beforeFindMany, {
-                    filters,
-                    queryOptions,
-                    context,
-                });
+    shouldHashPassword(data) {
+        return kebabCase(this.modelName) === "user" && data?.password;
+    }
+    async processPasswordHashing(data) {
+        if (Array.isArray(data)) {
+            const processedArray = [];
+            for (let i = 0; i < data.length; i++) {
+                const curr = data[i];
+                if ("password" in curr &&
+                    !authService.isPasswordHashed(curr.password)) {
+                    processedArray[i] = {
+                        ...curr,
+                        password: await authService.hashPassword(curr.password),
+                    };
+                }
+                else {
+                    processedArray[i] = curr;
+                }
             }
-            const prisma = getPrismaInstance();
-            const result = await prisma[this.modelName].findMany(deepmerge({ where: filters }, queryOptions || {}));
-            if (serviceHooks?.afterFindMany &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterFindMany, {
-                    result,
-                    filters,
-                    queryOptions,
-                    context,
-                });
-            return result;
+            return processedArray;
         }
-        catch (err) {
-            if (serviceHooks?.onFindManyError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onFindManyError, {
-                    error: err,
-                    filters,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return [];
+        else {
+            if (data.password && !authService.isPasswordHashed(data.password)) {
+                return {
+                    ...data,
+                    password: await authService.hashPassword(data.password),
+                };
+            }
         }
+        return data;
+    }
+    async createOne(data, queryOptions, context) {
+        return this.executeOperation({
+            operationType: "createOne",
+            prismaMethod: "create",
+            requiresPasswordHashing: true,
+            relationFieldsHandling: ["delete", "disconnect", "update"],
+            returnsFallback: undefined,
+        })(data, queryOptions, context);
+    }
+    async createMany(data, queryOptions, context) {
+        return this.executeOperation({
+            operationType: "createMany",
+            prismaMethod: "createMany",
+            requiresPasswordHashing: true,
+            relationFieldsHandling: ["delete", "disconnect", "update"],
+            returnsFallback: undefined,
+            customPrismaLogic: async (args, prisma, _, serviceContext) => {
+                const data = args[0];
+                const queryOptions = args[1];
+                const dataWithRelationFieldsHandled = [];
+                if (Array.isArray(data)) {
+                    for (let i = 0; i < data.length; i++) {
+                        let curr = data[i];
+                        if ("password" in curr && serviceContext.modelName === "user") {
+                            if (!authService.isPasswordHashed(curr.password)) {
+                                curr = {
+                                    ...curr,
+                                    password: await authService.hashPassword(curr.password),
+                                };
+                            }
+                        }
+                        dataWithRelationFieldsHandled[i] = handleRelationFieldsInBody(curr, serviceContext.relationFields, ["delete", "disconnect", "update"]);
+                    }
+                }
+                return await prisma[serviceContext.modelName].createMany(deepmerge({ data: dataWithRelationFieldsHandled }, queryOptions || {}));
+            },
+        })(data, queryOptions, context);
+    }
+    async count(filters, context) {
+        return this.executeOperation({
+            operationType: "count",
+            prismaMethod: "count",
+            returnsFallback: 0,
+        })(filters, context);
+    }
+    async findMany(filters, queryOptions, context) {
+        return this.executeOperation({
+            operationType: "findMany",
+            prismaMethod: "findMany",
+            returnsFallback: [],
+        })(filters, queryOptions, context);
     }
     async findById(id, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeFindById &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before")) {
-                await serviceHooksManager.handleHook(serviceHooks.beforeFindById, {
-                    id,
-                    queryOptions,
-                    context,
-                });
-            }
-            const prisma = getPrismaInstance();
-            const result = await prisma[this.modelName].findUnique(deepmerge({
-                where: { id },
-            }, queryOptions || {}));
-            if (serviceHooks?.afterFindById &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after")) {
-                await serviceHooksManager.handleHook(serviceHooks.afterFindById, {
-                    result,
-                    id,
-                    queryOptions,
-                    context,
-                });
-            }
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onFindByIdError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onFindByIdError, {
-                    error: err,
-                    id,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+        return this.executeOperation({
+            operationType: "findById",
+            prismaMethod: "findUnique",
+            returnsFallback: undefined,
+        })(id, queryOptions, context);
     }
     async findOne(filters, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeFindOne &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before")) {
-                await serviceHooksManager.handleHook(serviceHooks.beforeFindOne, {
-                    filters,
-                    queryOptions,
-                    context,
-                });
-            }
-            const prisma = getPrismaInstance();
-            let result;
-            if (Object.keys(filters).length === 1 &&
-                "id" in filters &&
-                filters.id !== "me")
-                result = await prisma[this.modelName].findUnique(deepmerge({
-                    where: filters,
-                }, queryOptions || {}));
-            else
-                result = await prisma[this.modelName].findFirst(deepmerge({
-                    where: filters,
-                }, queryOptions || {}));
-            if (serviceHooks?.afterFindOne &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterFindOne, {
-                    result,
-                    filters,
-                    queryOptions,
-                    context,
-                });
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onFindOneError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onFindOneError, {
-                    error: err,
-                    filters,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+        return this.executeOperation({
+            operationType: "findOne",
+            prismaMethod: "findFirst",
+            returnsFallback: undefined,
+            customPrismaLogic: async (args, prisma, _, serviceContext) => {
+                const filters = args[0];
+                const queryOptions = args[1];
+                if (Object.keys(filters).length === 1 &&
+                    "id" in filters &&
+                    filters.id !== "me") {
+                    return await prisma[serviceContext.modelName].findUnique(deepmerge({ where: filters }, queryOptions || {}));
+                }
+                else {
+                    return await prisma[serviceContext.modelName].findFirst(deepmerge({ where: filters }, queryOptions || {}));
+                }
+            },
+        })(filters, queryOptions, context);
     }
     async updateOne(filters, data, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeUpdateOne &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before"))
-                await serviceHooksManager.handleHook(serviceHooks.beforeUpdateOne, {
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            if (kebabCase(this.modelName) === "user" && data?.password) {
-                if (!authService.isPasswordHashed(data.password))
-                    data.password = await authService.hashPassword(data?.password);
-            }
-            const prisma = getPrismaInstance();
-            const dataWithRelationFieldsHandled = handleRelationFieldsInBody(data, {
-                ...this.relationFields,
-            });
-            const result = await prisma[this.modelName].update(deepmerge({
-                where: filters,
-                data: dataWithRelationFieldsHandled,
-            }, queryOptions || {}));
-            if (serviceHooks?.afterUpdateOne &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterUpdateOne, {
-                    result,
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onUpdateOneError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onUpdateOneError, {
-                    error: err,
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+        return this.executeOperation({
+            operationType: "updateOne",
+            prismaMethod: "update",
+            requiresPasswordHashing: true,
+            relationFieldsHandling: [],
+            returnsFallback: undefined,
+        })(filters, data, queryOptions, context);
     }
     async updateMany(filters, data, queryOptions, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeUpdateMany &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before"))
-                await serviceHooksManager.handleHook(serviceHooks.beforeUpdateMany, {
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            const prisma = getPrismaInstance();
-            if (this.modelName === "user" &&
-                "password" in data &&
-                data?.password) {
-                if (!authService.isPasswordHashed(data.password)) {
-                    data.password = await authService.hashPassword(data?.password);
+        return this.executeOperation({
+            operationType: "updateMany",
+            prismaMethod: "updateMany",
+            requiresPasswordHashing: true,
+            returnsFallback: undefined,
+            customPrismaLogic: async (args, prisma, _, serviceContext) => {
+                const filters = args[0];
+                const data = args[1];
+                const queryOptions = args[2];
+                let processedData = data;
+                if (serviceContext.modelName === "user" && data?.password) {
+                    if (!authService.isPasswordHashed(data.password)) {
+                        processedData = {
+                            ...data,
+                            password: await authService.hashPassword(data.password),
+                        };
+                    }
                 }
-            }
-            const firstMerge = deepmerge({ data }, queryOptions || {});
-            const result = await prisma[this.modelName].updateMany(deepmerge({ where: filters }, firstMerge));
-            if (serviceHooks?.afterUpdateMany &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterUpdateMany, {
-                    result,
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onUpdateManyError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onUpdateManyError, {
-                    error: err,
-                    filters,
-                    data,
-                    queryOptions,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+                const firstMerge = deepmerge({ data: processedData }, queryOptions || {});
+                return await prisma[serviceContext.modelName].updateMany(deepmerge({ where: filters }, firstMerge));
+            },
+        })(filters, data, queryOptions, context);
     }
     async deleteOne(filters, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeDeleteOne &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before"))
-                await serviceHooksManager.handleHook(serviceHooks.beforeDeleteOne, {
-                    filters,
-                    context,
-                });
-            const prisma = getPrismaInstance();
-            const result = await prisma[this.modelName].delete({
-                where: filters,
-            });
-            if (serviceHooks?.afterDeleteOne &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterDeleteOne, {
-                    result,
-                    filters,
-                    context,
-                });
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onDeleteOneError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onDeleteOneError, {
-                    error: err,
-                    filters,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+        return this.executeOperation({
+            operationType: "deleteOne",
+            prismaMethod: "delete",
+            returnsFallback: undefined,
+        })(filters, context);
     }
     async deleteMany(filters, context) {
-        const serviceHooks = getModuleComponents(this.modelName)?.hooks;
-        try {
-            if (serviceHooks?.beforeDeleteMany &&
-                context?.skip !== "before" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("before"))
-                await serviceHooksManager.handleHook(serviceHooks.beforeDeleteMany, {
-                    filters,
-                    context,
-                });
-            const prisma = getPrismaInstance();
-            const result = await prisma[this.modelName].deleteMany({
-                where: filters,
-            });
-            if (serviceHooks?.afterDeleteMany &&
-                context?.skip !== "after" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("after"))
-                await serviceHooksManager.handleHook(serviceHooks.afterDeleteMany, {
-                    result,
-                    filters,
-                    context,
-                });
-            return result;
-        }
-        catch (err) {
-            if (serviceHooks?.onDeleteManyError &&
-                context?.skip !== "error" &&
-                context?.skip !== "all" &&
-                !context?.skip?.includes("error"))
-                await serviceHooksManager.handleHook(serviceHooks.onDeleteManyError, {
-                    error: err,
-                    filters,
-                    context,
-                });
-            if (context?.throwOnError !== false)
-                throw err;
-            return undefined;
-        }
+        return this.executeOperation({
+            operationType: "deleteMany",
+            prismaMethod: "deleteMany",
+            returnsFallback: undefined,
+        })(filters, context);
+    }
+    async batchUpdate(dataArray, queryOptions, context) {
+        return this.executeTransactionOperation({
+            operationType: "batchUpdate",
+            prismaMethod: "update",
+            requiresPasswordHashing: true,
+            returnsFallback: undefined,
+        })(dataArray, queryOptions, context);
+    }
+    async batchDelete(batchFilters, context) {
+        return this.executeTransactionOperation({
+            operationType: "batchDelete",
+            prismaMethod: "delete",
+            returnsFallback: undefined,
+        })(batchFilters, context);
     }
 }
 //# sourceMappingURL=base.service.js.map