@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Routing/Collection/RouteCollection.ts

@@ -0,0 +1,227 @@
+/*
+ * 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 { allRequestMethods, RequestMethod } from '../../Message/Enum/RequestMethod.js';
+import { DynamicRoute } from '../Data/DynamicRoute.js';
+import { HttpRoutingData } from '../Data/HttpRoutingData.js';
+import { HttpRoutingInvalidDynamicRouteNameException } from '../Throwable/Exception/HttpRoutingInvalidDynamicRouteNameException.js';
+import { HttpRoutingInvalidRouteNameException } from '../Throwable/Exception/HttpRoutingInvalidRouteNameException.js';
+import { HttpRoutingInvalidRoutePathException } from '../Throwable/Exception/HttpRoutingInvalidRoutePathException.js';
+import { HttpRoutingInvalidRouteRegexException } from '../Throwable/Exception/HttpRoutingInvalidRouteRegexException.js';
+
+import type { DynamicRouteContract } from '../Data/Contract/DynamicRouteContract.js';
+import type { RouteContract } from '../Data/Contract/RouteContract.js';
+import type { RouteCollectionContract } from './Contract/RouteCollectionContract.js';
+
+export class RouteCollection implements RouteCollectionContract {
+    protected routes: Record<string, () => RouteContract | DynamicRouteContract> = {};
+    protected paths: Record<string, Record<string, string>> = {};
+    protected dynamicPaths: Record<string, Record<string, string>> = {};
+    protected regexes: Record<string, Record<string, string>> = {};
+
+    getData(): HttpRoutingData {
+        return new HttpRoutingData(this.routes, this.paths, this.dynamicPaths, this.regexes);
+    }
+
+    setFromData(data: HttpRoutingData): void {
+        this.routes = data.routes;
+        this.paths = data.paths as Record<string, Record<string, string>>;
+        this.dynamicPaths = data.dynamicPaths as Record<string, Record<string, string>>;
+        this.regexes = data.regexes as Record<string, Record<string, string>>;
+    }
+
+    add(route: RouteContract): void {
+        this.setRouteToRequestMethods(route);
+
+        const name = route.getName();
+
+        this.routes[name] = (): RouteContract => route;
+    }
+
+    hasPath(path: string, method: RequestMethod): boolean {
+        if (method !== RequestMethod.ANY) {
+            return this.paths[method]?.[path] !== undefined || this.dynamicPaths[method]?.[path] !== undefined;
+        }
+
+        return allRequestMethods().some((m) => this.hasPath(path, m));
+    }
+
+    getByPath(path: string, method: RequestMethod): RouteContract {
+        const route = this.internalGetByPath(path, method);
+
+        if (route !== null) {
+            return route;
+        }
+
+        throw new HttpRoutingInvalidRoutePathException(
+            `The path '${path}' is not a valid route for the given method '${method}'`,
+        );
+    }
+
+    hasRegex(regex: string, method: RequestMethod): boolean {
+        if (method !== RequestMethod.ANY) {
+            return this.regexes[method]?.[regex] !== undefined;
+        }
+
+        return allRequestMethods().some((m) => this.hasRegex(regex, m));
+    }
+
+    getByRegex(regex: string, method: RequestMethod): DynamicRouteContract {
+        const route = this.internalGetByRegex(regex, method);
+
+        if (route !== null) {
+            return route;
+        }
+
+        throw new HttpRoutingInvalidRouteRegexException(
+            `The regex '${regex}' is not a valid route for the given method '${method}'`,
+        );
+    }
+
+    getPaths(method: RequestMethod): Record<string, string> {
+        if (method !== RequestMethod.ANY) {
+            return this.paths[method] ?? {};
+        }
+
+        return Object.assign(
+            {},
+            ...allRequestMethods().map((m) => this.paths[m] ?? {}),
+            ...allRequestMethods().map((m) => this.dynamicPaths[m] ?? {}),
+        ) as Record<string, string>;
+    }
+
+    getRegexes(method: RequestMethod): Record<string, string> {
+        if (method !== RequestMethod.ANY) {
+            return this.regexes[method] ?? {};
+        }
+
+        return Object.assign({}, ...allRequestMethods().map((m) => this.regexes[m] ?? {})) as Record<string, string>;
+    }
+
+    hasName(name: string): boolean {
+        return this.routes[name] !== undefined;
+    }
+
+    getByName(name: string): RouteContract {
+        const route = this.routes[name];
+
+        if (route !== undefined) {
+            return route();
+        }
+
+        throw new HttpRoutingInvalidRouteNameException(`A route with the name '${name}' does not exist`);
+    }
+
+    getAll(method: RequestMethod): Record<string, RouteContract> {
+        const paths = this.getPaths(method);
+
+        return Object.fromEntries(Object.entries(paths).map(([, name]) => [name, this.getRouteFromName(name)]));
+    }
+
+    protected internalGetByPath(path: string, method: RequestMethod): RouteContract | null {
+        if (method !== RequestMethod.ANY) {
+            const name = this.paths[method]?.[path] ?? this.dynamicPaths[method]?.[path];
+
+            if (name !== undefined) {
+                return this.getRouteFromName(name);
+            }
+
+            return null;
+        }
+
+        for (const m of allRequestMethods()) {
+            const route = this.internalGetByPath(path, m);
+
+            if (route !== null) {
+                return route;
+            }
+        }
+
+        return null;
+    }
+
+    protected internalGetByRegex(regex: string, method: RequestMethod): DynamicRouteContract | null {
+        if (method !== RequestMethod.ANY) {
+            const name = this.regexes[method]?.[regex];
+
+            if (name !== undefined) {
+                return this.getDynamicRouteFromName(name);
+            }
+
+            return null;
+        }
+
+        for (const m of allRequestMethods()) {
+            const route = this.internalGetByRegex(regex, m);
+
+            if (route !== null) {
+                return route;
+            }
+        }
+
+        return null;
+    }
+
+    protected setRouteToRequestMethods(route: RouteContract): void {
+        let requestMethods = route.getRequestMethods();
+
+        if (requestMethods.includes(RequestMethod.ANY)) {
+            requestMethods = allRequestMethods();
+        }
+
+        for (const method of requestMethods) {
+            this.setRouteToRequestMethod(route, method);
+        }
+    }
+
+    protected setRouteToRequestMethod(route: RouteContract, method: RequestMethod): void {
+        if (method === RequestMethod.ANY) {
+            return;
+        }
+
+        const name = route.getName();
+        const path = route.getPath();
+
+        if (route instanceof DynamicRoute) {
+            const regex = route.getRegex();
+
+            this.dynamicPaths[method] ??= {};
+            this.regexes[method] ??= {};
+
+            this.dynamicPaths[method][path] = name;
+            this.regexes[method][regex] = name;
+
+            return;
+        }
+
+        this.paths[method] ??= {};
+
+        this.paths[method][path] = name;
+    }
+
+    protected getRouteFromName(name: string): RouteContract {
+        const route = this.routes[name];
+
+        if (route === undefined) {
+            throw new HttpRoutingInvalidRouteNameException(`Invalid name '${name}' provided`);
+        }
+
+        return route();
+    }
+
+    protected getDynamicRouteFromName(name: string): DynamicRouteContract {
+        const route = this.getRouteFromName(name);
+
+        if (route instanceof DynamicRoute) {
+            return route;
+        }
+
+        throw new HttpRoutingInvalidDynamicRouteNameException(`Invalid dynamic route ${name}`);
+    }
+}

package/src/Valkyrja/Http/Routing/Collector/Contract/RouteCollectorContract.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 RouteCollectorContract {
+    getRoutes(...classes: Array<new (...args: unknown[]) => unknown>): RouteContract[];
+}

package/src/Valkyrja/Http/Routing/Constant/HttpRoutingServiceId.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.
+ */
+
+export class HttpRoutingServiceId {
+    static readonly RouterContract = 'Valkyrja.Http.Routing.Dispatcher.RouterContract' as const;
+    static readonly RouteCollectionContract = 'Valkyrja.Http.Routing.Collection.RouteCollectionContract' as const;
+    static readonly RouteCollectorContract = 'Valkyrja.Http.Routing.Collector.RouteCollectorContract' as const;
+    static readonly MatcherContract = 'Valkyrja.Http.Routing.Matcher.MatcherContract' as const;
+    static readonly ProcessorContract = 'Valkyrja.Http.Routing.Processor.ProcessorContract' as const;
+    static readonly RoutingResponseFactory = 'Valkyrja.Http.Routing.Factory.RoutingResponseFactoryContract' as const;
+    static readonly UrlContract = 'Valkyrja.Http.Routing.Url.UrlContract' as const;
+    static readonly RouteContract = 'Valkyrja.Http.Routing.Data.RouteContract' as const;
+    static readonly HttpRoutingData = 'Valkyrja.Http.Routing.Data.HttpRoutingData' as const;
+    static readonly ListCommand = 'Valkyrja.Http.Routing.Cli.Command.ListCommand' as const;
+}

package/src/Valkyrja/Http/Routing/Constant/Regex.ts

@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+const UUID_PART = '[0-9A-Fa-f]';
+const ULID_VLID_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZabcdefghjkmnpqrstvwxyz';
+
+export class Regex {
+    static readonly PATH = '\\/';
+    static readonly ANY = '.*';
+    static readonly NUM = '\\d+';
+
+    static readonly ID = Regex.NUM;
+
+    static readonly SLUG = '[a-zA-Z0-9-]+';
+
+    static readonly UUID = `${UUID_PART}{8}-${UUID_PART}{4}-${UUID_PART}{4}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V1 = `${UUID_PART}{8}-${UUID_PART}{4}-[1]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V3 = `${UUID_PART}{8}-${UUID_PART}{4}-[3]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V4 = `${UUID_PART}{8}-${UUID_PART}{4}-[4]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V5 = `${UUID_PART}{8}-${UUID_PART}{4}-[5]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V6 = `${UUID_PART}{8}-${UUID_PART}{4}-[6]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V7 = `${UUID_PART}{8}-${UUID_PART}{4}-[7]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+    static readonly UUID_V8 = `${UUID_PART}{8}-${UUID_PART}{4}-[8]${UUID_PART}{3}-${UUID_PART}{4}-${UUID_PART}{12}`;
+
+    static readonly ULID = `[0-7][${ULID_VLID_CHARS}]{25}`;
+
+    static readonly VLID = `[0-7][${ULID_VLID_CHARS}]{12}[1-4][${ULID_VLID_CHARS}]{4}([${ULID_VLID_CHARS}]{4})?([${ULID_VLID_CHARS}]{4})?([${ULID_VLID_CHARS}]{4})?`;
+    static readonly VLID_V1 = `[0-7][${ULID_VLID_CHARS}]{12}[1][${ULID_VLID_CHARS}]{12}`;
+    static readonly VLID_V2 = `[0-7][${ULID_VLID_CHARS}]{12}[2][${ULID_VLID_CHARS}]{16}`;
+    static readonly VLID_V3 = `[0-7][${ULID_VLID_CHARS}]{12}[3][${ULID_VLID_CHARS}]{8}`;
+    static readonly VLID_V4 = `[0-7][${ULID_VLID_CHARS}]{12}[4][${ULID_VLID_CHARS}]{4}`;
+
+    static readonly ALPHA = '[a-zA-Z]+';
+    static readonly ALPHA_LOWERCASE = '[a-z]+';
+    static readonly ALPHA_UPPERCASE = '[A-Z]+';
+    static readonly ALPHA_NUM = '[a-zA-Z0-9]+';
+    static readonly ALPHA_NUM_UNDERSCORE = '\\w+';
+
+    static readonly START = '/^';
+    static readonly END = '$/';
+
+    static readonly START_CAPTURE_GROUP = '(';
+    static readonly START_NON_CAPTURE_GROUP = '(?:';
+    static readonly END_CAPTURE_GROUP = ')';
+    static readonly END_OPTIONAL_CAPTURE_GROUP = ')?';
+    static readonly START_OPTIONAL_CAPTURE_GROUP =
+        Regex.START_NON_CAPTURE_GROUP + Regex.PATH + Regex.END_OPTIONAL_CAPTURE_GROUP;
+
+    static readonly START_CAPTURE_GROUP_NAME = '?<';
+    static readonly END_CAPTURE_GROUP_NAME = '>';
+}

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

@@ -0,0 +1,18 @@
+/*
+ * 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 { ResponseFactoryContract } from '../../Message/Response/Factory/Contract/ResponseFactoryContract.js';
+
+export abstract class Controller {
+    constructor(
+        protected request: ServerRequestContract,
+        protected responseFactory: ResponseFactoryContract,
+    ) {}
+}

package/src/Valkyrja/Http/Routing/Data/Contract/DynamicRouteContract.ts

@@ -0,0 +1,19 @@
+/*
+ * 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 { ParameterContract } from './ParameterContract.js';
+import type { RouteContract } from './RouteContract.js';
+
+export interface DynamicRouteContract extends RouteContract {
+    getRegex(): string;
+    withRegex(regex: string): this;
+    getParameters(): ParameterContract[];
+    withParameters(...parameters: ParameterContract[]): this;
+    withAddedParameters(...parameters: ParameterContract[]): this;
+}

package/src/Valkyrja/Http/Routing/Data/Contract/ParameterContract.ts

@@ -0,0 +1,28 @@
+/*
+ * 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 { Cast } from '../../../../Type/Data/Cast.js';
+
+export interface ParameterContract {
+    getName(): string;
+    withName(name: string): this;
+    getRegex(): string;
+    withRegex(regex: string): this;
+    hasCast(): boolean;
+    getCast(): Cast;
+    withCast(cast: Cast): this;
+    isOptional(): boolean;
+    withIsOptional(isOptional: boolean): this;
+    shouldCapture(): boolean;
+    withShouldCapture(shouldCapture: boolean): this;
+    getDefault(): unknown;
+    withDefault(defaultValue?: unknown): this;
+    getValue(): unknown;
+    withValue(value?: unknown): this;
+}

package/src/Valkyrja/Http/Routing/Data/Contract/RouteContract.ts

@@ -0,0 +1,69 @@
+/*
+ * 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 { ContainerContract } from '../../../../Container/Manager/Contract/ContainerContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { RequestMethod } from '../../../Message/Enum/RequestMethod.js';
+import type { RouteMatchedMiddlewareContract } from '../../../Middleware/Contract/RouteMatchedMiddlewareContract.js';
+import type { RouteDispatchedMiddlewareContract } from '../../../Middleware/Contract/RouteDispatchedMiddlewareContract.js';
+import type { ThrowableCaughtMiddlewareContract } from '../../../Middleware/Contract/ThrowableCaughtMiddlewareContract.js';
+import type { SendingResponseMiddlewareContract } from '../../../Middleware/Contract/SendingResponseMiddlewareContract.js';
+import type { TerminatedMiddlewareContract } from '../../../Middleware/Contract/TerminatedMiddlewareContract.js';
+import type { RequestStructContract } from '../../../Struct/Request/Contract/RequestStructContract.js';
+import type { ResponseStructContract } from '../../../Struct/Response/Contract/ResponseStructContract.js';
+
+export interface RouteContract {
+    getPath(): string;
+    withPath(path: string): this;
+    withAddedPath(path: string): this;
+    getName(): string;
+    withName(name: string): this;
+    withAddedName(name: string): this;
+    getHandler(): (container: ContainerContract, route: RouteContract) => ResponseContract;
+    withHandler(handler: (container: ContainerContract, route: RouteContract) => ResponseContract): this;
+    getRequestMethods(): RequestMethod[];
+    hasRequestMethod(requestMethod: RequestMethod): boolean;
+    withRequestMethods(...requestMethods: RequestMethod[]): this;
+    withAddedRequestMethods(...requestMethods: RequestMethod[]): this;
+    getRouteMatchedMiddleware(): Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract>;
+    withRouteMatchedMiddleware(...middleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract>): this;
+    withAddedRouteMatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract>
+    ): this;
+    getRouteDispatchedMiddleware(): Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract>;
+    withRouteDispatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract>
+    ): this;
+    withAddedRouteDispatchedMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract>
+    ): this;
+    getThrowableCaughtMiddleware(): Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract>;
+    withThrowableCaughtMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract>
+    ): this;
+    withAddedThrowableCaughtMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract>
+    ): this;
+    getSendingResponseMiddleware(): Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>;
+    withSendingResponseMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>
+    ): this;
+    withAddedSendingResponseMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>
+    ): this;
+    getTerminatedMiddleware(): Array<new (...args: unknown[]) => TerminatedMiddlewareContract>;
+    withTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this;
+    withAddedTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this;
+    hasRequestStruct(): boolean;
+    getRequestStruct(): RequestStructContract;
+    withRequestStruct(requestStruct: RequestStructContract): this;
+    hasResponseStruct(): boolean;
+    getResponseStruct(): ResponseStructContract;
+    withResponseStruct(responseStruct: ResponseStructContract): this;
+}

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

@@ -0,0 +1,83 @@
+/*
+ * 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 { Route } from './Route.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 { DynamicRouteContract } from './Contract/DynamicRouteContract.js';
+import type { ParameterContract } from './Contract/ParameterContract.js';
+import type { RouteContract } from './Contract/RouteContract.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class DynamicRoute extends Route implements DynamicRouteContract {
+    constructor(
+        path: string,
+        name: string,
+        protected regex: string,
+        protected parameters: ParameterContract[],
+        handler: (container: ContainerContract, route: RouteContract) => ResponseContract,
+        requestMethods: RequestMethod[] = [RequestMethod.HEAD, RequestMethod.GET],
+        routeMatchedMiddleware: Array<new (...args: unknown[]) => RouteMatchedMiddlewareContract> = [],
+        routeDispatchedMiddleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract> = [],
+        throwableCaughtMiddleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract> = [],
+        sendingResponseMiddleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract> = [],
+        terminatedMiddleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract> = [],
+        requestStruct: RequestStructContract | null = null,
+        responseStruct: ResponseStructContract | null = null,
+    ) {
+        super(
+            path,
+            name,
+            handler,
+            requestMethods,
+            routeMatchedMiddleware,
+            routeDispatchedMiddleware,
+            throwableCaughtMiddleware,
+            sendingResponseMiddleware,
+            terminatedMiddleware,
+            requestStruct,
+            responseStruct,
+        );
+    }
+
+    getRegex(): string {
+        return this.regex;
+    }
+
+    withRegex(regex: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.regex = regex;
+        return clone;
+    }
+
+    getParameters(): ParameterContract[] {
+        return this.parameters;
+    }
+
+    withParameters(...parameters: ParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.parameters = parameters;
+        return clone;
+    }
+
+    withAddedParameters(...parameters: ParameterContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.parameters = [...this.parameters, ...parameters];
+        return clone;
+    }
+}

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

@@ -0,0 +1,22 @@
+/*
+ * 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 { DynamicRouteContract } from './Contract/DynamicRouteContract.js';
+import type { RouteContract } from './Contract/RouteContract.js';
+
+export type RequestMethodPaths = Partial<Record<string, Record<string, string>>>;
+
+export class HttpRoutingData {
+    constructor(
+        public readonly routes: Record<string, () => RouteContract | DynamicRouteContract> = {},
+        public readonly paths: RequestMethodPaths = {},
+        public readonly dynamicPaths: RequestMethodPaths = {},
+        public readonly regexes: RequestMethodPaths = {},
+    ) {}
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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 { Cast } from '../../../Type/Data/Cast.js';
+import { HttpRoutingNoCastException } from '../Throwable/Exception/HttpRoutingNoCastException.js';
+
+import type { ParameterContract } from './Contract/ParameterContract.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Parameter implements ParameterContract {
+    constructor(
+        protected name: string,
+        protected regex: string,
+        protected cast: Cast | null = null,
+        protected optional: boolean = false,
+        protected capture: boolean = true,
+        protected defaultValue: unknown = null,
+        protected val: unknown = null,
+    ) {}
+
+    getName(): string {
+        return this.name;
+    }
+
+    withName(name: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.name = name;
+        return clone;
+    }
+
+    getRegex(): string {
+        return this.regex;
+    }
+
+    withRegex(regex: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.regex = regex;
+        return clone;
+    }
+
+    hasCast(): boolean {
+        return this.cast !== null;
+    }
+
+    getCast(): Cast {
+        if (this.cast === null) {
+            throw new HttpRoutingNoCastException('No cast exists');
+        }
+
+        return this.cast;
+    }
+
+    withCast(cast: Cast): this {
+        const clone = ObjectFactory.clone(this);
+        clone.cast = cast;
+        return clone;
+    }
+
+    isOptional(): boolean {
+        return this.optional;
+    }
+
+    withIsOptional(isOptional: boolean): this {
+        const clone = ObjectFactory.clone(this);
+        clone.optional = isOptional;
+        return clone;
+    }
+
+    shouldCapture(): boolean {
+        return this.capture;
+    }
+
+    withShouldCapture(shouldCapture: boolean): this {
+        const clone = ObjectFactory.clone(this);
+        clone.capture = shouldCapture;
+        return clone;
+    }
+
+    getDefault(): unknown {
+        return this.defaultValue;
+    }
+
+    withDefault(defaultValue: unknown = null): this {
+        const clone = ObjectFactory.clone(this);
+        clone.defaultValue = defaultValue;
+        return clone;
+    }
+
+    getValue(): unknown {
+        return this.val;
+    }
+
+    withValue(value: unknown = null): this {
+        const clone = ObjectFactory.clone(this);
+        clone.val = value;
+        return clone;
+    }
+}