@valkyrjaio/valkyrja 26.2.0 → 26.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyrjaio/valkyrja",
-    "version": "26.2.0",
+    "version": "26.3.0",
     "description": "The Valkyrja Framework.",
     "keywords": [
         "framework",

package/src/Valkyrja/Application/Constant/ApplicationInfo.ts

@@ -8,8 +8,8 @@
  */
 
 export class ApplicationInfo {
-    static readonly VERSION = '26.2.0' as const;
-    static readonly VERSION_BUILD_DATE_TIME = 'July 24 2026 23:49:19 MST' as const;
+    static readonly VERSION = '26.3.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'July 25 2026 20:40:59 MST' as const;
     static readonly ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _

package/src/Valkyrja/Application/Kernel/Valkyrja.ts

@@ -47,18 +47,21 @@ export class Valkyrja implements ApplicationContract {
             return this.providers;
         }
 
-        const providers: ComponentProviderContract[][] = [];
-
         for (const provider of this.config.providers) {
-            providers.push(provider.getComponentProviders(this));
-            providers.push([provider]);
+            this.collectProviders(provider);
         }
 
-        this.providers = [...new Set(providers.flat())];
-
         return this.providers;
     }
 
+    protected collectProviders(provider: ComponentProviderContract): void {
+        for (const subProvider of provider.getComponentProviders(this)) {
+            this.collectProviders(subProvider);
+        }
+
+        this.providers.push(provider);
+    }
+
     getContainerProviders(): ServiceProviderContract[] {
         if (this.serviceProviders.length > 0) {
             return this.serviceProviders;

package/src/Valkyrja/Application/Provider/HttpApplicationComponentProvider.ts

@@ -8,6 +8,11 @@
  */
 
 import { ContainerComponentProvider } from '../../Container/Provider/ContainerComponentProvider.ts';
+import { HttpMessageComponentProvider } from '../../Http/Message/Provider/HttpMessageComponentProvider.ts';
+import { HttpMiddlewareComponentProvider } from '../../Http/Middleware/Provider/HttpMiddlewareComponentProvider.ts';
+import { HttpRoutingCliComponentProvider } from '../../Http/Routing/Provider/HttpRoutingCliComponentProvider.ts';
+import { HttpRoutingComponentProvider } from '../../Http/Routing/Provider/HttpRoutingComponentProvider.ts';
+import { HttpServerComponentProvider } from '../../Http/Server/Provider/HttpServerComponentProvider.ts';
 import { ApplicationComponentProvider } from './ApplicationComponentProvider.ts';
 
 import type { ApplicationContract } from '../Kernel/Contract/ApplicationContract.ts';
@@ -15,6 +20,13 @@ import type { ComponentProviderContract } from './Contract/ComponentProviderCont
 
 export class HttpApplicationComponentProvider extends ApplicationComponentProvider {
     override getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
-        return [new ContainerComponentProvider()];
+        return [
+            new ContainerComponentProvider(),
+            new HttpMessageComponentProvider(),
+            new HttpMiddlewareComponentProvider(),
+            new HttpRoutingComponentProvider(),
+            new HttpRoutingCliComponentProvider(),
+            new HttpServerComponentProvider(),
+        ];
     }
 }

package/src/Valkyrja/Http/Message/Provider/HttpMessageComponentProvider.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 { HttpMessageServiceProvider } from './HttpMessageServiceProvider.ts';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.ts';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.ts';
+import type { HttpRouteProviderContract } from '../../Routing/Provider/Contract/HttpRouteProviderContract.ts';
+
+export class HttpMessageComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [new HttpMessageServiceProvider()];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Http/Middleware/Provider/HttpMiddlewareComponentProvider.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 { HttpMiddlewareServiceProvider } from './HttpMiddlewareServiceProvider.ts';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.ts';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.ts';
+import type { HttpRouteProviderContract } from '../../Routing/Provider/Contract/HttpRouteProviderContract.ts';
+
+export class HttpMiddlewareComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [new HttpMiddlewareServiceProvider()];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Http/Middleware/Provider/HttpMiddlewareServiceProvider.ts

@@ -0,0 +1,96 @@
+/*
+ * 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.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import { HttpMiddlewareServiceId } from '../Constant/HttpMiddlewareServiceId.ts';
+import type { RequestReceivedHandlerContract } from '../Handler/Contract/RequestReceivedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from '../Handler/Contract/ResponseSentHandlerContract.ts';
+import type { RouteDispatchedHandlerContract } from '../Handler/Contract/RouteDispatchedHandlerContract.ts';
+import type { RouteMatchedHandlerContract } from '../Handler/Contract/RouteMatchedHandlerContract.ts';
+import type { RouteNotMatchedHandlerContract } from '../Handler/Contract/RouteNotMatchedHandlerContract.ts';
+import type { SendingResponseHandlerContract } from '../Handler/Contract/SendingResponseHandlerContract.ts';
+import type { ThrowableCaughtHandlerContract } from '../Handler/Contract/ThrowableCaughtHandlerContract.ts';
+import { RequestReceivedHandler } from '../Handler/RequestReceivedHandler.ts';
+import { ResponseSentHandler } from '../Handler/ResponseSentHandler.ts';
+import { RouteDispatchedHandler } from '../Handler/RouteDispatchedHandler.ts';
+import { RouteMatchedHandler } from '../Handler/RouteMatchedHandler.ts';
+import { RouteNotMatchedHandler } from '../Handler/RouteNotMatchedHandler.ts';
+import { SendingResponseHandler } from '../Handler/SendingResponseHandler.ts';
+import { ThrowableCaughtHandler } from '../Handler/ThrowableCaughtHandler.ts';
+
+export class HttpMiddlewareServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [HttpMiddlewareServiceId.RequestReceivedHandlerContract]:
+                HttpMiddlewareServiceProvider.publishRequestReceivedHandler,
+            [HttpMiddlewareServiceId.ThrowableCaughtHandlerContract]:
+                HttpMiddlewareServiceProvider.publishThrowableCaughtHandler,
+            [HttpMiddlewareServiceId.RouteMatchedHandlerContract]:
+                HttpMiddlewareServiceProvider.publishRouteMatchedHandler,
+            [HttpMiddlewareServiceId.RouteNotMatchedHandlerContract]:
+                HttpMiddlewareServiceProvider.publishRouteNotMatchedHandler,
+            [HttpMiddlewareServiceId.RouteDispatchedHandlerContract]:
+                HttpMiddlewareServiceProvider.publishRouteDispatchedHandler,
+            [HttpMiddlewareServiceId.SendingResponseHandlerContract]:
+                HttpMiddlewareServiceProvider.publishSendingResponseHandler,
+            [HttpMiddlewareServiceId.ResponseSentHandlerContract]:
+                HttpMiddlewareServiceProvider.publishResponseSentHandler,
+        };
+    }
+
+    static publishRequestReceivedHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<RequestReceivedHandlerContract>(
+            HttpMiddlewareServiceId.RequestReceivedHandlerContract,
+            new RequestReceivedHandler(container),
+        );
+    }
+
+    static publishThrowableCaughtHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<ThrowableCaughtHandlerContract>(
+            HttpMiddlewareServiceId.ThrowableCaughtHandlerContract,
+            new ThrowableCaughtHandler(container),
+        );
+    }
+
+    static publishRouteMatchedHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<RouteMatchedHandlerContract>(
+            HttpMiddlewareServiceId.RouteMatchedHandlerContract,
+            new RouteMatchedHandler(container),
+        );
+    }
+
+    static publishRouteNotMatchedHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<RouteNotMatchedHandlerContract>(
+            HttpMiddlewareServiceId.RouteNotMatchedHandlerContract,
+            new RouteNotMatchedHandler(container),
+        );
+    }
+
+    static publishRouteDispatchedHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<RouteDispatchedHandlerContract>(
+            HttpMiddlewareServiceId.RouteDispatchedHandlerContract,
+            new RouteDispatchedHandler(container),
+        );
+    }
+
+    static publishSendingResponseHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<SendingResponseHandlerContract>(
+            HttpMiddlewareServiceId.SendingResponseHandlerContract,
+            new SendingResponseHandler(container),
+        );
+    }
+
+    static publishResponseSentHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<ResponseSentHandlerContract>(
+            HttpMiddlewareServiceId.ResponseSentHandlerContract,
+            new ResponseSentHandler(container),
+        );
+    }
+}

package/src/Valkyrja/Http/Routing/Provider/HttpRoutingComponentProvider.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 { HttpRoutingServiceProvider } from './HttpRoutingServiceProvider.ts';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.ts';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.ts';
+import type { HttpRouteProviderContract } from './Contract/HttpRouteProviderContract.ts';
+
+export class HttpRoutingComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [new HttpRoutingServiceProvider()];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Http/Routing/Provider/HttpRoutingServiceProvider.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 { ApplicationServiceId } from '../../../Application/Constant/ApplicationServiceId.ts';
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import { HttpMessageServiceId } from '../../Message/Constant/HttpMessageServiceId.ts';
+import type { ResponseFactoryContract } from '../../Message/Response/Factory/Contract/ResponseFactoryContract.ts';
+import { HttpMiddlewareServiceId } from '../../Middleware/Constant/HttpMiddlewareServiceId.ts';
+import type { ResponseSentHandlerContract } from '../../Middleware/Handler/Contract/ResponseSentHandlerContract.ts';
+import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.ts';
+import type { RouteMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteMatchedHandlerContract.ts';
+import type { RouteNotMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.ts';
+import type { SendingResponseHandlerContract } from '../../Middleware/Handler/Contract/SendingResponseHandlerContract.ts';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
+import type { RouteCollectionContract } from '../Collection/Contract/RouteCollectionContract.ts';
+import { RouteCollection } from '../Collection/RouteCollection.ts';
+import { HttpRoutingServiceId } from '../Constant/HttpRoutingServiceId.ts';
+import { HttpRoutingData } from '../Data/HttpRoutingData.ts';
+import type { RouterContract } from '../Dispatcher/Contract/RouterContract.ts';
+import { Router } from '../Dispatcher/Router.ts';
+import type { RoutingResponseFactoryContract } from '../Factory/Contract/RoutingResponseFactoryContract.ts';
+import { RoutingResponseFactory } from '../Factory/RoutingResponseFactory.ts';
+import type { MatcherContract } from '../Matcher/Contract/MatcherContract.ts';
+import { Matcher } from '../Matcher/Matcher.ts';
+import type { ProcessorContract } from '../Processor/Contract/ProcessorContract.ts';
+import { Processor } from '../Processor/Processor.ts';
+import type { UrlContract } from '../Url/Contract/UrlContract.ts';
+import { Url } from '../Url/Url.ts';
+
+export class HttpRoutingServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [HttpRoutingServiceId.RouterContract]: HttpRoutingServiceProvider.publishRouter,
+            [HttpRoutingServiceId.RouteCollectionContract]: HttpRoutingServiceProvider.publishRouteCollection,
+            [HttpRoutingServiceId.MatcherContract]: HttpRoutingServiceProvider.publishMatcher,
+            [HttpRoutingServiceId.UrlContract]: HttpRoutingServiceProvider.publishUrl,
+            [HttpRoutingServiceId.ProcessorContract]: HttpRoutingServiceProvider.publishProcessor,
+            [HttpRoutingServiceId.RoutingResponseFactory]: HttpRoutingServiceProvider.publishResponseFactory,
+            [HttpRoutingServiceId.HttpRoutingData]: HttpRoutingServiceProvider.publishData,
+        };
+    }
+
+    static publishRouter(this: void, container: ContainerContract): void {
+        container.setSingleton<RouterContract>(
+            HttpRoutingServiceId.RouterContract,
+            new Router(
+                container,
+                container.getSingleton<MatcherContract>(HttpRoutingServiceId.MatcherContract),
+                container.getSingleton<ResponseFactoryContract>(HttpMessageServiceId.ResponseFactoryContract),
+                container.getSingleton<ThrowableCaughtHandlerContract>(
+                    HttpMiddlewareServiceId.ThrowableCaughtHandlerContract,
+                ),
+                container.getSingleton<RouteMatchedHandlerContract>(
+                    HttpMiddlewareServiceId.RouteMatchedHandlerContract,
+                ),
+                container.getSingleton<RouteNotMatchedHandlerContract>(
+                    HttpMiddlewareServiceId.RouteNotMatchedHandlerContract,
+                ),
+                container.getSingleton<RouteDispatchedHandlerContract>(
+                    HttpMiddlewareServiceId.RouteDispatchedHandlerContract,
+                ),
+                container.getSingleton<SendingResponseHandlerContract>(
+                    HttpMiddlewareServiceId.SendingResponseHandlerContract,
+                ),
+                container.getSingleton<ResponseSentHandlerContract>(
+                    HttpMiddlewareServiceId.ResponseSentHandlerContract,
+                ),
+            ),
+        );
+    }
+
+    static publishRouteCollection(this: void, container: ContainerContract): void {
+        const collection = new RouteCollection();
+
+        container.setSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract, collection);
+
+        const app = container.getSingleton<ApplicationContract>(ApplicationServiceId.ApplicationContract);
+
+        if (app.getDebugMode()) {
+            HttpRoutingServiceProvider.publishData(container);
+
+            return;
+        }
+
+        const data = container.getSingleton<HttpRoutingData>(HttpRoutingServiceId.HttpRoutingData);
+
+        collection.setFromData(data);
+    }
+
+    static publishMatcher(this: void, container: ContainerContract): void {
+        container.setSingleton<MatcherContract>(
+            HttpRoutingServiceId.MatcherContract,
+            new Matcher(container.getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract)),
+        );
+    }
+
+    static publishUrl(this: void, container: ContainerContract): void {
+        container.setSingleton<UrlContract>(
+            HttpRoutingServiceId.UrlContract,
+            new Url(container.getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract)),
+        );
+    }
+
+    static publishProcessor(this: void, container: ContainerContract): void {
+        container.setSingleton<ProcessorContract>(HttpRoutingServiceId.ProcessorContract, new Processor());
+    }
+
+    static publishResponseFactory(this: void, container: ContainerContract): void {
+        container.setSingleton<RoutingResponseFactoryContract>(
+            HttpRoutingServiceId.RoutingResponseFactory,
+            new RoutingResponseFactory(
+                container.getSingleton<ResponseFactoryContract>(HttpMessageServiceId.ResponseFactoryContract),
+                container.getSingleton<UrlContract>(HttpRoutingServiceId.UrlContract),
+            ),
+        );
+    }
+
+    static publishData(this: void, container: ContainerContract): void {
+        const collection = container.getSingleton<RouteCollectionContract>(
+            HttpRoutingServiceId.RouteCollectionContract,
+        );
+        const app = container.getSingleton<ApplicationContract>(ApplicationServiceId.ApplicationContract);
+        const processor = container.getSingleton<ProcessorContract>(HttpRoutingServiceId.ProcessorContract);
+
+        for (const provider of app.getHttpProviders()) {
+            for (const route of provider.getRoutes()) {
+                collection.add(processor.route(route));
+            }
+        }
+
+        container.setSingleton(HttpRoutingServiceId.HttpRoutingData, collection.getData());
+    }
+}

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

@@ -98,11 +98,12 @@ export class RequestHandler implements RequestHandlerContract {
 
         const requestAfterMiddleware = this.requestReceivedHandler.requestReceived(request);
 
-        if (!('getPath' in requestAfterMiddleware)) {
-            return requestAfterMiddleware as ResponseContract;
+        // If the return value after middleware is a response return it.
+        if ('getStatusCode' in requestAfterMiddleware) {
+            return requestAfterMiddleware;
         }
 
-        const updatedRequest = requestAfterMiddleware as ServerRequestContract;
+        const updatedRequest = requestAfterMiddleware;
 
         this.container.setSingleton(HttpMessageServiceId.ServerRequestContract, updatedRequest);
 

package/src/Valkyrja/Http/Server/Provider/HttpServerComponentProvider.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 { HttpServerServiceProvider } from './HttpServerServiceProvider.ts';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.ts';
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.ts';
+import type { HttpRouteProviderContract } from '../../Routing/Provider/Contract/HttpRouteProviderContract.ts';
+
+export class HttpServerComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [new HttpServerServiceProvider()];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Http/Server/Provider/HttpServerServiceProvider.ts

@@ -0,0 +1,56 @@
+/*
+ * 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.ts';
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.ts';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.ts';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
+import { HttpMiddlewareServiceId } from '../../Middleware/Constant/HttpMiddlewareServiceId.ts';
+import type { RequestReceivedHandlerContract } from '../../Middleware/Handler/Contract/RequestReceivedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from '../../Middleware/Handler/Contract/ResponseSentHandlerContract.ts';
+import type { SendingResponseHandlerContract } from '../../Middleware/Handler/Contract/SendingResponseHandlerContract.ts';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
+import { HttpRoutingServiceId } from '../../Routing/Constant/HttpRoutingServiceId.ts';
+import type { RouterContract } from '../../Routing/Dispatcher/Contract/RouterContract.ts';
+import { HttpServerServiceId } from '../Constant/HttpServerServiceId.ts';
+import type { RequestHandlerContract } from '../Handler/Contract/RequestHandlerContract.ts';
+import { RequestHandler } from '../Handler/RequestHandler.ts';
+
+export class HttpServerServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [HttpServerServiceId.RequestHandlerContract]: HttpServerServiceProvider.publishRequestHandler,
+        };
+    }
+
+    static publishRequestHandler(this: void, container: ContainerContract): void {
+        const app = container.getSingleton<ApplicationContract>(ApplicationServiceId.ApplicationContract);
+
+        container.setSingleton<RequestHandlerContract>(
+            HttpServerServiceId.RequestHandlerContract,
+            new RequestHandler(
+                container,
+                container.getSingleton<RouterContract>(HttpRoutingServiceId.RouterContract),
+                container.getSingleton<RequestReceivedHandlerContract>(
+                    HttpMiddlewareServiceId.RequestReceivedHandlerContract,
+                ),
+                container.getSingleton<ThrowableCaughtHandlerContract>(
+                    HttpMiddlewareServiceId.ThrowableCaughtHandlerContract,
+                ),
+                container.getSingleton<SendingResponseHandlerContract>(
+                    HttpMiddlewareServiceId.SendingResponseHandlerContract,
+                ),
+                container.getSingleton<ResponseSentHandlerContract>(
+                    HttpMiddlewareServiceId.ResponseSentHandlerContract,
+                ),
+                app.getDebugMode(),
+            ),
+        );
+    }
+}