Add example tagged route, WICG/service-worker-static-routing-api#17

src/fetch/events.ts

@@ -30,6 +30,7 @@ export interface DurableFetchEventData extends DurableEventData {
 export interface FetchEvent extends Omit<DurableFetchEventData, "request">, FetchRespondWith {
     request: Request;
     waitUntil(promise: Promise<void | unknown>): void;
+    tag?: string;
 }
 
 function isFetchEvent(event: unknown): event is FetchEvent {

src/tests/worker/service-worker/worker.ts

@@ -20,8 +20,10 @@ self.addEventListener("install", event => {
                 ]
             },
             source: [
-                "network",
-                "fetch-event"
+                {
+                    type: "fetch-event",
+                    tag: "fetch-any"
+                }
             ]
         }
     ])
@@ -34,7 +36,7 @@ self.addEventListener("activate", event => {
 })
 
 self.addEventListener("fetch", event => {
-    console.log("In fetch handler!");
+    console.log("In fetch handler!", event.tag || "untagged");
     event.respondWith(onFetchEvent(event));
 });
 

src/worker/service-worker/execute-fetch.ts

@@ -6,7 +6,11 @@ import type {FetchResponseMessage} from "./dispatch";
 import {DurableServiceWorkerRegistration, serviceWorker} from "./container";
 import {getOrigin} from "../../listen/config";
 
-export interface FetchInit extends RequestInit {
+export interface ServiceWorkerFetchOptions {
+    tag?: string;
+}
+
+export interface FetchInit extends RequestInit, ServiceWorkerFetchOptions {
     duplex?: "half";
 }
 
@@ -42,18 +46,20 @@ export function createServiceWorkerFetch(registration: DurableServiceWorkerRegis
         }
         return executeServiceWorkerFetch(
             registration,
-            request
+            request,
+            init
         );
     }
 }
 
-export async function executeServiceWorkerFetch(registration: DurableServiceWorkerRegistration, request: Request | DurableRequestData) {
+export async function executeServiceWorkerFetch(registration: DurableServiceWorkerRegistration, request: Request | DurableRequestData, options?: ServiceWorkerFetchOptions) {
     return executeServiceWorkerFetchEvent(registration, {
         type: "fetch",
         request: request instanceof Request ?
             await fromRequest(request) :
             request,
         virtual: true,
+        tag: options?.tag
     });
 }
 
@@ -79,26 +85,6 @@ export async function executeServiceWorkerFetchEvent(registration: DurableServic
         return fromDurableResponse(message.response)
     }
 
-    function createBody(): undefined | BodyInit {
-        const stream = new ReadableStream({
-            async pull(controller) {
-                const message = await next();
-                if (!message) {
-                    return controller.close();
-                }
-                if (message.data) {
-                    controller.enqueue(message.data);
-                }
-            },
-            async cancel() {
-                await iterator.return?.();
-            }
-        });
-        ok<BodyInit>(stream);
-        return stream;
-    }
-
-
     async function next() {
         const { value, done } = await iterator.next();
         if (done) {

src/worker/service-worker/router.ts

@@ -28,18 +28,27 @@ export interface RouterSource {
     behaviorEnum?: RouterSourceBehaviorEnum;
 }
 
+export interface RouterRaceNetworkAndFetchHandlerSource extends RouterSource {
+    type: "race-network-and-fetch-handler";
+    tag?: string;
+}
+
 export interface RouterNetworkSource extends RouterSource {
+    type: "network";
     updatedCacheName?: string;
-    cacheErrorResponse?: boolean
+    cacheErrorResponse?: boolean;
 }
 
 export interface RouterCacheSource extends RouterSource {
+    type: "cache";
     cacheName?: string;
     request?: RequestInfo;
 }
 
 export interface RouterFetchEventSource extends RouterSource {
+    type: "fetch-event";
     id?: string;
+    tag?: string;
 }
 
 export interface RouterURLPatternCondition {
@@ -98,6 +107,7 @@ export type RouterRuleSource =
     | RouterSource
     | RouterCacheSource
     | RouterFetchEventSource
+    | RouterRaceNetworkAndFetchHandlerSource
     | RouterSourceEnum;
 
 export interface RouterRule {
@@ -158,14 +168,14 @@ export function isRouterNotCondition(condition: RouterCondition): condition is R
     return "not" in condition && Boolean(condition.not);
 }
 
-export function isRouterSourceObject(source: RouterRuleSource): source is RouterNetworkSource {
+export function isRouterSourceObject(source: RouterRuleSource): source is RouterSource {
     return (
         typeof source === "object" &&
         "type" in source
     );
 }
 
-export function isRouterSourceType(source: RouterRuleSource, type: RouterSourceEnum) {
+export function isRouterSourceType<T extends RouterSourceEnum>(source: RouterRuleSource, type: T): source is RouterRuleSource & { type: T } | T {
     return (
         source === type ||
         (
@@ -497,11 +507,18 @@ export async function createRouter(serviceWorkers?: DurableServiceWorkerRegistra
             }
         }
 
-        async function serviceWorkerFetch() {
+        async function serviceWorkerFetch(source: RouterSourceEnum | RouterFetchEventSource | RouterRaceNetworkAndFetchHandlerSource) {
             // TODO check if any fetch event handlers added.
             const fetch = fetchers.get(serviceWorker);
             ok(fetch, "Expected to find fetcher for service worker, internal state corrupt");
-            return fetch(clone(), init);
+            let resolvedInit = init;
+            if (typeof source === "object" && source.tag) {
+                resolvedInit = {
+                    ...init,
+                    tag: source.tag
+                }
+            }
+            return fetch(clone(), resolvedInit);
         }
 
         async function source(ruleSource: RouterRuleSource): Promise<Response | undefined> {
@@ -518,12 +535,12 @@ export async function createRouter(serviceWorkers?: DurableServiceWorkerRegistra
                 return response;
             }
             if (isRouterSourceType(ruleSource, "fetch-event")) {
-                return serviceWorkerFetch();
+                return serviceWorkerFetch(ruleSource);
             }
             if (isRouterSourceType(ruleSource, "race-network-and-fetch-handler")) {
                 return Promise.race([
                     source("network"),
-                    serviceWorkerFetch()
+                    serviceWorkerFetch(ruleSource)
                 ]);
             }
             if (isRouterSourceType(ruleSource, "cache")) {

src/worker/worker.ts

@@ -17,7 +17,7 @@ async function getDefaultNodeWorker(url: string, options: WorkerOptions): Promis
         worker.stderr.pipe(process.stderr);
     }
     return worker;
-};
+}
 
 export function getWorkerURLForImportURL(relative: string, url: string | URL) {
     const instance = new URL(url, getOrigin());