Route /cdn-cgi/mf/scheduled to mounts based on host, closes #163

Author: mrbbot

packages/core/src/index.ts

@@ -991,6 +991,18 @@ export class MiniflareCore<
     return this.#mounts!.get(name)!;
   }
 
+  #matchMount(url: URL): MiniflareCore<Plugins> | undefined {
+    if (this.#mounts?.size) {
+      const mountMatch = this.#router!.match(url);
+      const name = this.#instances!.CorePlugin.name;
+      // If there was a match, and it isn't the current (parent) worker,
+      // forward the request to the matching mount instead
+      if (mountMatch !== null && mountMatch !== name) {
+        return this.#mounts.get(mountMatch);
+      }
+    }
+  }
+
   async dispatchFetch<WaitUntil extends any[] = unknown[]>(
     input: RequestInfo,
     init?: RequestInit
@@ -1003,16 +1015,8 @@ export class MiniflareCore<
     const url = new URL(request.url);
 
     // Forward to matching mount if any
-    if (this.#mounts?.size) {
-      const mountMatch = this.#router!.match(url);
-      const name = this.#instances!.CorePlugin.name;
-      // If there was a match, and it isn't the current (parent) worker,
-      // forward the request to the matching mount instead
-      if (mountMatch !== null && mountMatch !== name) {
-        const mount = this.#mounts.get(mountMatch);
-        if (mount) return mount.dispatchFetch(request);
-      }
-    }
+    const mount = this.#matchMount(url);
+    if (mount) return mount.dispatchFetch(request);
 
     // If upstream set, and the request URL doesn't begin with it, rewrite it
     // so fetching the incoming request gets a response from the upstream
@@ -1065,9 +1069,19 @@ export class MiniflareCore<
 
   async dispatchScheduled<WaitUntil extends any[] = unknown[]>(
     scheduledTime?: number,
-    cron?: string
+    cron?: string,
+    url?: string | URL
   ): Promise<WaitUntil> {
     await this.#initPromise;
+
+    // Forward to matching mount if any (this is primarily intended for the
+    // "/cdn-cgi/mf/scheduled" route)
+    if (url !== undefined) {
+      if (typeof url === "string") url = new URL(url);
+      const mount = this.#matchMount(url);
+      if (mount) return mount.dispatchScheduled(scheduledTime, cron);
+    }
+
     const globalScope = this.#globalScope;
     // Each fetch gets its own context (e.g. 50 subrequests).
     // Start a new pipeline too.

packages/core/test/index.mounts.spec.ts

@@ -480,6 +480,40 @@ test("MiniflareCore: uses original protocol and host when matching mount routes"
   t.is(body, "https://example.com/a:custom.mf");
 });
 
+test("MiniflareCore: dispatches scheduled event to mount", async (t) => {
+  const mf = useMiniflare(
+    {},
+    {
+      modules: true,
+      script: `export default {
+        scheduled(controller, env, ctx) {
+          ctx.waitUntil("parent");
+          ctx.waitUntil(controller.scheduledTime);
+          ctx.waitUntil(controller.cron);
+        }
+      }`,
+      mounts: {
+        a: {
+          routes: ["https://test.mf/*"],
+          script: `addEventListener("scheduled", (event) => {
+            event.waitUntil("mount");
+            event.waitUntil(event.scheduledTime);
+            event.waitUntil(event.cron);
+          })`,
+        },
+      },
+    }
+  );
+  let waitUntil = await mf.dispatchScheduled(1000, "* * * * *");
+  t.deepEqual(waitUntil, ["parent", 1000, "* * * * *"]);
+  waitUntil = await mf.dispatchScheduled(
+    1000,
+    "* * * * *",
+    "https://test.mf/cdn-cgi/mf/scheduled"
+  );
+  t.deepEqual(waitUntil, ["mount", 1000, "* * * * *"]);
+});
+
 // Shared storage persistence tests
 type PersistOptions = Pick<
   MiniflareOptions,

packages/http-server/src/index.ts

@@ -154,7 +154,8 @@ export function createRequestListener<Plugins extends HTTPPluginSignatures>(
         const cron = url.searchParams.get("cron");
         waitUntil = mf.dispatchScheduled(
           time ? parseInt(time) : undefined,
-          cron ?? undefined
+          cron ?? undefined,
+          url
         );
         status = 200;
       } else {

packages/http-server/test/index.spec.ts

@@ -348,6 +348,30 @@ test("createRequestListener: handles scheduled event trigger over http", async (
   t.is(events[2].scheduledTime, 1000);
   t.is(events[2].cron, "* * * * *");
 });
+test("createRequestListener: handles scheduled event triggers over http for mounts", async (t) => {
+  const events: string[] = [];
+  const mf = useMiniflare(
+    { HTTPPlugin, BindingsPlugin },
+    {
+      globals: { events },
+      script: `addEventListener("scheduled", () => events.push("parent"))`,
+      mounts: {
+        a: {
+          routes: ["http://mount.mf/*"],
+          globals: { events },
+          script: `addEventListener("scheduled", () => events.push("child"))`,
+        },
+      },
+    }
+  );
+  const port = await listen(t, http.createServer(createRequestListener(mf)));
+
+  await request(port, "/cdn-cgi/mf/scheduled");
+  t.deepEqual(events, ["parent"]);
+
+  await request(port, "/cdn-cgi/mf/scheduled", { host: "mount.mf" });
+  t.deepEqual(events, ["parent", "child"]);
+});
 test("createRequestListener: displays appropriately-formatted error page", async (t) => {
   const log = new TestLog();
   log.error = (message) =>