@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Routing/Provider/Contract/HttpRouteProviderContract.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 { DynamicRouteContract } from '../../Data/Contract/DynamicRouteContract.js';
+import type { RouteContract } from '../../Data/Contract/RouteContract.js';
+
+export interface HttpRouteProviderContract {
+    getRoutes(): Array<RouteContract | DynamicRouteContract>;
+}
+
+export namespace HttpRouteProviderContract {
+    export function instanceOf(value: unknown): value is HttpRouteProviderContract {
+        return typeof value === 'object' && value !== null && 'getRoutes' in value;
+    }
+}

package/src/Valkyrja/Http/Routing/Provider/HttpRoutingCliComponentProvider.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 { HttpRoutingCliRouteProvider } from './HttpRoutingCliRouteProvider.js';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.js';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.js';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { HttpRouteProviderContract } from './Contract/HttpRouteProviderContract.js';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+
+export class HttpRoutingCliComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [new HttpRoutingCliRouteProvider()];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Http/Routing/Provider/HttpRoutingCliRouteProvider.ts

@@ -0,0 +1,42 @@
+/*
+ * 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 { ApplicationServiceId } from '../../../Application/Constant/ApplicationServiceId.js';
+import { CliInteractionServiceId } from '../../../Cli/Interaction/Constant/CliInteractionServiceId.js';
+import { Route } from '../../../Cli/Routing/Data/Route.js';
+import { HttpRoutingServiceId } from '../Constant/HttpRoutingServiceId.js';
+import { ListCommand } from '../Cli/Command/ListCommand.js';
+import { HttpCommandName } from '../Cli/Command/Constant/CommandName.js';
+
+import type { CliConfigContract } from '../../../Application/Data/Contract/CliConfigContract.js';
+import type { OutputContract } from '../../../Cli/Interaction/Output/Contract/OutputContract.js';
+import type { OutputFactoryContract } from '../../../Cli/Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import type { RouteContract } from '../../../Cli/Routing/Data/Contract/RouteContract.js';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { RouteCollectionContract } from '../Collection/Contract/RouteCollectionContract.js';
+
+export class HttpRoutingCliRouteProvider implements CliRouteProviderContract {
+    getRoutes(): RouteContract[] {
+        return [
+            new Route(HttpCommandName.LIST, 'List all routes', HttpRoutingCliRouteProvider.listHandler, () =>
+                ListCommand.help(),
+            ),
+        ];
+    }
+
+    static listHandler(this: void, container: ContainerContract, cliRoute: RouteContract): OutputContract {
+        return new ListCommand(
+            container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract),
+            cliRoute,
+            container.getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract),
+            container.getSingleton<OutputFactoryContract>(CliInteractionServiceId.OutputFactoryContract),
+        ).run();
+    }
+}

package/src/Valkyrja/Http/Routing/Throwable/Contract/HttpRoutingThrowable.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpThrowable } from '../../../Throwable/Contract/HttpThrowable.js';
+
+export type HttpRoutingThrowable = HttpThrowable;

package/src/Valkyrja/Http/Routing/Throwable/Exception/Abstract/HttpRoutingInvalidArgumentException.ts

@@ -0,0 +1,16 @@
+/*
+ * 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 { HttpInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/HttpInvalidArgumentException.js';
+
+import type { HttpRoutingThrowable } from '../../Contract/HttpRoutingThrowable.js';
+
+export abstract class HttpRoutingInvalidArgumentException
+    extends HttpInvalidArgumentException
+    implements HttpRoutingThrowable {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/Abstract/HttpRoutingRuntimeException.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 { HttpRuntimeException } from '../../../../Throwable/Exception/Abstract/HttpRuntimeException.js';
+
+import type { HttpRoutingThrowable } from '../../Contract/HttpRoutingThrowable.js';
+
+export abstract class HttpRoutingRuntimeException extends HttpRuntimeException implements HttpRoutingThrowable {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidDynamicRouteNameException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidDynamicRouteNameException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidMethodTypeException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidMethodTypeException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidParameterRegexException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidParameterRegexException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidRouteNameException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidRouteNameException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidRouteParameterException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidRouteParameterException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidRoutePathException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidRoutePathException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingInvalidRouteRegexException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingInvalidArgumentException } from './Abstract/HttpRoutingInvalidArgumentException.js';
+
+export class HttpRoutingInvalidRouteRegexException extends HttpRoutingInvalidArgumentException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingNoCastException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingRuntimeException } from './Abstract/HttpRoutingRuntimeException.js';
+
+export class HttpRoutingNoCastException extends HttpRoutingRuntimeException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingNoRequestStructException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingRuntimeException } from './Abstract/HttpRoutingRuntimeException.js';
+
+export class HttpRoutingNoRequestStructException extends HttpRoutingRuntimeException {}

package/src/Valkyrja/Http/Routing/Throwable/Exception/HttpRoutingNoResponseStructException.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 { HttpRoutingRuntimeException } from './Abstract/HttpRoutingRuntimeException.js';
+
+export class HttpRoutingNoResponseStructException extends HttpRoutingRuntimeException {}

package/src/Valkyrja/Http/Routing/Url/Contract/UrlContract.ts

@@ -0,0 +1,12 @@
+/*
+ * 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 interface UrlContract {
+    getUrl(name: string, data: Record<string, string | number>): string;
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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 { RouteCollectionContract } from '../Collection/Contract/RouteCollectionContract.js';
+import type { UrlContract } from './Contract/UrlContract.js';
+
+export class Url implements UrlContract {
+    constructor(protected collection: RouteCollectionContract) {}
+
+    getUrl(name: string, data: Record<string, string | number>): string {
+        const route = this.collection.getByName(name);
+
+        let path = route.getPath();
+
+        for (const [key, value] of Object.entries(data)) {
+            path = path.replace('{' + key + '}', String(value));
+        }
+
+        return path;
+    }
+}

package/src/Valkyrja/Http/Server/Constant/HttpServerServiceId.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.
+ */
+
+export class HttpServerServiceId {
+    static readonly RequestHandlerContract = 'Valkyrja.Http.Server.Handler.RequestHandlerContract' as const;
+    static readonly ExceptionResponseHandlerContract =
+        'Valkyrja.Http.Server.Handler.ExceptionResponseRequestHandlerContract' as const;
+}

package/src/Valkyrja/Http/Server/Handler/Contract/ExceptionResponseRequestHandlerContract.ts

@@ -0,0 +1,15 @@
+/*
+ * 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 { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { RequestHandlerContract } from './RequestHandlerContract.js';
+
+export interface ExceptionResponseRequestHandlerContract extends RequestHandlerContract {
+    createResponseFromException(exception: Error): ResponseContract;
+}

package/src/Valkyrja/Http/Server/Handler/Contract/RequestHandlerContract.ts

@@ -0,0 +1,20 @@
+/*
+ * 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 { ServerResponse } from 'node:http';
+
+import type { ServerRequestContract } from '../../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+
+export interface RequestHandlerContract {
+    handle(request: ServerRequestContract): ResponseContract;
+    send(response: ResponseContract, nodeResponse: ServerResponse): this;
+    terminate(request: ServerRequestContract, response: ResponseContract): void;
+    run(request: ServerRequestContract, nodeResponse: ServerResponse): void;
+}

package/src/Valkyrja/Http/Server/Handler/RequestHandler.ts

@@ -0,0 +1,141 @@
+/*
+ * 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 { ServerResponse } from 'node:http';
+
+import { Container } from '../../../Container/Manager/Container.js';
+import { StatusCode } from '../../Message/Enum/StatusCode.js';
+import { HttpMessageServiceId } from '../../Message/Constant/HttpMessageServiceId.js';
+import { Response } from '../../Message/Response/Response.js';
+import { Stream } from '../../Message/Stream/Stream.js';
+import { HttpResponseException } from '../../Message/Throwable/Exception/HttpResponseException.js';
+import { RequestReceivedHandler } from '../../Middleware/Handler/RequestReceivedHandler.js';
+import { SendingResponseHandler } from '../../Middleware/Handler/SendingResponseHandler.js';
+import { TerminatedHandler } from '../../Middleware/Handler/TerminatedHandler.js';
+import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.js';
+import { Router } from '../../Routing/Dispatcher/Router.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 { RequestReceivedHandlerContract } from '../../Middleware/Handler/Contract/RequestReceivedHandlerContract.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 { RouterContract } from '../../Routing/Dispatcher/Contract/RouterContract.js';
+import type { RequestHandlerContract } from './Contract/RequestHandlerContract.js';
+
+export class RequestHandler implements RequestHandlerContract {
+    constructor(
+        protected container: ContainerContract = new Container(),
+        protected router: RouterContract = new Router(),
+        protected requestReceivedHandler: RequestReceivedHandlerContract = new RequestReceivedHandler(),
+        protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
+        protected sendingResponseHandler: SendingResponseHandlerContract = new SendingResponseHandler(),
+        protected terminatedHandler: TerminatedHandlerContract = new TerminatedHandler(),
+        protected debug: boolean = false,
+    ) {}
+
+    handle(request: ServerRequestContract): ResponseContract {
+        let response: ResponseContract;
+
+        try {
+            response = this.dispatchRouter(request);
+        } catch (throwable) {
+            const error = throwable instanceof Error ? throwable : new Error(String(throwable));
+
+            response = this.getResponseFromThrowable(error);
+            response = this.throwableCaughtHandler.throwableCaught(request, response, error);
+        }
+
+        this.container.setSingleton(Response.name, response);
+
+        return response;
+    }
+
+    send(response: ResponseContract, nodeResponse: ServerResponse): this {
+        const statusCode = response.getStatusCode();
+
+        nodeResponse.statusCode = statusCode;
+        nodeResponse.statusMessage = response.getReasonPhrase();
+
+        const headers = response.getHeaders().getAll();
+
+        for (const header of Object.values(headers)) {
+            nodeResponse.setHeader(header.getName(), header.getHeaderLine());
+        }
+
+        const body = response.getBody();
+        body.rewind();
+        nodeResponse.end(body.getContents());
+
+        return this;
+    }
+
+    terminate(request: ServerRequestContract, response: ResponseContract): void {
+        this.terminatedHandler.terminated(request, response);
+    }
+
+    run(request: ServerRequestContract, nodeResponse: ServerResponse): void {
+        let response = this.handle(request);
+
+        response = this.sendingResponseHandler.sendingResponse(request, response);
+
+        this.container.setSingleton(Response.name, response);
+
+        this.send(response, nodeResponse);
+        this.terminate(request, response);
+    }
+
+    protected dispatchRouter(request: ServerRequestContract): ResponseContract {
+        this.container.setSingleton(HttpMessageServiceId.ServerRequestContract, request);
+
+        const requestAfterMiddleware = this.requestReceivedHandler.requestReceived(request);
+
+        if (!('getPath' in requestAfterMiddleware)) {
+            return requestAfterMiddleware as ResponseContract;
+        }
+
+        const updatedRequest = requestAfterMiddleware as ServerRequestContract;
+
+        this.container.setSingleton(HttpMessageServiceId.ServerRequestContract, updatedRequest);
+
+        return this.router.dispatch(updatedRequest);
+    }
+
+    protected getResponseFromThrowable(throwable: Error): ResponseContract {
+        if (this.debug) {
+            throw throwable;
+        }
+
+        if (throwable instanceof HttpResponseException) {
+            return throwable.getResponse() ?? this.getDefaultErrorResponseForHttpException(throwable);
+        }
+
+        return this.getDefaultErrorResponse();
+    }
+
+    protected getDefaultErrorResponse(): ResponseContract {
+        const body = new Stream();
+        body.write('Unknown Server Error Occurred');
+        body.rewind();
+
+        return new Response(body, StatusCode.INTERNAL_SERVER_ERROR);
+    }
+
+    protected getDefaultErrorResponseForHttpException(httpException: HttpResponseException): ResponseContract {
+        const statusCode = httpException.getStatusCode();
+        const body = new Stream();
+
+        body.write('Unknown Server Error Occurred - ' + httpException.getTraceCode());
+        body.rewind();
+
+        return new Response(body, statusCode);
+    }
+}

package/src/Valkyrja/Http/Server/Middleware/RequestReceived/RedirectTrailingSlashMiddleware.ts

@@ -0,0 +1,47 @@
+/*
+ * 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 { RedirectResponse } from '../../../Message/Response/RedirectResponse.js';
+
+import type { ServerRequestContract } from '../../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { RedirectResponseContract } from '../../../Message/Response/Contract/RedirectResponseContract.js';
+import type { UriContract } from '../../../Message/Uri/Contract/UriContract.js';
+import type { RequestReceivedMiddlewareContract } from '../../../Middleware/Contract/RequestReceivedMiddlewareContract.js';
+import type { RequestReceivedHandlerContract } from '../../../Middleware/Handler/Contract/RequestReceivedHandlerContract.js';
+
+export class RedirectTrailingSlashMiddleware implements RequestReceivedMiddlewareContract {
+    requestReceived(
+        request: ServerRequestContract,
+        handler: RequestReceivedHandlerContract,
+    ): ServerRequestContract | ResponseContract {
+        if (this.shouldRedirectRequest(request)) {
+            const uri = this.createBeforeRedirectUri(request.getUri());
+
+            return this.createBeforeRedirectResponse(uri);
+        }
+
+        return handler.requestReceived(request);
+    }
+
+    protected shouldRedirectRequest(request: ServerRequestContract): boolean {
+        const path = request.getUri().getPath();
+
+        return path !== '/' && path.endsWith('/');
+    }
+
+    protected createBeforeRedirectUri(uri: UriContract): UriContract {
+        const path = '/' + uri.getPath().replace(/^\/+|\/+$/g, '');
+        return uri.withPath(path);
+    }
+
+    protected createBeforeRedirectResponse(uri: UriContract): RedirectResponseContract {
+        return RedirectResponse.createFromUri(uri);
+    }
+}

package/src/Valkyrja/Http/Server/Middleware/RouteMatched/ResponseStructMiddleware.ts

@@ -0,0 +1,45 @@
+/*
+ * 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 { JsonResponseContract } from '../../../Message/Response/Contract/JsonResponseContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { RouteDispatchedMiddlewareContract } from '../../../Middleware/Contract/RouteDispatchedMiddlewareContract.js';
+import type { RouteDispatchedHandlerContract } from '../../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.js';
+import type { RouteContract } from '../../../Routing/Data/Contract/RouteContract.js';
+import type { ResponseStructContract } from '../../../Struct/Response/Contract/ResponseStructContract.js';
+
+export class ResponseStructMiddleware implements RouteDispatchedMiddlewareContract {
+    routeDispatched(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        route: RouteContract,
+        handler: RouteDispatchedHandlerContract,
+    ): ResponseContract {
+        if (route.hasResponseStruct() && this.isJsonResponse(response)) {
+            const responseStruct = route.getResponseStruct();
+            response = this.updateJsonWithResponseStruct(response, responseStruct);
+        }
+
+        return handler.routeDispatched(request, response, route);
+    }
+
+    protected isJsonResponse(response: ResponseContract): response is JsonResponseContract {
+        return 'getBodyAsJson' in response;
+    }
+
+    protected updateJsonWithResponseStruct(
+        response: JsonResponseContract,
+        responseStruct: ResponseStructContract,
+    ): JsonResponseContract {
+        const data = response.getBodyAsJson();
+
+        return response.withJsonAsBody(responseStruct.getStructuredData(data));
+    }
+}

package/src/Valkyrja/Http/Server/Middleware/SendingResponse/NoCacheResponseMiddleware.ts

@@ -0,0 +1,36 @@
+/*
+ * 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 { HeaderName } from '../../../Message/Constant/HeaderName.js';
+import { Header } from '../../../Message/Header/Header.js';
+
+import type { ServerRequestContract } from '../../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+import type { SendingResponseMiddlewareContract } from '../../../Middleware/Contract/SendingResponseMiddlewareContract.js';
+import type { SendingResponseHandlerContract } from '../../../Middleware/Handler/Contract/SendingResponseHandlerContract.js';
+
+export class NoCacheResponseMiddleware implements SendingResponseMiddlewareContract {
+    protected expires: string[] = ['Sun, 01 Jan 2014 00:00:00 GMT'];
+    protected cacheControl: string[] = ['no-store', 'no-cache', 'must-revalidate', 'post-check=0', 'pre-check=0'];
+    protected pragma: string[] = ['no-cache'];
+
+    sendingResponse(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        handler: SendingResponseHandlerContract,
+    ): ResponseContract {
+        const headers = response
+            .getHeaders()
+            .withHeader(new Header(HeaderName.EXPIRES, ...this.expires))
+            .withHeader(new Header(HeaderName.CACHE_CONTROL, ...this.cacheControl))
+            .withHeader(new Header(HeaderName.PRAGMA, ...this.pragma));
+
+        return handler.sendingResponse(request, response.withHeaders(headers));
+    }
+}