arkos 1.2.31-test → 1.3.0-beta

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;

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

@@ -1,6 +1,5 @@
 import multer from "multer";
-import { NextFunction } from "express";
-import { ArkosRequest, ArkosResponse } from "../../types";
+import { ArkosRequest, ArkosRequestHandler, ArkosResponse } from "../../types";
 export declare class FileUploadService {
     readonly uploadDir: string;
     private fileSizeLimit;
@@ -10,9 +9,9 @@ export declare class FileUploadService {
     constructor(uploadDir: string, fileSizeLimit?: number, allowedFileTypes?: RegExp, maxCount?: number);
     private fileFilter;
     getUpload(): multer.Multer;
-    handleSingleUpload(oldFilePath?: string): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => void;
-    handleMultipleUpload(): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => void;
-    handleDeleteSingleFile(oldFilePath: string): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => Promise<void>;
+    handleSingleUpload(oldFilePath?: string): ArkosRequestHandler;
+    handleMultipleUpload(): ArkosRequestHandler;
+    handleDeleteSingleFile(oldFilePath: string): ArkosRequestHandler;
     deleteFileByUrl(fileUrl: string): Promise<boolean>;
     private getFieldName;
     upload(req: ArkosRequest, res: ArkosResponse, options?: {

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-system-json-schemas.d.ts

@@ -0,0 +1,4 @@
+import { ArkosConfig } from "../../../../../exports";
+export default function generateSystemJsonSchemas(arkosConfig: ArkosConfig): {
+    FindManyAuthActionSystemSchema: any;
+};

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,9 @@
 import { ArkosConfig } from "../../../../exports";
 import { OpenAPIV3 } from "openapi-types";
-export declare function getOpenAPIJsonSchemasByConfigMode(swaggerConfig: ArkosConfig["swagger"]): Promise<void | Record<string, any>>;
+import { ValidationFileMappingKey } from "../../../../utils/dynamic-loader";
+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>;
+export declare function localValidatorFileExists(action: ValidationFileMappingKey, modelName: string, arkosConfig: ArkosConfig): Promise<boolean>;

package/dist/types/server.d.ts

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

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/auth.d.ts

@@ -1,7 +1,13 @@
 import { JwtPayload } from "jsonwebtoken";
 export type AccessAction = "Create" | "Update" | "Delete" | "View" | string;
+export type DetailedAccessControlRule = {
+    roles: string[];
+    name?: string;
+    description?: string;
+    errorMessage?: string;
+};
 export type AccessControlRules = {
-    [key in AccessAction]: string[];
+    [key in AccessAction]: string[] | DetailedAccessControlRule;
 };
 export type AuthenticationControlRules = {
     [key in AccessAction]: boolean;

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

@@ -1,4 +1,4 @@
-import { NextFunction, Request, RequestHandler, Response } from "express";
+import { ErrorRequestHandler, NextFunction, Request, RequestHandler, Response } from "express";
 export type PrismaOperations = "findMany";
 export type PrismaQueryOptions<T extends Record<string, any>> = {
     queryOptions?: Partial<Parameters<T["findMany"]>[0]>;
@@ -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 {
 }
@@ -129,3 +130,5 @@ export interface ArkosNextFunction extends NextFunction {
 }
 export interface ArkosRequestHandler extends RequestHandler {
 }
+export interface ArkosErrorRequestHandler extends ErrorRequestHandler {
+}

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

@@ -1,10 +1,32 @@
 export type RouterEndpoint = "createOne" | "findOne" | "updateOne" | "deleteOne" | "findMany" | "createMany" | "updateMany" | "deleteMany";
-export type RouterConfig = {
+export type AuthRouterEndpoint = "getMe" | "updateMe" | "deleteMe" | "login" | "logout" | "signup" | "updatePassword" | "findManyAuthAction" | "findOneAuthAction";
+export type FileUploadRouterEndpoint = "findFile" | "uploadFile" | "updateFile" | "deleteFile";
+interface PrismaBaseRouterConfig {
     parent?: {
         model?: string;
         foreignKeyField?: string;
         endpoints?: "*" | RouterEndpoint[];
     };
+}
+export type RouterConfig<T extends string = string> = T extends "auth" ? {
+    disable?: boolean | {
+        getMe?: boolean;
+        updateMe?: boolean;
+        deleteMe?: boolean;
+        login?: boolean;
+        logout?: boolean;
+        signup?: boolean;
+        updatePassword?: boolean;
+        findManyAuthAction?: boolean;
+    };
+} : T extends "file-upload" ? {
+    disable?: boolean | {
+        findFile?: boolean;
+        uploadFile?: boolean;
+        updateFile?: boolean;
+        deleteFile?: boolean;
+    };
+} : PrismaBaseRouterConfig & {
     disable?: boolean | {
         createOne?: boolean;
         findOne?: boolean;
@@ -16,3 +38,4 @@ export type RouterConfig = {
         deleteMany?: boolean;
     };
 };
+export {};

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

@@ -6,8 +6,9 @@ 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>;
+    hooks: (options: GenerateOptions) => Promise<void>;
     queryOptions: (options: GenerateOptions) => Promise<void>;
 };
 export {};

package/dist/types/utils/cli/utils/smart-fs-watcher.d.ts

@@ -0,0 +1,11 @@
+declare class SmartFSWather {
+    private watchedFiles;
+    private watcher;
+    private onNewFile;
+    start(onNewFile: (filePath: string) => void): void;
+    private setupListeners;
+    reset(): void;
+    close(): void;
+}
+declare const smartFsWatcher: SmartFSWather;
+export default smartFsWatcher;

package/dist/types/utils/cli/utils/template-generator/templates/generate-hooks-template.d.ts

@@ -0,0 +1,2 @@
+import { TemplateOptions } from "../../template-generators";
+export default function generateHooksTemplate(options: TemplateOptions): string;

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/dynamic-loader.d.ts

@@ -0,0 +1,104 @@
+import { ZodTypeAny } from "zod";
+import { AuthConfigs } from "../types/auth";
+import { ArkosConfig } from "../exports";
+type AppModuleComponent = Awaited<ReturnType<typeof importModuleComponents>>;
+export declare function setModuleComponents(modelName: string, modules: AppModuleComponent): any;
+export declare function getModuleComponents(modelName: string): importModuleComponentsReturnType;
+export type ValidationFileMappingKey = keyof ReturnType<typeof getFileModuleComponentsFileStructure>["dtos"];
+export declare function getFileModuleComponentsFileStructure(modelName: string): {
+    core: {
+        hooks: string;
+        interceptors: string;
+        authConfigs: string;
+        authConfigsNew: string;
+        prismaQueryOptions: string;
+        prismaQueryOptionsNew: string;
+        router: 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;
+    } | {
+        model: string;
+        create: string;
+        createOne: string;
+        createMany: string;
+        update: string;
+        updateOne: string;
+        updateMany: string;
+        query: string;
+        findOne: string;
+        findMany: 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;
+    } | {
+        model: string;
+        create: string;
+        createOne: string;
+        createMany: string;
+        update: string;
+        updateOne: string;
+        updateMany: string;
+        query: string;
+        findOne: string;
+        findMany: string;
+        login?: undefined;
+        signup?: undefined;
+        getMe?: undefined;
+        updateMe?: undefined;
+        updatePassword?: undefined;
+    };
+};
+export declare function isClass(value: any): boolean;
+export declare function isZodSchema(value: any): value is ZodTypeAny;
+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;
+    prismaQueryOptionsNew?: any;
+    router?: any;
+    dtos?: Record<string, any>;
+    schemas?: Record<string, any>;
+};
+export declare function validateNamingConventions(key: string, fileName: string, result: importModuleComponentsReturnType): void;
+export declare function assignModuleToResult(appModule: string, key: string, module: any, result: importModuleComponentsReturnType, arkosConfig: ArkosConfig): void;
+export declare function importModuleComponents(modelName: string, arkosConfig: ArkosConfig, moduleDirExists?: boolean): Promise<importModuleComponentsReturnType>;
+export declare const appModules: string[];
+export declare function loadAllModuleComponents(arkosConfig: ArkosConfig): Promise<void>;
+export {};

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,3 @@
+import { ArkosConfig, RouterConfig } from "../../exports";
+export declare function applyStrictRoutingRules<T extends string>(appModule: T, arkosConfig: ArkosConfig, moduleConfig?: RouterConfig<T>): RouterConfig<T>;
+export declare function pathExists(path: string): Promise<boolean>;

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>;

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

@@ -1,2 +1,6 @@
-export declare const safeCatchAsync: (middleware: any) => ((req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>) | undefined;
-export declare const processMiddleware: (middleware: any) => ((req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>)[];
+export declare const safeCatchAsync: (middleware: any, options?: {
+    type: "error" | "normal";
+}) => any;
+export declare const processMiddleware: (middleware: any, options?: {
+    type: "error" | "normal";
+}) => any[];

package/dist/types/utils/prisma/prisma-json-schema-generator.d.ts

@@ -0,0 +1,34 @@
+import { ArkosConfig } from "../../exports";
+import { ValidationFileMappingKey } from "../dynamic-loader";
+import { JsonSchema } from "./types";
+export interface SchemaGenerationConfig {
+    modelName: string;
+    arkosConfig: ArkosConfig;
+    schemasToGenerate?: ValidationFileMappingKey[];
+}
+export interface GeneratedSchemas {
+    [key: string]: JsonSchema;
+}
+export declare class PrismaJsonSchemaGenerator {
+    schema: import("./types").PrismaSchema;
+    generateModelSchemas(config: SchemaGenerationConfig): Promise<GeneratedSchemas>;
+    private generateAuthSchemas;
+    private generateCrudSchemas;
+    private generateCreateSchema;
+    private generateUpdateSchema;
+    private generateResponseSchema;
+    private generateNestedRelationSchema;
+    private generateLoginSchema;
+    private generateSignupSchema;
+    private generateUpdateMeSchema;
+    private generateUpdatePasswordSchema;
+    private resolvePrismaQueryOptions;
+    private getGeneralOptionsForAction;
+    private isEndpointDisabled;
+    private isModelRelation;
+    private convertFieldToJsonSchema;
+    private mapPrismaTypeToJsonSchema;
+    private isEnum;
+}
+declare const prismaJsonSchemaGenerator: PrismaJsonSchemaGenerator;
+export default prismaJsonSchemaGenerator;

package/dist/types/utils/prisma/prisma-schema-parser.d.ts

@@ -0,0 +1,28 @@
+import { PrismaSchema, PrismaModel, PrismaEnum, PrismaField } from "./types";
+export declare class PrismaSchemaParser {
+    enums: PrismaEnum[];
+    models: PrismaModel[];
+    prismaSchemasContent: string;
+    parsed: boolean;
+    constructor();
+    parse({ override }?: {
+        override: boolean;
+    }): PrismaSchema;
+    private extractEnums;
+    private parseEnumBlock;
+    private extractModels;
+    private extractModelBlocks;
+    private parseModelBlock;
+    private parseFields;
+    private parseFieldLine;
+    private parseDefaultValue;
+    getPrismaSchemasContent(): string;
+    private getAllPrismaFiles;
+    isEnum(typeName: string): boolean;
+    isModel(typeName: string): boolean;
+    getModelUniqueFields(modelName: string): PrismaField[] | undefined;
+    getModelRelations(modelName: string): PrismaField[] | undefined;
+    getModelsAsArrayOfStrings(): string[];
+}
+declare const prismaSchemaParser: PrismaSchemaParser;
+export default prismaSchemaParser;