@dotdo/postgres 0.1.0

package/src/storage/swr-cache.test.ts

@@ -0,0 +1,832 @@
+/**
+ * Tests for SWRCacheLayer - Stale-While-Revalidate Cache Layer
+ * GitHub Issue #138
+ *
+ * CRITICAL: Cloudflare Cache API is FREE! This is our competitive advantage.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  SWRCacheLayer,
+  SWRCacheConfig,
+  SWRCacheStats,
+  SWRResult,
+  ExecutionContext,
+  createSWRCacheLayer,
+} from './swr-cache'
+
+// Mock the Cloudflare Cache API
+const mockPrimaryCache = {
+  match: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+}
+
+const mockStaleCache = {
+  match: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+}
+
+const mockCaches = {
+  open: vi.fn().mockImplementation((name: string) => {
+    if (name === 'pglite-pages-primary' || name.includes('primary')) {
+      return Promise.resolve(mockPrimaryCache)
+    }
+    return Promise.resolve(mockStaleCache)
+  }),
+}
+
+// Polyfill global caches for testing
+;(globalThis as any).caches = mockCaches
+
+// Mock execution context
+const createMockContext = (): ExecutionContext => ({
+  waitUntil: vi.fn(),
+})
+
+describe('SWRCacheLayer - Stale-While-Revalidate Cache Layer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockPrimaryCache.match.mockReset()
+    mockPrimaryCache.put.mockReset()
+    mockPrimaryCache.delete.mockReset()
+    mockStaleCache.match.mockReset()
+    mockStaleCache.put.mockReset()
+    mockStaleCache.delete.mockReset()
+  })
+
+  describe('SWRCacheConfig', () => {
+    it('should have required config fields', () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      expect(config.baseUrl).toBe('https://pglite.cache.local')
+    })
+
+    it('should support optional TTL config', () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+        primaryTtlSeconds: 30,
+        staleTtlSeconds: 7200,
+      }
+      expect(config.primaryTtlSeconds).toBe(30)
+      expect(config.staleTtlSeconds).toBe(7200)
+    })
+
+    it('should support custom cache names', () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+        primaryCacheName: 'my-primary-cache',
+        staleCacheName: 'my-stale-cache',
+      }
+      expect(config.primaryCacheName).toBe('my-primary-cache')
+      expect(config.staleCacheName).toBe('my-stale-cache')
+    })
+  })
+
+  describe('createSWRCacheLayer()', () => {
+    it('should return a SWRCacheLayer instance', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+      expect(layer).toBeDefined()
+      expect(layer).toBeInstanceOf(SWRCacheLayer)
+    })
+
+    it('should open both primary and stale caches', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      await createSWRCacheLayer(config)
+      expect(mockCaches.open).toHaveBeenCalledWith('pglite-pages-primary')
+      expect(mockCaches.open).toHaveBeenCalledWith('pglite-pages-stale')
+    })
+
+    it('should use custom cache names when provided', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+        primaryCacheName: 'custom-primary',
+        staleCacheName: 'custom-stale',
+      }
+      await createSWRCacheLayer(config)
+      expect(mockCaches.open).toHaveBeenCalledWith('custom-primary')
+      expect(mockCaches.open).toHaveBeenCalledWith('custom-stale')
+    })
+  })
+
+  describe('SWRCacheLayer.get() - Primary cache hit', () => {
+    it('should return data from primary cache when available', async () => {
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      mockPrimaryCache.match.mockResolvedValue(
+        new Response(data, {
+          headers: { 'Content-Type': 'application/octet-stream' },
+        })
+      )
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.get('page-123')
+      expect(result.data).toEqual(data)
+      expect(result.hit).toBe(true)
+      expect(result.stale).toBe(false)
+      expect(result.revalidating).toBe(false)
+    })
+
+    it('should not check stale cache on primary hit', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(new Response(data))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('page-123')
+      expect(mockStaleCache.match).not.toHaveBeenCalled()
+    })
+
+    it('should track primary hit statistics', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(new Response(data))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('page-123')
+      const stats = layer.getStats()
+      expect(stats.primaryHits).toBe(1)
+      expect(stats.staleHits).toBe(0)
+      expect(stats.misses).toBe(0)
+    })
+  })
+
+  describe('SWRCacheLayer.get() - Stale cache hit', () => {
+    it('should return stale data when primary misses but stale hits', async () => {
+      const data = new Uint8Array([10, 20, 30])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(
+        new Response(data, {
+          headers: { 'Content-Type': 'application/octet-stream' },
+        })
+      )
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.get('page-123')
+      expect(result.data).toEqual(data)
+      expect(result.hit).toBe(true)
+      expect(result.stale).toBe(true)
+    })
+
+    it('should trigger background revalidation with origin fetcher and context', async () => {
+      const staleData = new Uint8Array([10, 20, 30])
+      const freshData = new Uint8Array([40, 50, 60])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+      const ctx = createMockContext()
+
+      // Set origin fetcher
+      const originFetcher = vi.fn().mockResolvedValue(freshData)
+      layer.setOriginFetcher(originFetcher)
+
+      const result = await layer.get('page-123', ctx)
+      expect(result.stale).toBe(true)
+      expect(result.revalidating).toBe(true)
+      expect(ctx.waitUntil).toHaveBeenCalled()
+    })
+
+    it('should not trigger revalidation without context', async () => {
+      const staleData = new Uint8Array([10, 20, 30])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const originFetcher = vi.fn().mockResolvedValue(new Uint8Array([1]))
+      layer.setOriginFetcher(originFetcher)
+
+      const result = await layer.get('page-123') // No context
+      expect(result.stale).toBe(true)
+      expect(result.revalidating).toBe(false)
+    })
+
+    it('should not trigger revalidation without origin fetcher', async () => {
+      const staleData = new Uint8Array([10, 20, 30])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+      const ctx = createMockContext()
+
+      // No origin fetcher set
+      const result = await layer.get('page-123', ctx)
+      expect(result.stale).toBe(true)
+      expect(result.revalidating).toBe(false)
+      expect(ctx.waitUntil).not.toHaveBeenCalled()
+    })
+
+    it('should track stale hit statistics', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(data))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('page-123')
+      const stats = layer.getStats()
+      expect(stats.primaryHits).toBe(0)
+      expect(stats.staleHits).toBe(1)
+      expect(stats.misses).toBe(0)
+    })
+
+    it('should track revalidation count', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(data))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+      const ctx = createMockContext()
+
+      layer.setOriginFetcher(vi.fn().mockResolvedValue(new Uint8Array([1])))
+
+      await layer.get('page-123', ctx)
+      const stats = layer.getStats()
+      expect(stats.revalidations).toBe(1)
+    })
+  })
+
+  describe('SWRCacheLayer.get() - Cache miss', () => {
+    it('should return null data on complete miss', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(undefined)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.get('page-123')
+      expect(result.data).toBeNull()
+      expect(result.hit).toBe(false)
+      expect(result.stale).toBe(false)
+      expect(result.revalidating).toBe(false)
+    })
+
+    it('should track miss statistics', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(undefined)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('page-123')
+      const stats = layer.getStats()
+      expect(stats.primaryHits).toBe(0)
+      expect(stats.staleHits).toBe(0)
+      expect(stats.misses).toBe(1)
+    })
+  })
+
+  describe('SWRCacheLayer.put()', () => {
+    it('should store data in both caches', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      await layer.put('page-123', data)
+
+      expect(mockPrimaryCache.put).toHaveBeenCalled()
+      expect(mockStaleCache.put).toHaveBeenCalled()
+    })
+
+    it('should set correct TTL for primary cache (default 60s)', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await layer.put('page-123', data)
+
+      const response = mockPrimaryCache.put.mock.calls[0][1] as Response
+      expect(response.headers.get('Cache-Control')).toContain('max-age=60')
+    })
+
+    it('should set correct TTL for stale cache (default 3600s)', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await layer.put('page-123', data)
+
+      const response = mockStaleCache.put.mock.calls[0][1] as Response
+      expect(response.headers.get('Cache-Control')).toContain('max-age=3600')
+    })
+
+    it('should use custom TTL values when provided', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+        primaryTtlSeconds: 30,
+        staleTtlSeconds: 7200,
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await layer.put('page-123', data)
+
+      const primaryResponse = mockPrimaryCache.put.mock.calls[0][1] as Response
+      const staleResponse = mockStaleCache.put.mock.calls[0][1] as Response
+      expect(primaryResponse.headers.get('Cache-Control')).toContain('max-age=30')
+      expect(staleResponse.headers.get('Cache-Control')).toContain('max-age=7200')
+    })
+
+    it('should track write statistics', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      await layer.put('page-123', data)
+
+      const stats = layer.getStats()
+      expect(stats.writes).toBe(1)
+    })
+
+    it('should track bytes written (both caches)', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      await layer.put('page-123', data)
+
+      const stats = layer.getStats()
+      expect(stats.bytesWritten).toBe(10) // 5 bytes * 2 caches
+    })
+  })
+
+  describe('SWRCacheLayer.invalidate()', () => {
+    it('should delete from both caches', async () => {
+      mockPrimaryCache.delete.mockResolvedValue(true)
+      mockStaleCache.delete.mockResolvedValue(true)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.invalidate('page-123')
+
+      expect(mockPrimaryCache.delete).toHaveBeenCalled()
+      expect(mockStaleCache.delete).toHaveBeenCalled()
+    })
+
+    it('should track invalidation statistics', async () => {
+      mockPrimaryCache.delete.mockResolvedValue(true)
+      mockStaleCache.delete.mockResolvedValue(true)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.invalidate('page-123')
+
+      const stats = layer.getStats()
+      expect(stats.invalidations).toBe(1)
+    })
+  })
+
+  describe('SWRCacheLayer.has()', () => {
+    it('should return true if found in primary cache', async () => {
+      mockPrimaryCache.match.mockResolvedValue(new Response(new Uint8Array([1])))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.has('page-123')
+      expect(result).toBe(true)
+    })
+
+    it('should return true if found only in stale cache', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(new Uint8Array([1])))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.has('page-123')
+      expect(result).toBe(true)
+    })
+
+    it('should return false if not found in either cache', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(undefined)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const result = await layer.has('nonexistent')
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('SWRCacheLayer.getStats()', () => {
+    it('should return SWRCacheStats object with all fields', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const stats = layer.getStats()
+      expect(stats).toHaveProperty('primaryHits')
+      expect(stats).toHaveProperty('staleHits')
+      expect(stats).toHaveProperty('misses')
+      expect(stats).toHaveProperty('revalidations')
+      expect(stats).toHaveProperty('writes')
+      expect(stats).toHaveProperty('invalidations')
+      expect(stats).toHaveProperty('bytesRead')
+      expect(stats).toHaveProperty('bytesWritten')
+      expect(stats).toHaveProperty('errors')
+      expect(stats).toHaveProperty('primaryHitRatio')
+      expect(stats).toHaveProperty('combinedHitRatio')
+    })
+
+    it('should calculate primary hit ratio correctly', async () => {
+      mockPrimaryCache.match
+        .mockResolvedValueOnce(new Response(new Uint8Array([1]))) // primary hit
+        .mockResolvedValueOnce(undefined) // primary miss
+        .mockResolvedValueOnce(undefined) // primary miss
+      mockStaleCache.match
+        .mockResolvedValueOnce(new Response(new Uint8Array([2]))) // stale hit
+        .mockResolvedValueOnce(undefined) // stale miss
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('key1') // primary hit
+      await layer.get('key2') // stale hit
+      await layer.get('key3') // miss
+
+      const stats = layer.getStats()
+      expect(stats.primaryHitRatio).toBeCloseTo(1 / 3, 2) // 1 primary hit / 3 total
+    })
+
+    it('should calculate combined hit ratio correctly', async () => {
+      mockPrimaryCache.match
+        .mockResolvedValueOnce(new Response(new Uint8Array([1]))) // primary hit
+        .mockResolvedValueOnce(undefined) // primary miss
+        .mockResolvedValueOnce(undefined) // primary miss
+        .mockResolvedValueOnce(undefined) // primary miss
+      mockStaleCache.match
+        .mockResolvedValueOnce(new Response(new Uint8Array([2]))) // stale hit
+        .mockResolvedValueOnce(new Response(new Uint8Array([3]))) // stale hit
+        .mockResolvedValueOnce(undefined) // stale miss
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('key1') // primary hit
+      await layer.get('key2') // stale hit
+      await layer.get('key3') // stale hit
+      await layer.get('key4') // miss
+
+      const stats = layer.getStats()
+      expect(stats.combinedHitRatio).toBeCloseTo(3 / 4, 2) // 3 hits / 4 total
+    })
+
+    it('should return 0 for ratios with no requests', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const stats = layer.getStats()
+      expect(stats.primaryHitRatio).toBe(0)
+      expect(stats.combinedHitRatio).toBe(0)
+    })
+  })
+
+  describe('SWRCacheLayer.resetStats()', () => {
+    it('should reset all statistics counters', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(new Response(data))
+      mockPrimaryCache.delete.mockResolvedValue(true)
+      mockStaleCache.delete.mockResolvedValue(true)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      // Generate some statistics
+      await layer.get('key1')
+      await layer.put('key2', data)
+      await layer.invalidate('key3')
+
+      // Verify stats exist
+      let stats = layer.getStats()
+      expect(stats.primaryHits).toBeGreaterThan(0)
+      expect(stats.writes).toBeGreaterThan(0)
+
+      // Reset stats
+      layer.resetStats()
+
+      // Verify stats are reset
+      stats = layer.getStats()
+      expect(stats.primaryHits).toBe(0)
+      expect(stats.staleHits).toBe(0)
+      expect(stats.misses).toBe(0)
+      expect(stats.revalidations).toBe(0)
+      expect(stats.writes).toBe(0)
+      expect(stats.invalidations).toBe(0)
+      expect(stats.bytesRead).toBe(0)
+      expect(stats.bytesWritten).toBe(0)
+      expect(stats.errors).toBe(0)
+    })
+  })
+
+  describe('SWRCacheLayer.getConfig()', () => {
+    it('should return the current configuration with defaults', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const returnedConfig = layer.getConfig()
+      expect(returnedConfig.baseUrl).toBe('https://pglite.cache.local')
+      expect(returnedConfig.primaryTtlSeconds).toBe(60)
+      expect(returnedConfig.staleTtlSeconds).toBe(3600)
+      expect(returnedConfig.primaryCacheName).toBe('pglite-pages-primary')
+      expect(returnedConfig.staleCacheName).toBe('pglite-pages-stale')
+    })
+
+    it('should return custom configuration values', async () => {
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://custom.cache.local',
+        primaryTtlSeconds: 30,
+        staleTtlSeconds: 7200,
+        primaryCacheName: 'my-primary',
+        staleCacheName: 'my-stale',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const returnedConfig = layer.getConfig()
+      expect(returnedConfig.baseUrl).toBe('https://custom.cache.local')
+      expect(returnedConfig.primaryTtlSeconds).toBe(30)
+      expect(returnedConfig.staleTtlSeconds).toBe(7200)
+      expect(returnedConfig.primaryCacheName).toBe('my-primary')
+      expect(returnedConfig.staleCacheName).toBe('my-stale')
+    })
+  })
+
+  describe('Error handling', () => {
+    it('should handle primary cache errors gracefully', async () => {
+      mockPrimaryCache.match.mockRejectedValue(new Error('Cache unavailable'))
+      mockStaleCache.match.mockResolvedValue(undefined)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      // Should not throw, continue to stale cache
+      const result = await layer.get('page-123')
+      expect(result.hit).toBe(false)
+    })
+
+    it('should handle stale cache errors gracefully', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockRejectedValue(new Error('Cache unavailable'))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      // Should not throw, return miss
+      const result = await layer.get('page-123')
+      expect(result.hit).toBe(false)
+    })
+
+    it('should track errors in statistics', async () => {
+      mockPrimaryCache.match.mockRejectedValue(new Error('Cache unavailable'))
+      mockStaleCache.match.mockRejectedValue(new Error('Cache unavailable'))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('page-123')
+
+      const stats = layer.getStats()
+      expect(stats.errors).toBeGreaterThan(0)
+    })
+
+    it('should handle put errors gracefully', async () => {
+      mockPrimaryCache.put.mockRejectedValue(new Error('Cache unavailable'))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      // Should not throw
+      await expect(layer.put('page-123', new Uint8Array([1, 2, 3]))).resolves.not.toThrow()
+
+      const stats = layer.getStats()
+      expect(stats.errors).toBe(1)
+    })
+
+    it('should handle invalidate errors gracefully', async () => {
+      mockPrimaryCache.delete.mockRejectedValue(new Error('Cache unavailable'))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      // Should not throw
+      await expect(layer.invalidate('page-123')).resolves.not.toThrow()
+
+      const stats = layer.getStats()
+      expect(stats.errors).toBe(1)
+    })
+  })
+
+  describe('Background revalidation', () => {
+    it('should call origin fetcher during revalidation', async () => {
+      const staleData = new Uint8Array([1, 2, 3])
+      const freshData = new Uint8Array([4, 5, 6])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const originFetcher = vi.fn().mockResolvedValue(freshData)
+      layer.setOriginFetcher(originFetcher)
+
+      // Create context that immediately executes waitUntil
+      const waitUntilPromises: Promise<unknown>[] = []
+      const ctx: ExecutionContext = {
+        waitUntil: (p) => waitUntilPromises.push(p),
+      }
+
+      await layer.get('page-123', ctx)
+
+      // Wait for background revalidation
+      await Promise.all(waitUntilPromises)
+
+      expect(originFetcher).toHaveBeenCalledWith('page-123')
+    })
+
+    it('should update caches with fresh data during revalidation', async () => {
+      const staleData = new Uint8Array([1, 2, 3])
+      const freshData = new Uint8Array([4, 5, 6])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const originFetcher = vi.fn().mockResolvedValue(freshData)
+      layer.setOriginFetcher(originFetcher)
+
+      const waitUntilPromises: Promise<unknown>[] = []
+      const ctx: ExecutionContext = {
+        waitUntil: (p) => waitUntilPromises.push(p),
+      }
+
+      await layer.get('page-123', ctx)
+
+      // Wait for background revalidation
+      await Promise.all(waitUntilPromises)
+
+      // Both caches should be updated
+      expect(mockPrimaryCache.put).toHaveBeenCalled()
+      expect(mockStaleCache.put).toHaveBeenCalled()
+    })
+
+    it('should handle origin fetcher returning null', async () => {
+      const staleData = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const originFetcher = vi.fn().mockResolvedValue(null)
+      layer.setOriginFetcher(originFetcher)
+
+      const waitUntilPromises: Promise<unknown>[] = []
+      const ctx: ExecutionContext = {
+        waitUntil: (p) => waitUntilPromises.push(p),
+      }
+
+      await layer.get('page-123', ctx)
+
+      // Wait for background revalidation
+      await Promise.all(waitUntilPromises)
+
+      // Should not update caches if origin returns null
+      expect(mockPrimaryCache.put).not.toHaveBeenCalled()
+    })
+
+    it('should handle origin fetcher errors gracefully', async () => {
+      const staleData = new Uint8Array([1, 2, 3])
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(new Response(staleData))
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      const originFetcher = vi.fn().mockRejectedValue(new Error('Origin unavailable'))
+      layer.setOriginFetcher(originFetcher)
+
+      const waitUntilPromises: Promise<unknown>[] = []
+      const ctx: ExecutionContext = {
+        waitUntil: (p) => waitUntilPromises.push(p),
+      }
+
+      await layer.get('page-123', ctx)
+
+      // Wait for background revalidation - should not throw
+      await expect(Promise.all(waitUntilPromises)).resolves.not.toThrow()
+
+      const stats = layer.getStats()
+      expect(stats.errors).toBe(1)
+    })
+  })
+
+  describe('Cache key construction', () => {
+    it('should construct correct cache key URL', async () => {
+      mockPrimaryCache.match.mockResolvedValue(undefined)
+      mockStaleCache.match.mockResolvedValue(undefined)
+
+      const config: SWRCacheConfig = {
+        baseUrl: 'https://pglite.cache.local',
+      }
+      const layer = await createSWRCacheLayer(config)
+
+      await layer.get('my-page-key')
+      expect(mockPrimaryCache.match).toHaveBeenCalledWith(expect.any(Request))
+      const request = mockPrimaryCache.match.mock.calls[0][0] as Request
+      expect(request.url).toBe('https://pglite.cache.local/my-page-key')
+    })
+  })
+})