arkos 1.2.32-test → 1.3.0-beta

package/dist/esm/utils/validate-schema.js

@@ -1,9 +1 @@
-import AppError from "../modules/error-handler/utils/app-error.js";
-export default async function validateSchema(schema, data) {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-        throw new AppError("Invalid request body", 400, result.error.format(), "invalid_request_body");
-    }
-    return result.data;
-}
-//# sourceMappingURL=validate-schema.js.map
+"use strict";import a from"../modules/error-handler/utils/app-error.js";export default async function o(e,t){const r=e.safeParse(t);if(!r.success)throw new a("Invalid request body",400,r.error.format(),"InvalidRequestBody");return r.data}

package/dist/esm/utils/validate-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"validate-schema.js","sourceRoot":"","sources":["../../../src/utils/validate-schema.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,MAAM,0CAA0C,CAAC;AA2BhE,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,cAAc,CAC1C,MAAoB,EACpB,IAAa;IAEb,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,QAAQ,CAChB,sBAAsB,EACtB,GAAG,EACH,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,EACrB,sBAAsB,CACvB,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC","sourcesContent":["import { ZodSchema } from \"zod\";\nimport AppError from \"../modules/error-handler/utils/app-error\";\n\n/**\n * Validates data using a Zod schema and throws an AppError if validation fails.\n *\n * @param {ZodSchema} schema - The Zod schema to validate against.\n * @param {unknown} data - The data to validate.\n * @returns {Promise<any>} - The validated data or throws an AppError on failure.\n *\n * @example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string(),\n *   email: z.string().email()\n * });\n *\n * async function main() {\n *   const data = { name: \"Uanela Como\", email: \"invalid-email\" };\n *   try {\n *     const validatedUser = await validateSchema(userSchema, data);\n *     // do something\n *   } catch (error) {\n *     console.error(error.message);\n *   }\n * }\n * ```\n */\nexport default async function validateSchema<T>(\n  schema: ZodSchema<T>,\n  data: unknown\n): Promise<T> {\n  const result = schema.safeParse(data);\n  if (!result.success) {\n    throw new AppError(\n      \"Invalid request body\",\n      400,\n      result.error.format(),\n      \"invalid_request_body\"\n    );\n  }\n  return result.data;\n}\n"]}
+{"version":3,"file":"validate-schema.js","sourceRoot":"","sources":["../../../src/utils/validate-schema.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,MAAM,0CAA0C,CAAC;AA2BhE,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,cAAc,CAC1C,MAAoB,EACpB,IAAa;IAEb,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,QAAQ,CAChB,sBAAsB,EACtB,GAAG,EACH,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,EACrB,oBAAoB,CACrB,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC","sourcesContent":["import { ZodSchema } from \"zod\";\nimport AppError from \"../modules/error-handler/utils/app-error\";\n\n/**\n * Validates data using a Zod schema and throws an AppError if validation fails.\n *\n * @param {ZodSchema} schema - The Zod schema to validate against.\n * @param {unknown} data - The data to validate.\n * @returns {Promise<any>} - The validated data or throws an AppError on failure.\n *\n * @example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string(),\n *   email: z.string().email()\n * });\n *\n * async function main() {\n *   const data = { name: \"Uanela Como\", email: \"invalid-email\" };\n *   try {\n *     const validatedUser = await validateSchema(userSchema, data);\n *     // do something\n *   } catch (error) {\n *     console.error(error.message);\n *   }\n * }\n * ```\n */\nexport default async function validateSchema<T>(\n  schema: ZodSchema<T>,\n  data: unknown\n): Promise<T> {\n  const result = schema.safeParse(data);\n  if (!result.success) {\n    throw new AppError(\n      \"Invalid request body\",\n      400,\n      result.error.format(),\n      \"InvalidRequestBody\"\n    );\n  }\n  return result.data;\n}\n"]}

package/dist/types/exports/prisma/index.d.ts

@@ -1,3 +1,4 @@
 import { PrismaQueryOptions, AuthPrismaQueryOptions } from "../../types";
-import { getModels } from "../../utils/helpers/models.helpers";
-export { PrismaQueryOptions, getModels as getPrismaModels, AuthPrismaQueryOptions, };
+import prismaSchemaParser from "../../utils/prisma/prisma-schema-parser";
+export declare function getPrismaModels(): string[];
+export { PrismaQueryOptions, prismaSchemaParser, AuthPrismaQueryOptions };

package/dist/types/exports/services/index.d.ts

@@ -2,8 +2,9 @@ import { getFileUploadServices, FileUploadService } from "../../modules/file-upl
 import { EmailOptions } from "../../modules/email/email.service";
 import authService, { AuthService } from "../../modules/auth/auth.service";
 import emailService, { EmailService } from "../../modules/email/email.service";
-import { BaseService, getBaseServices } from "../../modules/base/base.service";
+import { BaseService } from "../../modules/base/base.service";
+import { ServiceBaseContext, BeforeCreateOneHookArgs, AfterCreateOneHookArgs, BeforeCreateManyHookArgs, AfterCreateManyHookArgs, BeforeCountHookArgs, AfterCountHookArgs, BeforeFindManyHookArgs, AfterFindManyHookArgs, BeforeFindOneHookArgs, AfterFindOneHookArgs, BeforeUpdateOneHookArgs, AfterUpdateOneHookArgs, BeforeUpdateManyHookArgs, AfterUpdateManyHookArgs, BeforeDeleteOneHookArgs, AfterDeleteOneHookArgs, BeforeDeleteManyHookArgs, AfterDeleteManyHookArgs, OnCreateOneErrorHookArgs, OnCreateManyErrorHookArgs, OnCountErrorHookArgs, OnFindManyErrorHookArgs, OnFindByIdErrorHookArgs, OnFindOneErrorHookArgs, OnUpdateOneErrorHookArgs, OnUpdateManyErrorHookArgs, OnDeleteOneErrorHookArgs, OnDeleteManyErrorHookArgs } from "../../modules/base/types/base.service.types";
 export { authService, AuthService };
-export { BaseService, getBaseServices };
+export { BaseService, ServiceBaseContext, BeforeCreateOneHookArgs, AfterCreateOneHookArgs, BeforeCreateManyHookArgs, AfterCreateManyHookArgs, BeforeCountHookArgs, AfterCountHookArgs, BeforeFindManyHookArgs, AfterFindManyHookArgs, BeforeFindOneHookArgs, AfterFindOneHookArgs, BeforeUpdateOneHookArgs, AfterUpdateOneHookArgs, BeforeUpdateManyHookArgs, AfterUpdateManyHookArgs, BeforeDeleteOneHookArgs, AfterDeleteOneHookArgs, BeforeDeleteManyHookArgs, AfterDeleteManyHookArgs, OnCreateOneErrorHookArgs, OnCreateManyErrorHookArgs, OnCountErrorHookArgs, OnFindManyErrorHookArgs, OnFindByIdErrorHookArgs, OnFindOneErrorHookArgs, OnUpdateOneErrorHookArgs, OnUpdateManyErrorHookArgs, OnDeleteOneErrorHookArgs, OnDeleteManyErrorHookArgs, };
 export { emailService, EmailService, EmailOptions };
 export { getFileUploadServices, FileUploadService };

package/dist/types/modules/auth/auth.controller.d.ts

@@ -1,13 +1,14 @@
-import { ArkosRequest, ArkosResponse, ArkosNextFunction } from "../../types";
 export declare const defaultExcludedUserFields: {
     password: boolean;
 };
-export declare const authControllerFactory: (middlewares?: any) => Promise<{
-    getMe: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    updateMe: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    logout: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    login: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    signup: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    deleteMe: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    updatePassword: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+export declare const authControllerFactory: (interceptors?: any) => Promise<{
+    getMe: any;
+    updateMe: any;
+    logout: any;
+    login: any;
+    signup: any;
+    deleteMe: any;
+    updatePassword: any;
+    findManyAuthAction: any;
+    findOneAuthAction: any;
 }>;

package/dist/types/modules/auth/auth.service.d.ts

@@ -1,8 +1,9 @@
 import { User } from "../../types";
-import { ArkosRequest, ArkosResponse, ArkosNextFunction, ArkosRequestHandler } from "../../types";
+import { ArkosRequest, ArkosRequestHandler } from "../../types";
 import { AuthJwtPayload, AccessAction, AccessControlConfig, AuthenticationControlConfig } from "../../types/auth";
 import { MsDuration } from "./utils/helpers/auth.controller.helpers";
 export declare class AuthService {
+    actionsPerResource: Record<string, Set<string>>;
     signJwtToken(id: number | string, expiresIn?: MsDuration | number, secret?: string): string;
     isPasswordHashed(password: string): boolean;
     isCorrectPassword(candidatePassword: string, userPassword: string): Promise<boolean>;
@@ -10,10 +11,13 @@ export declare class AuthService {
     isPasswordStrong(password: string): boolean;
     userChangedPasswordAfter(user: User, JWTTimestamp: number): boolean;
     verifyJwtToken(token: string, secret?: string): Promise<AuthJwtPayload>;
-    handleAccessControl(action: AccessAction, resourceName: string, accessControl?: AccessControlConfig): ArkosRequestHandler;
+    protected checkStaticAccessControl(user: User, action: string, accessControl: AccessControlConfig): boolean;
+    protected checkDynamicAccessControl(userId: string, action: string, resource: string): Promise<boolean>;
+    handleAccessControl(action: AccessAction, resource: string, accessControl?: AccessControlConfig): ArkosRequestHandler;
     getAuthenticatedUser(req: ArkosRequest): Promise<User | null>;
-    authenticate: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+    authenticate: any;
     handleAuthenticationControl(action: AccessAction, authenticationControl?: AuthenticationControlConfig | undefined): ArkosRequestHandler;
+    permission(action: string, resource: string, accessControl?: AccessControlConfig): (user: Record<string, any>) => Promise<boolean>;
 }
 declare const authService: AuthService;
 export default authService;

package/dist/types/modules/auth/utils/auth-error-objects.d.ts

@@ -0,0 +1,3 @@
+import AppError from "../../error-handler/utils/app-error";
+export declare const loginRequiredError: AppError;
+export declare const invaliAuthTokenError: AppError;

package/dist/types/modules/auth/utils/services/auth-action.service.d.ts

@@ -0,0 +1,23 @@
+import { AccessControlConfig } from "../../../../types/auth";
+interface AuthAction {
+    roles: string[];
+    action: string;
+    resource: string;
+    name?: string;
+    description?: string;
+    errorMessage?: string;
+}
+declare class AuthActionService {
+    authActions: AuthAction[];
+    add(action: string, resource: string, accessControl?: AccessControlConfig): void;
+    getAll(): AuthAction[];
+    getOne(action: string, resource: string): AuthAction | undefined;
+    private transformAccessControlToValidAuthAction;
+    getUniqueActions(): string[];
+    getUniqueResources(): string[];
+    getByResource(resource: string): AuthAction | undefined;
+    getByAction(action: string): AuthAction[];
+    exists(action: string, resource: string): boolean;
+}
+declare const authActionService: AuthActionService;
+export default authActionService;

package/dist/types/modules/base/base.controller.d.ts

@@ -1,17 +1,15 @@
-import { ArkosRequest, ArkosResponse, ArkosNextFunction } from "../../types";
 export declare class BaseController {
     private service;
     private modelName;
-    private middlewares;
+    private interceptors;
     constructor(modelName: string);
-    createOne: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    createMany: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    findMany: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    findOne: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    updateOne: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    updateMany: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    deleteOne: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    deleteMany: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+    createOne: any;
+    createMany: any;
+    findMany: any;
+    findOne: any;
+    updateOne: any;
+    updateMany: any;
+    deleteOne: any;
+    deleteMany: any;
 }
-export declare function getAvalibleRoutes(req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction): void;
-export declare const getAvailableResources: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+export declare const getAvailableResources: any;

package/dist/types/modules/base/base.middlewares.d.ts

@@ -1,13 +1,13 @@
 import { NextFunction, Request, Response } from "express";
-import { PrismaQueryOptions, ArkosNextFunction, ArkosRequest, ArkosRequestHandler, ArkosResponse, AuthPrismaQueryOptions } from "../../types";
+import { PrismaQueryOptions, ArkosRequest, ArkosRequestHandler, ArkosResponse, AuthPrismaQueryOptions } from "../../types";
 import { ZodSchema } from "zod";
 import { ClassConstructor } from "class-transformer";
 import { ValidatorOptions } from "class-validator";
-export declare function callNext(req: Request, res: Response, next: NextFunction): void;
-export declare function sendResponse(req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction): void;
+export declare function callNext(_: Request, _1: Response, next: NextFunction): void;
+export declare function sendResponse(req: ArkosRequest, res: ArkosResponse): void;
 export declare function addRouteMiddlwaresAndConfigs(): void;
 export type ControllerActions = keyof PrismaQueryOptions<any> | keyof Omit<AuthPrismaQueryOptions<any>, keyof PrismaQueryOptions<any>>;
-export declare function addPrismaQueryOptionsToRequest<T extends Record<string, any>>(prismaQueryOptions: PrismaQueryOptions<T> | AuthPrismaQueryOptions<T>, action: ControllerActions): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => void;
+export declare function addPrismaQueryOptionsToRequest<T extends Record<string, any>>(prismaQueryOptions: PrismaQueryOptions<T> | AuthPrismaQueryOptions<T>, action: ControllerActions): (req: ArkosRequest, _: ArkosResponse, next: NextFunction) => void;
 export declare function handleRequestLogs(req: Request, res: Response, next: NextFunction): void;
 export declare function handleRequestBodyValidationAndTransformation<T extends object>(schemaOrDtoClass?: ClassConstructor<T>, classValidatorValidationOptions?: ValidatorOptions): ArkosRequestHandler;
 export declare function handleRequestBodyValidationAndTransformation<T extends object>(schemaOrDtoClass?: ZodSchema<T>): ArkosRequestHandler;

package/dist/types/modules/base/base.service.d.ts

@@ -1,72 +1,18 @@
-import { RelationFields } from "../../utils/helpers/models.helpers";
-export declare class BaseService<ModelDelegate extends Record<string, any> = any> {
+import { ModelGroupRelationFields } from "./utils/helpers/base.service.helpers";
+import { ModelDelegate, CreateOneData, CreateOneOptions, CreateOneResult, CreateManyData, CreateManyOptions, CreateManyResult, CountFilters, FindManyFilters, FindManyOptions, FindManyResult, FindByIdOptions, FindByIdResult, FindOneFilters, FindOneOptions, FindOneResult, UpdateOneFilters, UpdateOneData, UpdateOneOptions, UpdateOneResult, UpdateManyFilters, UpdateManyData, UpdateManyOptions, UpdateManyResult, DeleteOneFilters, DeleteOneResult, DeleteManyFilters, DeleteManyResult, ServiceBaseContext } from "./types/base.service.types";
+export declare class BaseService<T extends ModelDelegate = any> {
     modelName: string;
-    relationFields: RelationFields;
+    relationFields: ModelGroupRelationFields;
     prisma: any;
     constructor(modelName: string);
-    createOne<TOptions extends Omit<Parameters<ModelDelegate["create"]>[0], "data">>(data: Parameters<ModelDelegate["create"]>[0] extends {
-        data: infer D;
-        [x: string]: any;
-    } ? D : any, queryOptions?: TOptions): Promise<ModelDelegate["create"] extends (args: {
-        data: any;
-    }) => infer R ? R : any>;
-    createMany<TOptions extends Omit<Parameters<ModelDelegate["createMany"]>[0], "data">>(data: Parameters<ModelDelegate["createMany"]>[0] extends {
-        data: infer D;
-        [x: string]: any;
-    } ? D : any, queryOptions?: TOptions): Promise<ModelDelegate["createMany"] extends (args: {
-        data: any;
-    }) => infer R ? R : any>;
-    count(filters: Parameters<ModelDelegate["count"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any): Promise<number>;
-    findMany<TOptions extends Omit<Parameters<ModelDelegate["findMany"]>[0], "where">>(filters?: Parameters<ModelDelegate["findMany"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any, queryOptions?: TOptions): Promise<ModelDelegate["findMany"] extends (args: {
-        where: any;
-    } & TOptions) => infer R ? R : any>;
-    findById<TOptions extends Omit<Parameters<ModelDelegate["findUnique"]>[0], "where">>(id: string | number, queryOptions?: TOptions): Promise<ModelDelegate["findUnique"] extends (args: {
-        where: any;
-    }) => infer R ? R : any>;
-    findOne<TOptions extends Omit<Parameters<ModelDelegate["findFirst"]>[0], "where"> | Omit<Parameters<ModelDelegate["findUnique"]>[0], "where">>(filters: Parameters<ModelDelegate["findFirst"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any | Parameters<ModelDelegate["findUnique"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any, queryOptions?: TOptions): Promise<ModelDelegate["findFirst"] extends (args: {
-        where: any;
-    }) => infer R ? R : ModelDelegate["findUnique"] extends (args: {
-        where: any;
-    }) => infer R2 ? R2 : any>;
-    updateOne<TOptions extends Omit<Parameters<ModelDelegate["update"]>[0], "where" | "data">>(filters: Parameters<ModelDelegate["update"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any, data: Parameters<ModelDelegate["update"]>[0] extends {
-        data: infer D;
-        [x: string]: any;
-    } ? D : any, queryOptions?: TOptions): Promise<ModelDelegate["update"] extends (args: {
-        where: any;
-        data: any;
-    }) => infer R ? R : any>;
-    updateMany<TOptions extends Omit<Parameters<ModelDelegate["updateMany"]>[0], "where" | "data">>(filters: Parameters<ModelDelegate["updateMany"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any, data: Parameters<ModelDelegate["updateMany"]>[0] extends {
-        data: infer D;
-        [x: string]: any;
-    } ? D : any, queryOptions?: TOptions): Promise<ModelDelegate["updateMany"] extends (args: {
-        where: any;
-        data: any;
-    }) => infer R ? R : any>;
-    deleteOne(filters: Parameters<ModelDelegate["delete"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : any): Promise<ReturnType<ModelDelegate["delete"]>>;
-    deleteMany(filters: Parameters<ModelDelegate["deleteMany"]>[0] extends {
-        where?: infer W;
-        [x: string]: any;
-    } ? W : Record<string, any>): Promise<ReturnType<ModelDelegate["deleteMany"]>>;
+    createOne<TOptions extends CreateOneOptions<T>>(data: CreateOneData<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<CreateOneResult<T>>;
+    createMany<TOptions extends CreateManyOptions<T>>(data: CreateManyData<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<CreateManyResult<T>>;
+    count(filters?: CountFilters<T>, context?: ServiceBaseContext): Promise<number>;
+    findMany<TOptions extends FindManyOptions<T>>(filters?: FindManyFilters<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<FindManyResult<T, TOptions>>;
+    findById<TOptions extends FindByIdOptions<T>>(id: string | number, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<FindByIdResult<T>>;
+    findOne<TOptions extends FindOneOptions<T>>(filters: FindOneFilters<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<FindOneResult<T>>;
+    updateOne<TOptions extends UpdateOneOptions<T>>(filters: UpdateOneFilters<T>, data: UpdateOneData<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<UpdateOneResult<T>>;
+    updateMany<TOptions extends UpdateManyOptions<T>>(filters: UpdateManyFilters<T>, data: UpdateManyData<T>, queryOptions?: TOptions, context?: ServiceBaseContext): Promise<UpdateManyResult<T>>;
+    deleteOne(filters: DeleteOneFilters<T>, context?: ServiceBaseContext): Promise<DeleteOneResult<T>>;
+    deleteMany(filters: DeleteManyFilters<T>, context?: ServiceBaseContext): Promise<DeleteManyResult<T>>;
 }
-export declare function getBaseServices(): Record<string, BaseService<any>>;

package/dist/types/modules/base/types/base.service.types.d.ts

@@ -0,0 +1,215 @@
+import { User } from "../../../types";
+export type ModelDelegate = Record<string, any>;
+export type CreateOneData<T extends ModelDelegate> = Parameters<T["create"]>[0] extends {
+    data: infer D;
+    [x: string]: any;
+} ? D : any;
+export type CreateOneOptions<T extends ModelDelegate> = Omit<Parameters<T["create"]>[0], "data">;
+export type CreateOneResult<T extends ModelDelegate> = T["create"] extends (args: {
+    data: any;
+}) => infer R ? R : any;
+export type CreateManyData<T extends ModelDelegate> = Parameters<T["createMany"]>[0] extends {
+    data: infer D;
+    [x: string]: any;
+} ? D : any;
+export type CreateManyOptions<T extends ModelDelegate> = Omit<Parameters<T["createMany"]>[0], "data">;
+export type CreateManyResult<T extends ModelDelegate> = T["createMany"] extends (args: {
+    data: any;
+}) => infer R ? R : any;
+export type CountFilters<T extends ModelDelegate> = Parameters<T["count"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type FindManyFilters<T extends ModelDelegate> = Parameters<T["findMany"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type FindManyOptions<T extends ModelDelegate> = Omit<Parameters<T["findMany"]>[0], "where">;
+export type FindManyResult<T extends ModelDelegate, TOptions = any> = T["findMany"] extends (args: {
+    where: any;
+} & TOptions) => infer R ? R : any;
+export type FindByIdOptions<T extends ModelDelegate> = Omit<Parameters<T["findUnique"]>[0], "where">;
+export type FindByIdResult<T extends ModelDelegate> = T["findUnique"] extends (args: {
+    where: any;
+}) => infer R ? R : any;
+export type FindOneFilters<T extends ModelDelegate> = Parameters<T["findFirst"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type FindOneOptions<T extends ModelDelegate> = Omit<Parameters<T["findFirst"]>[0], "where"> | Omit<Parameters<T["findUnique"]>[0], "where">;
+export type FindOneResult<T extends ModelDelegate> = T["findFirst"] extends (args: {
+    where: any;
+}) => infer R ? R : T["findUnique"] extends (args: {
+    where: any;
+}) => infer R2 ? R2 : any;
+export type UpdateOneFilters<T extends ModelDelegate> = Parameters<T["update"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type UpdateOneData<T extends ModelDelegate> = Parameters<T["update"]>[0] extends {
+    data: infer D;
+    [x: string]: any;
+} ? D : any;
+export type UpdateOneOptions<T extends ModelDelegate> = Omit<Parameters<T["update"]>[0], "where" | "data">;
+export type UpdateOneResult<T extends ModelDelegate> = T["update"] extends (args: {
+    where: any;
+    data: any;
+}) => infer R ? R : any;
+export type UpdateManyFilters<T extends ModelDelegate> = Parameters<T["updateMany"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type UpdateManyData<T extends ModelDelegate> = Parameters<T["updateMany"]>[0] extends {
+    data: infer D;
+    [x: string]: any;
+} ? D : any;
+export type UpdateManyOptions<T extends ModelDelegate> = Omit<Parameters<T["updateMany"]>[0], "where" | "data">;
+export type UpdateManyResult<T extends ModelDelegate> = T["updateMany"] extends (args: {
+    where: any;
+    data: any;
+}) => infer R ? R : any;
+export type DeleteOneFilters<T extends ModelDelegate> = Parameters<T["delete"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : any;
+export type DeleteOneResult<T extends ModelDelegate> = ReturnType<T["delete"]>;
+export type DeleteManyFilters<T extends ModelDelegate> = Parameters<T["deleteMany"]>[0] extends {
+    where?: infer W;
+    [x: string]: any;
+} ? W : Record<string, any>;
+export type DeleteManyResult<T extends ModelDelegate> = ReturnType<T["deleteMany"]>;
+export interface ServiceBaseContext {
+    user?: User;
+    accessToken?: string;
+    skip?: ("before" | "after" | "error")[];
+    throwOnError?: boolean;
+}
+export interface BeforeCreateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    data: CreateOneData<T>;
+    queryOptions?: CreateOneOptions<T>;
+    context?: Context;
+}
+export interface AfterCreateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: CreateOneResult<T>;
+    data: CreateOneData<T>;
+    queryOptions?: CreateOneOptions<T>;
+    context?: Context;
+}
+export interface BeforeCreateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    data: CreateManyData<T>;
+    queryOptions?: CreateManyOptions<T>;
+    context?: Context;
+}
+export interface AfterCreateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: CreateManyResult<T>;
+    queryOptions?: CreateManyOptions<T>;
+    context?: Context;
+}
+export interface BeforeCountHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters?: CountFilters<T>;
+    context?: Context;
+}
+export interface AfterCountHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: number;
+    filters?: CountFilters<T>;
+    context?: Context;
+}
+export interface BeforeFindManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters?: FindManyFilters<T>;
+    queryOptions?: FindManyOptions<T>;
+    context?: Context;
+}
+export interface AfterFindManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: FindManyResult<T>;
+    filters?: FindManyFilters<T>;
+    queryOptions?: FindManyOptions<T>;
+    context?: Context;
+}
+export interface BeforeFindOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters: FindOneFilters<T>;
+    queryOptions?: FindOneOptions<T>;
+    context?: Context;
+}
+export interface AfterFindOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: FindOneResult<T>;
+    filters: FindOneFilters<T>;
+    queryOptions?: FindOneOptions<T>;
+    context?: Context;
+}
+export interface BeforeUpdateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters: UpdateOneFilters<T>;
+    data: UpdateOneData<T>;
+    queryOptions?: UpdateOneOptions<T>;
+    context?: Context;
+}
+export interface AfterUpdateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: UpdateOneResult<T>;
+    filters: UpdateOneFilters<T>;
+    data: UpdateOneData<T>;
+    queryOptions?: UpdateOneOptions<T>;
+    context?: Context;
+}
+export interface BeforeUpdateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters: UpdateManyFilters<T>;
+    data: UpdateManyData<T>;
+    queryOptions?: UpdateManyOptions<T>;
+    context?: Context;
+}
+export interface AfterUpdateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: UpdateManyResult<T>;
+    filters: UpdateManyFilters<T>;
+    data: UpdateManyData<T>;
+    queryOptions?: UpdateManyOptions<T>;
+    context?: Context;
+}
+export interface BeforeDeleteOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters: DeleteOneFilters<T>;
+    context?: Context;
+}
+export interface AfterDeleteOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: DeleteOneResult<T>;
+    filters: DeleteOneFilters<T>;
+    context?: Context;
+}
+export interface BeforeDeleteManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    filters: DeleteManyFilters<T>;
+    context?: Context;
+}
+export interface AfterDeleteManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    result: DeleteManyResult<T>;
+    filters: DeleteManyFilters<T>;
+    context?: Context;
+}
+export interface OnCreateOneErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeCreateOneHookArgs<T, Context> {
+    error: any;
+}
+export interface OnCreateManyErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeCreateManyHookArgs<T, Context> {
+    error: any;
+}
+export interface OnCountErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeCountHookArgs<T, Context> {
+    error: any;
+}
+export interface OnFindManyErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeFindManyHookArgs<T, Context> {
+    error: any;
+}
+export interface OnFindByIdErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
+    error: any;
+    id: string | number;
+    queryOptions?: FindByIdOptions<T>;
+    context?: Context;
+}
+export interface OnFindOneErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeFindOneHookArgs<T, Context> {
+    error: any;
+}
+export interface OnUpdateOneErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeUpdateOneHookArgs<T, Context> {
+    error: any;
+}
+export interface OnUpdateManyErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeUpdateManyHookArgs<T, Context> {
+    error: any;
+}
+export interface OnDeleteOneErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeDeleteOneHookArgs<T, Context> {
+    error: any;
+}
+export interface OnDeleteManyErrorHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> extends BeforeDeleteManyHookArgs<T, Context> {
+    error: any;
+}

package/dist/types/modules/base/utils/helpers/base.controller.helpers.d.ts

@@ -1,6 +1,4 @@
-import { ArkosRequest } from "../../../../types";
 export declare const getAppRoutes: () => {
     method: string;
     path: string;
 }[];
-export declare function parseAndGetPrismaQueryOptions(req: ArkosRequest): void;

package/dist/types/modules/base/utils/helpers/base.router.helpers.d.ts

@@ -1,6 +1,6 @@
 import { Router } from "express";
 import { ArkosConfig, RouterConfig } from "../../../../exports";
-import { RouterEndpoint } from "../../../../types/router-config";
-export declare function setupRouters(models: string[], router: Router, arkosConfigs: ArkosConfig): Promise<void>[];
-export declare function isEndpointDisabled(routerConfig: RouterConfig, endpoint: RouterEndpoint): boolean;
+import { AuthRouterEndpoint, FileUploadRouterEndpoint, RouterEndpoint } from "../../../../types/router-config";
+export declare function setupRouters(router: Router, arkosConfigs: ArkosConfig): Promise<Promise<void>[]>;
+export declare function isEndpointDisabled<RouterType extends string = "prisma">(routerConfig: RouterConfig<RouterType>, endpoint: RouterEndpoint | AuthRouterEndpoint | FileUploadRouterEndpoint): boolean;
 export declare function isParentEndpointAllowed(routerConfig: any, endpoint: string): boolean;

package/dist/types/modules/base/utils/helpers/base.service.helpers.d.ts

@@ -1,5 +1,12 @@
-import { RelationFields } from "../../../../utils/helpers/models.helpers";
+import { PrismaField } from "../../../../utils/prisma/types";
 export declare function removeApiAction(obj: Record<string, any>): Record<string, any>;
 export declare function isPrismaRelationFormat(obj: Record<string, any>): boolean;
-export declare function handleRelationFieldsInBody(body: Record<string, any>, relationFields: RelationFields, ignoreActions?: string[]): Record<string, any>;
+export declare function throwErrorIfApiActionIsInvalid(apiAction: string): void;
+export declare function handleRelationFieldsInBody(body: Record<string, any>, relationFields: ModelGroupRelationFields, ignoreActions?: string[]): Record<string, any>;
+export type ModelGroupRelationFields = ReturnType<typeof getGroupedModelReations>;
+declare function getGroupedModelReations(modelName: string): {
+    singular: PrismaField[] | undefined;
+    list: PrismaField[] | undefined;
+};
 export declare function canBeUsedToConnect(modelName: string, bodyField: Record<string, any> | undefined | null): boolean;
+export {};

package/dist/types/modules/base/utils/router-validator.d.ts

@@ -0,0 +1,5 @@
+declare class RouterValidator {
+    isExpressRouter(router: any): boolean;
+}
+declare const routerValidator: RouterValidator;
+export default routerValidator;

package/dist/types/modules/base/utils/service-hooks-manager.d.ts

@@ -0,0 +1,7 @@
+type ServiceHook = (args: Record<string, any>) => Promise<void>;
+declare class ServiceHooksManager {
+    handleHook(hooksReceived: ServiceHook | ServiceHook[], hooksArgs: Record<string, any>): Promise<void>;
+    validateServiceHook(hook: ServiceHook): void;
+}
+declare const serviceHooksManager: ServiceHooksManager;
+export default serviceHooksManager;

package/dist/types/modules/error-handler/error-handler.controller.d.ts

@@ -1,3 +1,3 @@
 import { NextFunction, Request, Response } from "express";
 import AppError from "./utils/app-error";
-export default function errorHandler(err: AppError, req: Request, res: Response, next: NextFunction): void;
+export default function errorHandler(err: AppError, req: Request, res: Response, _: NextFunction): void;

package/dist/types/modules/error-handler/utils/catch-async.d.ts

@@ -1,4 +1,6 @@
-import { ArkosRequest, ArkosResponse, ArkosNextFunction, ArkosRequestHandler } from "../../../types";
-declare const catchAsync: (fn: ArkosRequestHandler) => (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+import { ArkosRequestHandler, ArkosErrorRequestHandler } from "../../../types";
+declare const catchAsync: (fn: ArkosRequestHandler | ArkosErrorRequestHandler, options?: {
+    type: "error" | "normal";
+}) => any;
 export type CatchAsyncReturnType = ReturnType<typeof catchAsync>;
 export default catchAsync;

package/dist/types/modules/error-handler/utils/error-handler.helpers.d.ts

@@ -8,39 +8,40 @@ export interface PrismaError {
 export declare function handleJWTError(): AppError;
 export declare function handleJWTExpired(): AppError;
 export declare function handlePrismaClientValidationError(err: AppError): AppError;
-export declare function handleAuthenticationError(err: AppError): AppError;
-export declare function handleServerNotReachableError(err: AppError): AppError;
-export declare function handleConnectionTimeoutError(err: AppError): AppError;
-export declare function handleDatabaseNotFoundError(err: AppError): AppError;
+export declare function handleAuthenticationError(_: AppError): AppError;
+export declare function handleServerNotReachableError(_: AppError): AppError;
+export declare function handleConnectionTimeoutError(_: AppError): AppError;
+export declare function handleDatabaseNotFoundError(_: AppError): AppError;
 export declare function handleEnvironmentVariableError(err: AppError): AppError;
 export declare function handleFieldValueTooLargeError(err: AppError): AppError;
-export declare function handleRecordNotFoundError(err: AppError): AppError;
+export declare function handleRecordNotFoundError(_: AppError): AppError;
 export declare function handleUniqueConstraintError(err: AppError): AppError;
-export declare function handleForeignKeyConstraintError(err: AppError): AppError;
+export declare function handleForeignKeyConstraintError(_: AppError): AppError;
 export declare function handleConstraintFailedError(err: AppError): AppError;
 export declare function handleInvalidFieldValueError(err: AppError): AppError;
 export declare function handleInvalidFieldProvidedError(err: AppError): AppError;
-export declare function handleDataValidationError(err: AppError): AppError;
+export declare function handleDataValidationError(_: AppError): AppError;
 export declare function handleQueryParsingError(err: AppError): AppError;
 export declare function handleInvalidQueryFormatError(err: AppError): AppError;
-export declare function handleRawQueryExecutionError(err: AppError): AppError;
+export declare function handleRawQueryExecutionError(_: AppError): AppError;
 export declare function handleNullConstraintViolationError(err: AppError): AppError;
-export declare function handleSchemaCreationFailedError(err: AppError): AppError;
+export declare function handleSchemaCreationFailedError(_: AppError): AppError;
 export declare function handleMigrationAlreadyAppliedError(err: AppError): AppError;
 export declare function handleMigrationScriptFailedError(err: AppError): AppError;
-export declare function handleVersionMismatchError(err: AppError): AppError;
+export declare function handleVersionMismatchError(_: AppError): AppError;
 export declare function handleMigrationFileReadError(err: AppError): AppError;
-export declare function handleSchemaDriftError(err: AppError): AppError;
-export declare function handleSchemaSyntaxError(err: AppError): AppError;
-export declare function handleClientTypeError(err: AppError): AppError;
-export declare function handleDynamicQueryError(err: AppError): AppError;
+export declare function handleSchemaDriftError(_: AppError): AppError;
+export declare function handleSchemaSyntaxError(_: AppError): AppError;
+export declare function handleClientTypeError(_: AppError): AppError;
+export declare function handleDynamicQueryError(_: AppError): AppError;
 export declare function handleRelationLoadingError(err: AppError): AppError;
 export declare function handleBinaryError(err: AppError): AppError;
-export declare function handleNetworkError(err: AppError): AppError;
-export declare function handleUnhandledPromiseError(err: AppError): AppError;
+export declare function handleNetworkError(_: AppError): AppError;
+export declare function handleUnhandledPromiseError(_: AppError): AppError;
 export declare function handleDataTypeError(err: AppError): AppError;
-export declare function handleEmptyResultError(err: AppError): AppError;
+export declare function handleEmptyResultError(_: AppError): AppError;
 export declare function handleNonExistingRecord(err: {
     meta?: Record<string, any>;
     [x: string]: any;
 }): AppError;
+export declare function handlePrismaClientInitializationError(_: any): AppError;

package/dist/types/modules/file-upload/file-upload.controller.d.ts

@@ -1,10 +1,8 @@
-import { ArkosNextFunction, ArkosRequest, ArkosResponse } from "../../types";
 declare class FileUploadController {
-    private middlewares;
-    uploadFile: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    deleteFile: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    updateFile: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
-    streamFile: (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
+    private interceptors;
+    uploadFile: any;
+    deleteFile: any;
+    updateFile: any;
 }
 declare const fileUploadController: FileUploadController;
 export default fileUploadController;