@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Routing/Data/Route.ts

@@ -0,0 +1,252 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { RequestMethod } from '../../Message/Enum/RequestMethod.js';
+import { HttpRoutingNoRequestStructException } from '../Throwable/Exception/HttpRoutingNoRequestStructException.js';
+import { HttpRoutingNoResponseStructException } from '../Throwable/Exception/HttpRoutingNoResponseStructException.js';
+
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { RouteDispatchedMiddlewareContract } from '../../Middleware/Contract/RouteDispatchedMiddlewareContract.js';
+import type { RouteMatchedMiddlewareContract } from '../../Middleware/Contract/RouteMatchedMiddlewareContract.js';
+import type { SendingResponseMiddlewareContract } from '../../Middleware/Contract/SendingResponseMiddlewareContract.js';
+import type { TerminatedMiddlewareContract } from '../../Middleware/Contract/TerminatedMiddlewareContract.js';
+import type { ThrowableCaughtMiddlewareContract } from '../../Middleware/Contract/ThrowableCaughtMiddlewareContract.js';
+import type { RequestStructContract } from '../../Struct/Request/Contract/RequestStructContract.js';
+import type { ResponseStructContract } from '../../Struct/Response/Contract/ResponseStructContract.js';
+import type { RouteContract } from './Contract/RouteContract.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Route implements RouteContract {
+    protected handler: (container: ContainerContract, route: RouteContract) => ResponseContract;
+
+    constructor(
+        protected path: string,
+        protected name: string,
+        handler: (container: ContainerContract, route: RouteContract) => ResponseContract,
+        protected requestMethods: RequestMethod[] = [RequestMethod.HEAD, RequestMethod.GET],
+        protected routeMatchedMiddleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract> = [],
+        protected routeDispatchedMiddleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract> = [],
+        protected throwableCaughtMiddleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract> = [],
+        protected sendingResponseMiddleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract> = [],
+        protected terminatedMiddleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract> = [],
+        protected requestStruct: RequestStructContract | null = null,
+        protected responseStruct: ResponseStructContract | null = null,
+    ) {
+        this.handler = handler;
+    }
+
+    getPath(): string {
+        return this.path;
+    }
+
+    withPath(path: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.path = this.getFilteredPath(path);
+        return clone;
+    }
+
+    withAddedPath(path: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.path = this.getFilteredPath(this.getFilteredPath(this.path) + this.getFilteredPath(path));
+        return clone;
+    }
+
+    getName(): string {
+        return this.name;
+    }
+
+    withName(name: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.name = name;
+        return clone;
+    }
+
+    withAddedName(name: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.name = this.name + name;
+        return clone;
+    }
+
+    getHandler(): (container: ContainerContract, route: RouteContract) => ResponseContract {
+        return this.handler;
+    }
+
+    withHandler(handler: (container: ContainerContract, route: RouteContract) => ResponseContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.handler = handler;
+        return clone;
+    }
+
+    getRequestMethods(): RequestMethod[] {
+        return this.requestMethods;
+    }
+
+    hasRequestMethod(requestMethod: RequestMethod): boolean {
+        return this.requestMethods.includes(requestMethod);
+    }
+
+    withRequestMethods(...requestMethods: RequestMethod[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.requestMethods = requestMethods;
+        return clone;
+    }
+
+    withAddedRequestMethods(...requestMethods: RequestMethod[]): this {
+        const clone = ObjectFactory.clone(this);
+        const existing = [...this.requestMethods];
+
+        for (const method of requestMethods) {
+            if (!existing.includes(method)) {
+                existing.push(method);
+            }
+        }
+
+        clone.requestMethods = existing;
+        return clone;
+    }
+
+    getRouteMatchedMiddleware(): Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract> {
+        return this.routeMatchedMiddleware;
+    }
+
+    withRouteMatchedMiddleware(...middleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract>): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeMatchedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedRouteMatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeMatchedMiddleware = [...this.routeMatchedMiddleware, ...middleware];
+        return clone;
+    }
+
+    getRouteDispatchedMiddleware(): Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract> {
+        return this.routeDispatchedMiddleware;
+    }
+
+    withRouteDispatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeDispatchedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedRouteDispatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.routeDispatchedMiddleware = [...this.routeDispatchedMiddleware, ...middleware];
+        return clone;
+    }
+
+    getThrowableCaughtMiddleware(): Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract> {
+        return this.throwableCaughtMiddleware;
+    }
+
+    withThrowableCaughtMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.throwableCaughtMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedThrowableCaughtMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.throwableCaughtMiddleware = [...this.throwableCaughtMiddleware, ...middleware];
+        return clone;
+    }
+
+    getSendingResponseMiddleware(): Array<new (...args: unknown[]) => SendingResponseMiddlewareContract> {
+        return this.sendingResponseMiddleware;
+    }
+
+    withSendingResponseMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.sendingResponseMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedSendingResponseMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.sendingResponseMiddleware = [...this.sendingResponseMiddleware, ...middleware];
+        return clone;
+    }
+
+    getTerminatedMiddleware(): Array<new (...args: unknown[]) => TerminatedMiddlewareContract> {
+        return this.terminatedMiddleware;
+    }
+
+    withTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this {
+        const clone = ObjectFactory.clone(this);
+        clone.terminatedMiddleware = middleware;
+        return clone;
+    }
+
+    withAddedTerminatedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>
+    ): this {
+        const clone = ObjectFactory.clone(this);
+        clone.terminatedMiddleware = [...this.terminatedMiddleware, ...middleware];
+        return clone;
+    }
+
+    hasRequestStruct(): boolean {
+        return this.requestStruct !== null;
+    }
+
+    getRequestStruct(): RequestStructContract {
+        if (this.requestStruct === null) {
+            throw new HttpRoutingNoRequestStructException('No request struct was set for this route');
+        }
+
+        return this.requestStruct;
+    }
+
+    withRequestStruct(requestStruct: RequestStructContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.requestStruct = requestStruct;
+        return clone;
+    }
+
+    hasResponseStruct(): boolean {
+        return this.responseStruct !== null;
+    }
+
+    getResponseStruct(): ResponseStructContract {
+        if (this.responseStruct === null) {
+            throw new HttpRoutingNoResponseStructException('No response struct was set for this route');
+        }
+
+        return this.responseStruct;
+    }
+
+    withResponseStruct(responseStruct: ResponseStructContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.responseStruct = responseStruct;
+        return clone;
+    }
+
+    protected getFilteredPath(path: string): string {
+        const trimmed = path.replace(/^\/+|\/+$/g, '');
+
+        return trimmed === '' ? '/' : '/' + trimmed;
+    }
+}

package/src/Valkyrja/Http/Routing/Dispatcher/Contract/RouterContract.ts

@@ -0,0 +1,17 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { RouteContract } from '../../Data/Contract/RouteContract.js';
+
+export interface RouterContract {
+    dispatch(request: ServerRequestContract): ResponseContract;
+    dispatchRoute(request: ServerRequestContract, route: RouteContract): ResponseContract;
+}

package/src/Valkyrja/Http/Routing/Dispatcher/Router.ts

@@ -0,0 +1,102 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Container } from '../../../Container/Manager/Container.js';
+import { RequestMethod } from '../../Message/Enum/RequestMethod.js';
+import { StatusCode } from '../../Message/Enum/StatusCode.js';
+import { ResponseFactory } from '../../Message/Response/Factory/ResponseFactory.js';
+import { RouteDispatchedHandler } from '../../Middleware/Handler/RouteDispatchedHandler.js';
+import { RouteMatchedHandler } from '../../Middleware/Handler/RouteMatchedHandler.js';
+import { RouteNotMatchedHandler } from '../../Middleware/Handler/RouteNotMatchedHandler.js';
+import { SendingResponseHandler } from '../../Middleware/Handler/SendingResponseHandler.js';
+import { TerminatedHandler } from '../../Middleware/Handler/TerminatedHandler.js';
+import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.js';
+import { Matcher } from '../Matcher/Matcher.js';
+
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { ResponseFactoryContract } from '../../Message/Response/Factory/Contract/ResponseFactoryContract.js';
+import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.js';
+import type { RouteMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteMatchedHandlerContract.js';
+import type { RouteNotMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.js';
+import type { SendingResponseHandlerContract } from '../../Middleware/Handler/Contract/SendingResponseHandlerContract.js';
+import type { TerminatedHandlerContract } from '../../Middleware/Handler/Contract/TerminatedHandlerContract.js';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+import type { RouteContract } from '../Data/Contract/RouteContract.js';
+import type { MatcherContract } from '../Matcher/Contract/MatcherContract.js';
+import type { RouterContract } from './Contract/RouterContract.js';
+
+export class Router implements RouterContract {
+    constructor(
+        protected container: ContainerContract = new Container(),
+        protected matcher: MatcherContract = new Matcher(),
+        protected responseFactory: ResponseFactoryContract = new ResponseFactory(),
+        protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
+        protected routeMatchedHandler: RouteMatchedHandlerContract = new RouteMatchedHandler(),
+        protected routeNotMatchedHandler: RouteNotMatchedHandlerContract = new RouteNotMatchedHandler(),
+        protected routeDispatchedHandler: RouteDispatchedHandlerContract = new RouteDispatchedHandler(),
+        protected sendingResponseHandler: SendingResponseHandlerContract = new SendingResponseHandler(),
+        protected terminatedHandler: TerminatedHandlerContract = new TerminatedHandler(),
+    ) {}
+
+    dispatch(request: ServerRequestContract): ResponseContract {
+        const matchedRoute = this.attemptToMatchRoute(request);
+
+        if (!(matchedRoute instanceof Object && 'getPath' in matchedRoute)) {
+            return this.routeNotMatchedHandler.routeNotMatched(request, matchedRoute);
+        }
+
+        return this.dispatchRoute(request, matchedRoute);
+    }
+
+    dispatchRoute(request: ServerRequestContract, route: RouteContract): ResponseContract {
+        this.routeMatched(route);
+
+        const routeAfterMiddleware = this.routeMatchedHandler.routeMatched(request, route);
+
+        if (!('getPath' in routeAfterMiddleware)) {
+            return routeAfterMiddleware;
+        }
+
+        const matchedRoute = routeAfterMiddleware;
+
+        this.container.setSingleton('RouteContract', matchedRoute);
+
+        const handler = matchedRoute.getHandler();
+        const response = handler(this.container, matchedRoute);
+
+        return this.routeDispatchedHandler.routeDispatched(request, response, matchedRoute);
+    }
+
+    protected attemptToMatchRoute(request: ServerRequestContract): RouteContract | ResponseContract {
+        const requestPath = decodeURIComponent(request.getUri().getPath());
+        const route = this.matcher.match(requestPath, request.getMethod());
+
+        if (route !== null) {
+            return route;
+        }
+
+        if (this.matcher.match(requestPath, RequestMethod.ANY) !== null) {
+            return this.responseFactory.createResponse(null, StatusCode.METHOD_NOT_ALLOWED);
+        }
+
+        return this.responseFactory.createResponse(null, StatusCode.NOT_FOUND);
+    }
+
+    protected routeMatched(route: RouteContract): void {
+        this.routeMatchedHandler.add(...route.getRouteMatchedMiddleware());
+        this.routeDispatchedHandler.add(...route.getRouteDispatchedMiddleware());
+        this.throwableCaughtHandler.add(...route.getThrowableCaughtMiddleware());
+        this.sendingResponseHandler.add(...route.getSendingResponseMiddleware());
+        this.terminatedHandler.add(...route.getTerminatedMiddleware());
+
+        this.container.setSingleton('RouteContract', route);
+    }
+}

package/src/Valkyrja/Http/Routing/Factory/Contract/RoutingResponseFactoryContract.ts

@@ -0,0 +1,21 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { StatusCode } from '../../../Message/Enum/StatusCode.js';
+import type { HeaderCollectionContract } from '../../../Message/Header/Collection/Contract/HeaderCollectionContract.js';
+import type { RedirectResponseContract } from '../../../Message/Response/Contract/RedirectResponseContract.js';
+
+export interface RoutingResponseFactoryContract {
+    createRouteRedirectResponse(
+        name: string,
+        data?: Record<string, string | number>,
+        statusCode?: StatusCode,
+        headers?: HeaderCollectionContract,
+    ): RedirectResponseContract;
+}

package/src/Valkyrja/Http/Routing/Factory/RoutingResponseFactory.ts

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { StatusCode } from '../../Message/Enum/StatusCode.js';
+import type { HeaderCollectionContract } from '../../Message/Header/Collection/Contract/HeaderCollectionContract.js';
+import type { RedirectResponseContract } from '../../Message/Response/Contract/RedirectResponseContract.js';
+import type { ResponseFactoryContract } from '../../Message/Response/Factory/Contract/ResponseFactoryContract.js';
+import type { UrlContract } from '../Url/Contract/UrlContract.js';
+import type { RoutingResponseFactoryContract } from './Contract/RoutingResponseFactoryContract.js';
+
+export class RoutingResponseFactory implements RoutingResponseFactoryContract {
+    constructor(
+        protected responseFactory: ResponseFactoryContract,
+        protected url: UrlContract,
+    ) {}
+
+    createRouteRedirectResponse(
+        name: string,
+        data: Record<string, string | number> = {},
+        statusCode?: StatusCode,
+        headers?: HeaderCollectionContract,
+    ): RedirectResponseContract {
+        const url = this.url.getUrl(name, data);
+
+        return this.responseFactory.createRedirectResponse(url, statusCode, headers);
+    }
+}

package/src/Valkyrja/Http/Routing/Matcher/Contract/MatcherContract.ts

@@ -0,0 +1,17 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { RequestMethod } from '../../../Message/Enum/RequestMethod.js';
+import type { RouteContract } from '../../Data/Contract/RouteContract.js';
+
+export interface MatcherContract {
+    match(path: string, requestMethod: RequestMethod): RouteContract | null;
+    matchStatic(path: string, requestMethod: RequestMethod): RouteContract | null;
+    matchDynamic(path: string, requestMethod: RequestMethod): RouteContract | null;
+}

package/src/Valkyrja/Http/Routing/Matcher/Matcher.ts

@@ -0,0 +1,109 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { RouteCollection } from '../Collection/RouteCollection.js';
+import { HttpRoutingInvalidRoutePathException } from '../Throwable/Exception/HttpRoutingInvalidRoutePathException.js';
+
+import type { RequestMethod } from '../../Message/Enum/RequestMethod.js';
+import type { DynamicRouteContract } from '../Data/Contract/DynamicRouteContract.js';
+import type { ParameterContract } from '../Data/Contract/ParameterContract.js';
+import type { RouteContract } from '../Data/Contract/RouteContract.js';
+import type { RouteCollectionContract } from '../Collection/Contract/RouteCollectionContract.js';
+import type { MatcherContract } from './Contract/MatcherContract.js';
+
+export class Matcher implements MatcherContract {
+    constructor(protected collection: RouteCollectionContract = new RouteCollection()) {}
+
+    match(path: string, requestMethod: RequestMethod): RouteContract | null {
+        const normalizedPath = '/' + path.replace(/^\/+|\/+$/g, '');
+        const route = this.matchStatic(normalizedPath, requestMethod);
+
+        return route ?? this.matchDynamic(normalizedPath, requestMethod);
+    }
+
+    matchStatic(path: string, requestMethod: RequestMethod): RouteContract | null {
+        if (this.collection.hasPath(path, requestMethod)) {
+            return Object.assign(
+                Object.create(
+                    Object.getPrototypeOf(this.collection.getByPath(path, requestMethod)) as object | null,
+                ) as RouteContract,
+                this.collection.getByPath(path, requestMethod),
+            );
+        }
+
+        return null;
+    }
+
+    matchDynamic(path: string, requestMethod: RequestMethod): RouteContract | null {
+        const regexes = this.collection.getRegexes(requestMethod);
+
+        for (const [regex] of Object.entries(regexes)) {
+            if (regex === '') {
+                continue;
+            }
+
+            const re = new RegExp(regex);
+            const matches = re.exec(path);
+
+            if (matches !== null) {
+                return this.processArguments(this.collection.getByRegex(regex, requestMethod), matches);
+            }
+        }
+
+        return null;
+    }
+
+    protected processArguments(route: DynamicRouteContract, matches: RegExpExecArray): DynamicRouteContract {
+        const parameters = route.getParameters();
+
+        if (parameters.length === 0) {
+            throw new HttpRoutingInvalidRoutePathException('Route parameters must not be empty');
+        }
+
+        const namedGroups = matches.groups ?? {};
+        const parametersWithValues: ParameterContract[] = [];
+
+        for (const parameter of parameters) {
+            const name = parameter.getName();
+            const match = namedGroups[name] ?? parameter.getDefault();
+
+            if (match === null || match === undefined) {
+                parametersWithValues.push(parameter);
+                continue;
+            }
+
+            const value = this.checkAndCastMatchValue(parameter, match as string);
+
+            parametersWithValues.push(parameter.withValue(value));
+        }
+
+        return route.withParameters(...parametersWithValues);
+    }
+
+    protected checkAndCastMatchValue(parameter: ParameterContract, match: string): unknown {
+        if (parameter.hasCast()) {
+            return this.castMatchValue(parameter, match);
+        }
+
+        return match;
+    }
+
+    protected castMatchValue(parameter: ParameterContract, match: string): unknown {
+        const cast = parameter.getCast();
+        const type = (cast.type as unknown as { fromValue: (v: unknown) => { asValue: () => unknown } }).fromValue(
+            match,
+        );
+
+        if (cast.convert) {
+            return type.asValue();
+        }
+
+        return type;
+    }
+}

package/src/Valkyrja/Http/Routing/Processor/Contract/ProcessorContract.ts

@@ -0,0 +1,14 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { RouteContract } from '../../Data/Contract/RouteContract.js';
+
+export interface ProcessorContract {
+    route(route: RouteContract): RouteContract;
+}

package/src/Valkyrja/Http/Routing/Processor/Processor.ts

@@ -0,0 +1,108 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Regex } from '../Constant/Regex.js';
+import { HttpRoutingInvalidRoutePathException } from '../Throwable/Exception/HttpRoutingInvalidRoutePathException.js';
+
+import type { DynamicRouteContract } from '../Data/Contract/DynamicRouteContract.js';
+import type { ParameterContract } from '../Data/Contract/ParameterContract.js';
+import type { RouteContract } from '../Data/Contract/RouteContract.js';
+import type { ProcessorContract } from './Contract/ProcessorContract.js';
+
+export class Processor implements ProcessorContract {
+    route(route: RouteContract): RouteContract {
+        const path = '/' + route.getPath().replace(/^\/+|\/+$/g, '');
+
+        route = route.withPath(path);
+
+        if (this.isDynamicRoute(route) && route.getPath().includes('{')) {
+            route = this.modifyRegex(route);
+        }
+
+        return route;
+    }
+
+    protected isDynamicRoute(route: RouteContract): route is DynamicRouteContract {
+        return 'getRegex' in route && typeof (route as DynamicRouteContract).getRegex === 'function';
+    }
+
+    protected modifyRegex(route: DynamicRouteContract): RouteContract {
+        if (route.getRegex() !== '') {
+            return route;
+        }
+
+        let regex = route.getPath().replace(/\//g, Regex.PATH);
+
+        const parameters = route.getParameters();
+
+        for (const parameter of parameters) {
+            const processed = this.processParameterInRegex(parameter, regex);
+
+            regex = this.replaceParameterNameInRegex(route, processed, regex);
+        }
+
+        regex = Regex.START + regex + Regex.END;
+
+        return route.withRegex(regex);
+    }
+
+    protected processParameterInRegex(parameter: ParameterContract, regex: string): ParameterContract {
+        if (parameter.isOptional() || regex.includes(parameter.getName() + '?')) {
+            return parameter.withIsOptional(true);
+        }
+
+        return parameter;
+    }
+
+    protected replaceParameterNameInRegex(route: RouteContract, parameter: ParameterContract, regex: string): string {
+        const nameReplacement = this.getRegexParameterNameReplacement(parameter);
+
+        if (!regex.includes(nameReplacement)) {
+            throw new HttpRoutingInvalidRoutePathException(`${route.getPath()} is missing ${nameReplacement}`);
+        }
+
+        const parameterRegex = this.getParameterRegex(parameter);
+
+        return regex.replace(nameReplacement, parameterRegex);
+    }
+
+    protected getRegexParameterNameReplacement(parameter: ParameterContract): string {
+        const isOptional = parameter.isOptional();
+
+        return (isOptional ? Regex.PATH : '') + '{' + parameter.getName() + (isOptional ? '?' : '') + '}';
+    }
+
+    protected getParameterRegex(parameter: ParameterContract): string {
+        return (
+            this.getParameterRegexOptionalCaptureGroupStart(parameter) +
+            this.getParameterRegexCaptureGroupStart(parameter) +
+            this.getParameterRegexNameCaptureGroup(parameter) +
+            parameter.getRegex() +
+            this.getParameterRegexCaptureGroupEnd(parameter)
+        );
+    }
+
+    protected getParameterRegexOptionalCaptureGroupStart(parameter: ParameterContract): string {
+        return parameter.isOptional() ? Regex.START_OPTIONAL_CAPTURE_GROUP : '';
+    }
+
+    protected getParameterRegexCaptureGroupStart(parameter: ParameterContract): string {
+        return !parameter.shouldCapture() ? Regex.START_NON_CAPTURE_GROUP : Regex.START_CAPTURE_GROUP;
+    }
+
+    protected getParameterRegexNameCaptureGroup(parameter: ParameterContract): string {
+        return parameter.shouldCapture()
+            ? Regex.START_CAPTURE_GROUP_NAME + parameter.getName() + Regex.END_CAPTURE_GROUP_NAME
+            : '';
+    }
+
+    protected getParameterRegexCaptureGroupEnd(parameter: ParameterContract): string {
+        return parameter.isOptional() ? Regex.END_OPTIONAL_CAPTURE_GROUP : Regex.END_CAPTURE_GROUP;
+    }
+}