@forklaunch/core 0.2.37 → 0.3.0

package/lib/src/http/router/expressLikeRouter.js

@@ -1,483 +0,0 @@
-import { isConstrainedForklaunchRouter } from '../guards/isConstrainedForklaunchRouter';
-import { isExpressLikeSchemaHandler } from '../guards/isExpressLikeSchemaHandler';
-import { isForklaunchExpressLikeRouter } from '../guards/isForklaunchExpressLikeRouter';
-import { isForklaunchRouter } from '../guards/isForklaunchRouter';
-import { isHttpContractDetails } from '../guards/isHttpContractDetails';
-import { isPathParamHttpContractDetails } from '../guards/isPathParamContractDetails';
-import { isTypedHandler } from '../guards/isTypedHandler';
-import { parseRequestAuth } from '../middleware/request/auth.middleware';
-import { cors } from '../middleware/request/cors.middleware';
-import { createContext } from '../middleware/request/createContext.middleware';
-import { enrichDetails } from '../middleware/request/enrichDetails.middleware';
-import { parse } from '../middleware/request/parse.middleware';
-/**
- * A class that represents an Express-like router.
- */
-export class ForklaunchExpressLikeRouter {
-    schemaValidator;
-    internal;
-    requestHandler;
-    routers = [];
-    routes = [];
-    basePath;
-    constructor(basePath, schemaValidator, internal) {
-        this.schemaValidator = schemaValidator;
-        this.internal = internal;
-        this.basePath = basePath;
-        this.internal.use(createContext(this.schemaValidator));
-        this.internal.use(cors);
-    }
-    /**
-     * 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 [
-            enrichDetails(contractDetails, requestSchema, responseSchemas),
-            parse,
-            (parseRequestAuth)
-        ];
-    }
-    /**
-     * Parses and runs the controller handler 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.
-     */
-    #parseAndRunControllerHandler(requestHandler) {
-        return async (req, res, next) => {
-            if (!requestHandler) {
-                throw new Error('Controller handler 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 handler from the provided handlers.
-     *
-     * @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>[]} handlers - The provided handlers.
-     * @returns {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>} - The extracted controller handler.
-     * @throws {Error} - Throws an error if the last argument is not a handler.
-     */
-    #extractControllerHandler(handlers) {
-        const controllerHandler = handlers.pop();
-        if (typeof controllerHandler !== 'function') {
-            throw new Error(`Last argument must be a handler, received: ${controllerHandler}`);
-        }
-        return controllerHandler;
-    }
-    #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,
-            ...(isPathParamHttpContractDetails(contractDetails) ||
-                isHttpContractDetails(contractDetails)
-                ? { ...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 handlers {ExpressLikeHandler<SV>}
-     * @param controllerHandler
-     * @returns
-     */
-    #localParamRequest(handlers, controllerHandler) {
-        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 = handlers.shift();
-            if (cursor) {
-                for (const fn of handlers) {
-                    await cursor(req, res, (err) => {
-                        if (err) {
-                            throw err;
-                        }
-                        cursor = fn;
-                    });
-                }
-                await cursor(req, res, async (err) => {
-                    if (err) {
-                        throw err;
-                    }
-                });
-            }
-            const cHandler = controllerHandler;
-            await cHandler(req, res, (err) => {
-                if (err) {
-                    throw err;
-                }
-            });
-            return {
-                code: statusCode,
-                response: responseMessage,
-                headers: responseHeaders
-            };
-        };
-    }
-    registerRoute(method, path, registrationMethod, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareAndTypedHandler) {
-        // in this case, we know that the first argument is the typedHandler. As a result, we only use defined handlers
-        if (isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
-            const { contractDetails, handlers } = contractDetailsOrMiddlewareOrTypedHandler;
-            return this.registerRoute(method, path, registrationMethod, contractDetails, ...handlers);
-        }
-        // in this case, we test for the last element of the handlers. If typed handler, break this down
-        else {
-            const maybeTypedHandler = middlewareOrMiddlewareAndTypedHandler[middlewareOrMiddlewareAndTypedHandler.length - 1];
-            if (isTypedHandler(maybeTypedHandler)) {
-                const { contractDetails, handlers } = maybeTypedHandler;
-                return this.registerRoute(method, path, registrationMethod, contractDetails, ...middlewareOrMiddlewareAndTypedHandler.concat(handlers));
-            }
-            else {
-                if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) ||
-                    isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
-                    throw new Error('Contract details are not defined');
-                }
-                const contractDetails = contractDetailsOrMiddlewareOrTypedHandler;
-                const handlers = middlewareOrMiddlewareAndTypedHandler.filter((handler) => isExpressLikeSchemaHandler(handler));
-                if (!isHttpContractDetails(contractDetails) &&
-                    !isPathParamHttpContractDetails(contractDetails)) {
-                    throw new Error('Contract details are malformed for route definition');
-                }
-                this.routes.push({
-                    basePath: this.basePath,
-                    path,
-                    method,
-                    contractDetails
-                });
-                const { requestSchema, responseSchemas } = this.#compile(contractDetails);
-                const controllerHandler = this.#extractControllerHandler(handlers);
-                registrationMethod.bind(this.internal)(path, ...this.#resolveMiddlewares(contractDetails, requestSchema, responseSchemas).concat(handlers), this.#parseAndRunControllerHandler(controllerHandler));
-                return this.#localParamRequest(handlers, controllerHandler);
-            }
-        }
-    }
-    #extractHandlers(handlers, processMiddleware) {
-        const last = handlers.pop();
-        let finalHandlers = last ? [last] : [];
-        if (isTypedHandler(last)) {
-            finalHandlers = last.handlers;
-        }
-        handlers.forEach((handler) => {
-            if (isTypedHandler(handler)) {
-                throw new Error('Only the last argument supplied to this function can be a typed handler. Please use only middleware.');
-            }
-        });
-        const middleware = processMiddleware
-            ? handlers.map(processMiddleware)
-            : handlers;
-        return [...middleware, ...finalHandlers];
-    }
-    #extractMiddlewareFromEnrichedTypedHandlerArray(handlers) {
-        return this.#extractHandlers(handlers);
-    }
-    #extractNestableMiddlewareFromEnrichedTypedHandlerArray(handlers) {
-        return this.#extractHandlers(handlers, (handler) => isForklaunchExpressLikeRouter(handler)
-            ? handler.internal
-            : handler);
-    }
-    #processTypedHandlerOrMiddleware(handler, middleware) {
-        if (isTypedHandler(handler)) {
-            middleware.push(...handler.handlers);
-        }
-        else if (isExpressLikeSchemaHandler(handler)) {
-            middleware.push(handler);
-        }
-    }
-    #extractMiddlewareAsRouterHandlers(contractDetailsOrMiddlewareOrTypedHandler, middlewareOrMiddlewareWithTypedHandler) {
-        const middleware = [];
-        this.#processTypedHandlerOrMiddleware(contractDetailsOrMiddlewareOrTypedHandler, middleware);
-        middleware.push(...this.#extractMiddlewareFromEnrichedTypedHandlerArray(middlewareOrMiddlewareWithTypedHandler));
-        return middleware;
-    }
-    #extractNestableMiddlewareAsRouterHandlers(contractDetailsOrMiddlewareOrTypedHandler, middlewareOrMiddlewareWithTypedHandler) {
-        const middleware = [];
-        this.#processTypedHandlerOrMiddleware(contractDetailsOrMiddlewareOrTypedHandler, middleware);
-        if (isForklaunchExpressLikeRouter(contractDetailsOrMiddlewareOrTypedHandler)) {
-            middleware.push(contractDetailsOrMiddlewareOrTypedHandler.internal);
-        }
-        middleware.push(...this.#extractNestableMiddlewareFromEnrichedTypedHandlerArray(middlewareOrMiddlewareWithTypedHandler));
-        return middleware;
-    }
-    registerMiddlewareHandler(registrationMethod, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) {
-        const middleware = [];
-        if (typeof pathOrContractDetailsOrMiddlewareOrTypedHandler === 'string') {
-            middleware.push(...this.#extractMiddlewareAsRouterHandlers(contractDetailsOrMiddlewareOrTypedHandler, middlewareOrMiddlewareWithTypedHandler));
-            const path = pathOrContractDetailsOrMiddlewareOrTypedHandler;
-            registrationMethod.bind(this.internal)(path, ...middleware);
-        }
-        else {
-            middleware.push(...this.#extractMiddlewareAsRouterHandlers(pathOrContractDetailsOrMiddlewareOrTypedHandler, (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) ||
-                isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)
-                ? [contractDetailsOrMiddlewareOrTypedHandler]
-                : []).concat(middlewareOrMiddlewareWithTypedHandler)));
-            registrationMethod.bind(this.internal)(...middleware);
-        }
-        return this;
-    }
-    registerNestableMiddlewareHandler(registrationMethod, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) {
-        const middleware = [];
-        let path;
-        if (typeof pathOrContractDetailsOrMiddlewareOrTypedHandler === 'string') {
-            middleware.push(...this.#extractNestableMiddlewareAsRouterHandlers(contractDetailsOrMiddlewareOrTypedHandler, middlewareOrMiddlewareWithTypedHandler));
-            path = pathOrContractDetailsOrMiddlewareOrTypedHandler;
-        }
-        else {
-            if (isConstrainedForklaunchRouter(pathOrContractDetailsOrMiddlewareOrTypedHandler)) {
-                path = pathOrContractDetailsOrMiddlewareOrTypedHandler.basePath;
-            }
-            middleware.push(...this.#extractNestableMiddlewareAsRouterHandlers(pathOrContractDetailsOrMiddlewareOrTypedHandler, (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) ||
-                isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler) ||
-                isConstrainedForklaunchRouter(contractDetailsOrMiddlewareOrTypedHandler)
-                ? [contractDetailsOrMiddlewareOrTypedHandler]
-                : []).concat(middlewareOrMiddlewareWithTypedHandler)));
-        }
-        if (path) {
-            registrationMethod.bind(this.internal)(path, ...middleware);
-        }
-        else {
-            registrationMethod.bind(this.internal)(...middleware);
-        }
-        return this;
-    }
-    use = (pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        [
-            pathOrContractDetailsOrMiddlewareOrTypedHandler,
-            contractDetailsOrMiddlewareOrTypedHandler,
-            ...middlewareOrMiddlewareWithTypedHandler
-        ].forEach((arg) => {
-            if (isForklaunchRouter(arg)) {
-                this.routers.push(arg);
-            }
-        });
-        return this.registerNestableMiddlewareHandler(this.internal.use, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler);
-    };
-    all = (pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return this.registerMiddlewareHandler(this.internal.all, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler);
-    };
-    connect = (pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return this.registerMiddlewareHandler(this.internal.connect, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler);
-    };
-    /**
-     * Registers a GET route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    get = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            get: this.registerRoute('get', path, this.internal.get, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a POST route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Expxwress router.
-     */
-    post = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            post: this.registerRoute('post', path, this.internal.post, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a PUT route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    put = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            put: this.registerRoute('put', path, this.internal.put, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a PATCH route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    patch = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            patch: this.registerRoute('patch', path, this.internal.patch, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a DELETE route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    delete = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            delete: this.registerRoute('delete', path, this.internal.delete, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a OPTIONS route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    options = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            options: this.registerRoute('options', path, this.internal.options, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a HEAD route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    head = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            head: this.registerRoute('head', path, this.internal.head, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-    /**
-     * Registers a TRACE route with the specified contract details and handler handlers.
-     *
-     * @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 {...SchemaHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>[]} handlers - The handler handlers.
-     * @returns {ExpressRouter} - The Express router.
-     */
-    trace = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-        return {
-            trace: this.registerRoute('trace', path, this.internal.trace, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler)
-        };
-    };
-}