@nifrajs/web 5.4.0 → 5.5.1

package/src/service-worker.ts

@@ -37,7 +37,9 @@ export interface ServiceWorkerOptions {
   /**
    * URL of a page to serve when a navigation fails and the network is unreachable. It must be a
    * static, user-independent document (a prerendered `/offline`), because every visitor gets the same
-   * bytes. Omit it and failed navigations simply fail, which is the honest default.
+   * bytes. Install fails rather than store it, or any precached URL, when the response is an error, a
+   * redirect, or marked `private` or `no-store`. Omit it and failed navigations simply fail, which is
+   * the honest default.
    */
   readonly offlineUrl?: string
   /**
@@ -115,10 +117,35 @@ const OWN_URLS = new Set(PRECACHE)
 const OWN = { cacheName: CACHE }
 const OFFLINE = ${offline === undefined ? "null" : JSON.stringify(offline)}
 
+// Whether every visitor may be served these bytes from this cache. CacheStorage itself ignores
+// Cache-Control, and a redirect can land one visitor's page under a shared URL.
+const shareable = (response) =>
+  response.ok &&
+  response.type === "basic" &&
+  !response.redirected &&
+  !(response.headers.get("cache-control") ?? "")
+    .split(",")
+    .some((directive) => /^\\s*(?:no-store|private)\\s*(?:=|$)/i.test(directive))
+
 self.addEventListener("install", (event) => {
-  // Take over as soon as the new assets are stored; the activate handler drops the old cache, so
-  // waiting would only serve stale bytes for longer.
-  event.waitUntil(caches.open(CACHE).then((c) => c.addAll(PRECACHE)).then(() => self.skipWaiting()))
+  // Every response is checked before any is stored, so a refused one leaves this build's cache
+  // empty and the install failed, as addAll would on an error status. Take over as soon as the new
+  // assets are stored; the activate handler drops the old cache, so waiting would only serve stale
+  // bytes for longer.
+  event.waitUntil(
+    Promise.all(
+      PRECACHE.map((url) =>
+        fetch(url).then((response) => {
+          if (shareable(response)) return response
+          throw new TypeError("[nifra/web] not precached, the response is not shareable: " + url)
+        }),
+      ),
+    )
+      .then((responses) =>
+        caches.open(CACHE).then((c) => Promise.all(responses.map((r, i) => c.put(PRECACHE[i], r)))),
+      )
+      .then(() => self.skipWaiting()),
+  )
 })
 
 self.addEventListener("activate", (event) => {
@@ -156,11 +183,7 @@ self.addEventListener("fetch", (event) => {
     caches.match(request, OWN).then((hit) => {
       if (hit !== undefined) return hit
       return fetch(request).then((response) => {
-        const cacheable =
-          response.ok &&
-          response.type === "basic" &&
-          !(response.headers.get("cache-control") ?? "").includes("no-store")
-        if (cacheable) {
+        if (shareable(response)) {
           const copy = response.clone()
           void caches.open(CACHE).then((c) => c.put(request, copy))
         }

package/src/zones.ts

@@ -170,7 +170,11 @@ export interface ZoneConfig {
   readonly backend?: readonly string[]
   /** App-relative folders or files holding frontend code, beside `frontend/`. */
   readonly frontend?: readonly string[]
-  /** App-relative folders or files holding code both sides import, beside `shared/`. */
+  /**
+   * App-relative folders or files holding code both sides import, beside `shared/`. Unlike the other
+   * sides, an entry may sit inside `frontend/` or `backend/`: a module there that both sides import
+   * stays where it is, held to the shared rules (it may import only shared code and packages).
+   */
   readonly shared?: readonly string[]
 }
 
@@ -258,8 +262,15 @@ export function parseZoneConfig(value: unknown, source: string): ZoneConfig {
       if (folder.split("/").includes("..")) fail(`"${side}" entry "${entry}" may not contain ".."`)
       if (/[*?[\]{}!]/.test(folder))
         fail(`"${side}" entry "${entry}" must be a plain path (a trailing "/**" is allowed)`)
-      if (RESERVED_FOLDERS.has(top) || top.startsWith(".nifra"))
-        fail(`"${side}" entry "${entry}" is inside ${top}/, which already has its own rules`)
+      const sharedInSide =
+        side === "shared" && (top === "frontend" || top === "backend") && folder !== top
+      if ((RESERVED_FOLDERS.has(top) && !sharedInSide) || top.startsWith(".nifra"))
+        fail(
+          `"${side}" entry "${entry}" is inside ${top}/, which already has its own rules` +
+            (top === "frontend" || top === "backend"
+              ? `; only a "shared" entry may name a path inside ${top}/`
+              : ""),
+        )
       const other = owner.get(folder)
       if (other !== undefined && other !== side)
         fail(`"${folder}" is listed as both ${other} and ${side}; a path has one side`)
@@ -587,11 +598,22 @@ export function createZoneClassifier(options: ZoneClassifierOptions): ZoneClassi
         if (suffix === "shared") return { zone: "shared" }
         return { zone: "route-frontend" }
       }
-      const configured = ZONE_FOLDERS[top] === undefined ? configuredPath(rel) : undefined
-      const folder = ZONE_FOLDERS[top] ?? configured?.[1]
+      // Inside a reserved folder only a "shared" entry can match: the parser refuses the others there.
+      const configured = configuredPath(rel)
+      const folder = configured?.[1] ?? ZONE_FOLDERS[top]
       if (folder !== undefined) {
         if (suffix === undefined || suffix === folder) return { zone: folder }
         if (suffix === "fn" && folder === "backend") return { zone: "fn" }
+        // Code both sides import may live beside the side that wrote it. Shared code may import only
+        // shared code and packages, so the declaration narrows what the file may reach, never widens it.
+        // A file "nifra.zones" lists by name has that side; its suffix cannot contradict it.
+        if (
+          suffix === "shared" &&
+          (folder === "frontend" || folder === "backend") &&
+          top !== "public" &&
+          configured?.[0] !== rel
+        )
+          return { zone: "shared" }
         const where =
           configured === undefined
             ? `sits in ${top}/`