arkos 1.4.0-canary.7 → 1.4.0-canary.71

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

@@ -1,4 +1,4 @@
 import { Router } from "express";
-import { ArkosConfig } from "../../types/arkos-config";
 import express from "express";
+import { ArkosConfig } from "../../exports";
 export declare function getSwaggerRouter(arkosConfig: ArkosConfig, app: express.Express): Promise<Router>;

package/dist/types/modules/swagger/utils/helpers/class-validator-to-json-schema.d.ts

@@ -0,0 +1,3 @@
+export default function classValidatorToJsonSchema(decoratedClass: new (...args: any[]) => object): any;
+export declare function resolveReferences(schema: any, allSchemas: Record<string, any>, visited?: Set<string>): any;
+export declare function extractSchemaName(ref: string): string;

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

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

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

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

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

@@ -1,46 +1,3 @@
 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>;
+import { ArkosConfig } from "../../../../exports";
+export default function getSwaggerDefaultConfig(defaultModelsPaths: Record<string, any>, defaultJsonSchemas: OpenAPIV3.PathsObject<{}, {}>): ArkosConfig["swagger"];

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

@@ -1 +1 @@
-export declare function generateClassValidatorJsonSchemas(): Promise<Record<string, any>>;
+export declare function generateClassValidatorJsonSchemas(): Record<string, any>;

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

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

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

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

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

@@ -1,3 +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>;
+export declare function generatePrismaModelMainRoutesPaths(model: string, paths: OpenAPIV3.PathsObject | undefined, arkosConfig: ArkosConfig): OpenAPIV3.PathsObject<{}, {}> | undefined;

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

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

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

@@ -7,7 +7,7 @@ declare class MissingJsonSchemasGenerator {
     private extractSchemaRefsWithContext;
     private extractPathSchemaRefs;
     private getSchemaNameFromRef;
-    generateMissingJsonSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>, arkosConfig: ArkosConfig): Promise<Record<string, any>>;
+    generateMissingJsonSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>, arkosConfig: ArkosConfig): Record<string, any>;
     private extractActionFromSchemaRef;
     analyzeMissingSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>): {
         allRefs: Array<{

package/dist/types/modules/swagger/utils/helpers/openapi-schema-converter.d.ts

@@ -0,0 +1,17 @@
+import { OpenAPIV3 } from "openapi-types";
+declare class OpenAPIchemaConverter {
+    private validatorToJsonSchema;
+    constructor();
+    private isSchemaLike;
+    private isPlainObject;
+    private convertToJsonSchema;
+    private getDefaultDescription;
+    convertResponseDefinition(statusCode: string, definition: any): OpenAPIV3.ResponseObject;
+    convertRequestBodyDefinition(definition: any): OpenAPIV3.RequestBodyObject | undefined;
+    convertParameters(parameters: any[] | undefined): (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[] | undefined;
+    convertResponses(responses: Record<string, any> | undefined): Record<string, OpenAPIV3.ResponseObject> | undefined;
+    convertOpenAPIConfig(config: any): any;
+    jsonSchemaToOpeApiParameters(paramType: string, schema: any, prefix?: string): any[];
+}
+declare const openApiSchemaConverter: OpenAPIchemaConverter;
+export default openApiSchemaConverter;

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

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

package/dist/types/server.d.ts

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

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

@@ -1,186 +1,9 @@
 import http from "http";
-import cors from "cors";
 import express from "express";
-import { Options as RateLimitOptions } from "express-rate-limit";
-import cookieParser from "cookie-parser";
-import compression from "compression";
-import { Options as QueryParserOptions } from "../utils/helpers/query-parser.helpers";
-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" };
-import nodemailer from "nodemailer";
-import { ModuleComponents } from "../utils/dynamic-loader";
-export type ArkosConfig = {
-    request?: {
-        parameters?: {
-            allowDangerousPrismaQueryOptions?: boolean;
-        };
-    };
-    welcomeMessage?: string;
-    port?: number | undefined;
-    host?: string;
-    authentication?: {
-        mode: "static" | "dynamic";
-        login?: {
-            allowedUsernames?: string[];
-            sendAccessTokenThrough?: "cookie-only" | "response-only" | "both";
-        };
-        passwordValidation?: {
-            regex: RegExp;
-            message?: string;
-        };
-        requestRateLimitOptions?: Partial<RateLimitOptions>;
-        jwt?: {
-            secret?: string;
-            expiresIn?: MsDuration | number;
-            cookie?: {
-                secure?: boolean;
-                httpOnly?: boolean;
-                sameSite?: "lax" | "strict" | "none";
-            };
-        };
-    };
-    validation?: {
-        strict?: boolean;
-    } & ({
-        resolver?: "class-validator";
-        validationOptions?: ValidatorOptions;
-    } | {
-        resolver?: "zod";
-        validationOptions?: Record<string, any>;
-    });
-    fileUpload?: {
-        baseUploadDir?: string;
-        baseRoute?: string;
-        expressStaticOptions?: Parameters<typeof express.static>[1];
-        restrictions?: {
-            images?: {
-                maxCount?: number;
-                maxSize?: number;
-                supportedFilesRegex?: RegExp;
-            };
-            videos?: {
-                maxCount?: number;
-                maxSize?: number;
-                supportedFilesRegex?: RegExp;
-            };
-            documents?: {
-                maxCount?: number;
-                maxSize?: number;
-                supportedFilesRegex?: RegExp;
-            };
-            files?: {
-                maxCount?: number;
-                maxSize?: number;
-                supportedFilesRegex?: RegExp;
-            };
-        };
-    };
-    globalRequestRateLimitOptions?: Partial<RateLimitOptions>;
-    jsonBodyParserOptions?: Parameters<typeof express.json>[0];
-    cookieParserParameters?: Parameters<typeof cookieParser>;
-    compressionOptions?: compression.CompressionOptions;
-    queryParserOptions?: QueryParserOptions;
-    cors?: {
-        allowedOrigins?: string | string[] | "*";
-        options?: cors.CorsOptions;
-        customHandler?: cors.CorsOptionsDelegate;
-    };
-    middlewares?: {
-        additional?: express.RequestHandler[];
-        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;
-            authRateLimit?: express.RequestHandler;
-            cors?: express.RequestHandler;
-            expressJson?: express.RequestHandler;
-            cookieParser?: express.RequestHandler;
-            queryParser?: 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?: {
-            authRouter?: (config: ArkosConfig) => express.Router | Promise<express.Router>;
-            prismaModelsRouter?: (config: ArkosConfig) => express.Router | Promise<express.Router>;
-            fileUpload?: (config: ArkosConfig) => express.Router | Promise<express.Router>;
-            welcomeEndpoint?: express.RequestHandler;
-        };
-    };
+import { IArkosRouter } from "../utils/arkos-router/types";
+import { ArkosErrorRequestHandler, ArkosRequestHandler } from ".";
+export type ArkosInitConfig = {
+    use?: IArkosRouter[] | ArkosRequestHandler[] | ArkosErrorRequestHandler[];
     configureApp?: (app: express.Express) => Promise<any> | any;
     configureServer?: (server: http.Server) => Promise<any> | any;
-    email?: {
-        name?: string;
-        host: string;
-        port?: number;
-        secure?: boolean;
-        auth: {
-            user: string;
-            pass: string;
-        };
-    } & Parameters<typeof nodemailer.createTransport>[0];
-    swagger?: {
-        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<ApiReferenceConfiguration>;
-    };
-    debugging?: {
-        requests?: {
-            level?: 0 | 1 | 2 | 3;
-            filter?: ("Query" | "Body" | "Params" | "TransformedQuery" | "ServiceArgs" | "FinalPrismaQueryArgs")[];
-        };
-        dynamicLoader?: {
-            level?: 0 | 1 | 2 | 3;
-            filters?: {
-                modules?: string[];
-                components?: keyof ModuleComponents[];
-            };
-        };
-    };
 };

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

@@ -116,15 +116,16 @@ export interface User {
     roles?: UserRole[] | any[];
     role?: UserRole | any;
 }
-export interface ArkosRequest<Body = any, Query = any> extends Request {
+export interface ArkosRequest<Params extends Record<string, any> = any, Body = any, Query extends Record<string, any> = any> extends Request<Params, any, Body, Query> {
     user?: User & Record<string, any>;
     relationFields?: Record<string, boolean>;
     include?: Record<string, any>;
-    responseData?: Record<string, any> | null | undefined;
-    additionalData?: Record<string, any> | null | undefined;
-    responseStatus?: number | string | null | undefined;
+    responseData?: Record<string, any> | null;
+    additionalData?: Record<string, any> | null;
+    responseStatus?: number;
     body: Body;
     prismaQueryOptions?: Record<string, any>;
+    query: Query;
     accessToken?: string;
     transformedQuery?: Record<string, any>;
     filters?: Record<string, any>;

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

@@ -0,0 +1,167 @@
+import cors from "cors";
+import express from "express";
+import { Options as RateLimitOptions } from "express-rate-limit";
+import cookieParser from "cookie-parser";
+import compression from "compression";
+import { Options as QueryParserOptions } from "../utils/helpers/query-parser.helpers";
+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" };
+import nodemailer from "nodemailer";
+import { ModuleComponents } from "../utils/dynamic-loader";
+import { ArkosRequestHandler } from ".";
+export type ArkosConfig = {
+    request?: {
+        parameters?: {
+            allowDangerousPrismaQueryOptions?: boolean;
+        };
+    };
+    welcomeMessage?: string;
+    port?: number | undefined;
+    host?: string;
+    authentication?: {
+        enabled?: boolean;
+        mode: "static" | "dynamic";
+        login?: {
+            allowedUsernames?: string[];
+            sendAccessTokenThrough?: "cookie-only" | "response-only" | "both";
+        };
+        passwordValidation?: {
+            regex: RegExp;
+            message?: string;
+        };
+        requestRateLimitOptions?: Partial<RateLimitOptions>;
+        jwt?: {
+            secret?: string;
+            expiresIn?: MsDuration | number;
+            cookie?: {
+                secure?: boolean;
+                httpOnly?: boolean;
+                sameSite?: "lax" | "strict" | "none";
+            };
+        };
+    };
+    validation?: {
+        strict?: boolean;
+    } & ({
+        resolver?: "class-validator";
+        validationOptions?: ValidatorOptions;
+    } | {
+        resolver?: "zod";
+        validationOptions?: Record<string, any>;
+    });
+    fileUpload?: {
+        baseUploadDir?: string;
+        baseRoute?: string;
+        expressStatic?: Parameters<typeof express.static>[1];
+        restrictions?: {
+            images?: {
+                maxCount?: number;
+                maxSize?: number;
+                supportedFilesRegex?: RegExp;
+            };
+            videos?: {
+                maxCount?: number;
+                maxSize?: number;
+                supportedFilesRegex?: RegExp;
+            };
+            documents?: {
+                maxCount?: number;
+                maxSize?: number;
+                supportedFilesRegex?: RegExp;
+            };
+            files?: {
+                maxCount?: number;
+                maxSize?: number;
+                supportedFilesRegex?: RegExp;
+            };
+        };
+    };
+    middlewares?: {
+        compression?: false | compression.CompressionOptions | ArkosRequestHandler;
+        rateLimit?: false | Partial<RateLimitOptions> | ArkosRequestHandler;
+        cors?: false | {
+            allowedOrigins?: string | string[] | "*";
+            options?: cors.CorsOptions;
+            customHandler?: cors.CorsOptionsDelegate;
+        } | ArkosRequestHandler;
+        expressJson?: false | Parameters<typeof express.json>[0] | ArkosRequestHandler;
+        cookieParser?: false | Parameters<typeof cookieParser> | ArkosRequestHandler;
+        queryParser?: false | QueryParserOptions | ArkosRequestHandler;
+        requestLogger?: false | ArkosRequestHandler;
+        errorHandler?: false | express.ErrorRequestHandler;
+    };
+    routers?: {
+        strict?: boolean | "no-bulk";
+        welcomeRoute?: false | ArkosRequestHandler;
+    };
+    email?: {
+        name?: string;
+        host: string;
+        port?: number;
+        secure?: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    } & Parameters<typeof nodemailer.createTransport>[0];
+    swagger?: {
+        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<ApiReferenceConfiguration>;
+    };
+    debugging?: {
+        requests?: {
+            level?: 0 | 1 | 2 | 3;
+            filter?: ("Query" | "Body" | "Params" | "TransformedQuery" | "ServiceArgs" | "FinalPrismaQueryArgs")[];
+        };
+        dynamicLoader?: {
+            level?: 0 | 1 | 2 | 3;
+            filters?: {
+                modules?: string[];
+                components?: keyof ModuleComponents[];
+            };
+        };
+    };
+};

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

@@ -1,3 +1,4 @@
+import { ArkosRouteConfig } from "../exports";
 export type RouterEndpoint = "createOne" | "findOne" | "updateOne" | "deleteOne" | "findMany" | "createMany" | "updateMany" | "deleteMany";
 export type AuthRouterEndpoint = "getMe" | "updateMe" | "deleteMe" | "login" | "logout" | "signup" | "updatePassword" | "findManyAuthAction" | "findOneAuthAction";
 export type FileUploadRouterEndpoint = "findFile" | "uploadFile" | "updateFile" | "deleteFile";
@@ -8,34 +9,26 @@ interface PrismaBaseRouterConfig {
         endpoints?: "*" | RouterEndpoint[];
     };
 }
-export type RouterConfig<T extends string = string> = T extends "auth" ? {
+type BaseRouterConfig = PrismaBaseRouterConfig & {
     disable?: boolean | {
-        getMe?: boolean;
-        updateMe?: boolean;
-        deleteMe?: boolean;
-        login?: boolean;
-        logout?: boolean;
-        signup?: boolean;
-        updatePassword?: boolean;
-        findManyAuthAction?: boolean;
+        [K in RouterEndpoint]?: boolean;
     };
-} : T extends "file-upload" ? {
+} & {
+    [K in RouterEndpoint]?: Omit<ArkosRouteConfig, "route">;
+};
+type AuthRouterConfig = {
     disable?: boolean | {
-        findFile?: boolean;
-        uploadFile?: boolean;
-        updateFile?: boolean;
-        deleteFile?: boolean;
+        [K in AuthRouterEndpoint]?: boolean;
     };
-} : PrismaBaseRouterConfig & {
+} & {
+    [K in AuthRouterEndpoint]?: Omit<ArkosRouteConfig, "route">;
+};
+type FileUploadRouterConfig = {
     disable?: boolean | {
-        createOne?: boolean;
-        findOne?: boolean;
-        updateOne?: boolean;
-        deleteOne?: boolean;
-        createMany?: boolean;
-        findMany?: boolean;
-        updateMany?: boolean;
-        deleteMany?: boolean;
+        [K in FileUploadRouterEndpoint]?: boolean;
     };
+} & {
+    [K in FileUploadRouterEndpoint]?: Omit<ArkosRouteConfig, "route" | "uploads">;
 };
+export type RouterConfig<T extends string = string> = T extends "auth" ? AuthRouterConfig : T extends "file-upload" ? FileUploadRouterConfig : BaseRouterConfig;
 export {};

package/dist/types/utils/arkos-router/types/index.d.ts

@@ -1,7 +1,14 @@
-import { ErrorRequestHandler, IRouter, RequestHandler } from "express";
-import { OpenAPIV3 } from "openapi-types";
+import { IRouter } from "express";
 import { ZodSchema } from "zod";
-type MethodHandler = (configOrPath: ArkosRouteConfig, ...handlers: (RequestHandler | ErrorRequestHandler)[]) => IArkosRouter;
+import { Options as RateLimitOptions } from "express-rate-limit";
+import { Options as QueryParserOptions } from "../../../utils/helpers/query-parser.helpers";
+import { DetailedAccessControlRule } from "../../../types/auth";
+import { ArkosErrorRequestHandler, ArkosRequestHandler } from "../../../types";
+import express from "express";
+import compression from "compression";
+import { OpenApiConfig } from "./openapi-config";
+import { UploadConfig } from "./upload-config";
+type MethodHandler = (config: ArkosRouteConfig, ...handlers: (ArkosRequestHandler | ArkosErrorRequestHandler)[]) => IRouter;
 export interface IArkosRouter extends Omit<IRouter, "get" | "post" | "put" | "patch" | "delete" | "options" | "head" | "trace" | "all"> {
     get: MethodHandler;
     post: MethodHandler;
@@ -14,17 +21,40 @@ export interface IArkosRouter extends Omit<IRouter, "get" | "post" | "put" | "pa
     all: MethodHandler;
 }
 export interface ArkosRouteConfig {
+    disabled?: boolean;
     route: string;
     authentication?: boolean | {
         resource: string;
         action: string;
-        rule?: any;
+        rule?: DetailedAccessControlRule | string[];
     };
-    validation?: undefined | {
-        query?: ZodSchema | (new (...args: any[]) => object) | undefined;
-        body?: ZodSchema | (new (...args: any[]) => object) | undefined;
-        params?: ZodSchema | (new (...args: any[]) => object) | undefined;
+    validation?: false | {
+        query?: ZodSchema | (new (...args: any[]) => object) | false;
+        body?: ZodSchema | (new (...args: any[]) => object) | false;
+        params?: ZodSchema | (new (...args: any[]) => object) | false;
+    };
+    rateLimit?: Partial<RateLimitOptions>;
+    compression?: compression.CompressionOptions;
+    queryParser?: QueryParserOptions;
+    bodyParser?: {
+        parser: "json";
+        options?: Parameters<typeof express.json>[0];
+    } | {
+        parser: "urlencoded";
+        options?: Parameters<typeof express.urlencoded>[0];
+    } | {
+        parser: "raw";
+        options?: Parameters<typeof express.raw>[0];
+    } | {
+        parser: "raw";
+        options?: Parameters<typeof express.raw>[0];
+    } | {
+        parser: "text";
+        options?: Parameters<typeof express.text>[0];
+    } | false;
+    experimental?: {
+        openapi?: false | OpenApiConfig;
+        uploads?: UploadConfig;
     };
-    openapi?: boolean | Partial<OpenAPIV3.OperationObject>;
 }
 export {};