arkos 1.2.31-test → 1.3.0-canary

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

@@ -0,0 +1,183 @@
+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 | Parameters<T["findUnique"]>[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;
+}
+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;
+}

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 setupRouters(models: string[], router: Router, arkosConfigs: ArkosConfig): Promise<Promise<void>[]>;
 export declare function isEndpointDisabled(routerConfig: RouterConfig, endpoint: RouterEndpoint): 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,6 @@
-import { RelationFields } from "../../../../utils/helpers/models.helpers";
+import { RelationFields } from "../../../../utils/dynamic-loader";
 export declare function removeApiAction(obj: Record<string, any>): Record<string, any>;
 export declare function isPrismaRelationFormat(obj: Record<string, any>): boolean;
+export declare function throwErrorIfApiActionIsInvalid(apiAction: string): void;
 export declare function handleRelationFieldsInBody(body: Record<string, any>, relationFields: RelationFields, ignoreActions?: string[]): Record<string, any>;
 export declare function canBeUsedToConnect(modelName: string, bodyField: Record<string, any> | undefined | null): boolean;

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/error-handler.helpers.d.ts

@@ -44,3 +44,4 @@ 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,6 +1,6 @@
 import { ArkosNextFunction, ArkosRequest, ArkosResponse } from "../../types";
 declare class FileUploadController {
-    private middlewares;
+    private interceptors;
     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>;

package/dist/types/modules/swagger/utils/helpers/get-authentication-json-schema-paths.d.ts

@@ -1,2 +1,4 @@
 import { OpenAPIV3 } from "openapi-types";
-export declare function getAuthenticationJsonSchemaPaths(): OpenAPIV3.PathsObject<{}, {}>;
+import { ArkosConfig } from "../../../../exports";
+export declare const getSchemaMode: (action: string, arkosConfig: ArkosConfig) => Promise<"prisma" | "zod" | "class-validator">;
+export default function getAuthenticationJsonSchemaPaths(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject<{}, {}>>;

package/dist/types/modules/swagger/utils/helpers/get-swagger-default-configs.d.ts

@@ -0,0 +1,46 @@
+import { OpenAPIV3 } from "openapi-types";
+export default function getSwaggerDefaultConfig(defaultModelsPaths: Record<string, any>, defaultJsonSchemas: OpenAPIV3.PathsObject<{}, {}>): Promise<{
+    enableAfterBuild?: boolean;
+    endpoint?: string;
+    mode: "prisma" | "class-validator" | "zod";
+    strict?: boolean;
+    options?: {
+        definition?: {
+            openapi?: string;
+            info?: {
+                title?: string;
+                version?: string;
+                description?: string;
+            };
+            servers?: {
+                url: string;
+                description?: string;
+            }[];
+            paths?: OpenAPIV3.PathsObject;
+            termsOfService?: string;
+            contact?: {
+                name?: string;
+                url?: string;
+                email?: string;
+            };
+            license?: {
+                name: string;
+                url?: string;
+            };
+            tags?: {
+                name: string;
+                description?: string;
+            }[];
+            components?: {
+                securitySchemes?: Record<string, any>;
+                schemas?: Record<string, any>;
+            };
+            security?: Array<Record<string, string[]>>;
+        };
+        apis?: string[];
+        deepLinking?: boolean;
+        tryItOutEnabled?: boolean;
+        persistAuthorization?: boolean;
+    };
+    scalarApiReferenceConfiguration?: Partial<import("@scalar/express-api-reference").ApiReferenceConfiguration>;
+} | undefined>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.d.ts

@@ -1 +1,2 @@
-export declare function generatePrismaJsonSchemas(): Promise<void>;
+import { ArkosConfig } from "../../../../../exports";
+export declare function generatePrismaJsonSchemas(arkosConfig: ArkosConfig): Promise<import("../../../../../utils/prisma/prisma-json-schema-generator").GeneratedSchemas>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/generate-zod-json-schemas.d.ts

@@ -0,0 +1 @@
+export default function generateZodJsonSchemas(): Promise<Record<string, any>>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-main-routes-paths.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../../../exports";
+export declare function generatePrismaModelMainRoutesPaths(model: string, paths: OpenAPIV3.PathsObject | undefined, arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject<{}, {}> | undefined>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-parent-routes-paths.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../../../exports";
+export default function generatePrismaModelParentRoutesPaths(model: string, paths: OpenAPIV3.PathsObject, arkosConfig: ArkosConfig): Promise<void>;

package/dist/types/modules/swagger/utils/helpers/missing-json-schemas-generator.d.ts

@@ -0,0 +1,34 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../exports";
+declare class MissingJsonSchemasGenerator {
+    private extractModelNameFromSchemaRef;
+    private extractActionFromOperationId;
+    private extractModelNameFromOperationId;
+    private extractSchemaRefsWithContext;
+    private extractPathSchemaRefs;
+    private getSchemaNameFromRef;
+    generateMissingJsonSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>, arkosConfig: ArkosConfig): Promise<Record<string, any>>;
+    private extractActionFromSchemaRef;
+    analyzeMissingSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>): {
+        allRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        missingRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        existingRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        modelActions: {
+            model: string;
+            action: string;
+            ref: string;
+            operationId?: string;
+        }[];
+    };
+}
+declare const missingJsonSchemaGenerator: MissingJsonSchemasGenerator;
+export default missingJsonSchemaGenerator;

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

@@ -1,7 +1,7 @@
 import { ArkosConfig } from "../../../../exports";
 import { OpenAPIV3 } from "openapi-types";
-export declare function getOpenAPIJsonSchemasByConfigMode(swaggerConfig: ArkosConfig["swagger"]): Promise<void | Record<string, any>>;
+export declare function getOpenAPIJsonSchemasByConfigMode(arkosConfig: ArkosConfig): Promise<Record<string, any>>;
 export declare function getCorrectJsonSchemaName(type: string, modelName: string, suffix: "Dto" | "Schema"): string;
 export declare function kebabToHuman(kebabStr: string): string;
-export declare function getSchemaRef(schemaName: string, mode: string): string;
+export declare function getSchemaRef(schemaName: string, mode: "prisma" | "zod" | "class-validator"): string;
 export declare function generatePathsForModels(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject>;

package/dist/types/server.d.ts

@@ -2,6 +2,9 @@ import { IncomingMessage, Server, ServerResponse } from "http";
 import { Express } from "express";
 import { ArkosConfig } from "./types/arkos-config";
 declare let server: Server<typeof IncomingMessage, typeof ServerResponse>;
+export declare let _arkosConfig: ArkosConfig & {
+    available?: boolean;
+};
 declare function initApp(arkosConfig?: ArkosConfig): Promise<Express>;
 export declare function terminateApplicationRunningProcessAndServer(): void;
 export declare function getArkosConfig(): ArkosConfig;

package/dist/types/types/arkos-config.d.ts

@@ -8,6 +8,7 @@ import { Options as QueryParserOptions } from "../utils/helpers/query-parser.hel
 import { ValidatorOptions } from "class-validator";
 import { MsDuration } from "../modules/auth/utils/helpers/auth.controller.helpers";
 import { OpenAPIV3 } from "openapi-types";
+import type { ApiReferenceConfiguration } from "@scalar/express-api-reference" with { "resolution-mode": "import" };
 export type ArkosConfig = {
     request?: {
         parameters?: {
@@ -84,7 +85,7 @@ export type ArkosConfig = {
     };
     middlewares?: {
         additional?: express.RequestHandler[];
-        disable?: ("compression" | "global-rate-limit" | "auth-rate-limit" | "cors" | "express-json" | "cookie-parser" | "query-parser" | "database-connection" | "request-logger" | "global-error-handler")[];
+        disable?: ("compression" | "global-rate-limit" | "auth-rate-limit" | "cors" | "express-json" | "cookie-parser" | "query-parser" | "request-logger" | "global-error-handler")[];
         replace?: {
             compression?: express.RequestHandler;
             globalRateLimit?: express.RequestHandler;
@@ -93,12 +94,12 @@ export type ArkosConfig = {
             expressJson?: express.RequestHandler;
             cookieParser?: express.RequestHandler;
             queryParser?: express.RequestHandler;
-            databaseConnection?: express.RequestHandler;
             requestLogger?: express.RequestHandler;
             globalErrorHandler?: express.ErrorRequestHandler;
         };
     };
     routers?: {
+        strict?: boolean | "no-bulk";
         additional?: express.Router[];
         disable?: ("auth-router" | "prisma-models-router" | "file-upload" | "welcome-endpoint")[];
         replace?: {
@@ -124,6 +125,7 @@ export type ArkosConfig = {
         enableAfterBuild?: boolean;
         endpoint?: string;
         mode: "prisma" | "class-validator" | "zod";
+        strict?: boolean;
         options?: {
             definition?: {
                 openapi?: string;
@@ -158,10 +160,10 @@ export type ArkosConfig = {
                 security?: Array<Record<string, string[]>>;
             };
             apis?: string[];
-            swaggerUiOptions?: Record<string, any>;
             deepLinking?: boolean;
             tryItOutEnabled?: boolean;
             persistAuthorization?: boolean;
         };
+        scalarApiReferenceConfiguration?: Partial<ApiReferenceConfiguration>;
     };
 };

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

@@ -122,6 +122,7 @@ export interface ArkosRequest<Body = any, Query = any> extends Request {
     responseStatus?: number | string | null | undefined;
     body: Body;
     prismaQueryOptions?: Record<string, any>;
+    accessToken?: string;
 }
 export interface ArkosResponse extends Response {
 }

package/dist/types/utils/cli/generate.d.ts

@@ -6,7 +6,7 @@ export declare const generateCommand: {
     controller: (options: GenerateOptions) => Promise<void>;
     service: (options: GenerateOptions) => Promise<void>;
     router: (options: GenerateOptions) => Promise<void>;
-    middlewares: (options: GenerateOptions) => Promise<void>;
+    interceptors: (options: GenerateOptions) => Promise<void>;
     authConfigs: (options: GenerateOptions) => Promise<void>;
     queryOptions: (options: GenerateOptions) => Promise<void>;
 };

package/dist/types/utils/cli/utils/watermark-stamper.d.ts

@@ -0,0 +1,9 @@
+declare class WatermarkStamper {
+    stamp({ envFiles, host, port, }: {
+        envFiles: string[] | undefined;
+        host: string | undefined;
+        port: string | undefined;
+    }): void;
+}
+declare const watermarkStamper: WatermarkStamper;
+export default watermarkStamper;

package/dist/types/utils/{helpers/models.helpers.d.ts → dynamic-loader.d.ts}

@@ -1,13 +1,13 @@
-import { AuthConfigs } from "../../types/auth";
-import { ArkosConfig } from "../../exports";
-type ModeModules = Awaited<ReturnType<typeof importPrismaModelModules>>;
-export declare function setModelModules(modelName: string, modules: ModeModules): void;
-export declare function getModelModules(modelName: string): importPrismaModelModulesReturnType;
-export declare function getFileModelModulesFileStructure(modelName: string): {
+import { AuthConfigs } from "../types/auth";
+import { ArkosConfig } from "../exports";
+type ModeModules = Awaited<ReturnType<typeof importModuleComponents>>;
+export declare function setModuleComponents(modelName: string, modules: ModeModules): any;
+export declare function getModuleComponents(modelName: string): importModuleComponentsReturnType;
+export type ValidationFileMappingKey = keyof ReturnType<typeof getFileModuleComponentsFileStructure>["dtos"];
+export declare function getFileModuleComponentsFileStructure(modelName: string): {
     core: {
-        service: string;
-        controller: string;
-        middlewares: string;
+        hooks: string;
+        interceptors: string;
         authConfigs: string;
         authConfigsNew: string;
         prismaQueryOptions: string;
@@ -17,63 +17,74 @@ export declare function getFileModelModulesFileStructure(modelName: string): {
     dtos: {
         login: string;
         signup: string;
+        getMe: string;
         updateMe: string;
         updatePassword: string;
         model?: undefined;
         create?: undefined;
+        createOne?: undefined;
         createMany?: undefined;
         update?: undefined;
+        updateOne?: undefined;
         updateMany?: undefined;
+        query?: undefined;
         findOne?: undefined;
         findMany?: undefined;
-        query?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
+        query: string;
         findOne: string;
         findMany: string;
-        query: string;
         login?: undefined;
         signup?: undefined;
+        getMe?: undefined;
         updateMe?: undefined;
         updatePassword?: undefined;
     };
     schemas: {
         login: string;
         signup: string;
+        getMe: string;
         updateMe: string;
         updatePassword: string;
         model?: undefined;
         create?: undefined;
+        createOne?: undefined;
         createMany?: undefined;
         update?: undefined;
+        updateOne?: undefined;
         updateMany?: undefined;
+        query?: undefined;
         findOne?: undefined;
         findMany?: undefined;
-        query?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
+        query: string;
         findOne: string;
         findMany: string;
-        query: string;
         login?: undefined;
         signup?: undefined;
+        getMe?: undefined;
         updateMe?: undefined;
         updatePassword?: undefined;
     };
 };
-export declare function processSubdir(modelName: string, type: "dtos" | "schemas", result?: Record<string, any>): Promise<Record<string, any>>;
-type importPrismaModelModulesReturnType = {
-    service?: any;
-    controller?: any;
-    middlewares?: any;
+export declare function processSubdir(modelName: string, type: "dtos" | "schemas"): Promise<Record<string, any>>;
+type importModuleComponentsReturnType = {
+    hooks?: any;
+    interceptors?: any;
     authConfigs?: AuthConfigs;
     authConfigsNew?: AuthConfigs;
     prismaQueryOptions?: any;
@@ -82,9 +93,9 @@ type importPrismaModelModulesReturnType = {
     dtos?: Record<string, any>;
     schemas?: Record<string, any>;
 };
-export declare function validateNamingConventions(key: string, fileName: string, result: importPrismaModelModulesReturnType): void;
-export declare function assignModuleToResult(key: string, module: any, result: importPrismaModelModulesReturnType): void;
-export declare function importPrismaModelModules(modelName: string, arkosConfig: ArkosConfig): Promise<importPrismaModelModulesReturnType>;
+export declare function validateNamingConventions(key: string, fileName: string, result: importModuleComponentsReturnType): void;
+export declare function assignModuleToResult(key: string, module: any, result: importModuleComponentsReturnType, arkosConfig: ArkosConfig): void;
+export declare function importModuleComponents(modelName: string, arkosConfig: ArkosConfig, moduleDirExists?: boolean): Promise<importModuleComponentsReturnType>;
 export type ModelFieldDefition = {
     name: string;
     type: string;
@@ -104,4 +115,6 @@ export declare function getPrismaModelRelations(modelName: string): RelationFiel
 declare function getModels(): string[];
 export declare function getPrismaSchemasContent(): string;
 declare function getModelUniqueFields(modelName: string): ModelFieldDefition[];
+export declare function localValidatorFileExists(action: ValidationFileMappingKey, modelName: string, arkosConfig: ArkosConfig): Promise<boolean>;
+export declare function loadAllModuleComponents(arkosConfig: ArkosConfig): Promise<void>;
 export { getModels, getModelUniqueFields };

package/dist/types/utils/features/port-and-host-allocator.d.ts

@@ -0,0 +1,21 @@
+import { ArkosConfig } from "../../exports";
+declare class PortAndHostAllocator {
+    private host;
+    private port;
+    private prevWarnings;
+    getCorrectHostAndPortToUse(env: Record<string, any>, config?: ArkosConfig): {
+        port: string;
+        host: string;
+    };
+    getHostAndAvailablePort(env: Record<string, any>, config?: ArkosConfig & {
+        logWarning?: boolean;
+        caller?: string;
+    }): Promise<{
+        port: string;
+        host: string;
+    }>;
+    private isPortAvailable;
+    logWarnings(): void;
+}
+declare const portAndHostAllocator: PortAndHostAllocator;
+export default portAndHostAllocator;

package/dist/types/utils/helpers/dynamic-loader.helpers.d.ts

@@ -0,0 +1,2 @@
+import { ArkosConfig, RouterConfig } from "../../exports";
+export declare function applyStrictRoutingRules(arkosConfig: ArkosConfig, moduleConfig?: RouterConfig): RouterConfig;

package/dist/types/utils/helpers/fs.helpers.d.ts

@@ -1,7 +1,3 @@
-import fs from "fs";
-export declare const statAsync: typeof fs.stat.__promisify__;
-export declare const accessAsync: typeof fs.access.__promisify__;
-export declare const mkdirAsync: typeof fs.mkdir.__promisify__;
 export declare const crd: () => string;
 export declare function fullCleanCwd(path: string): string;
 export declare let userFileExtension: "ts" | "js" | undefined;

package/dist/types/utils/helpers/global.helpers.d.ts

@@ -3,4 +3,5 @@ export declare function isEsm(): boolean;
 export declare function importModule(modulePath: string, options?: {
     fixExtension: boolean;
 }): Promise<any>;
+export declare function importEsmPreventingTsTransformation(path: string): Promise<any>;
 export declare function detectPackageManagerFromUserAgent(): string;

package/dist/types/utils/helpers/prisma.helpers.d.ts

@@ -1,4 +1,3 @@
 export declare let prismaInstance: any;
 export declare function loadPrismaModule(): Promise<any>;
 export declare function getPrismaInstance(): any;
-export declare const checkDatabaseConnection: (req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>;