diff --git a/src/adapters/service-worker/service-worker-entry.ts b/src/adapters/service-worker/service-worker-entry.ts index 5d269a9f..57af0ebe 100644 --- a/src/adapters/service-worker/service-worker-entry.ts +++ b/src/adapters/service-worker/service-worker-entry.ts @@ -89,18 +89,32 @@ self.addEventListener("activate", (event) => { event.waitUntil(runtime.onActivate()); }); -self.addEventListener("fetch", (event) => { - const request = event.request; - event.respondWith( - runtime - .onFetch({ - method: request.method, - url: request.url, - mode: request.mode, - }) - .then((cached) => cached ?? fetch(request)), - ); -}); +// R-6.6. Without the static asset handler there is nothing to answer, and +// no fetch listener means the browser never boots this worker for a fetch. +if (handlers.includes("PWA_STATIC_ASSETS")) { + self.addEventListener("fetch", (event) => { + const request = event.request; + // R-6.6. Decided synchronously: only a GET for a verified static asset of + // this release is answered. Navigations, API calls and cross-origin + // requests are left to the browser untouched. + if ( + request.method !== "GET" || + request.mode === "navigate" || + !runtime.manifestUrls.has(request.url) + ) { + return; + } + event.respondWith( + runtime + .onFetch({ + method: request.method, + url: request.url, + mode: request.mode, + }) + .then((cached) => cached ?? fetch(request)), + ); + }); +} self.addEventListener("message", (event) => { const parsed = parseServiceWorkerMessage(event.data); diff --git a/tests/unit/service-worker-runtime.test.ts b/tests/unit/service-worker-runtime.test.ts index efa3334a..c0de17ce 100644 --- a/tests/unit/service-worker-runtime.test.ts +++ b/tests/unit/service-worker-runtime.test.ts @@ -1330,6 +1330,96 @@ describe("page ↔ worker activation seam", () => { }); }); +/** + * Loads the real worker entry against stubbed worker globals and build-time + * constants, and returns the listeners it registered on `self`. + */ +async function loadWorkerEntry(handlers: readonly string[]) { + const listeners = new Map void>(); + vi.stubGlobal("self", { + addEventListener: (type: string, listener: (event: unknown) => void) => { + listeners.set(type, listener); + }, + registration: { scope: `${ORIGIN}/` }, + clients: { matchAll: async () => [] }, + skipWaiting: async () => {}, + }); + vi.stubGlobal("__CA_SERVICE_WORKER_BUILD_INFO__", identity); + vi.stubGlobal("__CA_SERVICE_WORKER_ASSETS__", { + schemaVersion: 1, + buildId: identity.buildId, + releaseId: identity.releaseId, + setDigest: identity.staticAssetSetDigest, + assets: [ + { + url: "/assets/app-Dq3x8Yk2.js", + sha256: `sha256:${"d".repeat(64)}`, + bytes: 6, + contentType: "text/javascript", + }, + ], + }); + vi.stubGlobal("__CA_SERVICE_WORKER_HANDLERS__", handlers); + vi.stubGlobal("__CA_RUNTIME_CONFIG_URL__", "/runtime-config.json"); + vi.stubGlobal("__CA_RELEASE_MANIFEST_URL__", "/release-manifest.json"); + vi.stubGlobal("caches", { + open: async () => ({ match: async () => new Response("cached") }), + keys: async () => [], + delete: async () => true, + }); + vi.stubGlobal("fetch", async () => new Response("network")); + vi.resetModules(); + // A computed specifier keeps the WebWorker-lib entry out of the DOM-lib + // test type program. + const entry = "../../src/adapters/service-worker/service-worker-entry.ts"; + await import(/* @vite-ignore */ entry); + return listeners; +} + +describe("service worker entry fetch interception (R-6.6)", () => { + function fetchEvent(request: { method: string; url: string; mode: string }) { + return { request, respondWith: vi.fn() }; + } + + it("answers only same-origin GETs for manifest assets", async () => { + try { + const listeners = await loadWorkerEntry(["PWA_STATIC_ASSETS"]); + const onFetch = listeners.get("fetch")!; + const asset = `${ORIGIN}/assets/app-Dq3x8Yk2.js`; + const passthrough = [ + { method: "GET", url: `${ORIGIN}/`, mode: "navigate" }, + { method: "GET", url: asset, mode: "navigate" }, + { method: "POST", url: asset, mode: "cors" }, + { method: "GET", url: `${ORIGIN}/api/users`, mode: "cors" }, + { method: "GET", url: `${ORIGIN}/runtime-config.json`, mode: "cors" }, + { method: "GET", url: "https://cdn.example/assets/app-Dq3x8Yk2.js", mode: "cors" }, + ]; + for (const request of passthrough) { + const event = fetchEvent(request); + onFetch(event); + expect(event.respondWith, `${request.method} ${request.url} ${request.mode}`).not.toHaveBeenCalled(); + } + + const event = fetchEvent({ method: "GET", url: asset, mode: "cors" }); + onFetch(event); + expect(event.respondWith).toHaveBeenCalledOnce(); + const response = (await event.respondWith.mock.calls[0]![0]) as Response; + await expect(response.text()).resolves.toBe("cached"); + } finally { + vi.unstubAllGlobals(); + } + }); + + it("registers no fetch listener without the static asset handler", async () => { + try { + const listeners = await loadWorkerEntry(["WEB_PUSH"]); + expect(listeners.has("fetch")).toBe(false); + } finally { + vi.unstubAllGlobals(); + } + }); +}); + /** * SW-01. The marker read must be bounded in bytes, not only in logic. Adding a * whole chunk and *then* comparing the running total meant a corrupt body could