@rangojs/router 0.0.0-experimental.bd6e11bc → 0.0.0-experimental.bdaf10aa

package/src/host/pattern-matcher.ts

@@ -12,15 +12,18 @@
  * - `**.example.com` - any depth subdomain
  * - `admin.*` - admin subdomain of any apex
  * - `example.com/admin` - specific domain with path prefix
+ *
+ * Apex vs subdomain is classified purely by dot-part COUNT (apex == exactly 2
+ * parts) — there is no Public Suffix List. A registrable domain under a
+ * multi-label public suffix (example.co.uk, shop.com.au) has 3+ parts and is
+ * therefore treated as a SUBDOMAIN, not an apex: `.`/`*` will NOT match it and
+ * `*.` WILL. If registrable-domain accuracy matters for a host-router consumer,
+ * supply an explicit apex/host hint rather than relying on the part count.
  */
 
 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("/");
   if (slashIndex !== -1) {
     const domain = pattern.slice(0, slashIndex);
@@ -30,9 +33,6 @@ export function normalizePattern(pattern: string): string {
   return pattern;
 }
 
-/**
- * Parse hostname and path from request URL
- */
 export function parseRequest(request: Request): {
   hostname: string;
   pathname: string;
@@ -46,26 +46,14 @@ export function parseRequest(request: Request): {
   return { hostname, pathname, parts };
 }
 
-/**
- * Count subdomain levels (0 for apex, 1+ for subdomains)
- */
 function getSubdomainLevel(parts: string[]): number {
-  // Apex domain has 2 parts (example.com)
-  // Single subdomain has 3 parts (www.example.com)
-  // Multi-level has 4+ parts (a.b.example.com)
   return Math.max(0, parts.length - 2);
 }
 
-/**
- * Check if hostname is an apex domain (no subdomains)
- */
 function isApexDomain(parts: string[]): boolean {
   return parts.length === 2;
 }
 
-/**
- * Match a single pattern against hostname and path
- */
 export function matchPattern(
   pattern: string,
   hostname: string,
@@ -74,19 +62,30 @@ export function matchPattern(
 ): boolean {
   const normalized = normalizePattern(pattern);
 
-  // Check if pattern has path component
   const slashIndex = normalized.indexOf("/");
   const hasPath = slashIndex !== -1;
-  const domainPattern = hasPath ? normalized.slice(0, slashIndex) : normalized;
+  // Hosts are case-insensitive (RFC 3986): lowercase the domain literal and the
+  // request host once so matching folds case. Wildcards (*, **, .) are
+  // unaffected by lowercasing. The path is left untouched (paths are
+  // case-sensitive).
+  const domainPattern = (
+    hasPath ? normalized.slice(0, slashIndex) : normalized
+  ).toLowerCase();
   const pathPattern = hasPath ? normalized.slice(slashIndex) : null;
 
-  // First match domain
-  const domainMatch = matchDomainPattern(domainPattern, hostname, parts);
+  const lowerHostname = hostname.toLowerCase();
+  const lowerParts =
+    lowerHostname === hostname ? parts : lowerHostname.split(".");
+
+  const domainMatch = matchDomainPattern(
+    domainPattern,
+    lowerHostname,
+    lowerParts,
+  );
   if (!domainMatch) {
     return false;
   }
 
-  // Then match path (prefix match)
   if (pathPattern) {
     return pathname === pathPattern || pathname.startsWith(pathPattern + "/");
   }
@@ -94,81 +93,62 @@ export function matchPattern(
   return true;
 }
 
-/**
- * Match domain pattern against hostname
- */
 function matchDomainPattern(
   pattern: string,
   hostname: string,
   parts: string[],
 ): boolean {
-  // Exact match
   if (pattern === hostname) {
     return true;
   }
 
-  // `.` or `*` - any apex domain
   if (pattern === "." || pattern === "*") {
     return isApexDomain(parts);
   }
 
-  // `**` - any domain (apex + all subdomains)
   if (pattern === "**") {
     return true;
   }
 
-  // `*.` - any single-level subdomain
   if (pattern === "*.") {
     return getSubdomainLevel(parts) === 1;
   }
 
-  // `**.` - any multi-level subdomain (2+ levels)
   if (pattern === "**.") {
     return getSubdomainLevel(parts) >= 2;
   }
 
-  // `*.tld` - any apex domain with specific TLD (e.g., *.com)
   if (pattern.startsWith("*.") && !pattern.includes(".", 2)) {
     const tld = pattern.slice(2);
     return isApexDomain(parts) && hostname.endsWith("." + tld);
   }
 
-  // `*.example.com` - single subdomain of specific domain
   if (pattern.startsWith("*.")) {
     const baseDomain = pattern.slice(2);
     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(".");
       return parts.length === patternParts.length + 1;
     }
     return false;
   }
 
-  // `**.example.com` - any depth subdomain of specific domain
   if (pattern.startsWith("**.")) {
     const baseDomain = pattern.slice(3);
     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;
     }
     return false;
   }
 
-  // `subdomain.*` - specific subdomain of any apex domain
-  // e.g., admin.* matches admin.example.com, admin.google.com
   if (pattern.endsWith(".*")) {
     const subdomain = pattern.slice(0, -2);
-    // Must be single-level subdomain (3 parts total)
     if (parts.length === 3 && parts[0] === subdomain) {
       return true;
     }
     return false;
   }
 
-  // `subdomain.**` - specific subdomain of any domain (including multi-level)
-  // e.g., admin.** matches admin.example.com, admin.sub.example.com
   if (pattern.endsWith(".**")) {
     const subdomain = pattern.slice(0, -3);
     if (parts.length >= 3 && parts[0] === subdomain) {
@@ -177,11 +157,8 @@ function matchDomainPattern(
     return false;
   }
 
-  // `subdomain.` - specific subdomain of any apex domain (no wildcard)
-  // e.g., admin. matches admin.example.com, admin.google.com
   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) {
       return true;
     }
@@ -191,9 +168,6 @@ function matchDomainPattern(
   return false;
 }
 
-/**
- * Validate pattern format
- */
 export function validatePattern(pattern: string): void {
   if (!pattern || typeof pattern !== "string") {
     throw new InvalidPatternError(
@@ -203,12 +177,9 @@ export function validatePattern(pattern: string): void {
     );
   }
 
-  // Check for invalid characters (spaces, etc.)
   if (/\s/.test(pattern)) {
     throw new InvalidPatternError(pattern, "contains whitespace", {
       cause: { pattern },
     });
   }
-
-  // Additional validation can be added here
 }

package/src/host/router.ts

@@ -32,27 +32,16 @@ import {
   InvalidHandlerError,
 } from "./errors.js";
 
-/**
- * Registry entry for a host router instance.
- * Stores references to the live routes array and fallback, so the discovery
- * plugin can iterate handlers registered after createHostRouter() returns.
- */
 export interface HostRouterRegistryEntry {
   routes: RouteEntry[];
   fallback: RouteEntry | null;
 }
 
-/**
- * Global registry for host routers (parallel to RouterRegistry for RSC routers).
- * 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();
 
 let hostRouterAutoId = 0;
 
-/** Whether a value is thenable (a Promise or Promise-like). */
 function isThenable(value: unknown): value is PromiseLike<unknown> {
   return (
     value !== null &&
@@ -61,12 +50,6 @@ function isThenable(value: unknown): value is PromiseLike<unknown> {
   );
 }
 
-/**
- * Whether a resolved value looks like a module namespace from a lazy import -
- * an object with a `default` export that is a function (a Handler) or a host
- * router (an object with `match`). Used to detect a `.map(() => import(...))`
- * misuse: an inline handler should return a Response, not a module.
- */
 function looksLikeLazyModule(value: unknown): boolean {
   if (value === null || typeof value !== "object" || !("default" in value)) {
     return false;
@@ -80,9 +63,6 @@ function looksLikeLazyModule(value: unknown): boolean {
   );
 }
 
-/**
- * Create a host router
- */
 export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
   const routes: RouteEntry[] = [];
   const globalMiddleware: Middleware[] = [];
@@ -96,9 +76,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     }
   }
 
-  /**
-   * Create a route builder for chaining
-   */
   function createRouteBuilder(
     patterns: string[],
     isFallback = false,
@@ -147,9 +124,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     };
   }
 
-  /**
-   * Find matching route for hostname and path
-   */
   function findMatchingRoute(
     hostname: string,
     pathname: string,
@@ -168,9 +142,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     return null;
   }
 
-  /**
-   * Execute middleware chain
-   */
   async function executeMiddleware(
     middleware: Middleware[],
     request: Request,
@@ -189,8 +160,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         return finalHandler();
       }
 
-      // 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) {
@@ -208,15 +177,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     return next();
   }
 
-  /**
-   * Execute a route entry, branching on its declared kind:
-   *   - "lazy": await the loader, then delegate to the default export
-   *     (a nested HostRouter via `.match`, or a request Handler directly).
-   *   - "handler": call the inline handler with the request. A `.map()` handler
-   *     that resolves to a module namespace (`{ default }`) is almost certainly
-   *     a misused lazy import, so it is rejected with a clear message rather
-   *     than silently returning a module object as the response.
-   */
   async function executeHandler(
     entry: RouteEntry,
     request: Request,
@@ -236,8 +196,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
 
     const result = (handler as Handler)(request, input);
 
-    // Inline handlers may be async; await to obtain the Response and to run the
-    // misuse guard below.
     if (isThenable(result)) {
       const awaited = await result;
       if (looksLikeLazyModule(awaited)) {
@@ -251,10 +209,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     return result;
   }
 
-  /**
-   * Resolve a `.lazy()` mount: invoke the zero-arg loader, then dispatch to the
-   * module's default export.
-   */
   async function executeLazyMount(
     loader: LazyHandler,
     request: Request,
@@ -266,7 +220,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
       const defaultExport = (module as { default: Handler | HostRouter })
         .default;
 
-      // Default export is a nested host router
       if (
         typeof defaultExport === "object" &&
         defaultExport !== null &&
@@ -275,7 +228,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         return (defaultExport as HostRouter).match(request, input);
       }
 
-      // Otherwise treat the default export as a request handler
       return (defaultExport as Handler)(request, input);
     }
 
@@ -288,14 +240,10 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
     });
   }
 
-  /**
-   * Router instance
-   */
   const router: HostRouter = {
     host(patterns: HostPattern): HostRouteBuilder {
       const patternsArray = Array.isArray(patterns) ? patterns : [patterns];
 
-      // Validate and normalize patterns
       const normalized = patternsArray.map((p) => {
         validatePattern(p);
         return normalizePattern(p);
@@ -314,9 +262,8 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
       return createRouteBuilder([], true);
     },
 
-    test(hostname: string): HostMatchResult | null {
+    test(hostname: string, pathname = "/"): HostMatchResult | null {
       const parts = hostname.split(".");
-      const pathname = "/";
 
       for (const route of routes) {
         for (const pattern of route.patterns) {
@@ -342,14 +289,11 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
       let effectiveHostname: string;
 
       try {
-        // Handle cookie override (may throw HostRouterError)
         effectiveHostname = handleCookieOverride(request, hostOverride, input);
       } catch (error) {
-        // If it's a HostRouterError from cookie override
         if (error instanceof HostRouterError) {
           log(`Cookie override error: ${error.message}`);
 
-          // If fallback exists, use it
           if (fallbackRoute) {
             const fallbackInput = { ...input, error };
             const allMiddleware = [
@@ -365,7 +309,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
             );
           }
 
-          // Otherwise return error response with cookie deletion
           if (hostOverride) {
             return createCookieErrorResponse(
               hostOverride.cookieName,
@@ -374,7 +317,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
           }
         }
 
-        // Re-throw non-HostRouterErrors
         throw error;
       }
 
@@ -384,7 +326,6 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         log(`Cookie override: ${effectiveHostname}`);
       }
 
-      // Find matching route
       const matchedRoute = findMatchingRoute(effectiveHostname, pathname);
 
       if (!matchedRoute) {
@@ -397,19 +338,14 @@ export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
         });
       }
 
-      // Combine global and route-specific middleware
       const allMiddleware = [...globalMiddleware, ...matchedRoute.middleware];
 
-      // Execute middleware chain and handler
       return executeMiddleware(allMiddleware, request, input, () =>
         executeHandler(matchedRoute, request, input),
       );
     },
   };
 
-  // Register in the global HostRouterRegistry for build-time discovery.
-  // The routes array and fallbackRoute ref are live - they reflect routes
-  // added via .host().map()/.lazy() after this point.
   const registryId = `host-router-${hostRouterAutoId++}`;
   HostRouterRegistry.set(registryId, {
     get routes() {

package/src/host/testing.ts

@@ -4,7 +4,7 @@
  * Helper functions for testing host routing.
  */
 
-import { matchPattern } from "./pattern-matcher.js";
+import { matchPattern, parseRequest } from "./pattern-matcher.js";
 
 export interface CreateTestRequestOptions {
   host: string;
@@ -14,18 +14,6 @@ export interface CreateTestRequestOptions {
   headers?: Record<string, string>;
 }
 
-/**
- * Create a test request with specific host and cookies
- *
- * @example
- * ```ts
- * const request = createTestRequest({
- *   host: 'admin.example.com',
- *   path: '/dashboard',
- *   cookies: { 'x-requested-host': 'api.example.com' }
- * });
- * ```
- */
 export function createTestRequest(options: CreateTestRequestOptions): Request {
   const {
     host,
@@ -38,7 +26,6 @@ export function createTestRequest(options: CreateTestRequestOptions): Request {
   const url = `http://${host}${path}`;
   const requestHeaders = new Headers(headers);
 
-  // Add cookies if provided
   if (Object.keys(cookies).length > 0) {
     const cookieString = Object.entries(cookies)
       .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
@@ -52,28 +39,54 @@ export function createTestRequest(options: CreateTestRequestOptions): Request {
   });
 }
 
+function matchPatterns(
+  pattern: string | string[],
+  hostname: string,
+  pathname: string,
+  parts: string[],
+): boolean {
+  const patterns = Array.isArray(pattern) ? pattern : [pattern];
+  return patterns.some((p) => matchPattern(p, hostname, pathname, parts));
+}
+
 /**
- * Test if a pattern matches a hostname
+ * Test if a pattern matches a hostname (and, for path-based patterns, a pathname).
+ *
+ * `pathname` defaults to `"/"`, so a host-only pattern works with two args. Pass
+ * the third arg to test a path-based pattern (`**.workers.dev/admin`,
+ * `localhost/shop`) — without it those patterns can never match.
  *
  * @example
  * ```ts
- * expect(testPattern('admin.*', 'admin.example.com')).toBe(true);
- * expect(testPattern(['*', 'www.*'], 'example.com')).toBe(true);
+ * expect(testPattern("admin.*", "admin.example.com")).toBe(true);
+ * expect(testPattern(["*", "www.*"], "example.com")).toBe(true);
+ * expect(testPattern("**.workers.dev/admin", "foo.workers.dev", "/admin")).toBe(true);
  * ```
  */
 export function testPattern(
   pattern: string | string[],
   hostname: string,
+  pathname: string = "/",
 ): boolean {
-  const patterns = Array.isArray(pattern) ? pattern : [pattern];
-  const parts = hostname.split(".");
-  const pathname = "/";
-
-  for (const p of patterns) {
-    if (matchPattern(p, hostname, pathname, parts)) {
-      return true;
-    }
-  }
+  return matchPatterns(pattern, hostname, pathname, hostname.split("."));
+}
 
-  return false;
+/**
+ * Test if a pattern matches a `Request` — the hostname AND pathname are taken
+ * from the request URL (via the same `parseRequest` the host router uses), so a
+ * path-based pattern is tested against a real request without splitting the URL
+ * by hand.
+ *
+ * @example
+ * ```ts
+ * const req = new Request("https://foo.workers.dev/admin");
+ * expect(matchesHost("**.workers.dev/admin", req)).toBe(true);
+ * ```
+ */
+export function matchesHost(
+  pattern: string | string[],
+  request: Request,
+): boolean {
+  const { hostname, pathname, parts } = parseRequest(request);
+  return matchPatterns(pattern, hostname, pathname, parts);
 }

package/src/host/types.ts

@@ -110,9 +110,13 @@ export interface HostRouter {
   fallback(): HostRouteBuilder;
 
   /**
-   * Test which handler would match a hostname
+   * Test which handler would match a hostname (and optional pathname).
+   *
+   * `pathname` defaults to `"/"`. Pass it to probe path-prefixed patterns
+   * such as `host(["example.com/admin"])`, which only match when the request
+   * path is under the prefix.
    */
-  test(hostname: string): HostMatchResult | null;
+  test(hostname: string, pathname?: string): HostMatchResult | null;
 }
 
 /**

package/src/href-client.ts

@@ -16,7 +16,6 @@
 
 import type { GetRegisteredRoutes } from "./types.js";
 import type { JsonSerialize } from "./serialize.js";
-import type { ResponseEnvelope } from "./urls.js";
 
 /**
  * Parse constraint values into a union type for paths
@@ -163,16 +162,16 @@ type ResponsePayloadForKey<
     }[keyof TRoutes];
 
 /**
- * Public response type for a route, keyed by pattern or concrete path. The
- * payload is wrapped in `JsonSerialize` so it describes the JSON **wire** value a
- * consumer receives from `fetch().then(r => r.json())`, not the handler's raw
- * return type — e.g. a handler returning `{ createdAt: Date }` resolves here to
- * `ResponseEnvelope<{ createdAt: string }>`.
+ * Public response type for a route, keyed by pattern or concrete path. JSON
+ * response routes send the handler's return value verbatim (bare), so the
+ * payload is wrapped only in `JsonSerialize` to describe the JSON **wire** value
+ * a consumer receives from `fetch().then(r => r.json())` — e.g. a handler
+ * returning `{ createdAt: Date }` resolves here to `{ createdAt: string }`.
  */
 export type PathResponse<
   TPath extends string,
   TRoutes = GetRegisteredRoutes,
-> = ResponseEnvelope<JsonSerialize<ResponsePayloadFor<TPath, TRoutes>>>;
+> = JsonSerialize<ResponsePayloadFor<TPath, TRoutes>>;
 
 /**
  * Strip trailing slash from a path (e.g., "/blog/" -> "/blog" | "/blog/")
@@ -256,7 +255,7 @@ declare global {
      *
      * The payload is the JSON **wire** shape (via `Rango.JsonSerialize`), not the
      * handler's raw return — a handler returning `{ createdAt: Date }` resolves
-     * here to `ResponseEnvelope<{ createdAt: string }>`, matching what
+     * here to `{ createdAt: string }` (bare, no envelope), matching what
      * `fetch().then(r => r.json())` actually yields.
      *
      * Only resolves once `Rango.RegisteredRoutes` carries response metadata (the
@@ -299,13 +298,9 @@ declare global {
  */
 export function href<T extends ValidPaths>(path: T, mount?: string): string {
   if (mount && mount !== "/") {
-    // Strip trailing slash from mount to avoid double-slash when joining
     const normalizedMount = mount.endsWith("/") ? mount.slice(0, -1) : mount;
     return normalizedMount + path;
   }
-  // ValidPaths is built from template literals so T does extend string at
-  // runtime, but the inference can fail past a certain route-union complexity
-  // and TypeScript reports T as not assignable to string.
   return path as string;
 }