fix(cache): only apply 1-year deleteAt for immutable responses (#4913)

* fix(cache): only apply 1-year deleteAt for immutable responses

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test(cache): add tests for determineDeleteAt behavior

Verify that:
- max-age responses get deleteAt proportional to freshness lifetime (not 1 year)
- immutable responses get deleteAt of ~1 year
- stale-while-revalidate correctly extends deleteAt beyond staleAt

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: metalix2

lib/handler/cache-handler.js

@@ -493,10 +493,18 @@ function determineDeleteAt (now, cacheControlDirectives, staleAt) {
     staleIfError = staleAt + (cacheControlDirectives['stale-if-error'] * 1000)
   }
 
-  if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
+  if (cacheControlDirectives.immutable && staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
     immutable = now + 31536000000
   }
 
+  // When no stale directives or immutable flag, add a revalidation buffer
+  // equal to the freshness lifetime so the entry survives past staleAt long
+  // enough to be revalidated instead of silently disappearing.
+  if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity && immutable === -Infinity) {
+    const freshnessLifetime = staleAt - now
+    return staleAt + freshnessLifetime
+  }
+
   return Math.max(staleAt, staleWhileRevalidate, staleIfError, immutable)
 }
 

test/interceptors/cache.js

@@ -7,6 +7,7 @@ const { equal, strictEqual, notEqual, fail } = require('node:assert')
 const { setTimeout: sleep } = require('node:timers/promises')
 const FakeTimers = require('@sinonjs/fake-timers')
 const { Client, interceptors, cacheStores: { MemoryCacheStore } } = require('../../index')
+const { makeCacheKey } = require('../../lib/util/cache.js')
 
 describe('Cache Interceptor', () => {
   test('caches request', async () => {
@@ -1984,4 +1985,110 @@ describe('Cache Interceptor', () => {
       }
     })
   })
+
+  describe('determineDeleteAt', () => {
+    test('max-age response has deleteAt proportional to freshness lifetime, not 1 year', async () => {
+      const clock = FakeTimers.install({ now: 1000 })
+      after(() => clock.uninstall())
+
+      const store = new MemoryCacheStore()
+      const server = createServer({ joinDuplicateHeaders: true }, (_, res) => {
+        res.setHeader('cache-control', 'public, max-age=60')
+        res.setHeader('date', new Date(clock.now).toUTCString())
+        res.sendDate = false
+        res.end('short-lived')
+      }).listen(0)
+
+      after(async () => {
+        server.close()
+        await client.close()
+      })
+
+      await once(server, 'listening')
+
+      const origin = `http://localhost:${server.address().port}`
+      const client = new Client(origin)
+        .compose(interceptors.cache({ store }))
+
+      const res = await client.request({ origin, method: 'GET', path: '/delete-at-maxage' })
+      strictEqual(await res.body.text(), 'short-lived')
+
+      const cached = store.get(makeCacheKey({ origin, method: 'GET', path: '/delete-at-maxage', headers: {} }))
+
+      notEqual(cached, undefined)
+      // deleteAt should be approximately 2x max-age (staleAt + freshnessLifetime),
+      // not 1 year out
+      const maxExpected = clock.now + (60 * 1000 * 3) // generous upper bound
+      equal(cached.deleteAt < maxExpected, true, `deleteAt (${cached.deleteAt}) should be well under 3x max-age (${maxExpected})`)
+      equal(cached.deleteAt > cached.staleAt, true, 'deleteAt should be greater than staleAt to allow revalidation')
+    })
+
+    test('immutable response has deleteAt of ~1 year', async () => {
+      const clock = FakeTimers.install({ now: 1000 })
+      after(() => clock.uninstall())
+
+      const store = new MemoryCacheStore()
+      const server = createServer({ joinDuplicateHeaders: true }, (_, res) => {
+        res.setHeader('cache-control', 'public, immutable')
+        res.setHeader('date', new Date(clock.now).toUTCString())
+        res.sendDate = false
+        res.end('immutable-content')
+      }).listen(0)
+
+      after(async () => {
+        server.close()
+        await client.close()
+      })
+
+      await once(server, 'listening')
+
+      const origin = `http://localhost:${server.address().port}`
+      const client = new Client(origin)
+        .compose(interceptors.cache({ store }))
+
+      const res = await client.request({ origin, method: 'GET', path: '/delete-at-immutable' })
+      strictEqual(await res.body.text(), 'immutable-content')
+
+      const cached = store.get(makeCacheKey({ origin, method: 'GET', path: '/delete-at-immutable', headers: {} }))
+
+      notEqual(cached, undefined)
+      const oneYear = 31536000000
+      // deleteAt should be approximately 1 year out
+      equal(cached.deleteAt >= clock.now + oneYear - 1000, true, `deleteAt (${cached.deleteAt}) should be ~1 year out`)
+    })
+
+    test('stale-while-revalidate extends deleteAt beyond staleAt', async () => {
+      const clock = FakeTimers.install({ now: 1000 })
+      after(() => clock.uninstall())
+
+      const store = new MemoryCacheStore()
+      const server = createServer({ joinDuplicateHeaders: true }, (_, res) => {
+        res.setHeader('cache-control', 'public, max-age=60, stale-while-revalidate=300')
+        res.setHeader('date', new Date(clock.now).toUTCString())
+        res.sendDate = false
+        res.end('swr-content')
+      }).listen(0)
+
+      after(async () => {
+        server.close()
+        await client.close()
+      })
+
+      await once(server, 'listening')
+
+      const origin = `http://localhost:${server.address().port}`
+      const client = new Client(origin)
+        .compose(interceptors.cache({ store }))
+
+      const res = await client.request({ origin, method: 'GET', path: '/delete-at-swr' })
+      strictEqual(await res.body.text(), 'swr-content')
+
+      const cached = store.get(makeCacheKey({ origin, method: 'GET', path: '/delete-at-swr', headers: {} }))
+
+      notEqual(cached, undefined)
+      // deleteAt should be staleAt + stale-while-revalidate (300s)
+      const expectedDeleteAt = cached.staleAt + (300 * 1000)
+      equal(cached.deleteAt, expectedDeleteAt, `deleteAt (${cached.deleteAt}) should be staleAt + 300s (${expectedDeleteAt})`)
+    })
+  })
 })