@valkyrjaio/valkyrja 26.2.0 → 26.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyrjaio/valkyrja",
-    "version": "26.2.0",
+    "version": "26.4.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.4.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'July 27 2026 22:05:07 MST' as const;
     static readonly ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _

package/src/Valkyrja/Application/Entry/Cli.ts

@@ -29,6 +29,8 @@ export class Cli extends App {
     }
 
     static getInput(config: CliConfigContract): InputContract {
-        return InputFactory.fromGlobals(process.argv, config.applicationName, config.defaultCommandName);
+        // process.argv leads with the interpreter path, so drop it: the factory expects the vector
+        // to start with the caller, followed by the command name and the rest of the args.
+        return InputFactory.fromGlobals(process.argv.slice(1), config.applicationName, config.defaultCommandName);
     }
 }

package/src/Valkyrja/Application/Entry/Http.ts

@@ -8,7 +8,7 @@
  */
 
 import { createServer } from 'node:http';
-import type { IncomingMessage } from 'node:http';
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
 
 import { App } from './Abstract/App.ts';
 import { HttpServerServiceId } from '../../Http/Server/Constant/HttpServerServiceId.ts';
@@ -20,6 +20,14 @@ import type { RequestHandlerContract } from '../../Http/Server/Handler/Contract/
 
 export class Http extends App {
     static run(config: HttpConfigContract, port: number = 3000): void {
+        const server = this.createServer((req, res) => {
+            this.handle(config, req, res);
+        });
+
+        this.listen(server, port);
+    }
+
+    static handle(config: HttpConfigContract, nodeRequest: IncomingMessage, nodeResponse: ServerResponse): void {
         const app = this.start(config);
         const container = app.getContainer();
 
@@ -27,15 +35,37 @@ export class Http extends App {
 
         const handler = container.getSingleton<RequestHandlerContract>(HttpServerServiceId.RequestHandlerContract);
 
-        const server = createServer((req, res) => {
-            const request = this.getRequest(req);
-            handler.run(request, res);
-        });
-
-        server.listen(port);
+        handler.run(this.getRequest(nodeRequest), nodeResponse);
     }
 
     static getRequest(nodeRequest: IncomingMessage): ServerRequestContract {
         return RequestFactory.fromNodeRequest(nodeRequest);
     }
+
+    /**
+     * Create the native HTTP server.
+     *
+     * Overridable runtime seam wrapping Node's socket-creating `createServer`, so
+     * tests can substitute a double without opening a real socket. Ignored for
+     * coverage because it is irreducible runtime I/O that only runs against a live
+     * server.
+     */
+    /* v8 ignore start */
+    static createServer(handler: (request: IncomingMessage, response: ServerResponse) => void): Server {
+        return createServer(handler);
+    }
+    /* v8 ignore stop */
+
+    /**
+     * Bind the server to the given port.
+     *
+     * Overridable runtime seam wrapping Node's socket-binding `listen`, so tests
+     * can substitute a double without binding a real port. Ignored for coverage
+     * because it is irreducible runtime I/O that only runs against a live server.
+     */
+    /* v8 ignore start */
+    static listen(server: Server, port: number): void {
+        server.listen(port);
+    }
+    /* v8 ignore stop */
 }

package/src/Valkyrja/Application/Entry/WorkerHttp.ts

@@ -0,0 +1,122 @@
+/*
+ * 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 { createServer } from 'node:http';
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+
+import { ChildApplication } from '../Kernel/ChildApplication.ts';
+import { ChildContainer } from '../../Container/Manager/ChildContainer.ts';
+import { ApplicationServiceId } from '../Constant/ApplicationServiceId.ts';
+import { ContainerServiceId } from '../../Container/Constant/ContainerServiceId.ts';
+import { HttpServerServiceId } from '../../Http/Server/Constant/HttpServerServiceId.ts';
+import { HttpRoutingServiceId } from '../../Http/Routing/Constant/HttpRoutingServiceId.ts';
+import { RequestFactory } from '../../Http/Message/Request/Factory/RequestFactory.ts';
+import { App } from './Abstract/App.ts';
+
+import type { ApplicationContract } from '../Kernel/Contract/ApplicationContract.ts';
+import type { ContainerContract } from '../../Container/Manager/Contract/ContainerContract.ts';
+import type { ContainerData } from '../../Container/Data/ContainerData.ts';
+import type { HttpConfigContract } from '../Data/Contract/HttpConfigContract.ts';
+import type { ServerRequestContract } from '../../Http/Message/Request/Contract/ServerRequestContract.ts';
+import type { RequestHandlerContract } from '../../Http/Server/Handler/Contract/RequestHandlerContract.ts';
+import type { RouteCollectionContract } from '../../Http/Routing/Collection/Contract/RouteCollectionContract.ts';
+
+export class WorkerHttp extends App {
+    static run(config: HttpConfigContract, port: number = 3000): void {
+        const app = this.bootstrap(config);
+        const data = app.getContainer().getData();
+
+        const server = this.createServer((req, res) => {
+            this.handle(app, data, req, res);
+        });
+
+        this.listen(server, port);
+    }
+
+    static bootstrap(config: HttpConfigContract): ApplicationContract {
+        const app = this.start(config);
+        const container = app.getContainer();
+
+        this.bootstrapThrowableHandler(app, container);
+        this.bootstrapParentServices(app);
+
+        return app;
+    }
+
+    static handle(
+        app: ApplicationContract,
+        data: ContainerData,
+        nodeRequest: IncomingMessage,
+        nodeResponse: ServerResponse,
+    ): void {
+        const request = this.getRequest(nodeRequest);
+        const childContainer = this.getChildContainer(app, data);
+        const childApp = this.getChildApplication(app, childContainer);
+
+        this.bootstrapChildContainer(childApp, childContainer);
+        this.handleRequest(childContainer, request, nodeResponse);
+    }
+
+    static getChildApplication(app: ApplicationContract, container: ContainerContract): ApplicationContract {
+        return new ChildApplication(app, container);
+    }
+
+    static getChildContainer(app: ApplicationContract, data: ContainerData): ContainerContract {
+        return new ChildContainer(app.getContainer(), data);
+    }
+
+    static bootstrapChildContainer(app: ApplicationContract, container: ContainerContract): void {
+        container.setSingleton(ApplicationServiceId.ApplicationContract, app);
+        container.setSingleton(ContainerServiceId.Contract, container);
+    }
+
+    static handleRequest(
+        container: ContainerContract,
+        request: ServerRequestContract,
+        nodeResponse: ServerResponse,
+    ): void {
+        const handler = container.getSingleton<RequestHandlerContract>(HttpServerServiceId.RequestHandlerContract);
+        handler.run(request, nodeResponse);
+    }
+
+    static getRequest(nodeRequest: IncomingMessage): ServerRequestContract {
+        return RequestFactory.fromNodeRequest(nodeRequest);
+    }
+
+    static bootstrapParentServices(app: ApplicationContract): void {
+        app.getContainer().getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract);
+    }
+
+    /**
+     * Create the native HTTP server.
+     *
+     * Overridable runtime seam wrapping Node's socket-creating `createServer`, so
+     * tests can substitute a double without opening a real socket. Ignored for
+     * coverage because it is irreducible runtime I/O that only runs against a live
+     * server.
+     */
+    /* v8 ignore start */
+    static createServer(handler: (request: IncomingMessage, response: ServerResponse) => void): Server {
+        return createServer(handler);
+    }
+    /* v8 ignore stop */
+
+    /**
+     * Bind the server to the given port.
+     *
+     * Overridable runtime seam wrapping Node's socket-binding `listen`, so tests
+     * can substitute a double without binding a real port. Ignored for coverage
+     * because it is irreducible runtime I/O that only runs against a live server.
+     */
+    /* v8 ignore start */
+    static listen(server: Server, port: number): void {
+        server.listen(port);
+    }
+    /* v8 ignore stop */
+}

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/Cli/Interaction/Input/Factory/InputFactory.ts

@@ -25,11 +25,18 @@ export abstract class InputFactory {
     ): InputContract {
         const arguments_ = [];
         const options = [];
+        let endOfOptions = false;
 
         for (const [key, arg] of args.entries()) {
             if (key === 0) {
                 applicationName = arg;
-            } else if (arg.startsWith('-')) {
+            } else if (!endOfOptions && arg === '--') {
+                // POSIX end-of-options marker: the `--` itself is consumed, and every arg after
+                // it is an operand — never an option, however many dashes it starts with. A
+                // second `--` is therefore an ordinary operand.
+                endOfOptions = true;
+            } else if (!endOfOptions && arg !== '-' && arg.startsWith('-')) {
+                // A lone `-` is an operand by convention (it names standard input), not an option.
                 options.push(...OptionFactory.fromArg(arg));
             } else if (key === 1) {
                 commandName = arg;

package/src/Valkyrja/Cli/Interaction/Option/Factory/OptionFactory.ts

@@ -18,12 +18,11 @@ export abstract class OptionFactory {
         OptionFactory.validateArgIsOption(arg);
 
         const type = OptionFactory.getOptionType(arg);
-        // The name is everything before the first '='; the value is the segment after it (if any).
-        const name = arg
-            .replace(/=[\s\S]*$/, '')
-            .replace(/^-+/, '')
-            .trim();
-        const value = arg.split('=')[1] ?? '';
+        // Split on the first `=` only, so a value that itself contains one survives intact
+        // (`--expr=a=b` yields `a=b`, not `a`).
+        const separatorIndex = arg.indexOf('=');
+        const name = (separatorIndex === -1 ? arg : arg.slice(0, separatorIndex)).replace(/^-+/, '').trim();
+        const value = separatorIndex === -1 ? '' : arg.slice(separatorIndex + 1);
 
         OptionFactory.validateNonEmptyName(name);
 

package/src/Valkyrja/Cli/Routing/Data/OptionParameter.ts

@@ -176,6 +176,14 @@ export class OptionParameter extends Parameter implements OptionParameterContrac
             valid = valid && this.options.length <= 1;
         }
 
+        if (this.validValues.length > 0) {
+            for (const option of this.options) {
+                if (!this.validValues.includes(option.getValue())) {
+                    return false;
+                }
+            }
+        }
+
         return valid;
     }
 

package/src/Valkyrja/Http/Message/Header/Collection/HeaderCollection.ts

@@ -101,10 +101,28 @@ export class HeaderCollection implements HeaderCollectionContract {
     withAddedHeaders(...headers: HeaderContract[]): this {
         const clone = ObjectFactory.clone(this);
         clone.headers = { ...this.headers };
-        this.setHeadersOnCollection(clone, ...headers);
+        for (const header of headers) {
+            clone.addHeader(header);
+        }
         return clone;
     }
 
+    /**
+     * Add a header, merging its values into an existing header of the same name.
+     */
+    protected addHeader(header: HeaderContract): void {
+        const name = header.getNormalizedName();
+        const existing = this.headers[name];
+
+        if (existing === undefined) {
+            this.headers[name] = header;
+
+            return;
+        }
+
+        this.headers[name] = existing.withAddedValues(...header.getValues());
+    }
+
     protected setHeaders(...headers: HeaderContract[]): void {
         this.setHeadersOnCollection(this, ...headers);
     }

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/Constant/Regex.ts

@@ -42,8 +42,8 @@ export class Regex {
     static readonly ALPHA_NUM = '[a-zA-Z0-9]+';
     static readonly ALPHA_NUM_UNDERSCORE = '\\w+';
 
-    static readonly START = '/^';
-    static readonly END = '$/';
+    static readonly START = '^';
+    static readonly END = '$';
 
     static readonly START_CAPTURE_GROUP = '(';
     static readonly START_NON_CAPTURE_GROUP = '(?:';

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(),
+            ),
+        );
+    }
+}

package/src/Valkyrja/Application/Entry/Abstract/WorkerHttp.ts

@@ -1,83 +0,0 @@
-/*
- * 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 { IncomingMessage, ServerResponse } from 'node:http';
-
-import { ChildApplication } from '../../Kernel/ChildApplication.ts';
-import { ChildContainer } from '../../../Container/Manager/ChildContainer.ts';
-import { ApplicationServiceId } from '../../Constant/ApplicationServiceId.ts';
-import { ContainerServiceId } from '../../../Container/Constant/ContainerServiceId.ts';
-import { HttpServerServiceId } from '../../../Http/Server/Constant/HttpServerServiceId.ts';
-import { HttpRoutingServiceId } from '../../../Http/Routing/Constant/HttpRoutingServiceId.ts';
-import { RequestFactory } from '../../../Http/Message/Request/Factory/RequestFactory.ts';
-import { App } from './App.ts';
-
-import type { ApplicationContract } from '../../Kernel/Contract/ApplicationContract.ts';
-import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.ts';
-import type { ContainerData } from '../../../Container/Data/ContainerData.ts';
-import type { HttpConfigContract } from '../../Data/Contract/HttpConfigContract.ts';
-import type { ServerRequestContract } from '../../../Http/Message/Request/Contract/ServerRequestContract.ts';
-import type { RequestHandlerContract } from '../../../Http/Server/Handler/Contract/RequestHandlerContract.ts';
-import type { RouteCollectionContract } from '../../../Http/Routing/Collection/Contract/RouteCollectionContract.ts';
-
-export abstract class WorkerHttp extends App {
-    static bootstrap(config: HttpConfigContract): ApplicationContract {
-        const app = this.start(config);
-        const container = app.getContainer();
-
-        this.bootstrapThrowableHandler(app, container);
-        this.bootstrapParentServices(app);
-
-        return app;
-    }
-
-    static handle(
-        app: ApplicationContract,
-        data: ContainerData,
-        nodeRequest: IncomingMessage,
-        nodeResponse: ServerResponse,
-    ): void {
-        const request = this.getRequest(nodeRequest);
-        const childContainer = this.getChildContainer(app, data);
-        const childApp = this.getChildApplication(app, childContainer);
-
-        this.bootstrapChildContainer(childApp, childContainer);
-        this.handleRequest(childContainer, request, nodeResponse);
-    }
-
-    static getChildApplication(app: ApplicationContract, container: ContainerContract): ApplicationContract {
-        return new ChildApplication(app, container);
-    }
-
-    static getChildContainer(app: ApplicationContract, data: ContainerData): ContainerContract {
-        return new ChildContainer(app.getContainer(), data);
-    }
-
-    static bootstrapChildContainer(app: ApplicationContract, container: ContainerContract): void {
-        container.setSingleton(ApplicationServiceId.ApplicationContract, app);
-        container.setSingleton(ContainerServiceId.Contract, container);
-    }
-
-    static handleRequest(
-        container: ContainerContract,
-        request: ServerRequestContract,
-        nodeResponse: ServerResponse,
-    ): void {
-        const handler = container.getSingleton<RequestHandlerContract>(HttpServerServiceId.RequestHandlerContract);
-        handler.run(request, nodeResponse);
-    }
-
-    static getRequest(nodeRequest: IncomingMessage): ServerRequestContract {
-        return RequestFactory.fromNodeRequest(nodeRequest);
-    }
-
-    static bootstrapParentServices(app: ApplicationContract): void {
-        app.getContainer().getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract);
-    }
-}