@forklaunch/core 0.2.3 → 0.2.6

package/lib/dist/http/interfaces/expressLikeRouter.interface.js

@@ -0,0 +1,336 @@
+import { isHttpContractDetails } from '../guards/isHttpContractDetails';
+import { corsMiddleware, createRequestContext, enrichRequestDetails, parseRequest } from '../middleware';
+/**
+ * A class that represents an Express-like router.
+ */
+export class ForklaunchExpressLikeRouter {
+    schemaValidator;
+    internal;
+    routes = [];
+    basePath;
+    constructor(basePath, schemaValidator, internal) {
+        this.schemaValidator = schemaValidator;
+        this.internal = internal;
+        this.basePath = basePath;
+        this.internal.use(createRequestContext(this.schemaValidator));
+        this.internal.use(corsMiddleware);
+    }
+    /**
+     * Resolves middlewares based on the contract details.
+     *
+     * @param {PathParamHttpContractDetails<SV> | HttpContractDetails<SV>} contractDetails - The contract details.
+     * @returns {MiddlewareHandler<SV>[]} - The resolved middlewares.
+     */
+    #resolveMiddlewares(contractDetails, requestSchema, responseSchemas) {
+        return [
+            enrichRequestDetails(contractDetails, requestSchema, responseSchemas),
+            parseRequest
+        ];
+    }
+    /**
+     * Parses and runs the controller function with error handling.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @template StatusCode - The type of status code.
+     * @param {MiddlewareHandler<SV, P, ResBodyMap | string, ReqBody, ReqQuery, LocalsObj, StatusCode>} requestHandler - The request handler.
+     * @returns {ExpressMiddlewareHandler} - The Express request handler.
+     */
+    #parseAndRunControllerFunction(requestHandler) {
+        return async (req, res, next) => {
+            if (!requestHandler) {
+                throw new Error('Controller function is not defined');
+            }
+            try {
+                await requestHandler(req, res, next);
+            }
+            catch (error) {
+                next?.(error);
+                console.error(error);
+                if (!res.headersSent) {
+                    res.status(500).send('Internal Server Error');
+                }
+            }
+        };
+    }
+    /**
+     * Extracts the controller function from the provided functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The provided functions.
+     * @returns {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>} - The extracted controller function.
+     * @throws {Error} - Throws an error if the last argument is not a function.
+     */
+    #extractControllerFunction(functions) {
+        const controllerFunction = functions.pop();
+        if (typeof controllerFunction !== 'function') {
+            throw new Error('Last argument must be a function');
+        }
+        return controllerFunction;
+    }
+    // TODO: Move to UniversalSDK
+    //   /**
+    //    * Extracts the SDK path from the given path.
+    //    *
+    //    * @param {string | RegExp | (string | RegExp)[]} path - The provided path.
+    //    * @returns {string} - The extracted SDK path.
+    //    * @throws {Error} - Throws an error if the path is not defined.
+    //    */
+    //   extractSdkPath(path: string | RegExp | (string | RegExp)[]): string {
+    //     let sdkPath = path;
+    //     if (Array.isArray(path)) {
+    //       sdkPath = path.pop() || path[0];
+    //     }
+    //     if (!sdkPath) {
+    //       throw new Error('Path is not defined');
+    //     }
+    //     if (sdkPath instanceof RegExp) {
+    //       sdkPath = generateStringFromRegex(sdkPath);
+    //     }
+    //     return sdkPath as string;
+    //   }
+    /**
+     * Registers middleware to the router.
+     *
+     * @param {...unknown[]} args - The middleware to register.
+     * @returns {this} - The router instance.
+     */
+    use(...args) {
+        this.internal.use(...args);
+        return this;
+    }
+    #compile(contractDetails) {
+        const schemaValidator = this.schemaValidator;
+        const requestSchema = schemaValidator.compile(schemaValidator.schemify({
+            ...(contractDetails.params ? { params: contractDetails.params } : {}),
+            ...(contractDetails.requestHeaders
+                ? { headers: contractDetails.requestHeaders }
+                : {}),
+            ...(contractDetails.query ? { query: contractDetails.query } : {}),
+            ...(isHttpContractDetails(contractDetails) && contractDetails.body
+                ? { body: contractDetails.body }
+                : {})
+        }));
+        const responseEntries = {
+            400: schemaValidator.string,
+            401: schemaValidator.string,
+            403: schemaValidator.string,
+            404: schemaValidator.string,
+            500: schemaValidator.string,
+            ...contractDetails.responses
+        };
+        const responseSchemas = {
+            responses: {},
+            ...(contractDetails.responseHeaders
+                ? {
+                    headers: schemaValidator.compile(schemaValidator.schemify(contractDetails.responseHeaders))
+                }
+                : {})
+        };
+        Object.entries(responseEntries).forEach(([code, responseShape]) => {
+            responseSchemas.responses[Number(code)] = schemaValidator.compile(schemaValidator.schemify(responseShape));
+        });
+        return {
+            requestSchema,
+            responseSchemas
+        };
+    }
+    /**
+     * Executes request locally, applying parameters
+     *
+     * @param functions {ForklaunchMiddlewareHandler<SV>}
+     * @param controllerFunction
+     * @returns
+     */
+    #localParamRequest(functions, controllerFunction) {
+        return async (route, request) => {
+            let statusCode;
+            let responseMessage;
+            const responseHeaders = {};
+            const req = {
+                params: request?.params ?? {},
+                query: request?.query ?? {},
+                headers: request?.headers ?? {},
+                body: request?.body ?? {},
+                path: route
+            };
+            const res = {
+                status: (code) => {
+                    statusCode = code;
+                    return res;
+                },
+                send: (message) => {
+                    responseMessage = message;
+                },
+                json: (body) => {
+                    responseMessage = body;
+                },
+                jsonp: (body) => {
+                    responseMessage = body;
+                },
+                setHeader: (key, value) => {
+                    responseHeaders[key] = value;
+                }
+            };
+            let cursor = functions.shift();
+            if (cursor) {
+                for (const fn of functions) {
+                    await cursor(req, res, (err) => {
+                        if (err) {
+                            throw err;
+                        }
+                        cursor = fn;
+                    });
+                }
+                await cursor(req, res, async (err) => {
+                    if (err) {
+                        throw err;
+                    }
+                });
+            }
+            const cFunction = controllerFunction;
+            await cFunction(req, res, (err) => {
+                if (err) {
+                    throw err;
+                }
+            });
+            return {
+                code: statusCode,
+                response: responseMessage,
+                headers: responseHeaders
+            };
+        };
+    }
+    #registerRoute(method, path, registrationFunction, contractDetailsOrTypedHandler, ...functions) {
+        if (contractDetailsOrTypedHandler instanceof TypedHandler) {
+            const typedHandler = contractDetailsOrTypedHandler;
+            return this.#registerRoute(method, path, registrationFunction, typedHandler.contractDetails, ...typedHandler.functions.concat(functions));
+        }
+        const contractDetails = contractDetailsOrTypedHandler;
+        this.routes.push({
+            basePath: this.basePath,
+            path,
+            method,
+            contractDetails
+        });
+        const { requestSchema, responseSchemas } = this.#compile(contractDetails);
+        const controllerFunction = this.#extractControllerFunction(functions);
+        registrationFunction.bind(this.internal)(path, ...this.#resolveMiddlewares(contractDetails, requestSchema, responseSchemas).concat(functions), this.#parseAndRunControllerFunction(controllerFunction));
+        return this.#localParamRequest(functions, controllerFunction);
+    }
+    /**
+     * Registers a GET route with the specified contract details and handler functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {string} path - The path for the route.
+     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
+     * @param {...SchemaMiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The handler functions.
+     * @returns {ExpressRouter} - The Express router.
+     */
+    get(path, contractDetailsOrTypedHandler, ...functions) {
+        return {
+            get: this.#registerRoute('get', path, this.internal.get, contractDetailsOrTypedHandler, ...functions)
+        };
+    }
+    /**
+     * Registers a POST route with the specified contract details and handler functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {string} path - The path for the route.
+     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
+     * @param {...SchemaMiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The handler functions.
+     * @returns {ExpressRouter} - The Express router.
+     */
+    post(path, contractDetailsOrTypedHandler, ...functions) {
+        return {
+            post: this.#registerRoute('post', path, this.internal.post, contractDetailsOrTypedHandler, ...functions)
+        };
+    }
+    /**
+     * Registers a PUT route with the specified contract details and handler functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {string} path - The path for the route.
+     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
+     * @param {...SchemaMiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The handler functions.
+     * @returns {ExpressRouter} - The Express router.
+     */
+    put(path, contractDetailsOrTypedHandler, ...functions) {
+        return {
+            put: this.#registerRoute('put', path, this.internal.put, contractDetailsOrTypedHandler, ...functions)
+        };
+    }
+    /**
+     * Registers a PATCH route with the specified contract details and handler functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {string} path - The path for the route.
+     * @param {HttpContractDetails<SV, P, ResBodyMap, ReqBody, ReqQuery>} contractDetails - The contract details.
+     * @param {...SchemaMiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The handler functions.
+     * @returns {ExpressRouter} - The Express router.
+     */
+    patch(path, contractDetailsOrTypedHandler, ...functions) {
+        return {
+            patch: this.#registerRoute('patch', path, this.internal.patch, contractDetailsOrTypedHandler, ...functions)
+        };
+    }
+    /**
+     * Registers a DELETE route with the specified contract details and handler functions.
+     *
+     * @template P - The type of request parameters.
+     * @template ResBodyMap - The type of response body.
+     * @template ReqBody - The type of request body.
+     * @template ReqQuery - The type of request query.
+     * @template LocalsObj - The type of local variables.
+     * @param {string} path - The path for the route.
+     * @param {PathParamHttpContractDetails<SV, P, ResBodyMap, ReqQuery>} contractDetails - The contract details.
+     * @param {...SchemaMiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} functions - The handler functions.
+     * @returns {ExpressRouter} - The Express router.
+     */
+    delete(path, contractDetailsOrTypedHandler, ...functions) {
+        return {
+            delete: this.#registerRoute('delete', path, this.internal.delete, contractDetailsOrTypedHandler, ...functions)
+        };
+    }
+}
+class TypedHandler {
+    contractDetails;
+    functions;
+    constructor(contractDetails, functions) {
+        this.contractDetails = contractDetails;
+        this.functions = functions;
+    }
+}
+/**
+ * Router class that sets up routes and middleware for an Express router, for use with controller/routes pattern.
+ *
+ * @template SV - A type that extends AnySchemaValidator.
+ * @template contractDetails - The contract details.
+ * @template functions - The handler middlware and function.
+ */
+export function typedHandler(_schemaValidator, _method, contractDetails, ...functions) {
+    return new TypedHandler(contractDetails, functions);
+}

package/lib/dist/http/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./expressLikeApplication.interface";
+export * from "./expressLikeRouter.interface";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/http/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../dist/http/interfaces/index.js"],"names":[],"mappings":""}

package/lib/dist/http/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './expressLikeApplication.interface';
+export * from './expressLikeRouter.interface';

package/lib/dist/http/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./request.middleware";
+export * from "./response.middleware";
+//# sourceMappingURL=index.d.ts.map

package/lib/dist/http/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../dist/http/middleware/index.js"],"names":[],"mappings":""}

package/lib/dist/http/middleware/request.middleware.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Cors middleware handler
+ *
+ * @param req - Express-like request object
+ * @param res - Express-like response object
+ * @param next - Express-like next function
+ */
+export function corsMiddleware(req: any, res: any, next: any): void;
+/**
+ * Middleware to create and add a request context.
+ *
+ * @template SV - A type that extends AnySchemaValidator.
+ * @template Request - A type that extends ForklaunchRequest.
+ * @template Response - A type that extends ForklaunchResponse.
+ * @template NextFunction - A type that extends ForklaunchNextFunction.
+ * @param {SV} schemaValidator - The schema validator.
+ * @returns {Function} - Middleware function to create request context.
+ */
+export function createRequestContext<SV, Request, Response, NextFunction>(schemaValidator: SV): Function;
+/**
+ * Middleware to enrich the request details with contract details.
+ *
+ * @template SV - A type that extends AnySchemaValidator.
+ * @template Request - A type that extends ForklaunchRequest.
+ * @template Response - A type that extends ForklaunchResponse.
+ * @template NextFunction - A type that extends ForklaunchNextFunction.
+ * @param {PathParamHttpContractDetails<SV> | HttpContractDetails<SV>} contractDetails - The contract details.
+ * @returns {Function} - Middleware function to enrich request details.
+ */
+export function enrichRequestDetails<SV, Request, Response, NextFunction>(contractDetails: PathParamHttpContractDetails<SV> | HttpContractDetails<SV>, requestSchema: any, responseSchemas: any): Function;
+/**
+ * Pre-handler function to parse and validate input.
+ *
+ * @template SV - A type that extends AnySchemaValidator.
+ * @template Request - A type that extends ForklaunchRequest.
+ * @template Response - A type that extends ForklaunchResponse.
+ * @template NextFunction - A type that extends ForklaunchNextFunction.
+ * @param {Request} req - The request object.
+ * @param {Response} res - The response object.
+ * @param {NextFunction} [next] - The next middleware function.
+ */
+export function parseRequest<SV, Request, Response, NextFunction>(req: Request, _res: any, next?: NextFunction | undefined): void;
+/**
+ * Maps roles from authorization.
+ *
+ * @param {AuthMethod} [authorizationType] - The method of authorization.
+ * @param {string} [authorizationToken] - The authorization token.
+ * @returns {string[]} - The mapped roles.
+ */
+/**
+ * Maps permissions from authorization.
+ *
+ * @param {AuthMethod} [authorizationType] - The method of authorization.
+ * @param {string} [authorizationToken] - The authorization token.
+ * @returns {string[]} - The mapped permissions.
+ */
+/**
+ * Middleware to parse request authorization.
+ *
+ * @template SV - A type that extends AnySchemaValidator.
+ * @template Request - A type that extends ForklaunchRequest.
+ * @template Response - A type that extends ForklaunchResponse.
+ * @template NextFunction - A type that extends ForklaunchNextFunction.
+ * @param {Request} req - The request object.
+ * @param {Response} res - The response object.
+ * @param {NextFunction} [next] - The next middleware function.
+ */
+export function parseRequestAuth<SV, Request, Response, NextFunction>(req: Request, res: Response, next?: NextFunction | undefined): Promise<void>;
+//# sourceMappingURL=request.middleware.d.ts.map

package/lib/dist/http/middleware/request.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.middleware.d.ts","sourceRoot":"","sources":["../../../../dist/http/middleware/request.middleware.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,oEAMC;AACD;;;;;;;;;GASG;AACH,qCAPa,EAAE,EACF,OAAO,EACP,QAAQ,EACR,YAAY,mBACd,EAAE,YAiBZ;AACD;;;;;;;;;GASG;AACH,qCAPa,EAAE,EACF,OAAO,EACP,QAAQ,EACR,YAAY,mBACd,4BAA4B,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,EAAE,CAAC,sDAWpE;AACD;;;;;;;;;;GAUG;AACH,6BARa,EAAE,EACF,OAAO,EACP,QAAQ,EACR,YAAY,OACd,OAAO,oDAkCjB;AA8BD;;;;;;GAMG;AAOH;;;;;;GAMG;AAOH;;;;;;;;;;GAUG;AACH,iCARa,EAAE,EACF,OAAO,EACP,QAAQ,EACR,YAAY,OACd,OAAO,OACP,QAAQ,kDA0ClB"}

package/{dist → lib/dist}/http/middleware/request.middleware.js

@@ -1,5 +1,21 @@
+import cors from 'cors';
 import * as jose from 'jose';
 import { v4 } from 'uuid';
+import { isResponseShape } from '../guards/isResponseShape';
+/**
+ * Cors middleware handler
+ *
+ * @param req - Express-like request object
+ * @param res - Express-like response object
+ * @param next - Express-like next function
+ */
+export function corsMiddleware(req, res, next) {
+    console.debug('[MIDDLEWARE] cors started');
+    if (req.method === 'OPTIONS') {
+        res.cors = true;
+    }
+    cors()(req, res, next ?? (() => { }));
+}
 /**
  * Middleware to create and add a request context.
  *
@@ -12,6 +28,7 @@ import { v4 } from 'uuid';
  */
 export function createRequestContext(schemaValidator) {
     return (req, res, next) => {
+        console.debug('[MIDDLEWARE] createRequestContext started');
         req.schemaValidator = schemaValidator;
         let correlationId = v4();
         if (req.headers['x-correlation-id']) {
@@ -21,9 +38,7 @@ export function createRequestContext(schemaValidator) {
         req.context = {
             correlationId: correlationId
         };
-        if (next) {
-            next();
-        }
+        next?.();
     };
 }
 /**
@@ -36,36 +51,19 @@ export function createRequestContext(schemaValidator) {
  * @param {PathParamHttpContractDetails<SV> | HttpContractDetails<SV>} contractDetails - The contract details.
  * @returns {Function} - Middleware function to enrich request details.
  */
-export function enrichRequestDetails(contractDetails) {
-    return (req, _res, next) => {
+export function enrichRequestDetails(contractDetails, requestSchema, responseSchemas) {
+    return (req, res, next) => {
+        console.debug('[MIDDLEWARE] enrichRequestDetails started');
         req.contractDetails = contractDetails;
-        if (next) {
-            next();
-        }
+        req.requestSchema = requestSchema;
+        res.responseSchemas = responseSchemas;
+        next?.();
     };
 }
 /**
  * Pre-handler function to parse and validate input.
  *
  * @template SV - A type that extends AnySchemaValidator.
- * @param {SchemaValidator} schemaValidator - The schema validator.
- * @param {unknown} object - The object to validate.
- * @param {StringOnlyObject<SV>} [schemaInput] - The schema input.
- * @returns {number | void} - Returns 400 if validation fails.
- */
-export function preHandlerParse(schemaValidator, object, schemaInput) {
-    if (!schemaInput) {
-        return;
-    }
-    const schema = schemaValidator.schemify(schemaInput);
-    if (!schemaValidator.validate(schema, object)) {
-        return 400;
-    }
-}
-/**
- * Middleware to parse request parameters.
- *
- * @template SV - A type that extends AnySchemaValidator.
  * @template Request - A type that extends ForklaunchRequest.
  * @template Response - A type that extends ForklaunchResponse.
  * @template NextFunction - A type that extends ForklaunchNextFunction.
@@ -73,89 +71,36 @@ export function preHandlerParse(schemaValidator, object, schemaInput) {
  * @param {Response} res - The response object.
  * @param {NextFunction} [next] - The next middleware function.
  */
-export function parseRequestParams(req, res, next) {
-    const params = req.contractDetails.params;
-    if (preHandlerParse(req.schemaValidator, req.params, params) === 400) {
-        res.status(400).send('Invalid request parameters.');
-        if (next) {
-            next(new Error('Invalid request parameters.'));
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-/**
- * Middleware to parse request body.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template Request - A type that extends ForklaunchRequest.
- * @template Response - A type that extends ForklaunchResponse.
- * @template NextFunction - A type that extends ForklaunchNextFunction.
- * @param {Request} req - The request object.
- * @param {Response} res - The response object.
- * @param {NextFunction} [next] - The next middleware function.
- */
-export function parseRequestBody(req, res, next) {
-    if (req.headers['content-type'] === 'application/json') {
-        const body = (req.schemaValidator,
-            req.contractDetails).body;
-        if (preHandlerParse(req.schemaValidator, req.body, body) === 400) {
-            res.status(400).send('Invalid request body.');
-            if (next) {
-                next(new Error('Invalid request body.'));
-            }
-        }
-    }
-    if (next) {
-        next();
-    }
-}
-/**
- * Middleware to parse request headers.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template Request - A type that extends ForklaunchRequest.
- * @template Response - A type that extends ForklaunchResponse.
- * @template NextFunction - A type that extends ForklaunchNextFunction.
- * @param {Request} req - The request object.
- * @param {Response} res - The response object.
- * @param {NextFunction} [next] - The next middleware function.
- */
-export function parseReqHeaders(req, res, next) {
-    const headers = req.contractDetails.requestHeaders;
-    if (preHandlerParse(req.schemaValidator, req.headers, headers) === 400) {
-        res.status(400).send('Invalid request headers.');
-        if (next) {
-            next(new Error('Invalid request headers.'));
-        }
-    }
-    if (next) {
-        next();
+export function parseRequest(req, _res, next) {
+    console.debug('[MIDDLEWARE] parseRequest started');
+    const request = {
+        params: req.params,
+        query: req.query,
+        headers: req.headers,
+        body: req.body
+    };
+    const parsedRequest = req.schemaValidator.parse(req.requestSchema, request);
+    if (parsedRequest.ok &&
+        isResponseShape(parsedRequest.value)) {
+        req.body = parsedRequest.value.body;
+        req.params = parsedRequest.value.params;
+        req.query = parsedRequest.value.query;
+        req.headers = parsedRequest.value.headers;
     }
-}
-/**
- * Middleware to parse request query.
- *
- * @template SV - A type that extends AnySchemaValidator.
- * @template Request - A type that extends ForklaunchRequest.
- * @template Response - A type that extends ForklaunchResponse.
- * @template NextFunction - A type that extends ForklaunchNextFunction.
- * @param {Request} req - The request object.
- * @param {Response} res - The response object.
- * @param {NextFunction} [next] - The next middleware function.
- */
-export function parseRequestQuery(req, res, next) {
-    const query = req.contractDetails.query;
-    if (preHandlerParse(req.schemaValidator, req.query, query) === 400) {
-        res.status(400).send('Invalid request query.');
-        if (next) {
-            next(new Error('Invalid request query.'));
+    if (!parsedRequest.ok) {
+        switch (req.contractDetails.options?.requestValidation) {
+            default:
+            case 'error':
+                next?.(new Error(`Invalid request: ${parsedRequest.error}`));
+                break;
+            case 'warning':
+                console.warn(`Invalid request: ${parsedRequest.error}`);
+                break;
+            case 'none':
+                break;
         }
     }
-    if (next) {
-        next();
-    }
+    next?.();
 }
 /**
  * Checks the authorization token for validity.
@@ -229,9 +174,7 @@ export async function parseRequestAuth(req, res, next) {
         const errorAndMessage = await checkAuthorizationToken(auth.method, req.headers.authorization);
         if (Array.isArray(errorAndMessage)) {
             res.status(errorAndMessage[0]).send(errorAndMessage[1]);
-            if (next) {
-                next(new Error(errorAndMessage[1]));
-            }
+            next?.(new Error(errorAndMessage[1]));
         }
         // TODO: Implement role and permission checking
         //   const permissionSlugs = mapPermissions(
@@ -249,8 +192,7 @@ export async function parseRequestAuth(req, res, next) {
         //       req.contractDetails.auth?.forbiddenSlugs?.has(permissionSlug)
         //     ) {
         //       res.status(403).send(permissionErrorMessage);
-        //       if (next) {
-        //         next(new Error(permissionErrorMessage));
+        //       next?.(new Error(permissionErrorMessage));
         //       }
         //     }
         //   });
@@ -260,13 +202,9 @@ export async function parseRequestAuth(req, res, next) {
         //       req.contractDetails.auth?.forbiddenRoles?.has(role)
         //     ) {
         //       res.status(403).send(roleErrorMessage);
-        //       if (next) {
-        //         next(new Error(roleErrorMessage));
-        //       }
+        //       next?.(new Error(roleErrorMessage));
         //     }
         //   });
     }
-    // if (next) {
-    //     next();
-    // }
+    // next?.();
 }