@rangojs/router 0.0.0-experimental.9 → 0.0.0-experimental.90

package/src/host/cookie-handler.ts

@@ -4,30 +4,36 @@
  * Manages cookie-based host override for development environments.
  */
 
-import type { HostOverrideConfig } from './types.js';
-import { matchPattern, parseRequest } from './pattern-matcher.js';
+import type { HostOverrideConfig } from "./types.js";
+import type { RouterRequestInput } from "../router/router-interfaces.js";
+import { matchPattern, parseRequest } from "./pattern-matcher.js";
 import {
   HostOverrideNotAllowedError,
   InvalidHostnameError,
   HostValidationError,
-} from './errors.js';
+} from "./errors.js";
 
 /**
  * Parse cookies from request
  */
 export function parseCookies(request: Request): Record<string, string> {
-  const cookieHeader = request.headers.get('cookie');
+  const cookieHeader = request.headers.get("cookie");
   if (!cookieHeader) {
     return {};
   }
 
   const cookies: Record<string, string> = {};
-  const pairs = cookieHeader.split(';');
+  const pairs = cookieHeader.split(";");
 
   for (const pair of pairs) {
-    const [key, value] = pair.trim().split('=');
-    if (key && value) {
-      cookies[key] = decodeURIComponent(value);
+    const [name, ...rest] = pair.trim().split("=");
+    if (name && rest.length > 0) {
+      const value = rest.join("=");
+      try {
+        cookies[name] = decodeURIComponent(value);
+      } catch {
+        cookies[name] = value;
+      }
     }
   }
 
@@ -54,7 +60,7 @@ export function createDeleteCookieHeader(name: string): string {
  */
 export function createCookieErrorResponse(
   cookieName: string,
-  message: string
+  message: string,
 ): Response {
   return new Response(
     JSON.stringify({
@@ -64,10 +70,10 @@ export function createCookieErrorResponse(
     {
       status: 400,
       headers: {
-        'Content-Type': 'application/json',
-        'Set-Cookie': createDeleteCookieHeader(cookieName),
+        "Content-Type": "application/json",
+        "Set-Cookie": createDeleteCookieHeader(cookieName),
       },
-    }
+    },
   );
 }
 
@@ -76,7 +82,7 @@ export function createCookieErrorResponse(
  */
 export function isHostAllowed(
   request: Request,
-  allowedHosts: string[]
+  allowedHosts: string[],
 ): boolean {
   const { hostname, pathname, parts } = parseRequest(request);
 
@@ -98,7 +104,7 @@ export function isHostAllowed(
 export function handleCookieOverride(
   request: Request,
   config: HostOverrideConfig | undefined,
-  context: any
+  input: RouterRequestInput<any>,
 ): string {
   if (!config) {
     const { hostname } = parseRequest(request);
@@ -127,7 +133,7 @@ export function handleCookieOverride(
   // If allowed and has custom validation, run it
   if (validate) {
     try {
-      const validatedHostname = validate(request, cookieValue, context);
+      const validatedHostname = validate(request, cookieValue, input);
       return validatedHostname;
     } catch (error) {
       // Wrap in HostValidationError

package/src/host/errors.ts

@@ -22,7 +22,7 @@ export class HostRouterError extends Error {
     if (options?.cause) {
       this.cause = options.cause;
     }
-    this.name = 'HostRouterError';
+    this.name = "HostRouterError";
     Object.setPrototypeOf(this, HostRouterError.prototype);
   }
 }
@@ -33,7 +33,7 @@ export class HostRouterError extends Error {
 export class InvalidPatternError extends HostRouterError {
   constructor(pattern: string, reason: string, options?: ErrorOptions) {
     super(`Invalid pattern "${pattern}": ${reason}`, options);
-    this.name = 'InvalidPatternError';
+    this.name = "InvalidPatternError";
     Object.setPrototypeOf(this, InvalidPatternError.prototype);
   }
 }
@@ -45,9 +45,9 @@ export class HostOverrideNotAllowedError extends HostRouterError {
   constructor(currentHost: string, cookieName: string, options?: ErrorOptions) {
     super(
       `Host override not allowed on "${currentHost}" (cookie: ${cookieName})`,
-      options
+      options,
     );
-    this.name = 'HostOverrideNotAllowedError';
+    this.name = "HostOverrideNotAllowedError";
     Object.setPrototypeOf(this, HostOverrideNotAllowedError.prototype);
   }
 }
@@ -58,7 +58,7 @@ export class HostOverrideNotAllowedError extends HostRouterError {
 export class InvalidHostnameError extends HostRouterError {
   constructor(hostname: string, options?: ErrorOptions) {
     super(`Invalid hostname format: "${hostname}"`, options);
-    this.name = 'InvalidHostnameError';
+    this.name = "InvalidHostnameError";
     Object.setPrototypeOf(this, InvalidHostnameError.prototype);
   }
 }
@@ -69,7 +69,7 @@ export class InvalidHostnameError extends HostRouterError {
 export class HostValidationError extends HostRouterError {
   constructor(message: string, cause?: unknown) {
     super(message, { cause });
-    this.name = 'HostValidationError';
+    this.name = "HostValidationError";
     Object.setPrototypeOf(this, HostValidationError.prototype);
   }
 }
@@ -80,7 +80,7 @@ export class HostValidationError extends HostRouterError {
 export class NoRouteMatchError extends HostRouterError {
   constructor(hostname: string, pathname: string, options?: ErrorOptions) {
     super(`No route matched for ${hostname}${pathname}`, options);
-    this.name = 'NoRouteMatchError';
+    this.name = "NoRouteMatchError";
     Object.setPrototypeOf(this, NoRouteMatchError.prototype);
   }
 }
@@ -91,7 +91,7 @@ export class NoRouteMatchError extends HostRouterError {
 export class InvalidHandlerError extends HostRouterError {
   constructor(handler: unknown, options?: ErrorOptions) {
     super(`Invalid handler type: ${typeof handler}`, options);
-    this.name = 'InvalidHandlerError';
+    this.name = "InvalidHandlerError";
     Object.setPrototypeOf(this, InvalidHandlerError.prototype);
   }
 }

package/src/host/index.ts

@@ -23,13 +23,10 @@
  */
 
 // Core router
-export { createHostRouter } from './router.js';
-
-// Host router registry for build-time discovery
-export { HostRouterRegistry, type HostRouterRegistryEntry } from './router.js';
+export { createHostRouter } from "./router.js";
 
 // Utilities
-export { defineHosts } from './utils.js';
+export { defineHosts } from "./utils.js";
 
 // Errors
 export {
@@ -40,7 +37,7 @@ export {
   HostValidationError,
   NoRouteMatchError,
   InvalidHandlerError,
-} from './errors.js';
+} from "./errors.js";
 
 // Types
 export type {
@@ -53,4 +50,4 @@ export type {
   HostPattern,
   HostMatchResult,
   HostOverrideConfig,
-} from './types.js';
+} from "./types.js";

package/src/host/pattern-matcher.ts

@@ -14,17 +14,17 @@
  * - `example.com/admin` - specific domain with path prefix
  */
 
-import { InvalidPatternError } from './errors.js';
+import { InvalidPatternError } from "./errors.js";
 
 /**
  * Normalize a pattern by removing trailing slashes from paths
  */
 export function normalizePattern(pattern: string): string {
   // If pattern has a path component, remove trailing slash
-  const slashIndex = pattern.indexOf('/');
+  const slashIndex = pattern.indexOf("/");
   if (slashIndex !== -1) {
     const domain = pattern.slice(0, slashIndex);
-    const path = pattern.slice(slashIndex).replace(/\/$/, '');
+    const path = pattern.slice(slashIndex).replace(/\/$/, "");
     return domain + path;
   }
   return pattern;
@@ -41,7 +41,7 @@ export function parseRequest(request: Request): {
   const url = new URL(request.url);
   const hostname = url.hostname;
   const pathname = url.pathname;
-  const parts = hostname.split('.');
+  const parts = hostname.split(".");
 
   return { hostname, pathname, parts };
 }
@@ -70,12 +70,12 @@ export function matchPattern(
   pattern: string,
   hostname: string,
   pathname: string,
-  parts: string[]
+  parts: string[],
 ): boolean {
   const normalized = normalizePattern(pattern);
 
   // Check if pattern has path component
-  const slashIndex = normalized.indexOf('/');
+  const slashIndex = normalized.indexOf("/");
   const hasPath = slashIndex !== -1;
   const domainPattern = hasPath ? normalized.slice(0, slashIndex) : normalized;
   const pathPattern = hasPath ? normalized.slice(slashIndex) : null;
@@ -88,7 +88,7 @@ export function matchPattern(
 
   // Then match path (prefix match)
   if (pathPattern) {
-    return pathname === pathPattern || pathname.startsWith(pathPattern + '/');
+    return pathname === pathPattern || pathname.startsWith(pathPattern + "/");
   }
 
   return true;
@@ -100,7 +100,7 @@ export function matchPattern(
 function matchDomainPattern(
   pattern: string,
   hostname: string,
-  parts: string[]
+  parts: string[],
 ): boolean {
   // Exact match
   if (pattern === hostname) {
@@ -108,48 +108,48 @@ function matchDomainPattern(
   }
 
   // `.` or `*` - any apex domain
-  if (pattern === '.' || pattern === '*') {
+  if (pattern === "." || pattern === "*") {
     return isApexDomain(parts);
   }
 
   // `**` - any domain (apex + all subdomains)
-  if (pattern === '**') {
+  if (pattern === "**") {
     return true;
   }
 
   // `*.` - any single-level subdomain
-  if (pattern === '*.') {
+  if (pattern === "*.") {
     return getSubdomainLevel(parts) === 1;
   }
 
   // `**.` - any multi-level subdomain (2+ levels)
-  if (pattern === '**.') {
+  if (pattern === "**.") {
     return getSubdomainLevel(parts) >= 2;
   }
 
   // `*.tld` - any apex domain with specific TLD (e.g., *.com)
-  if (pattern.startsWith('*.') && !pattern.includes('.', 2)) {
+  if (pattern.startsWith("*.") && !pattern.includes(".", 2)) {
     const tld = pattern.slice(2);
-    return isApexDomain(parts) && hostname.endsWith('.' + tld);
+    return isApexDomain(parts) && hostname.endsWith("." + tld);
   }
 
   // `*.example.com` - single subdomain of specific domain
-  if (pattern.startsWith('*.')) {
+  if (pattern.startsWith("*.")) {
     const baseDomain = pattern.slice(2);
-    if (hostname.endsWith('.' + baseDomain)) {
+    if (hostname.endsWith("." + baseDomain)) {
       // Count parts: if pattern is *.example.com (3 parts),
       // hostname should have exactly 4 parts (www.example.com)
-      const patternParts = baseDomain.split('.');
+      const patternParts = baseDomain.split(".");
       return parts.length === patternParts.length + 1;
     }
     return false;
   }
 
   // `**.example.com` - any depth subdomain of specific domain
-  if (pattern.startsWith('**.')) {
+  if (pattern.startsWith("**.")) {
     const baseDomain = pattern.slice(3);
-    if (hostname.endsWith('.' + baseDomain)) {
-      const patternParts = baseDomain.split('.');
+    if (hostname.endsWith("." + baseDomain)) {
+      const patternParts = baseDomain.split(".");
       // Must have more parts than the base domain (i.e., has subdomains)
       return parts.length > patternParts.length;
     }
@@ -158,7 +158,7 @@ function matchDomainPattern(
 
   // `subdomain.*` - specific subdomain of any apex domain
   // e.g., admin.* matches admin.example.com, admin.google.com
-  if (pattern.endsWith('.*')) {
+  if (pattern.endsWith(".*")) {
     const subdomain = pattern.slice(0, -2);
     // Must be single-level subdomain (3 parts total)
     if (parts.length === 3 && parts[0] === subdomain) {
@@ -169,7 +169,7 @@ function matchDomainPattern(
 
   // `subdomain.**` - specific subdomain of any domain (including multi-level)
   // e.g., admin.** matches admin.example.com, admin.sub.example.com
-  if (pattern.endsWith('.**')) {
+  if (pattern.endsWith(".**")) {
     const subdomain = pattern.slice(0, -3);
     if (parts.length >= 3 && parts[0] === subdomain) {
       return true;
@@ -179,7 +179,7 @@ function matchDomainPattern(
 
   // `subdomain.` - specific subdomain of any apex domain (no wildcard)
   // e.g., admin. matches admin.example.com, admin.google.com
-  if (pattern.endsWith('.') && !pattern.includes('*')) {
+  if (pattern.endsWith(".") && !pattern.includes("*")) {
     const subdomain = pattern.slice(0, -1);
     // Must be exactly 3 parts (subdomain.domain.tld)
     if (parts.length === 3 && parts[0] === subdomain) {
@@ -195,17 +195,17 @@ function matchDomainPattern(
  * Validate pattern format
  */
 export function validatePattern(pattern: string): void {
-  if (!pattern || typeof pattern !== 'string') {
+  if (!pattern || typeof pattern !== "string") {
     throw new InvalidPatternError(
       pattern,
-      'Pattern must be a non-empty string',
-      { cause: { type: typeof pattern, value: pattern } }
+      "Pattern must be a non-empty string",
+      { cause: { type: typeof pattern, value: pattern } },
     );
   }
 
   // Check for invalid characters (spaces, etc.)
   if (/\s/.test(pattern)) {
-    throw new InvalidPatternError(pattern, 'contains whitespace', {
+    throw new InvalidPatternError(pattern, "contains whitespace", {
       cause: { pattern },
     });
   }

package/src/host/router.ts

@@ -14,22 +14,23 @@ import type {
   HostPattern,
   RouteEntry,
   HostMatchResult,
-} from './types.js';
+} from "./types.js";
+import type { RouterRequestInput } from "../router/router-interfaces.js";
 import {
   matchPattern,
   parseRequest,
   normalizePattern,
   validatePattern,
-} from './pattern-matcher.js';
+} from "./pattern-matcher.js";
 import {
   handleCookieOverride,
   createCookieErrorResponse,
-} from './cookie-handler.js';
+} from "./cookie-handler.js";
 import {
   HostRouterError,
   NoRouteMatchError,
   InvalidHandlerError,
-} from './errors.js';
+} from "./errors.js";
 
 /**
  * Registry entry for a host router instance.
@@ -46,7 +47,8 @@ export interface HostRouterRegistryEntry {
  * Populated by createHostRouter() so the build-time discovery plugin can find
  * host routers and resolve their lazy handlers to trigger sub-app createRouter() calls.
  */
-export const HostRouterRegistry: Map<string, HostRouterRegistryEntry> = new Map();
+export const HostRouterRegistry: Map<string, HostRouterRegistryEntry> =
+  new Map();
 
 let hostRouterAutoId = 0;
 
@@ -71,7 +73,7 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
    */
   function createRouteBuilder(
     patterns: string[],
-    isFallback = false
+    isFallback = false,
   ): HostRouteBuilder {
     const middleware: Middleware[] = [];
 
@@ -96,8 +98,8 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         }
 
         log(
-          `Registered ${isFallback ? 'fallback' : 'route'}:`,
-          patterns.join(', ')
+          `Registered ${isFallback ? "fallback" : "route"}:`,
+          patterns.join(", "),
         );
 
         return router;
@@ -110,9 +112,9 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
    */
   function findMatchingRoute(
     hostname: string,
-    pathname: string
+    pathname: string,
   ): RouteEntry | null {
-    const parts = hostname.split('.');
+    const parts = hostname.split(".");
 
     for (const route of routes) {
       for (const pattern of route.patterns) {
@@ -132,8 +134,8 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
   async function executeMiddleware(
     middleware: Middleware[],
     request: Request,
-    context: any,
-    finalHandler: () => Promise<Response>
+    input: RouterRequestInput<any>,
+    finalHandler: () => Promise<Response>,
   ): Promise<Response> {
     let index = 0;
 
@@ -147,7 +149,20 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         return finalHandler();
       }
 
-      return mw(request, context, next);
+      // Guard against double next() calls — a second call would
+      // re-enter the downstream chain and run handlers/side-effects twice.
+      let nextCalled = false;
+      const guardedNext = (): Promise<Response> => {
+        if (nextCalled) {
+          throw new Error(
+            `[HostRouter] Middleware called next() more than once.`,
+          );
+        }
+        nextCalled = true;
+        return next();
+      };
+
+      return mw(request, input, guardedNext);
     }
 
     return next();
@@ -159,34 +174,34 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
   async function executeHandler(
     handler: Handler | LazyHandler,
     request: Request,
-    context: any
+    input: RouterRequestInput<any>,
   ): Promise<Response> {
     // Check if it's a lazy handler (function that returns promise)
-    if (typeof handler === 'function') {
-      const result = handler(request, context);
+    if (typeof handler === "function") {
+      const result = handler(request, input);
 
       // If it returns a promise with default export
-      if (result && typeof result === 'object' && 'then' in result) {
+      if (result && typeof result === "object" && "then" in result) {
         const module = await result;
         if (
-          typeof module === 'object' &&
+          typeof module === "object" &&
           module !== null &&
-          'default' in module
+          "default" in module
         ) {
           const defaultExport = (module as { default: Handler | HostRouter })
             .default;
 
           // If default export is a router with match method
           if (
-            typeof defaultExport === 'object' &&
+            typeof defaultExport === "object" &&
             defaultExport !== null &&
-            'match' in defaultExport
+            "match" in defaultExport
           ) {
-            return (defaultExport as HostRouter).match(request, context);
+            return (defaultExport as HostRouter).match(request, input);
           }
 
           // Otherwise treat as handler
-          return (defaultExport as Handler)(request, context);
+          return (defaultExport as Handler)(request, input);
         }
         // If promise resolves to Response
         return result as Promise<Response>;
@@ -228,8 +243,8 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     },
 
     test(hostname: string): HostMatchResult | null {
-      const parts = hostname.split('.');
-      const pathname = '/';
+      const parts = hostname.split(".");
+      const pathname = "/";
 
       for (const route of routes) {
         for (const pattern of route.patterns) {
@@ -245,18 +260,17 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
       return null;
     },
 
-    async match(request: Request, context: any = {}): Promise<Response> {
+    async match(
+      request: Request,
+      input: RouterRequestInput<any> = {},
+    ): Promise<Response> {
       log(`Request: ${request.url}`);
 
       let effectiveHostname: string;
 
       try {
         // Handle cookie override (may throw HostRouterError)
-        effectiveHostname = handleCookieOverride(
-          request,
-          hostOverride,
-          context
-        );
+        effectiveHostname = handleCookieOverride(request, hostOverride, input);
       } catch (error) {
         // If it's a HostRouterError from cookie override
         if (error instanceof HostRouterError) {
@@ -264,14 +278,18 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
 
           // If fallback exists, use it
           if (fallbackRoute) {
-            context.error = error;
+            const fallbackInput = { ...input, error };
             const allMiddleware = [
               ...globalMiddleware,
               ...fallbackRoute.middleware,
             ];
 
-            return executeMiddleware(allMiddleware, request, context, () =>
-              executeHandler(fallbackRoute!.handler, request, context)
+            return executeMiddleware(
+              allMiddleware,
+              request,
+              fallbackInput,
+              () =>
+                executeHandler(fallbackRoute!.handler, request, fallbackInput),
             );
           }
 
@@ -279,7 +297,7 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
           if (hostOverride) {
             return createCookieErrorResponse(
               hostOverride.cookieName,
-              error.message
+              error.message,
             );
           }
         }
@@ -311,8 +329,8 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
       const allMiddleware = [...globalMiddleware, ...matchedRoute.middleware];
 
       // Execute middleware chain and handler
-      return executeMiddleware(allMiddleware, request, context, () =>
-        executeHandler(matchedRoute.handler, request, context)
+      return executeMiddleware(allMiddleware, request, input, () =>
+        executeHandler(matchedRoute.handler, request, input),
       );
     },
   };
@@ -322,8 +340,12 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
   // added via .host().map() after this point.
   const registryId = `host-router-${hostRouterAutoId++}`;
   HostRouterRegistry.set(registryId, {
-    get routes() { return routes; },
-    get fallback() { return fallbackRoute; },
+    get routes() {
+      return routes;
+    },
+    get fallback() {
+      return fallbackRoute;
+    },
   });
 
   return router;

package/src/host/testing.ts

@@ -4,7 +4,7 @@
  * Helper functions for testing host routing.
  */
 
-import { matchPattern } from './pattern-matcher.js';
+import { matchPattern } from "./pattern-matcher.js";
 
 export interface CreateTestRequestOptions {
   host: string;
@@ -29,8 +29,8 @@ export interface CreateTestRequestOptions {
 export function createTestRequest(options: CreateTestRequestOptions): Request {
   const {
     host,
-    path = '/',
-    method = 'GET',
+    path = "/",
+    method = "GET",
     cookies = {},
     headers = {},
   } = options;
@@ -42,8 +42,8 @@ export function createTestRequest(options: CreateTestRequestOptions): Request {
   if (Object.keys(cookies).length > 0) {
     const cookieString = Object.entries(cookies)
       .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-      .join('; ');
-    requestHeaders.set('cookie', cookieString);
+      .join("; ");
+    requestHeaders.set("cookie", cookieString);
   }
 
   return new Request(url, {
@@ -63,11 +63,11 @@ export function createTestRequest(options: CreateTestRequestOptions): Request {
  */
 export function testPattern(
   pattern: string | string[],
-  hostname: string
+  hostname: string,
 ): boolean {
   const patterns = Array.isArray(pattern) ? pattern : [pattern];
-  const parts = hostname.split('.');
-  const pathname = '/';
+  const parts = hostname.split(".");
+  const pathname = "/";
 
   for (const p of patterns) {
     if (matchPattern(p, hostname, pathname, parts)) {