Use s-maxage for staleAt calculation (to start revalidation)

Author: Taz Singh

src/workerSwr.ts

@@ -61,6 +61,13 @@ export const workerSwr = ({
 
   const processResponse = (response: Response) => {
     const upstreamCacheControl = response.headers.get("cache-control");
+
+    // Parse s-maxage for staleAt calculation (when content becomes stale)
+    // Parse stale-while-revalidate and stale-if-error for the stale serving windows
+    let sMaxage: number | undefined;
+    let staleWhileRevalidate: number | undefined;
+    let staleIfError: number | undefined;
+
     if (upstreamCacheControl) {
       const directives = upstreamCacheControl
         .split(",")
@@ -69,18 +76,16 @@ export const workerSwr = ({
       for (const directive of directives) {
         const [name, value] = directive.split("=", 2);
 
+        if (name === "s-maxage" && value) {
+          sMaxage = parseInt(value, 10);
+        }
+
         if (name === "stale-while-revalidate" && value) {
-          response.headers.set(
-            swrConfig.staleAtHeaderName,
-            (Date.now() + parseInt(value, 10) * 1000).toString()
-          );
+          staleWhileRevalidate = parseInt(value, 10);
         }
 
         if (name === "stale-if-error" && value) {
-          response.headers.set(
-            swrConfig.staleErrorAtHeaderName,
-            (Date.now() + parseInt(value, 10) * 1000).toString()
-          );
+          staleIfError = parseInt(value, 10);
         }
       }
     }
@@ -102,22 +107,43 @@ export const workerSwr = ({
           );
         }
 
-        if (name === "stale-while-revalidate") {
-          response.headers.set(
-            swrConfig.staleAtHeaderName,
-            (Date.now() + parseInt(value, 10) * 1000).toString()
-          );
+        // Also parse from config directives
+        if (name === "s-maxage" && value && sMaxage === undefined) {
+          sMaxage = parseInt(value, 10);
         }
 
-        if (name === "stale-if-error") {
-          response.headers.set(
-            swrConfig.staleErrorAtHeaderName,
-            (Date.now() + parseInt(value, 10) * 1000).toString()
-          );
+        if (name === "stale-while-revalidate" && value && staleWhileRevalidate === undefined) {
+          staleWhileRevalidate = parseInt(value, 10);
+        }
+
+        if (name === "stale-if-error" && value && staleIfError === undefined) {
+          staleIfError = parseInt(value, 10);
         }
       }
     }
 
+    // Set staleAt based on s-maxage (when content becomes "stale" and revalidation should start)
+    // If no s-maxage, fall back to stale-while-revalidate for backwards compatibility
+    // If neither, use defaultStaleSeconds
+    const staleAtSeconds = sMaxage ?? staleWhileRevalidate ?? swrConfig.defaultStaleSeconds;
+    response.headers.set(
+      swrConfig.staleAtHeaderName,
+      (Date.now() + staleAtSeconds * 1000).toString()
+    );
+
+    // Set staleErrorAt based on stale-if-error (if present)
+    if (staleIfError !== undefined) {
+      response.headers.set(
+        swrConfig.staleErrorAtHeaderName,
+        (Date.now() + staleIfError * 1000).toString()
+      );
+    } else if (swrConfig.defaultStaleErrorSeconds) {
+      response.headers.set(
+        swrConfig.staleErrorAtHeaderName,
+        (Date.now() + swrConfig.defaultStaleErrorSeconds * 1000).toString()
+      );
+    }
+
     if (varyDirectives) {
       const existingVary =
         response.headers
@@ -137,23 +163,6 @@ export const workerSwr = ({
         response.headers.set("vary", vary.join(", "));
       }
     }
-
-    if (!response.headers.has(swrConfig.staleAtHeaderName)) {
-      response.headers.set(
-        swrConfig.staleAtHeaderName,
-        (Date.now() + swrConfig.defaultStaleSeconds * 1000).toString()
-      );
-    }
-
-    if (
-      !response.headers.has(swrConfig.staleErrorAtHeaderName) &&
-      swrConfig.defaultStaleErrorSeconds
-    ) {
-      response.headers.set(
-        swrConfig.staleErrorAtHeaderName,
-        (Date.now() + swrConfig.defaultStaleErrorSeconds * 1000).toString()
-      );
-    }
   };
 
   return async (request: Request, env: any, ctx: ExecutionContext) => {

test/workerSwr.test.ts

@@ -497,7 +497,30 @@ describe("workerSwr", () => {
       expect(diff).toBeLessThan(110000);
     });
 
-    it("respects upstream stale-while-revalidate header", async () => {
+    it("uses s-maxage for staleAt calculation (when content becomes stale)", async () => {
+      const swrFetcher = workerSwr({
+        fetcher: async () =>
+          new Response("ok", {
+            headers: { "cache-control": "s-maxage=10, stale-while-revalidate=3600" },
+          }),
+      });
+
+      await swrFetcher(
+        new Request("https://example.com"),
+        {},
+        executionContext
+      );
+
+      const cachedResponse = (cachePut as Mock).mock.calls[0][1] as Response;
+      const staleAt = cachedResponse.headers.get("x-edge-cache-stale-at");
+
+      // Should be roughly 10 seconds from now (s-maxage), not 3600 (stale-while-revalidate)
+      const diff = parseInt(staleAt!) - Date.now();
+      expect(diff).toBeGreaterThan(9000);
+      expect(diff).toBeLessThan(11000);
+    });
+
+    it("falls back to stale-while-revalidate for staleAt if no s-maxage", async () => {
       const swrFetcher = workerSwr({
         fetcher: async () =>
           new Response("ok", {
@@ -514,6 +537,7 @@ describe("workerSwr", () => {
       const cachedResponse = (cachePut as Mock).mock.calls[0][1] as Response;
       const staleAt = cachedResponse.headers.get("x-edge-cache-stale-at");
 
+      // Falls back to stale-while-revalidate when no s-maxage
       const diff = parseInt(staleAt!) - Date.now();
       expect(diff).toBeGreaterThan(9000);
       expect(diff).toBeLessThan(11000);