@valkyrjaio/valkyrja 26.3.0 → 26.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyrjaio/valkyrja",
-    "version": "26.3.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.3.0' as const;
-    static readonly VERSION_BUILD_DATE_TIME = 'July 25 2026 20:40:59 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/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/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/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);
-    }
-}