arkos 1.3.1-beta → 1.3.2-beta

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

@@ -1 +1,81 @@
-"use strict";import{getArkosConfig as m}from"../../server.js";import u from"../../utils/helpers/deepmerge.helper.js";import{catchAsync as l}from"../../exports/error-handler/index.js";import f from"../../utils/validate-dto.js";import x from"../../utils/validate-schema.js";import{resolvePrismaQueryOptions as c}from"./utils/helpers/base.middlewares.helpers.js";export function callNext(t,e,n){n()}export function sendResponse(t,e){Number(t?.responseStatus)===204?e.status(Number(t?.responseStatus)).send():t.responseData&&t?.responseStatus?e.status(Number(t?.responseStatus)).json(t.responseData):Number(t?.responseStatus)&&!t.responseData?e.status(Number(t?.responseStatus)).send():e.status(500).json({message:"No status or data attached to the response"})}export function addRouteMiddlwaresAndConfigs(){}export function addPrismaQueryOptionsToRequest(t,e){return(n,i,r)=>{const s=m(),o=c(t,e),a=s?.request?.parameters?.allowDangerousPrismaQueryOptions?JSON.parse(n.query?.prismaQueryOptions||"{}"):{};n.prismaQueryOptions=u(o,a),r()}}export function handleRequestLogs(t,e,n){const i=Date.now(),r={GET:"\x1B[36m",POST:"\x1B[32m",PUT:"\x1B[33m",PATCH:"\x1B[33m",DELETE:"\x1B[31m",HEAD:"\x1B[34m",OPTIONS:"\x1B[34m"},s=o=>o>=200&&o<300?"\x1B[32m":o>=300&&o<400||o>=400&&o<500?"\x1B[33m":o>=500?"\x1B[31m":"\x1B[0m";e.on("finish",()=>{const o=Date.now()-i,p=new Date().toTimeString().split(" ")[0],d=r[t.method]||"\x1B[0m",b=s(e.statusCode);console.info(`[\x1B[36mInfo\x1B[0m] \x1B[90m${p}\x1B[0m ${d}${t.method}\x1B[0m ${decodeURIComponent(t.originalUrl)} ${b}${e.statusCode}\x1B[0m \x1B[35m${o}ms\x1B[0m`)}),n()}export function handleRequestBodyValidationAndTransformation(t,e){return l(async(n,i,r)=>{const s=m()?.validation;let o=n.body;s?.resolver==="class-validator"&&t?n.body=await f(t,o,u({whitelist:!0,...e},s?.validationOptions||{})):s?.resolver==="zod"&&t&&(n.body=await x(t,o)),r()})}
+import { getArkosConfig } from "../../server.js";
+import deepmerge from "../../utils/helpers/deepmerge.helper.js";
+import { catchAsync } from "../../exports/error-handler/index.js";
+import validateDto from "../../utils/validate-dto.js";
+import validateSchema from "../../utils/validate-schema.js";
+import { resolvePrismaQueryOptions } from "./utils/helpers/base.middlewares.helpers.js";
+export function callNext(_, _1, next) {
+    next();
+}
+export function sendResponse(req, res) {
+    if (Number(req?.responseStatus) === 204)
+        res.status(Number(req?.responseStatus)).send();
+    else if (req.responseData && req?.responseStatus)
+        res.status(Number(req?.responseStatus)).json(req.responseData);
+    else if (Number(req?.responseStatus) && !req.responseData)
+        res.status(Number(req?.responseStatus)).send();
+    else
+        res
+            .status(500)
+            .json({ message: "No status or data attached to the response" });
+}
+export function addRouteMiddlwaresAndConfigs() { }
+export function addPrismaQueryOptionsToRequest(prismaQueryOptions, action) {
+    return (req, _, next) => {
+        const configs = getArkosConfig();
+        const resolvedOptions = resolvePrismaQueryOptions(prismaQueryOptions, action);
+        const requestQueryOptions = configs?.request?.parameters
+            ?.allowDangerousPrismaQueryOptions
+            ? JSON.parse(req.query?.prismaQueryOptions || "{}")
+            : {};
+        req.prismaQueryOptions = deepmerge(resolvedOptions, requestQueryOptions);
+        next();
+    };
+}
+export function handleRequestLogs(req, res, next) {
+    const startTime = Date.now();
+    const methodColors = {
+        GET: "\x1b[36m",
+        POST: "\x1b[32m",
+        PUT: "\x1b[33m",
+        PATCH: "\x1b[33m",
+        DELETE: "\x1b[31m",
+        HEAD: "\x1b[34m",
+        OPTIONS: "\x1b[34m",
+    };
+    const getStatusColor = (statusCode) => {
+        if (statusCode >= 200 && statusCode < 300)
+            return "\x1b[32m";
+        if (statusCode >= 300 && statusCode < 400)
+            return "\x1b[33m";
+        if (statusCode >= 400 && statusCode < 500)
+            return "\x1b[33m";
+        if (statusCode >= 500)
+            return "\x1b[31m";
+        return "\x1b[0m";
+    };
+    res.on("finish", () => {
+        const duration = Date.now() - startTime;
+        const now = new Date();
+        const time = now.toTimeString().split(" ")[0];
+        const methodColor = methodColors[req.method] || "\x1b[0m";
+        const statusColor = getStatusColor(res.statusCode);
+        console.info(`[\x1b[36mInfo\x1b[0m] \x1b[90m${time}\x1b[0m ${methodColor}${req.method}\x1b[0m ${decodeURIComponent(req.originalUrl)} ${statusColor}${res.statusCode}\x1b[0m \x1b[35m${duration}ms\x1b[0m`);
+    });
+    next();
+}
+export function handleRequestBodyValidationAndTransformation(schemaOrDtoClass, classValidatorValidationOptions) {
+    return catchAsync(async (req, _, next) => {
+        const validationConfigs = getArkosConfig()?.validation;
+        let body = req.body;
+        if (validationConfigs?.resolver === "class-validator" && schemaOrDtoClass)
+            req.body = await validateDto(schemaOrDtoClass, body, deepmerge({
+                whitelist: true,
+                ...classValidatorValidationOptions,
+            }, validationConfigs?.validationOptions || {}));
+        else if (validationConfigs?.resolver === "zod" && schemaOrDtoClass)
+            req.body = await validateSchema(schemaOrDtoClass, body);
+        next();
+    });
+}
+//# sourceMappingURL=base.middlewares.js.map

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

@@ -1 +1,15 @@
-"use strict";import{Router as r}from"express";import{getAvailableResources as o}from"./base.controller.js";import a from"../auth/auth.service.js";import{setupRouters as u}from"./utils/helpers/base.router.helpers.js";export async function getPrismaModelsRouter(e){const t=r();return await Promise.all(await u(t,e)),t}export function getAvailableResourcesAndRoutesRouter(){const e=r();return e.get("/available-resources",a?.authenticate,o),e}
+import { Router } from "express";
+import { getAvailableResources } from "./base.controller.js";
+import authService from "../auth/auth.service.js";
+import { setupRouters } from "./utils/helpers/base.router.helpers.js";
+export async function getPrismaModelsRouter(arkosConfigs) {
+    const router = Router();
+    await Promise.all(await setupRouters(router, arkosConfigs));
+    return router;
+}
+export function getAvailableResourcesAndRoutesRouter() {
+    const router = Router();
+    router.get("/available-resources", authService?.authenticate, getAvailableResources);
+    return router;
+}
+//# sourceMappingURL=base.router.js.map

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

@@ -1 +1,500 @@
-"use strict";import{camelCase as p,kebabCase as u}from"../../utils/helpers/change-case.helpers.js";import{getModuleComponents as l}from"../../utils/dynamic-loader.js";import f from"../../utils/helpers/deepmerge.helper.js";import{handleRelationFieldsInBody as k}from"./utils/helpers/base.service.helpers.js";import{getPrismaInstance as h}from"../../utils/helpers/prisma.helpers.js";import w from"../auth/auth.service.js";import i from"./utils/service-hooks-manager.js";import c from"../../utils/prisma/prisma-schema-parser.js";export class BaseService{constructor(a){this.modelName=p(a);const r=c.getModelRelations(a);this.relationFields={singular:r?.filter(e=>e.isRelation&&!e.isArray)||[],list:r?.filter(e=>e.isRelation&&e.isArray)||[]}}async createOne(a,r,e){const o=l(this.modelName)?.hooks;try{o?.beforeCreateOne&&!e?.skip?.includes("before")&&await i.handleHook(o.beforeCreateOne,{data:a,queryOptions:r,context:e}),u(this.modelName)==="user"&&a.password&&(w.isPasswordHashed(a.password)||(a.password=await w.hashPassword(a.password)));const s=h(),n=k(a,{...this.relationFields},["delete","disconnect","update"]),t=await s[this.modelName].create(f({data:n},r||{}));return o?.afterCreateOne&&!e?.skip?.includes("after")&&await i.handleHook(o.afterCreateOne,{result:t,data:a,queryOptions:r,context:e}),t}catch(s){if(o?.onCreateOneError&&!e?.skip?.includes("error")&&await i.handleHook(o.onCreateOneError,{error:s,data:a,queryOptions:r,context:e}),e?.throwOnError!==!1)throw s;return}}async createMany(a,r,e){const o=l(this.modelName)?.hooks;try{o?.beforeCreateMany&&!e?.skip?.includes("before")&&await i.handleHook(o.beforeCreateMany,{data:a,queryOptions:r,context:e});const s=h(),n=[];if(Array.isArray(a))for(let d=0;d<a.length;d++){const m=a[d];"password"in m&&this.modelName==="user"&&(w.isPasswordHashed(m.password)||(a[d].password=await w.hashPassword(m?.password))),n[d]=k(a[d],{...this.relationFields},["delete","disconnect","update"])}const t=await s[this.modelName].createMany(f({data:n},r||{}));return o?.afterCreateMany&&!e?.skip?.includes("after")&&await i.handleHook(o.afterCreateMany,{result:t,data:a,queryOptions:r,context:e}),t}catch(s){if(o?.onCreateManyError&&!e?.skip?.includes("error")&&await i.handleHook(o.onCreateManyError,{error:s,data:a,queryOptions:r,context:e}),e?.throwOnError!==!1)throw s;return}}async count(a,r){const e=l(this.modelName)?.hooks;try{e?.beforeCount&&!r?.skip?.includes("before")&&await i.handleHook(e.beforeCount,{filters:a,context:r});const s=await h()[this.modelName].count({where:a});return e?.afterCount&&!r?.skip?.includes("after")&&await i.handleHook(e.afterCount,{result:s,filters:a,context:r}),s}catch(o){if(e?.onCountError&&!r?.skip?.includes("error")&&await i.handleHook(e.onCountError,{error:o,filters:a,context:r}),r?.throwOnError!==!1)throw o;return 0}}async findMany(a,r,e){const o=l(this.modelName)?.hooks;try{o?.beforeFindMany&&!e?.skip?.includes("before")&&await i.handleHook(o.beforeFindMany,{filters:a,queryOptions:r,context:e});const n=await h()[this.modelName].findMany(f({where:a},r||{}));return o?.afterFindMany&&!e?.skip?.includes("after")&&await i.handleHook(o.afterFindMany,{result:n,filters:a,queryOptions:r,context:e}),n}catch(s){if(o?.onFindManyError&&!e?.skip?.includes("error")&&await i.handleHook(o.onFindManyError,{error:s,filters:a,queryOptions:r,context:e}),e?.throwOnError!==!1)throw s;return[]}}async findById(a,r,e){const o=l(this.modelName)?.hooks;try{o?.beforeFindById&&!e?.skip?.includes("before")&&await i.handleHook(o.beforeFindById,{id:a,queryOptions:r,context:e});const n=await h()[this.modelName].findUnique(f({where:{id:a}},r||{}));return o?.afterFindById&&!e?.skip?.includes("after")&&await i.handleHook(o.afterFindById,{result:n,id:a,queryOptions:r,context:e}),n}catch(s){if(o?.onFindByIdError&&!e?.skip?.includes("error")&&await i.handleHook(o.onFindByIdError,{error:s,id:a,queryOptions:r,context:e}),e?.throwOnError!==!1)throw s;return}}async findOne(a,r,e){const o=l(this.modelName)?.hooks;try{o?.beforeFindOne&&!e?.skip?.includes("before")&&await i.handleHook(o.beforeFindOne,{filters:a,queryOptions:r,context:e});const s=h();let n;return Object.keys(a).length===1&&"id"in a&&a.id!=="me"?n=await s[this.modelName].findUnique(f({where:a},r||{})):n=await s[this.modelName].findFirst(f({where:a},r||{})),o?.afterFindOne&&!e?.skip?.includes("after")&&await i.handleHook(o.afterFindOne,{result:n,filters:a,queryOptions:r,context:e}),n}catch(s){if(o?.onFindOneError&&!e?.skip?.includes("error")&&await i.handleHook(o.onFindOneError,{error:s,filters:a,queryOptions:r,context:e}),e?.throwOnError!==!1)throw s;return}}async updateOne(a,r,e,o){const s=l(this.modelName)?.hooks;try{s?.beforeUpdateOne&&!o?.skip?.includes("before")&&await i.handleHook(s.beforeUpdateOne,{filters:a,data:r,queryOptions:e,context:o}),u(this.modelName)==="user"&&r?.password&&(w.isPasswordHashed(r.password)||(r.password=await w.hashPassword(r?.password)));const n=h(),t=k(r,{...this.relationFields}),d=await n[this.modelName].update(f({where:a,data:t},e||{}));return s?.afterUpdateOne&&!o?.skip?.includes("after")&&await i.handleHook(s.afterUpdateOne,{result:d,filters:a,data:r,queryOptions:e,context:o}),d}catch(n){if(s?.onUpdateOneError&&!o?.skip?.includes("error")&&await i.handleHook(s.onUpdateOneError,{error:n,filters:a,data:r,queryOptions:e,context:o}),o?.throwOnError!==!1)throw n;return}}async updateMany(a,r,e,o){const s=l(this.modelName)?.hooks;try{s?.beforeUpdateMany&&!o?.skip?.includes("before")&&await i.handleHook(s.beforeUpdateMany,{filters:a,data:r,queryOptions:e,context:o});const n=h();this.modelName==="user"&&"password"in r&&r?.password&&(w.isPasswordHashed(r.password)||(r.password=await w.hashPassword(r?.password)));const t=f({data:r},e||{}),d=await n[this.modelName].updateMany(f({where:a},t));return s?.afterUpdateMany&&!o?.skip?.includes("after")&&await i.handleHook(s.afterUpdateMany,{result:d,filters:a,data:r,queryOptions:e,context:o}),d}catch(n){if(s?.onUpdateManyError&&!o?.skip?.includes("error")&&await i.handleHook(s.onUpdateManyError,{error:n,filters:a,data:r,queryOptions:e,context:o}),o?.throwOnError!==!1)throw n;return}}async deleteOne(a,r){const e=l(this.modelName)?.hooks;try{e?.beforeDeleteOne&&!r?.skip?.includes("before")&&await i.handleHook(e.beforeDeleteOne,{filters:a,context:r});const s=await h()[this.modelName].delete({where:a});return e?.afterDeleteOne&&!r?.skip?.includes("after")&&await i.handleHook(e.afterDeleteOne,{result:s,filters:a,context:r}),s}catch(o){if(e?.onDeleteOneError&&!r?.skip?.includes("error")&&await i.handleHook(e.onDeleteOneError,{error:o,filters:a,context:r}),r?.throwOnError!==!1)throw o;return}}async deleteMany(a,r){const e=l(this.modelName)?.hooks;try{e?.beforeDeleteMany&&!r?.skip?.includes("before")&&await i.handleHook(e.beforeDeleteMany,{filters:a,context:r});const s=await h()[this.modelName].deleteMany({where:a});return e?.afterDeleteMany&&!r?.skip?.includes("after")&&await i.handleHook(e.afterDeleteMany,{result:s,filters:a,context:r}),s}catch(o){if(e?.onDeleteManyError&&!r?.skip?.includes("error")&&await i.handleHook(e.onDeleteManyError,{error:o,filters:a,context:r}),r?.throwOnError!==!1)throw o;return}}}
+import { camelCase, kebabCase } 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";
+import { getPrismaInstance } from "../../utils/helpers/prisma.helpers.js";
+import authService from "../auth/auth.service.js";
+import serviceHooksManager from "./utils/service-hooks-manager.js";
+import prismaSchemaParser from "../../utils/prisma/prisma-schema-parser.js";
+export class BaseService {
+    constructor(modelName) {
+        this.modelName = camelCase(modelName);
+        const modelFields = prismaSchemaParser.getModelRelations(modelName);
+        this.relationFields = {
+            singular: modelFields?.filter((field) => field.isRelation && !field.isArray) ||
+                [],
+            list: modelFields?.filter((field) => field.isRelation && field.isArray) || [],
+        };
+    }
+    async createOne(data, queryOptions, 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,
+                    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,
+                    context,
+                });
+            return result;
+        }
+        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;
+        }
+    }
+    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"]);
+                }
+            }
+            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;
+        }
+    }
+    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,
+                });
+            }
+            const prisma = getPrismaInstance();
+            const result = await prisma[this.modelName].count({
+                where: filters,
+            });
+            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 (context?.throwOnError !== false)
+                throw err;
+            return 0;
+        }
+    }
+    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,
+                });
+            }
+            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;
+        }
+        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 [];
+        }
+    }
+    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;
+        }
+    }
+    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;
+        }
+    }
+    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;
+        }
+    }
+    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);
+                }
+            }
+            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;
+        }
+    }
+    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;
+        }
+    }
+    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;
+        }
+    }
+}
+//# sourceMappingURL=base.service.js.map