arkos 2.0.0-next.3 → 2.0.0-next.30

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

@@ -1,78 +1,14 @@
-import { camelCase, kebabCase, pascalCase, } from "../../utils/helpers/change-case.helpers.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";
-import loadableRegistry from "../../components/arkos-loadable-registry/index.js";
-import { serviceHookReader } from "../../components/arkos-service-hook/reader.js";
-export class BaseService {
+import { camelCase, kebabCase, pascalCase, } from '../../utils/helpers/change-case.helpers.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 prismaSchemaParser from '../../utils/prisma/prisma-schema-parser.js';
+export class ArkosPrismaService {
+    modelName;
+    relationFields;
+    prismaInstace;
     constructor(modelName) {
-        this.executeOperation = (config) => {
-            return async (...args) => {
-                const context = args[args.length - 1];
-                try {
-                    let argsWithRelationFieldsHandled = await this.processRelationFieldsInBody(args, config);
-                    let prismaFinalArgs = await this.handlePasswordHashing(argsWithRelationFieldsHandled, config);
-                    await this.executeHooks("before", config.operationType, this.buildHookParams(argsWithRelationFieldsHandled, config), context);
-                    if (config.hooks?.beforeOperation)
-                        await config.hooks.beforeOperation(this.buildHookParams(argsWithRelationFieldsHandled, config));
-                    if (config.hooks?.beforePrisma) {
-                        argsWithRelationFieldsHandled = await config.hooks.beforePrisma(argsWithRelationFieldsHandled, this.buildHookParams(argsWithRelationFieldsHandled, config));
-                    }
-                    const prisma = getPrismaInstance();
-                    let result;
-                    if (config.customPrismaLogic) {
-                        result = await config.customPrismaLogic(argsWithRelationFieldsHandled, prisma, config, this);
-                    }
-                    else {
-                        const prismaArgs = this.buildPrismaArgs(prismaFinalArgs, config);
-                        result = await prisma[this.modelName][config.prismaMethod](prismaArgs);
-                    }
-                    if (config.hooks?.afterPrisma) {
-                        result = await config.hooks.afterPrisma(result, this.buildHookParams(argsWithRelationFieldsHandled, config));
-                    }
-                    await this.executeHooks("after", config.operationType, {
-                        ...this.buildHookParams(argsWithRelationFieldsHandled, config),
-                        result,
-                    }, context);
-                    if (config.hooks?.afterOperation) {
-                        await config.hooks.afterOperation(result, this.buildHookParams(argsWithRelationFieldsHandled, 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 {
-                    let argsWithRelationFieldsHandled = await this.processRelationFieldsInBody(args, config);
-                    let prismaFinalArgs = await this.handlePasswordHashing(argsWithRelationFieldsHandled, config);
-                    await this.executeHooks("before", config.operationType, this.buildTransactionHookParams(argsWithRelationFieldsHandled, config), context);
-                    const prisma = getPrismaInstance();
-                    const results = await this.executeTransactionLogic(prismaFinalArgs, config, prisma);
-                    await this.executeHooks("after", config.operationType, {
-                        ...this.buildTransactionHookParams(argsWithRelationFieldsHandled, 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 = {
@@ -80,82 +16,41 @@ export class BaseService {
                 [],
             list: modelFields?.filter((field) => field.isRelation && field.isArray) || [],
         };
-        this.prisma = getPrismaInstance();
-    }
-    getServiceHook() {
-        return loadableRegistry.getItem("ArkosServiceHook", kebabCase(this.modelName));
     }
-    async executeHooks(hookType, operationType, params, context) {
-        const serviceHook = this.getServiceHook();
-        if (!serviceHook)
-            return;
-        const skipCondition = context?.skip === hookType ||
-            context?.skip === "all" ||
-            (Array.isArray(context?.skip) && context.skip.includes(hookType));
-        if (skipCondition || ["batchDelete", "batchUpdate"].includes(operationType))
-            return;
-        const hooks = serviceHookReader.getHooks(this.modelName, operationType);
-        if (!hooks)
-            return;
-        const handlers = hookType === "before"
-            ? hooks.before
-            : hookType === "after"
-                ? hooks.after
-                : hooks.onError;
-        if (handlers?.length)
-            await serviceHooksManager.handleHook(handlers, 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,
-                };
-            case "updateMany":
-                return {
-                    filters: args[0],
-                    data: args[1],
-                    queryOptions: args[2],
-                    context,
-                };
-            case "deleteOne":
-                return { filters: args[0], context };
-            case "deleteMany":
-                return { filters: args[0], context };
-            case "count":
-                return { filters: args[0], context };
-            default:
-                return { context };
-        }
-    }
-    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 };
-        }
+    get prisma() {
+        if (!this.prismaInstace)
+            this.prismaInstace = getPrismaInstance();
+        return this.prismaInstace;
     }
+    executeOperation = (config) => {
+        return async (...args) => {
+            let argsWithRelationFieldsHandled = await this.processRelationFieldsInBody(args, config);
+            let prismaFinalArgs = await this.handlePasswordHashing(argsWithRelationFieldsHandled, config);
+            const prisma = getPrismaInstance();
+            let result;
+            if (config.customPrismaLogic) {
+                result = await config.customPrismaLogic(argsWithRelationFieldsHandled, prisma, config, this);
+            }
+            else {
+                const prismaArgs = this.buildPrismaArgs(prismaFinalArgs, config);
+                result = await prisma[this.modelName][config.prismaMethod](prismaArgs);
+            }
+            return result;
+        };
+    };
+    executeTransactionOperation = (config) => {
+        return async (...args) => {
+            let argsWithRelationFieldsHandled = await this.processRelationFieldsInBody(args, config);
+            let prismaFinalArgs = await this.handlePasswordHashing(argsWithRelationFieldsHandled, config);
+            const prisma = getPrismaInstance();
+            const results = await this.executeTransactionLogic(prismaFinalArgs, config, prisma);
+            return results;
+        };
+    };
     async handlePasswordHashing(args, config) {
         let processedArgs = [...args];
         if (config.requiresPasswordHashing) {
-            const dataIndex = config.operationType.includes("update") ? 1 : 0;
+            const dataIndex = config.operationType.includes('update') ? 1 : 0;
             const data = processedArgs[dataIndex];
             if (Array.isArray(data)) {
                 for (const i in data) {
@@ -172,20 +67,20 @@ export class BaseService {
     async processRelationFieldsInBody(args, config) {
         let processedArgs = [...args];
         if (config.relationFieldsHandling) {
-            const dataIndex = config.operationType.includes("update") ? 1 : 0;
-            if (config.operationType === "batchUpdate") {
+            const dataIndex = config.operationType.includes('update') ? 1 : 0;
+            if (config.operationType === 'batchUpdate') {
                 const dataArray = processedArgs[0];
                 if (Array.isArray(dataArray)) {
                     processedArgs[0] = dataArray.map((data) => handleRelationFieldsInBody(data, this.relationFields, config.relationFieldsHandling));
                 }
             }
-            else if (config.operationType === "batchDelete") {
+            else if (config.operationType === 'batchDelete') {
                 const batchFilters = processedArgs[0];
                 if (Array.isArray(batchFilters)) {
                     processedArgs[0] = batchFilters.map((filters) => handleRelationFieldsInBody(filters, this.relationFields));
                 }
             }
-            else if (config.operationType === "createMany") {
+            else if (config.operationType === 'createMany') {
                 const data = processedArgs[dataIndex];
                 if (Array.isArray(data)) {
                     processedArgs[dataIndex] = data.map((item) => handleRelationFieldsInBody(item, this.relationFields, config.relationFieldsHandling));
@@ -202,31 +97,31 @@ export class BaseService {
     }
     buildPrismaArgs(args, config) {
         switch (config.operationType) {
-            case "createOne":
-            case "createMany":
+            case 'createOne':
+            case 'createMany':
                 return deepmerge({ data: args[0] }, args[1] || {});
-            case "findMany":
+            case 'findMany':
                 return deepmerge({ where: args[0] }, args[1] || {});
-            case "findById":
+            case 'findById':
                 return deepmerge({ where: { id: args[0] } }, args[1] || {});
-            case "findOne":
+            case 'findOne':
                 return deepmerge({ where: args[0] }, args[1] || {});
-            case "updateOne":
+            case 'updateOne':
                 return deepmerge({ where: args[0], data: args[1] }, args[2] || {});
-            case "updateMany":
+            case 'updateMany':
                 const firstMerge = deepmerge({ data: args[1] }, args[2] || {});
                 return deepmerge({ where: args[0] }, firstMerge);
-            case "deleteOne":
-            case "deleteMany":
+            case 'deleteOne':
+            case 'deleteMany':
                 return { where: args[0] };
-            case "count":
+            case 'count':
                 return { where: args[0] };
             default:
                 return {};
         }
     }
     async executeTransactionLogic(args, config, prisma) {
-        if (config.operationType === "batchUpdate") {
+        if (config.operationType === 'batchUpdate') {
             const dataArray = args[0];
             const queryOptions = args[1];
             return await prisma.$transaction(async (tx) => {
@@ -238,7 +133,7 @@ export class BaseService {
                     const finalPrismaQueryParams = handleRelationFieldsInBody({
                         batchedData: {
                             ...processedData,
-                            apiAction: "update",
+                            apiAction: 'update',
                         },
                     }, {
                         singular: [
@@ -246,7 +141,7 @@ export class BaseService {
                                 ...prismaSchemaParser.getField({
                                     type: pascalCase(this.modelName),
                                 }),
-                                name: "batchedData",
+                                name: 'batchedData',
                             },
                         ],
                         list: [],
@@ -256,7 +151,7 @@ export class BaseService {
                 return await Promise.all(updatePromises);
             });
         }
-        if (config.operationType === "batchDelete") {
+        if (config.operationType === 'batchDelete') {
             const batchFilters = args[0];
             return await prisma.$transaction(async (tx) => {
                 const deletePromises = batchFilters.map(async (filters) => {
@@ -268,14 +163,14 @@ export class BaseService {
         throw new Error(`Unknown transaction operation: ${config.operationType}`);
     }
     shouldHashPassword(data) {
-        return kebabCase(this.modelName) === "user" && data?.password;
+        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 &&
+                if ('password' in curr &&
                     !authService.isPasswordHashed(curr.password)) {
                     processedArray[i] = {
                         ...curr,
@@ -300,54 +195,54 @@ export class BaseService {
     }
     async createOne(data, queryOptions, context) {
         return this.executeOperation({
-            operationType: "createOne",
-            prismaMethod: "create",
+            operationType: 'createOne',
+            prismaMethod: 'create',
             requiresPasswordHashing: true,
-            relationFieldsHandling: ["delete", "disconnect", "update"],
+            relationFieldsHandling: ['delete', 'disconnect', 'update'],
             returnsFallback: undefined,
         })(data, queryOptions, context);
     }
     async createMany(data, queryOptions, context) {
         return this.executeOperation({
-            operationType: "createMany",
-            prismaMethod: "createMany",
+            operationType: 'createMany',
+            prismaMethod: 'createMany',
             requiresPasswordHashing: true,
-            relationFieldsHandling: ["delete", "disconnect", "update"],
+            relationFieldsHandling: ['delete', 'disconnect', 'update'],
             returnsFallback: undefined,
         })(data, queryOptions, context);
     }
     async count(filters, context) {
         return this.executeOperation({
-            operationType: "count",
-            prismaMethod: "count",
+            operationType: 'count',
+            prismaMethod: 'count',
             returnsFallback: 0,
         })(filters, context);
     }
     async findMany(filters, queryOptions, context) {
         return this.executeOperation({
-            operationType: "findMany",
-            prismaMethod: "findMany",
+            operationType: 'findMany',
+            prismaMethod: 'findMany',
             returnsFallback: [],
         })(filters, queryOptions, context);
     }
     async findById(id, queryOptions, context) {
         return this.executeOperation({
-            operationType: "findById",
-            prismaMethod: "findUnique",
+            operationType: 'findById',
+            prismaMethod: 'findUnique',
             returnsFallback: undefined,
         })(id, queryOptions, context);
     }
     async findOne(filters, queryOptions, context) {
         return this.executeOperation({
-            operationType: "findOne",
-            prismaMethod: "findFirst",
+            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") {
+                    'id' in filters &&
+                    filters.id !== 'me') {
                     return await prisma[serviceContext.modelName].findUnique(deepmerge({ where: filters }, queryOptions || {}));
                 }
                 else {
@@ -358,8 +253,8 @@ export class BaseService {
     }
     async updateOne(filters, data, queryOptions, context) {
         return this.executeOperation({
-            operationType: "updateOne",
-            prismaMethod: "update",
+            operationType: 'updateOne',
+            prismaMethod: 'update',
             requiresPasswordHashing: true,
             relationFieldsHandling: [],
             returnsFallback: undefined,
@@ -367,8 +262,8 @@ export class BaseService {
     }
     async updateById(id, data, queryOptions, context) {
         return this.executeOperation({
-            operationType: "updateOne",
-            prismaMethod: "update",
+            operationType: 'updateOne',
+            prismaMethod: 'update',
             requiresPasswordHashing: true,
             relationFieldsHandling: [],
             returnsFallback: undefined,
@@ -376,8 +271,8 @@ export class BaseService {
     }
     async updateMany(filters, data, queryOptions, context) {
         return this.executeOperation({
-            operationType: "updateMany",
-            prismaMethod: "updateMany",
+            operationType: 'updateMany',
+            prismaMethod: 'updateMany',
             requiresPasswordHashing: true,
             relationFieldsHandling: [],
             returnsFallback: undefined,
@@ -385,29 +280,29 @@ export class BaseService {
     }
     async deleteById(id, context) {
         return this.executeOperation({
-            operationType: "deleteOne",
-            prismaMethod: "delete",
+            operationType: 'deleteOne',
+            prismaMethod: 'delete',
             returnsFallback: undefined,
         })({ id }, context);
     }
     async deleteOne(filters, context) {
         return this.executeOperation({
-            operationType: "deleteOne",
-            prismaMethod: "delete",
+            operationType: 'deleteOne',
+            prismaMethod: 'delete',
             returnsFallback: undefined,
         })(filters, context);
     }
     async deleteMany(filters, context) {
         return this.executeOperation({
-            operationType: "deleteMany",
-            prismaMethod: "deleteMany",
+            operationType: 'deleteMany',
+            prismaMethod: 'deleteMany',
             returnsFallback: undefined,
         })(filters, context);
     }
     async batchUpdate(dataArray, queryOptions, context) {
         return this.executeTransactionOperation({
-            operationType: "batchUpdate",
-            prismaMethod: "update",
+            operationType: 'batchUpdate',
+            prismaMethod: 'update',
             requiresPasswordHashing: true,
             relationFieldsHandling: [],
             returnsFallback: undefined,
@@ -415,8 +310,8 @@ export class BaseService {
     }
     async batchDelete(batchFilters, context) {
         return this.executeTransactionOperation({
-            operationType: "batchDelete",
-            prismaMethod: "delete",
+            operationType: 'batchDelete',
+            prismaMethod: 'delete',
             relationFieldsHandling: [],
             returnsFallback: undefined,
         })(batchFilters, context);