Open History to see the last commit
1import { describe, expect, it } from 'vitest'
2import { env } from 'cloudflare:test'
3import { eq } from 'drizzle-orm'
4
5import { getDb } from '../db/index.ts'
6import { cacheMeta } from '../db/schema.ts'
7import { swr } from './cache.ts'
8import type { SwrDeps } from './cache.ts'
9
10function makeDeps(start: number) {
11 const pending: Array<Promise<unknown>> = []
12 let current = start
13 const deps: SwrDeps = {
14 db: getDb(env),
15 kv: env.SCHEMA_CACHE,
16 waitUntil: (p) => pending.push(p),
17 now: () => current,
18 }
19 return {
20 deps,
21 flush: () => Promise.all(pending.splice(0)),
22 advance: (seconds: number) => {
23 current += seconds
24 },
25 pendingCount: () => pending.length,
26 }
27}
28
29function countingFetcher<T>(values: Array<T>) {
30 let calls = 0
31 return {
32 fetcher: () => {
33 const value = values[Math.min(calls, values.length - 1)]
34 calls++
35 if (value instanceof Error) return Promise.reject(value)
36 return Promise.resolve(value as Exclude<T, Error>)
37 },
38 calls: () => calls,
39 }
40}
41
42describe('swr', () => {
43 it('miss: fetches inline and persists value + metadata', async () => {
44 const { deps } = makeDeps(1000)
45 const { fetcher, calls } = countingFetcher([{ v: 1 }])
46
47 const result = await swr(deps, 'miss-key', fetcher, { staleTime: 60 })
48 expect(result).toEqual({
49 value: { v: 1 },
50 fetchedAt: 1000,
51 staleAt: 1060,
52 revalidating: false,
53 })
54 expect(calls()).toBe(1)
55
56 const meta = await deps.db.query.cacheMeta.findFirst({
57 where: eq(cacheMeta.key, 'miss-key'),
58 })
59 expect(meta).toMatchObject({
60 fetchedAt: 1000,
61 staleTime: 60,
62 refreshing: false,
63 })
64 })
65
66 it('fresh hit: serves from cache without calling the fetcher', async () => {
67 const { deps, advance } = makeDeps(1000)
68 const seed = countingFetcher([{ v: 'seed' }])
69 await swr(deps, 'fresh-key', seed.fetcher, { staleTime: 60 })
70
71 advance(30) // still fresh
72 const { fetcher, calls } = countingFetcher([{ v: 'never' }])
73 const result = await swr(deps, 'fresh-key', fetcher, { staleTime: 60 })
74 expect(result.value).toEqual({ v: 'seed' })
75 expect(result.revalidating).toBe(false)
76 expect(calls()).toBe(0)
77 })
78
79 it('stale hit: serves the old value and revalidates in the background', async () => {
80 const { deps, advance, flush } = makeDeps(1000)
81 const seed = countingFetcher([{ v: 'old' }])
82 await swr(deps, 'stale-key', seed.fetcher, { staleTime: 60 })
83
84 advance(61) // past staleAt, before the 2× stuck window
85 const { fetcher, calls } = countingFetcher([{ v: 'new' }])
86 const result = await swr(deps, 'stale-key', fetcher, { staleTime: 60 })
87 expect(result.value).toEqual({ v: 'old' }) // stale value served immediately
88 expect(result.revalidating).toBe(true)
89
90 await flush()
91 expect(calls()).toBe(1)
92
93 // Next read sees the revalidated value, fresh again.
94 const after = await swr(deps, 'stale-key', fetcher, { staleTime: 60 })
95 expect(after.value).toEqual({ v: 'new' })
96 expect(after.fetchedAt).toBe(1061)
97 expect(after.revalidating).toBe(false)
98 })
99
100 it('dedupes concurrent revalidation via the refreshing flag', async () => {
101 const { deps, advance, pendingCount } = makeDeps(1000)
102 const seed = countingFetcher([{ v: 'old' }])
103 await swr(deps, 'dedupe-key', seed.fetcher, { staleTime: 60 })
104
105 advance(61)
106 const first = countingFetcher([{ v: 'first' }])
107 const r1 = await swr(deps, 'dedupe-key', first.fetcher, { staleTime: 60 })
108 expect(r1.revalidating).toBe(true)
109
110 // Second stale read while the flag is set: no second revalidation.
111 const second = countingFetcher([{ v: 'second' }])
112 const r2 = await swr(deps, 'dedupe-key', second.fetcher, { staleTime: 60 })
113 expect(r2.revalidating).toBe(false)
114 expect(second.calls()).toBe(0)
115 expect(pendingCount()).toBe(1)
116 })
117
118 it('ignores a stuck refreshing flag older than 2× staleTime', async () => {
119 const { deps, advance, flush } = makeDeps(1000)
120 const seed = countingFetcher([{ v: 'old' }])
121 await swr(deps, 'stuck-key', seed.fetcher, { staleTime: 60 })
122
123 // Simulate a crashed revalidation that left the flag set.
124 await deps.db
125 .update(cacheMeta)
126 .set({ refreshing: true })
127 .where(eq(cacheMeta.key, 'stuck-key'))
128
129 advance(121) // > fetchedAt + 2×staleTime
130 const { fetcher, calls } = countingFetcher([{ v: 'recovered' }])
131 const result = await swr(deps, 'stuck-key', fetcher, { staleTime: 60 })
132 expect(result.revalidating).toBe(true)
133 await flush()
134 expect(calls()).toBe(1)
135
136 const after = await swr(deps, 'stuck-key', fetcher, { staleTime: 60 })
137 expect(after.value).toEqual({ v: 'recovered' })
138 })
139
140 it('records lastError and clears the flag when background revalidation fails', async () => {
141 const { deps, advance, flush } = makeDeps(1000)
142 const seed = countingFetcher([{ v: 'old' }])
143 await swr(deps, 'error-key', seed.fetcher, { staleTime: 60 })
144
145 advance(61)
146 const failing = countingFetcher([new Error('upstream exploded')])
147 const result = await swr(deps, 'error-key', failing.fetcher, {
148 staleTime: 60,
149 })
150 expect(result.value).toEqual({ v: 'old' })
151 await flush()
152
153 const meta = await deps.db.query.cacheMeta.findFirst({
154 where: eq(cacheMeta.key, 'error-key'),
155 })
156 expect(meta?.refreshing).toBe(false)
157 expect(meta?.lastError).toBe('upstream exploded')
158 // The stale value is still served on the next read.
159 const after = await swr(deps, 'error-key', seed.fetcher, { staleTime: 60 })
160 expect(after.value).toEqual({ v: 'old' })
161 })
162})