forked from vercel/next.js
/
spr-cache.ts
184 lines (165 loc) · 4.69 KB
/
spr-cache.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
import fs from 'fs'
import path from 'path'
import LRUCache from 'lru-cache'
import { promisify } from 'util'
import { PrerenderManifest } from '../../build'
import { PRERENDER_MANIFEST } from '../lib/constants'
import { normalizePagePath } from './normalize-page-path'
import mkdirpOrig from 'mkdirp'
const mkdirp = promisify(mkdirpOrig)
const readFile = promisify(fs.readFile)
const writeFile = promisify(fs.writeFile)
type SprCacheValue = {
html: string
pageData: any
isStale?: boolean
curRevalidate?: number | false
// milliseconds to revalidate after
revalidateAfter: number | false
}
let cache: LRUCache<string, SprCacheValue>
let prerenderManifest: PrerenderManifest
let sprOptions: {
flushToDisk?: boolean
pagesDir?: string
distDir?: string
dev?: boolean
} = {}
const getSeedPath = (pathname: string, ext: string): string => {
return path.join(sprOptions.pagesDir!, `${pathname}.${ext}`)
}
export const calculateRevalidate = (pathname: string): number | false => {
// in development we don't have a prerender-manifest
// and default to always revalidating to allow easier debugging
const curTime = new Date().getTime()
if (sprOptions.dev) return curTime - 1000
const { initialRevalidateSeconds } = prerenderManifest.routes[pathname] || {
initialRevalidateSeconds: 1,
}
const revalidateAfter =
typeof initialRevalidateSeconds === 'number'
? initialRevalidateSeconds * 1000 + curTime
: initialRevalidateSeconds
return revalidateAfter
}
// initialize the SPR cache
export function initializeSprCache({
max,
dev,
distDir,
pagesDir,
flushToDisk,
}: {
dev: boolean
max?: number
distDir: string
pagesDir: string
flushToDisk?: boolean
}) {
sprOptions = {
dev,
distDir,
pagesDir,
flushToDisk:
!dev && (typeof flushToDisk !== 'undefined' ? flushToDisk : true),
}
try {
prerenderManifest = dev
? { routes: {}, dynamicRoutes: [] }
: JSON.parse(
fs.readFileSync(path.join(distDir, PRERENDER_MANIFEST), 'utf8')
)
} catch (_) {
prerenderManifest = { version: 1, routes: {}, dynamicRoutes: {} }
}
cache = new LRUCache({
// default to 50MB limit
max: max || 50 * 1024 * 1024,
length(val) {
// rough estimate of size of cache value
return val.html.length + JSON.stringify(val.pageData).length
},
})
}
// get data from SPR cache if available
export async function getSprCache(
pathname: string
): Promise<SprCacheValue | undefined> {
if (sprOptions.dev) return
pathname = normalizePagePath(pathname)
let data: SprCacheValue | undefined = cache.get(pathname)
// let's check the disk for seed data
if (!data) {
try {
const html = await readFile(getSeedPath(pathname, 'html'), 'utf8')
const pageData = JSON.parse(
await readFile(getSeedPath(pathname, 'json'), 'utf8')
)
data = {
html,
pageData,
revalidateAfter: calculateRevalidate(pathname),
}
cache.set(pathname, data)
} catch (_) {
// unable to get data from disk
}
}
if (
data &&
data.revalidateAfter !== false &&
data.revalidateAfter < new Date().getTime()
) {
data.isStale = true
}
const manifestEntry = prerenderManifest.routes[pathname]
if (data && manifestEntry) {
data.curRevalidate = manifestEntry.initialRevalidateSeconds
}
return data
}
// populate the SPR cache with new data
export async function setSprCache(
pathname: string,
data: {
html: string
pageData: any
},
revalidateSeconds?: number | false
) {
if (sprOptions.dev) return
if (typeof revalidateSeconds !== 'undefined') {
// TODO: Update this to not mutate the manifest from the
// build.
prerenderManifest.routes[pathname] = {
dataRoute: path.posix.join(
'/_next/data',
`${normalizePagePath(pathname)}.json`
),
srcRoute: null, // FIXME: provide actual source route, however, when dynamically appending it doesn't really matter
initialRevalidateSeconds: revalidateSeconds,
}
}
pathname = normalizePagePath(pathname)
cache.set(pathname, {
...data,
revalidateAfter: calculateRevalidate(pathname),
})
// TODO: This option needs to cease to exist unless it stops mutating the
// `next build` output's manifest.
if (sprOptions.flushToDisk) {
try {
const seedPath = getSeedPath(pathname, 'html')
await mkdirp(path.dirname(seedPath))
await writeFile(seedPath, data.html, 'utf8')
await writeFile(
getSeedPath(pathname, 'json'),
JSON.stringify(data.pageData),
'utf8'
)
} catch (error) {
// failed to flush to disk
console.warn('Failed to update prerender files for', pathname, error)
}
}
}