Customisable mount routing, inspired by multiflare, thanks @dan-lee

- Mounts now get their routes from the standard
  or `[miniflare]` `route`/`routes`
  `wrangler.toml` keys
- `convertNodeRequest` no longer takes an
  upstream, it just uses the `Host` header
- `convertNodeRequest` will now give `https`
  requests `https` URLs
- `Miniflare#dispatchFetch` will now rewrite the
  request URL/`Host` header to match the upstream
- Upstream URLs are now validated on init

Author: mrbbot

packages/core/src/error.ts

@@ -0,0 +1,10 @@
+import { MiniflareError } from "@miniflare/shared";
+
+export type MiniflareCoreErrorCode =
+  | "ERR_NO_SCRIPT" // No script specified but one was required
+  | "ERR_MOUNT_NO_NAME" // Attempted to mount a worker with an empty string name
+  | "ERR_MOUNT_NESTED" // Attempted to recursively mount workers
+  | "ERR_MOUNT" // Error whilst mounting worker
+  | "ERR_INVALID_UPSTREAM"; // Invalid upstream URL
+
+export class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {}

packages/core/src/index.ts

@@ -7,7 +7,6 @@ import {
   Compatibility,
   Context,
   Log,
-  MiniflareError,
   Mutex,
   Options,
   PluginContext,
@@ -29,8 +28,10 @@ import {
 import type { Watcher } from "@miniflare/watcher";
 import { dequal } from "dequal/lite";
 import { dim } from "kleur/colors";
+import { MiniflareCoreError } from "./error";
 import { formatSize, pathsToString } from "./helpers";
 import { BindingsPlugin, CorePlugin, _populateBuildConfig } from "./plugins";
+import { Router } from "./router";
 import {
   Request,
   RequestInfo,
@@ -49,6 +50,9 @@ import { PluginStorageFactory } from "./storage";
 
 export * from "./plugins";
 export * from "./standards";
+
+export * from "./error";
+export * from "./router";
 export * from "./storage";
 
 /** @internal */
@@ -90,14 +94,6 @@ export type MiniflareCoreOptions<Plugins extends CorePluginSignatures> = Omit<
   mounts?: Record<string, string | Omit<Options<Plugins>, "mounts">>;
 };
 
-export type MiniflareCoreErrorCode =
-  | "ERR_NO_SCRIPT" // No script specified but one was required
-  | "ERR_MOUNT_NO_NAME" // Attempted to mount a worker with an empty string name
-  | "ERR_MOUNT_NESTED" // Attempted to recursively mount workers
-  | "ERR_MOUNT"; // Error whilst mounting worker
-
-export class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {}
-
 function getPluginEntries<Plugins extends PluginSignatures>(
   plugins: Plugins
 ): PluginEntries<Plugins> {
@@ -244,6 +240,7 @@ export class MiniflareCore<
   #previousRootPath?: string;
   #instances?: PluginInstances<Plugins>;
   #mounts?: Map<string, MiniflareCore<Plugins>>;
+  #router?: Router;
 
   #wranglerConfigPath?: string;
   #watching?: boolean;
@@ -512,12 +509,15 @@ export class MiniflareCore<
             scriptRunForModuleExports: false,
           };
           mount = new MiniflareCore(this.#originalPlugins, ctx, mountOptions);
-          mount.addEventListener("reload", (event) => {
+          mount.addEventListener("reload", async (event) => {
             // Reload parent (us) whenever mounted child reloads, ignoring the
             // initial reload. This ensures the page is reloaded when live
             // reloading, and also that we're using up-to-date Durable Object
             // classes from mounts.
-            if (!event.initial) this.#reload();
+            if (!event.initial) {
+              await this.#updateRouter();
+              await this.#reload();
+            }
           });
           try {
             await mount.getPlugins();
@@ -542,6 +542,26 @@ export class MiniflareCore<
         }
       }
     }
+    await this.#updateRouter();
+  }
+
+  async #updateRouter(): Promise<void> {
+    const allRoutes = new Map<string, string[]>();
+    for (const [name, mount] of this.#mounts!) {
+      const routes = (await mount.getPlugins()).CorePlugin.routes;
+      if (routes) allRoutes.set(name, routes);
+    }
+    this.#router ??= new Router();
+    this.#router.update(allRoutes);
+    if (this.#mounts!.size) {
+      this.#ctx.log.debug(
+        `Mount Routes:${this.#router.routes.length === 0 ? " <none>" : ""}`
+      );
+      for (let i = 0; i < this.#router.routes.length; i++) {
+        const route = this.#router.routes[i];
+        this.#ctx.log.debug(`${i + 1}. ${route.route} => ${route.target}`);
+      }
+    }
   }
 
   async #reload(): Promise<void> {
@@ -849,29 +869,38 @@ export class MiniflareCore<
     // noinspection SuspiciousTypeOfGuard
     let request =
       input instanceof Request && !init ? input : new Request(input, init);
+    const url = new URL(request.url);
 
     // Forward to matching mount if any
     if (this.#mounts?.size) {
-      const url = new URL(request.url);
-      for (const [name, mount] of this.#mounts) {
-        const prefix = `/${name}`;
-        if (url.pathname === prefix || url.pathname.startsWith(`${prefix}/`)) {
-          // Trim mount prefix from request URL
-          url.pathname = url.pathname.slice(prefix.length);
-          return mount.dispatchFetch(new Request(url, request));
-        }
+      const mountMatch = this.#router!.match(url);
+      if (mountMatch !== null) {
+        const mount = this.#mounts.get(mountMatch);
+        if (mount) return mount.dispatchFetch(request);
       }
     }
 
-    const corePlugin = this.#instances!.CorePlugin;
-    const globalScope = this.#globalScope;
+    // If upstream set, and the request URL doesn't begin with it, rewrite it
+    const { upstreamURL } = this.#instances!.CorePlugin;
+    if (upstreamURL && !url.toString().startsWith(upstreamURL.toString())) {
+      let path = url.pathname + url.search;
+      // Remove leading slash so we resolve relative to upstream's path
+      if (path.startsWith("/")) path = path.substring(1);
+      const newURL = new URL(path, upstreamURL);
+      request = new Request(newURL, request);
+      // Make sure Host header is correct
+      request.headers.set("host", upstreamURL.host);
+    }
 
+    // Parse form data files as strings if the compatibility flag isn't set
     if (!this.#compat!.isEnabled("formdata_parser_supports_files")) {
       request = withStringFormDataFiles(request);
     }
+
+    const globalScope = this.#globalScope;
     return globalScope![kDispatchFetch]<WaitUntil>(
       withImmutableHeaders(request),
-      !!corePlugin.upstream
+      !!upstreamURL // only proxy if upstream URL set
     );
   }
 

packages/core/src/plugins/core.ts

@@ -34,6 +34,7 @@ import {
   globsToMatcher,
 } from "@miniflare/shared";
 import { File, FormData, Headers } from "undici";
+import { MiniflareCoreError } from "../error";
 import {
   DOMException,
   FetchEvent,
@@ -98,6 +99,7 @@ export interface CoreOptions {
   updateCheck?: boolean;
   // Replaced in MiniflareCoreOptions with something plugins-specific
   mounts?: Record<string, string | CoreOptions | BindingsOptions>;
+  routes?: string[];
 }
 
 function mapMountEntries([name, pathEnv]: [string, string]): [
@@ -280,8 +282,22 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
   })
   mounts?: Record<string, string | CoreOptions | BindingsOptions>;
 
+  @Option({
+    type: OptionType.NONE,
+    fromWrangler: ({ route, routes, miniflare }) => {
+      const result: string[] = [];
+      if (route) result.push(route);
+      if (routes) result.push(...routes);
+      if (miniflare?.route) result.push(miniflare.route);
+      if (miniflare?.routes) result.push(...miniflare.routes);
+      return result.length ? result : undefined;
+    },
+  })
+  routes?: string[];
+
   readonly processedModuleRules: ProcessedModuleRule[] = [];
 
+  readonly upstreamURL?: URL;
   readonly #globals: Context;
 
   constructor(ctx: PluginContext, options?: CoreOptions) {
@@ -299,6 +315,18 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
       CompatResponse = proxyStringFormDataFiles(CompatResponse);
     }
 
+    // Try to parse upstream URL if set
+    try {
+      this.upstreamURL =
+        this.upstream === undefined ? undefined : new URL(this.upstream);
+    } catch (e: any) {
+      // Throw with a more helpful error message
+      throw new MiniflareCoreError(
+        "ERR_INVALID_UPSTREAM",
+        `Invalid upstream URL: \"${this.upstream}\". Make sure you've included the protocol.`
+      );
+    }
+
     // Build globals object
     // noinspection JSDeprecatedSymbols
     this.#globals = {

packages/core/src/router.ts

@@ -0,0 +1,138 @@
+import { URL } from "url";
+import { MiniflareError } from "@miniflare/shared";
+
+export type RouterErrorCode = "ERR_QUERY_STRING" | "ERR_INFIX_WILDCARD";
+
+export class RouterError extends MiniflareError<RouterErrorCode> {}
+
+export interface Route {
+  target: string;
+  route: string;
+
+  protocol?: string;
+  allowHostnamePrefix: boolean;
+  hostname: string;
+  path: string;
+  allowPathSuffix: boolean;
+}
+
+const A_MORE_SPECIFIC = -1;
+const B_MORE_SPECIFIC = 1;
+
+export class Router {
+  routes: Route[] = [];
+
+  update(allRoutes: Map<string, string[]>): void {
+    const newRoutes: Route[] = [];
+    for (const [target, routes] of allRoutes) {
+      for (const route of routes) {
+        const hasProtocol = /^[a-z0-9+\-.]+:\/\//i.test(route);
+
+        let urlInput = route;
+        // If route is missing a protocol, give it one so it parses
+        if (!hasProtocol) urlInput = `https://${urlInput}`;
+        const url = new URL(urlInput);
+
+        const protocol = hasProtocol ? url.protocol : undefined;
+
+        const allowHostnamePrefix = url.hostname.startsWith("*");
+        if (allowHostnamePrefix) {
+          url.hostname = url.hostname.substring(1);
+        }
+
+        const allowPathSuffix = url.pathname.endsWith("*");
+        if (allowPathSuffix) {
+          url.pathname = url.pathname.substring(0, url.pathname.length - 1);
+        }
+
+        if (url.search) {
+          throw new RouterError(
+            "ERR_QUERY_STRING",
+            `Route "${route}" for "${target}" contains a query string. This is not allowed.`
+          );
+        }
+        if (url.toString().includes("*")) {
+          throw new RouterError(
+            "ERR_INFIX_WILDCARD",
+            `Route "${route}" for "${target}" contains an infix wildcard. This is not allowed.`
+          );
+        }
+
+        newRoutes.push({
+          target,
+          route,
+
+          protocol,
+          allowHostnamePrefix,
+          hostname: url.hostname,
+          path: url.pathname,
+          allowPathSuffix,
+        });
+      }
+    }
+
+    // Sort with highest specificity first
+    newRoutes.sort((a, b) => {
+      // 1. If one route matches on protocol, it is more specific
+      const aHasProtocol = a.protocol !== undefined;
+      const bHasProtocol = b.protocol !== undefined;
+      if (aHasProtocol && !bHasProtocol) return A_MORE_SPECIFIC;
+      if (!aHasProtocol && bHasProtocol) return B_MORE_SPECIFIC;
+
+      // 2. If one route allows hostname prefixes, it is less specific
+      if (!a.allowHostnamePrefix && b.allowHostnamePrefix)
+        return A_MORE_SPECIFIC;
+      if (a.allowHostnamePrefix && !b.allowHostnamePrefix)
+        return B_MORE_SPECIFIC;
+
+      // 3. If one route allows path suffixes, it is less specific
+      if (!a.allowPathSuffix && b.allowPathSuffix) return A_MORE_SPECIFIC;
+      if (a.allowPathSuffix && !b.allowPathSuffix) return B_MORE_SPECIFIC;
+
+      // 4. If one route has more path segments, it is more specific
+      const aPathSegments = a.path.split("/");
+      const bPathSegments = b.path.split("/");
+
+      // Specifically handle known route specificity issue here:
+      // https://developers.cloudflare.com/workers/platform/known-issues#route-specificity
+      const aLastSegmentEmpty = aPathSegments[aPathSegments.length - 1] === "";
+      const bLastSegmentEmpty = bPathSegments[bPathSegments.length - 1] === "";
+      if (aLastSegmentEmpty && !bLastSegmentEmpty) return B_MORE_SPECIFIC;
+      if (!aLastSegmentEmpty && bLastSegmentEmpty) return A_MORE_SPECIFIC;
+
+      if (aPathSegments.length !== bPathSegments.length)
+        return bPathSegments.length - aPathSegments.length;
+
+      // 5. If one route has a longer path, it is more specific
+      if (a.path.length !== b.path.length) return b.path.length - a.path.length;
+
+      // 6. Finally, if one route has a longer hostname, it is more specific
+      return b.hostname.length - a.hostname.length;
+    });
+
+    this.routes = newRoutes;
+  }
+
+  match(url: URL): string | null {
+    for (const route of this.routes) {
+      if (route.protocol && route.protocol !== url.protocol) continue;
+
+      if (route.allowHostnamePrefix) {
+        if (!url.hostname.endsWith(route.hostname)) continue;
+      } else {
+        if (url.hostname !== route.hostname) continue;
+      }
+
+      const path = url.pathname + url.search;
+      if (route.allowPathSuffix) {
+        if (!path.startsWith(route.path)) continue;
+      } else {
+        if (path !== route.path) continue;
+      }
+
+      return route.target;
+    }
+
+    return null;
+  }
+}