@iqual/nuxt-icms 1.6.1 → 1.6.2-rc.1

package/cache/__tests__/pageCache.spec.ts

@@ -0,0 +1,540 @@
+import { describe, it, expect } from 'vitest'
+import {
+  createEvent,
+  getResponseHeaders,
+  setResponseHeader,
+  setResponseStatus,
+} from 'h3'
+import { IncomingMessage, ServerResponse } from 'node-mock-http'
+import { createStorage } from 'unstorage'
+import lruCacheDriver from 'unstorage/drivers/lru-cache'
+import { NuxtMultiCacheCDNHelper } from 'nuxt-multi-cache/dist/runtime/helpers/CDNHelper.js'
+import { NuxtMultiCacheRouteCacheHelper } from 'nuxt-multi-cache/dist/runtime/helpers/RouteCacheHelper.js'
+import { CacheTagInvalidator } from 'nuxt-multi-cache/dist/runtime/helpers/CacheTagInvalidator.js'
+import {
+  decodeRouteCacheItem,
+  encodeRouteCacheItem,
+  handleRawCacheData,
+} from 'nuxt-multi-cache/dist/runtime/helpers/cacheItem.js'
+import multiCache from '../../config/multiCache'
+import runtimeConfig from '../../config/runtimeConfig'
+import {
+  PAGE_CACHE_DEFAULTS,
+  alterCachedHeaders,
+  applyCacheControlHeaders,
+  boundedLruOptions,
+  buildRouteCacheKey,
+  cacheEntrySize,
+  containerMemoryLimit,
+  finalizeRouteCache,
+  hasDrupalSession,
+  pageCacheDefaults,
+  isBlokkliRequest,
+  resolvePageCacheConfig,
+  resolveRouteMaxSize,
+  routeCacheDriver,
+} from '../pageCache'
+import { LruCacheTagRegistry } from '../cacheTagRegistry'
+
+const MB = 1024 * 1024
+const NOW = Math.floor(Date.now() / 1000)
+
+function freshEvent(path = '/de/foo', headers: Record<string, string> = {}) {
+  const req = new IncomingMessage()
+  req.url = path
+  req.headers = { host: 'example.ch', ...headers }
+  return createEvent(req, new ServerResponse())
+}
+
+/**
+ * Simulates what the SSR render leaves on the event: the CDN helper with the
+ * collected cacheability (applied to the response, as nuxt-multi-cache does)
+ * and optionally a route cache helper.
+ */
+function renderedEvent(
+  configure: (cdn: NuxtMultiCacheCDNHelper) => void,
+  headers: Record<string, string> = {},
+) {
+  const event = freshEvent('/de/foo', headers)
+  const cdn = new NuxtMultiCacheCDNHelper(
+    NOW,
+    multiCache.cdn!.cacheControlHeader,
+    multiCache.cdn!.cacheTagHeader,
+  )
+  configure(cdn)
+  cdn.applyToEvent(event)
+  event.context.multiCache = { cdn }
+  return event
+}
+
+function cacheablePage(cdn: NuxtMultiCacheCDNHelper) {
+  cdn.public().setNumeric('sharedMaxAge', 31536000).addTags(['N:12'])
+}
+
+describe('page cache configuration', () => {
+  it('ships the defaults in the runtime config', () => {
+    // DDEV sets NODE_ENV=development for the whole container.
+    expect(runtimeConfig.pageCache).toEqual(
+      pageCacheDefaults(process.env.NODE_ENV === 'development'),
+    )
+    expect(PAGE_CACHE_DEFAULTS.mode).toBe('default')
+    expect(PAGE_CACHE_DEFAULTS.routeMaxSize).toBe('auto')
+    expect(PAGE_CACHE_DEFAULTS.routeCompression).toBe(true)
+    expect(PAGE_CACHE_DEFAULTS.routeMaxAge).toBe(7 * 86_400)
+  })
+
+  it('turns the route cache off in development', () => {
+    expect(pageCacheDefaults(false)).toEqual(PAGE_CACHE_DEFAULTS)
+    const dev = pageCacheDefaults(true)
+    expect(dev).toEqual({ ...PAGE_CACHE_DEFAULTS, routeMaxSize: 0 })
+    expect(resolvePageCacheConfig(dev).routeMaxSize).toBe(0)
+    // NUXT_PAGE_CACHE_ROUTE_MAX_SIZE=auto turns it back on.
+    expect(
+      resolvePageCacheConfig({ ...dev, routeMaxSize: 'auto' }).routeMaxSize,
+    ).toBe('auto')
+  })
+
+  it('derives the route cache budget from the container memory', () => {
+    const auto = { routeMaxSize: 'auto' } as const
+    expect(resolveRouteMaxSize(auto, null)).toBe(24 * MB)
+    expect(resolveRouteMaxSize(auto, 160 * MB)).toBe(8 * MB)
+    expect(resolveRouteMaxSize(auto, 448 * MB)).toBe(
+      Math.floor(448 * MB * 0.03),
+    )
+    expect(resolveRouteMaxSize(auto, 1024 * MB)).toBe(
+      Math.floor(1024 * MB * 0.03),
+    )
+    expect(resolveRouteMaxSize(auto, 4096 * MB)).toBe(64 * MB)
+    expect(resolveRouteMaxSize({ routeMaxSize: 0 }, 4096 * MB)).toBe(0)
+    expect(resolveRouteMaxSize({ routeMaxSize: MB }, null)).toBe(MB)
+  })
+
+  it('enables the route cache in the build', () => {
+    expect(multiCache.route?.enabled).toBe(true)
+    expect(multiCache.data?.enabled).toBe(true)
+  })
+
+  it('accepts numeric strings from environment variables', () => {
+    expect(
+      resolvePageCacheConfig({
+        mode: 'varnish',
+        routeMaxSize: '1048576',
+        browserMaxAge: '0',
+        routeCompression: 'false',
+      }),
+    ).toMatchObject({
+      mode: 'varnish',
+      routeMaxSize: MB,
+      browserMaxAge: 0,
+      routeCompression: false,
+    })
+    expect(resolvePageCacheConfig({ routeMaxSize: 'auto' }).routeMaxSize).toBe(
+      'auto',
+    )
+  })
+
+  it('falls back to the defaults for invalid values', () => {
+    expect(
+      resolvePageCacheConfig({
+        mode: 'redis',
+        routeMaxSize: 'lots',
+        dataMaxSize: -1,
+      }),
+    ).toEqual(PAGE_CACHE_DEFAULTS)
+    expect(resolvePageCacheConfig(undefined)).toEqual(PAGE_CACHE_DEFAULTS)
+  })
+})
+
+describe('request classification', () => {
+  it.each([
+    ['SSESSabc123=xyz', true],
+    ['_ga=GA1.2; SSESS0f3a=xyz; other=1', true],
+    ['SESSabc=xyz', true],
+    ['_ga=GA1.2.3; cookie-agreed=2', false],
+    ['tracking=SSESS', false],
+    ['', false],
+  ])('detects a Drupal session in "%s": %s', (cookie, expected) => {
+    expect(hasDrupalSession(cookie)).toBe(expected)
+  })
+
+  it.each([
+    ['/blokkli/library-item/123', true],
+    ['/de/foo?blokkliEditing=abc', true],
+    ['/de/foo?x=1&blokkliPreview=1', true],
+    ['/de/foo?blokkliPreview', true],
+    ['/de/foo', false],
+    ['/de/blokkli-tutorial', false],
+    ['/de/foo?q=blokkliEditing', false],
+  ])('detects the blökkli request "%s": %s', (path, expected) => {
+    expect(isBlokkliRequest(path)).toBe(expected)
+  })
+})
+
+describe('route cache key', () => {
+  it('ignores cookies', () => {
+    expect(buildRouteCacheKey(freshEvent('/de/foo', { cookie: '_ga=1' }))).toBe(
+      buildRouteCacheKey(freshEvent('/de/foo', { cookie: '_ga=2' })),
+    )
+  })
+
+  it('ignores tracking parameters and the parameter order', () => {
+    const plain = buildRouteCacheKey(freshEvent('/de/news?page=2&tag=a'))
+    expect(
+      buildRouteCacheKey(
+        freshEvent('/de/news?utm_source=nl&tag=a&gclid=x&page=2&fbclid=y'),
+      ),
+    ).toBe(plain)
+  })
+
+  it('keeps relevant query parameters apart', () => {
+    expect(buildRouteCacheKey(freshEvent('/de/news?page=2'))).not.toBe(
+      buildRouteCacheKey(freshEvent('/de/news?page=3')),
+    )
+    expect(buildRouteCacheKey(freshEvent('/de/news?page=2'))).not.toBe(
+      buildRouteCacheKey(freshEvent('/de/news')),
+    )
+  })
+
+  it('keeps hosts apart, including X-Forwarded-Host', () => {
+    const key = buildRouteCacheKey(freshEvent('/de/foo'))
+    expect(
+      buildRouteCacheKey(freshEvent('/de/foo', { host: 'other.ch' })),
+    ).not.toBe(key)
+    expect(
+      buildRouteCacheKey(
+        freshEvent('/de/foo', { 'x-forwarded-host': 'evil.example' }),
+      ),
+    ).not.toBe(key)
+  })
+
+  it('survives unstorage key normalization', async () => {
+    const storage = createStorage({ driver: lruCacheDriver({ max: 10 }) })
+    const paths = ['/de/news', '/de/news?page=2', '/de/news/page:2']
+    for (const path of paths) {
+      await storage.setItemRaw(buildRouteCacheKey(freshEvent(path)), path)
+    }
+    for (const path of paths) {
+      expect(
+        await storage.getItemRaw(buildRouteCacheKey(freshEvent(path))),
+      ).toBe(path)
+    }
+  })
+})
+
+describe('bounded LRU storage', () => {
+  it('counts two-byte strings double', () => {
+    expect(cacheEntrySize('a'.repeat(100), '')).toBe(100)
+    expect(cacheEntrySize('ä'.repeat(100), '')).toBe(100)
+    expect(cacheEntrySize('’' + 'a'.repeat(99), '')).toBe(200)
+  })
+
+  it('never grows beyond the byte budget', async () => {
+    const driver = lruCacheDriver(boundedLruOptions(MB))
+    const storage = createStorage({ driver })
+    const page = 'x'.repeat(100 * 1024)
+    for (let i = 0; i < 100; i++) {
+      await storage.setItemRaw(`page-${i}`, page + i)
+    }
+    const lru = driver.getInstance!()
+    expect(lru.calculatedSize).toBeLessThanOrEqual(MB)
+    expect(lru.size).toBeGreaterThan(5)
+    // Least recently used entries are evicted first.
+    expect(await storage.hasItem('page-0')).toBe(false)
+    expect(await storage.hasItem('page-99')).toBe(true)
+  })
+
+  it('bounds the data cache, which stores serialized objects', async () => {
+    const driver = lruCacheDriver(boundedLruOptions(64 * 1024))
+    const storage = createStorage({ driver })
+    for (let i = 0; i < 100; i++) {
+      await storage.setItem(`data-${i}`, {
+        data: 'y'.repeat(4096),
+        cacheTags: ['N:' + i],
+      })
+    }
+    expect(driver.getInstance!().calculatedSize).toBeLessThanOrEqual(64 * 1024)
+  })
+
+  it('rejects a single entry above a quarter of the budget', async () => {
+    const storage = createStorage({
+      driver: lruCacheDriver(boundedLruOptions(MB)),
+    })
+    await storage.setItemRaw('small', 'x'.repeat(1024))
+    await storage.setItemRaw('huge', 'x'.repeat(MB / 2))
+    expect(await storage.hasItem('huge')).toBe(false)
+    expect(await storage.hasItem('small')).toBe(true)
+  })
+})
+
+describe('route cache entry encoding', () => {
+  // Mostly ASCII markup with a typographic apostrophe, like a real page.
+  const page = '<p>It’s</p>' + '<div class="x">Hello</div>'.repeat(4000)
+  const item = encodeRouteCacheItem(page, {}, 200, -1, 0, false, ['N:1'])
+
+  it.each([true, false])(
+    'round-trips a page (compressed: %s)',
+    async (compress) => {
+      const storage = createStorage({ driver: routeCacheDriver(MB, compress) })
+      await storage.setItemRaw('key', item)
+      // What nuxt-multi-cache does when serving and when purging.
+      const raw = handleRawCacheData(await storage.getItemRaw('key'))
+      expect(decodeRouteCacheItem(raw!)?.data).toBe(page)
+      // The stats and inspect API endpoints.
+      expect(await storage.getItem('key')).toBe(item)
+      expect(await storage.getItemRaw('missing')).toBeNull()
+    },
+  )
+
+  it('stores pages in a fraction of their string size', async () => {
+    const [plain, gzipped] = await Promise.all(
+      [false, true].map(async (compress) => {
+        const driver = routeCacheDriver(MB, compress)
+        await createStorage({ driver }).setItemRaw('key', item)
+        return driver.getInstance!().calculatedSize
+      }),
+    )
+    // As a JS string the page counts two bytes per character.
+    expect(cacheEntrySize(item, 'key')).toBeGreaterThan(2 * item.length)
+    expect(plain).toBeLessThan(item.length * 1.01)
+    expect(gzipped).toBeLessThan(plain! / 10)
+  })
+})
+
+describe('container memory limit', () => {
+  const reader = (files: Record<string, string>) => (path: string) => {
+    if (path in files) {
+      return files[path]!
+    }
+    throw new Error('ENOENT')
+  }
+
+  it('reads the Platform.sh/Upsun container size', () => {
+    const config = JSON.stringify({ info: { limits: { memory: 448 } } })
+    expect(
+      containerMemoryLimit(
+        reader({
+          '/run/config.json': config,
+          '/sys/fs/cgroup/memory.max': '1073741824',
+        }),
+      ),
+    ).toBe(448 * MB)
+  })
+
+  it('falls back to the cgroup limit', () => {
+    expect(
+      containerMemoryLimit(
+        reader({ '/sys/fs/cgroup/memory.max': '536870912\n' }),
+      ),
+    ).toBe(512 * MB)
+    expect(
+      containerMemoryLimit(
+        reader({
+          '/sys/fs/cgroup/memory/memory.limit_in_bytes': String(256 * MB),
+        }),
+      ),
+    ).toBe(256 * MB)
+  })
+
+  it('is unknown without a limit', () => {
+    expect(
+      containerMemoryLimit(reader({ '/sys/fs/cgroup/memory.max': 'max' })),
+    ).toBeNull()
+    expect(
+      containerMemoryLimit(
+        reader({
+          '/sys/fs/cgroup/memory/memory.limit_in_bytes': '9223372036854771712',
+        }),
+      ),
+    ).toBeNull()
+    expect(containerMemoryLimit(reader({}))).toBeNull()
+  })
+})
+
+describe('tag purge', () => {
+  function setup(maxSize = MB) {
+    const registry = new LruCacheTagRegistry((cacheType, key) =>
+      cacheType === 'route' ? driver.hasItem(key, {}) : false,
+    )
+    const driver = lruCacheDriver(
+      boundedLruOptions(maxSize, (key) => registry.forget('route', key)),
+    )
+    const route = { storage: createStorage({ driver }), bubbleError: false }
+    // What nuxt-multi-cache's afterResponse hook does for a page.
+    const store = async (path: string, tags: string[], size = 10) => {
+      const key = buildRouteCacheKey(freshEvent(path))
+      await route.storage.setItemRaw(
+        key,
+        encodeRouteCacheItem('x'.repeat(size), {}, 200, -1, 0, false, tags),
+      )
+      await registry.addCacheTags(key, 'route', tags)
+    }
+    return { registry, route, store }
+  }
+
+  it('evicts route cache entries tagged by Drupal', async () => {
+    const { registry, route, store } = setup()
+    await store('/de/a', ['abc123', 'menu01'])
+    await store('/de/b', ['def456', 'menu01'])
+    await store('/de/c', ['ghi789'])
+
+    // nuxt-multi-cache's own invalidator, as triggered by the
+    // /api/multi-cache/purge/tags endpoint Drupal's purger calls. Both with
+    // the registry and by reading every entry.
+    for (const reg of [registry, null]) {
+      const invalidator = new CacheTagInvalidator({ route }, reg)
+      invalidator.add(['menu01'])
+      await invalidator.invalidate()
+      expect(await route.storage.getKeys()).toEqual([
+        buildRouteCacheKey(freshEvent('/de/c')),
+      ])
+    }
+    expect(registry.size('route')).toBe(1)
+  })
+
+  it('forgets the tags of entries the LRU evicts', async () => {
+    const { registry, route, store } = setup(64 * 1024)
+    for (let i = 0; i < 200; i++) {
+      await store(`/de/page-${i}`, ['N:' + i, 'menu01'], 4096)
+    }
+    const keys = await route.storage.getKeys()
+    expect(keys.length).toBeLessThan(200)
+    expect(registry.size('route')).toBe(keys.length)
+    expect((await registry.getCacheKeysForTags(['menu01'])).route).toEqual(
+      expect.arrayContaining(keys),
+    )
+    expect(await registry.getCacheKeysForTags(['N:0'])).toEqual({})
+  })
+
+  it('does not register entries the cache refused', async () => {
+    const { registry, store } = setup(64 * 1024)
+    await store('/de/huge', ['N:1'], 32 * 1024)
+    expect(registry.size('route')).toBe(0)
+  })
+
+  it('keeps the tags of a replaced entry consistent', async () => {
+    const { registry, store } = setup()
+    await store('/de/a', ['N:1'])
+    await store('/de/a', ['N:2'])
+    expect(await registry.getCacheKeysForTags(['N:1'])).toEqual({})
+    expect((await registry.getCacheKeysForTags(['N:2'])).route).toHaveLength(1)
+  })
+})
+
+describe('Cache-Control headers in the default mode', () => {
+  const config = resolvePageCacheConfig({})
+
+  it('turns a cacheable page into a short browser cache', () => {
+    const event = renderedEvent(cacheablePage)
+    applyCacheControlHeaders(event, config)
+    const headers = getResponseHeaders(event)
+    expect(headers['cache-control']).toBe('public, max-age=300')
+    expect(headers['cache-tag']).toBeUndefined()
+  })
+
+  it('never lets anything cache a response for a session', () => {
+    const event = renderedEvent(cacheablePage, { cookie: 'SSESSabc=1' })
+    applyCacheControlHeaders(event, config)
+    const headers = getResponseHeaders(event)
+    expect(headers['cache-control']).toBe('private, no-store')
+    expect(headers['cache-tag']).toBeUndefined()
+  })
+
+  it('keeps uncacheable responses uncacheable', () => {
+    const event = renderedEvent((cdn) => cdn.private())
+    applyCacheControlHeaders(event, config)
+    expect(getResponseHeaders(event)['cache-control']).toBe('private, no-store')
+  })
+
+  it('does not cache server errors', () => {
+    const event = renderedEvent(cacheablePage)
+    setResponseStatus(event, 500)
+    applyCacheControlHeaders(event, config)
+    expect(getResponseHeaders(event)['cache-control']).toBe('private, no-store')
+  })
+
+  it('marks the SPA shell for a session as private', () => {
+    const event = freshEvent('/de/foo', { cookie: 'SSESSabc=1' })
+    setResponseHeader(event, 'content-type', 'text/html;charset=utf-8')
+    applyCacheControlHeaders(event, config)
+    expect(getResponseHeaders(event)['cache-control']).toBe('private, no-store')
+  })
+
+  it('drops Cache-Tag copied over from an error page render', () => {
+    const event = freshEvent('/de/missing')
+    setResponseStatus(event, 404)
+    setResponseHeader(event, 'cache-control', 'no-cache')
+    setResponseHeader(event, 'cache-tag', '4xx-response http_response')
+    applyCacheControlHeaders(event, config)
+    const headers = getResponseHeaders(event)
+    expect(headers['cache-tag']).toBeUndefined()
+    expect(headers['cache-control']).toBe('no-cache')
+  })
+
+  it('leaves responses without collected cacheability alone', () => {
+    const event = freshEvent('/_nuxt/entry.js', { cookie: 'SSESSabc=1' })
+    setResponseHeader(event, 'cache-control', 'public,max-age=31536000')
+    applyCacheControlHeaders(event, config)
+    expect(getResponseHeaders(event)['cache-control']).toBe(
+      'public,max-age=31536000',
+    )
+  })
+
+  it('keeps the shared cache headers in the varnish mode', () => {
+    const event = renderedEvent(cacheablePage)
+    applyCacheControlHeaders(event, resolvePageCacheConfig({ mode: 'varnish' }))
+    const headers = getResponseHeaders(event)
+    expect(headers['cache-control']).toMatch(/\bs-maxage=31536000\b/)
+    expect(headers['cache-tag']).toBe('N:12')
+  })
+})
+
+describe('route cache finalization', () => {
+  const config = resolvePageCacheConfig({ routeMaxAge: 3600 })
+
+  function eventWithRoute(
+    configure: (route: NuxtMultiCacheRouteCacheHelper) => void,
+  ) {
+    const event = freshEvent()
+    const route = new NuxtMultiCacheRouteCacheHelper(NOW)
+    configure(route)
+    event.context.multiCache = { route }
+    return { event, route }
+  }
+
+  it('clamps a permanent max age to the configured ceiling', () => {
+    const { event, route } = eventWithRoute((r) => r.setCacheable())
+    expect(route.maxAge).toBe(-1)
+    finalizeRouteCache(event, config)
+    expect(route.maxAge).toBe(3600)
+  })
+
+  it('keeps a shorter max age', () => {
+    const { event, route } = eventWithRoute((r) =>
+      r.setCacheable().setMaxAge(60),
+    )
+    finalizeRouteCache(event, config)
+    expect(route.maxAge).toBe(60)
+  })
+
+  it('does not store responses that set a cookie', () => {
+    const { event, route } = eventWithRoute((r) => r.setCacheable())
+    setResponseHeader(event, 'set-cookie', 'foo=bar')
+    finalizeRouteCache(event, config)
+    expect(route.isCacheable()).toBe(false)
+  })
+
+  it('can not be made cacheable once a GraphQL response was uncacheable', () => {
+    const { route } = eventWithRoute((r) => r.setUncacheable().setCacheable())
+    expect(route.isCacheable()).toBe(false)
+  })
+
+  it('never replays cookies from the cache', () => {
+    expect(
+      alterCachedHeaders({
+        'set-cookie': ['a=b'],
+        'x-icms-page-cache': 'MISS',
+        'content-type': 'text/html',
+      }),
+    ).toEqual({ 'content-type': 'text/html' })
+  })
+})

package/cache/cacheTagRegistry.ts

@@ -0,0 +1,124 @@
+import { normalizeKey } from 'unstorage'
+import type { CacheTagRegistry } from 'nuxt-multi-cache/dist/runtime/types/CacheTagRegistry'
+
+type CacheType = 'route' | 'data' | 'component'
+
+/**
+ * A cache tag registry for caches that evict entries on their own (LRU).
+ *
+ * Without a registry nuxt-multi-cache finds the entries to purge by reading
+ * and decoding every cached entry. With one it looks the tags up instead.
+ * nuxt-multi-cache's own in-memory registry is never told when an LRU cache
+ * evicts an entry, so it would grow forever; this one is: the caches call
+ * forget() from their dispose callback, and only keys a cache actually holds
+ * are registered.
+ *
+ * Keys are normalized like unstorage does, so they match the keys the
+ * storage driver sees.
+ */
+export class LruCacheTagRegistry implements CacheTagRegistry {
+  private tagToKeys = new Map<CacheType, Map<string, Set<string>>>()
+  private keyToTags = new Map<CacheType, Map<string, Set<string>>>()
+
+  constructor(
+    private holds: (cacheType: CacheType, key: string) => boolean = () => true,
+  ) {}
+
+  private maps(cacheType: CacheType) {
+    if (!this.tagToKeys.has(cacheType)) {
+      this.tagToKeys.set(cacheType, new Map())
+      this.keyToTags.set(cacheType, new Map())
+    }
+    return {
+      tagToKeys: this.tagToKeys.get(cacheType)!,
+      keyToTags: this.keyToTags.get(cacheType)!,
+    }
+  }
+
+  /**
+   * Remove a key, e.g. when the cache evicted it.
+   */
+  forget(cacheType: CacheType, rawKey: string) {
+    const key = normalizeKey(rawKey)
+    const { tagToKeys, keyToTags } = this.maps(cacheType)
+    for (const tag of keyToTags.get(key) ?? []) {
+      const keys = tagToKeys.get(tag)
+      keys?.delete(key)
+      if (!keys?.size) {
+        tagToKeys.delete(tag)
+      }
+    }
+    keyToTags.delete(key)
+  }
+
+  /**
+   * Number of registered keys, for tests and monitoring.
+   */
+  size(cacheType: CacheType) {
+    return this.maps(cacheType).keyToTags.size
+  }
+
+  addCacheTags(rawKey: string, cacheType: CacheType, cacheTags: string[]) {
+    const key = normalizeKey(rawKey)
+    // An entry the cache refused (larger than maxEntrySize) or evicted
+    // right away would never be forgotten.
+    if (this.holds(cacheType, key)) {
+      const { tagToKeys, keyToTags } = this.maps(cacheType)
+      const tags = keyToTags.get(key) ?? new Set<string>()
+      keyToTags.set(key, tags)
+      for (const tag of cacheTags) {
+        tags.add(tag)
+        const keys = tagToKeys.get(tag) ?? new Set<string>()
+        tagToKeys.set(tag, keys)
+        keys.add(key)
+      }
+    }
+    return Promise.resolve()
+  }
+
+  getCacheKeysForTags(tags: string[]) {
+    const result: Partial<Record<CacheType, string[]>> = {}
+    for (const [cacheType, tagToKeys] of this.tagToKeys) {
+      const keys = new Set(
+        tags.flatMap((tag) => [...(tagToKeys.get(tag) ?? [])]),
+      )
+      if (keys.size) {
+        result[cacheType] = [...keys]
+      }
+    }
+    return Promise.resolve(result)
+  }
+
+  removeTags(tags: string[]) {
+    // The purged entries are removed from their cache right before this,
+    // which already forgot them through the dispose callback. Drop what is
+    // left, e.g. keys of a cache without that callback.
+    for (const [cacheType, tagToKeys] of this.tagToKeys) {
+      for (const tag of tags) {
+        for (const key of [...(tagToKeys.get(tag) ?? [])]) {
+          this.forget(cacheType, key)
+        }
+      }
+    }
+    return Promise.resolve()
+  }
+
+  removeCacheItem(cacheType: CacheType, key: string | string[]) {
+    for (const item of Array.isArray(key) ? key : [key]) {
+      this.forget(cacheType, item)
+    }
+    return Promise.resolve()
+  }
+
+  purgeCache(cacheType: CacheType) {
+    this.tagToKeys.delete(cacheType)
+    this.keyToTags.delete(cacheType)
+    return Promise.resolve()
+  }
+
+  purgeEverything() {
+    this.tagToKeys.clear()
+    this.keyToTags.clear()
+    return Promise.resolve()
+  }
+}

package/cache/enabledForRequest.ts

@@ -0,0 +1,21 @@
+import type { H3Event } from 'h3'
+import { getRequestHeader } from 'h3'
+
+/**
+ * Drupal session cookies are named SESS<hash> (http) or SSESS<hash> (https).
+ */
+const SESSION_COOKIE = /(?:^|;)\s*S?SESS[\w-]+=/
+
+export function hasDrupalSession(cookieHeader: string | undefined | null) {
+  return !!cookieHeader && SESSION_COOKIE.test(cookieHeader)
+}
+
+/**
+ * Requests with a Drupal session bypass all caches.
+ *
+ * Kept free of Nitro imports: the Vue app's SSR build imports it as its
+ * server options (modules/pageCache.ts).
+ */
+export function enabledForRequest(event: H3Event) {
+  return Promise.resolve(!hasDrupalSession(getRequestHeader(event, 'cookie')))
+}