Skip to content
Source
Sign inSign up
TanStack/cli
Open History to see the last commit

worker-manifest.test.ts

373 lines10.5 KB

1import { existsSync, readFileSync, statSync } from 'node:fs'
2import { dirname, resolve } from 'node:path'
3import { fileURLToPath } from 'node:url'
4​
5import ts from 'typescript'
6import { describe, expect, it, vi } from 'vitest'
7​
8import {
9 createApp as createEdgeApp,
10 createMemoryEnvironment as createEdgeMemoryEnvironment,
11 finalizeAddOns as finalizeEdgeAddOns,
12 getFrameworkById as getEdgeFrameworkById,
13 populateAddOnOptionsDefaults as populateEdgeAddOnOptionsDefaults,
14} from '../src/edge.js'
15import {
16 createMemoryEnvironment,
17 createWorkerCreate,
18 createWorkerManifestLoader,
19} from '../src/worker.js'
20import { createBundledWorkerManifestLoader } from '../src/generated/worker/bundled-loader.js'
21​
22import type { Options } from '../src/types.js'
23import type {
24 ManifestCatalog,
25 WorkerManifestLoader,
26 WorkerManifestModuleLoader,
27} from '../src/manifest-types.js'
28​
29const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '..')
30​
31function resolveSourceImport(from: string, specifier: string) {
32 const resolved = resolve(dirname(from), specifier)
33 const withoutJsExtension = specifier.endsWith('.js')
34 ? resolved.slice(0, -'.js'.length)
35 : resolved
36 const candidates = [
37 resolved,
38 `${withoutJsExtension}.ts`,
39 resolve(withoutJsExtension, 'index.ts'),
40 ]
41​
42 return candidates.find((candidate) => existsSync(candidate))
44​
45function collectStaticImportGraph(entry: string) {
46 const visited = new Set<string>()
47 const pending = [entry]
48​
49 while (pending.length) {
50 const file = pending.pop()!
51 if (visited.has(file)) {
52 continue
53 }
54 visited.add(file)
55​
56 const source = ts.createSourceFile(
57 file,
58 readFileSync(file, 'utf8'),
59 ts.ScriptTarget.Latest,
60 true,
61 ts.ScriptKind.TS,
62 )
63​
64 for (const statement of source.statements) {
65 if (
66 (ts.isImportDeclaration(statement) ||
67 ts.isExportDeclaration(statement)) &&
68 statement.moduleSpecifier &&
69 ts.isStringLiteral(statement.moduleSpecifier)
70 ) {
71 const specifier = statement.moduleSpecifier.text
72 if (!specifier.startsWith('.')) {
73 continue
74 }
75​
76 const imported = resolveSourceImport(file, specifier)
77 if (imported) {
78 pending.push(imported)
79 }
80 }
81 }
82 }
83​
84 return visited
86​
87function createTrackedLoader() {
88 const bundledLoader = createBundledWorkerManifestLoader()
89 const loaded = {
90 catalogs: 0,
91 frameworks: [] as Array<string>,
92 addOns: [] as Array<string>,
93 }
94​
95 const loader: WorkerManifestLoader = {
96 async loadCatalog() {
97 loaded.catalogs++
98 return bundledLoader.loadCatalog()
99 },
100 async loadFramework(frameworkId) {
101 loaded.frameworks.push(frameworkId)
102 return bundledLoader.loadFramework(frameworkId)
103 },
104 async loadAddOn(frameworkId, addOnId) {
105 loaded.addOns.push(`${frameworkId}:${addOnId}`)
106 return bundledLoader.loadAddOn(frameworkId, addOnId)
107 },
108 }
109​
110 return { loader, loaded }
112​
113describe('@tanstack/create/worker manifest loading', () => {
114 it('preserves loader method context and retries failed chunk loads', async () => {
115 const manifestCatalog: ManifestCatalog = {
116 frameworks: [
117 {
118 id: 'react',
119 name: 'React',
120 description: '',
121 version: '1.0.0',
122 basePackageJSON: {},
123 optionalPackages: {},
124 supportedModes: {
125 'file-router': {
126 displayName: 'File Router',
127 description: '',
128 forceTypescript: true,
129 },
130 },
131 addOns: [
132 {
133 id: 'retry',
134 name: 'Retry',
135 description: '',
136 type: 'add-on',
137 phase: 'add-on',
138 modes: ['file-router'],
139 },
140 ],
141 },
142 ],
143 }
144 let frameworkLoads = 0
145 let addOnLoads = 0
146 const moduleLoader: WorkerManifestModuleLoader & {
147 catalog: ManifestCatalog
148 } = {
149 catalog: manifestCatalog,
150 async loadCatalog() {
151 return this.catalog
152 },
153 async loadFramework() {
154 frameworkLoads++
155 if (frameworkLoads === 1) {
156 throw new Error('temporary framework load failure')
157 }
158​
159 return {
160 framework: {
161 id: 'react',
162 base: {
163 'package.json': '{}',
164 },
165 },
166 renderManifestTemplate: () => '',
167 }
168 },
169 async loadAddOn() {
170 addOnLoads++
171 if (addOnLoads === 1) {
172 throw new Error('temporary add-on load failure')
173 }
174​
175 return {
176 addOn: {
177 id: 'retry',
178 name: 'Retry',
179 description: '',
180 type: 'add-on',
181 phase: 'add-on',
182 modes: ['file-router'],
183 files: {
184 'src/retry.ts': '',
185 },
186 deletedFiles: [],
187 },
188 renderManifestTemplate: () => '',
189 }
190 },
191 }
192 const workerCreate = createWorkerCreate(
193 createWorkerManifestLoader(moduleLoader),
194 )
195 const framework = await workerCreate.getFrameworkById('react')
196​
197 await expect(framework!.getFiles()).rejects.toThrow(
198 'temporary framework load failure',
199 )
200 await expect(framework!.getFiles()).resolves.toEqual(['package.json'])
201​
202 const addOn = framework!.getAddOns()[0]!
203 await expect(addOn.getFiles()).rejects.toThrow(
204 'temporary add-on load failure',
205 )
206 await expect(addOn.getFiles()).resolves.toEqual(['src/retry.ts'])
207 })
208​
209 it('keeps the worker entrypoint away from generated manifest modules', () => {
210 const graph = collectStaticImportGraph(resolve(packageDir, 'src/worker.ts'))
211 const relativeGraph = Array.from(graph).map((file) =>
212 file.slice(packageDir.length + 1).replace(/\\/g, '/'),
213 )
214 const totalBytes = Array.from(graph).reduce(
215 (sum, file) => sum + statSync(file).size,
216 0,
217 )
218​
219 expect(relativeGraph).not.toContain('src/generated/create-manifest.ts')
220 expect(relativeGraph.some((file) => file.startsWith('src/generated/'))).toBe(
221 false,
222 )
223 expect(totalBytes).toBeLessThan(160_000)
224 })
225​
226 it('loads only selected manifest chunks and matches edge generation', async () => {
227 try {
228 vi.stubGlobal(
229 'fetch',
230 vi.fn(async () => {
231 return new Response(JSON.stringify({ version: '1.0.0' }), {
232 status: 200,
233 })
234 }),
235 )
236​
237 const { loader, loaded } = createTrackedLoader()
238 const workerCreate = createWorkerCreate(loader)
239​
240 const framework = await workerCreate.getFrameworkById('react')
241 expect(framework).toBeDefined()
242 expect(loaded).toEqual({
243 catalogs: 1,
244 frameworks: [],
245 addOns: [],
246 })
247​
248 const featureIds = workerCreate
249 .getAllAddOns(framework!, 'file-router')
250 .map((addOn) => addOn.id)
251 expect(featureIds).toContain('tanstack-query')
252 expect(featureIds).toContain('cloudflare')
253 expect(loaded.frameworks).toEqual([])
254 expect(loaded.addOns).toEqual([])
255​
256 const chosenAddOns = await workerCreate.finalizeAddOns(
257 framework!,
258 'file-router',
259 ['tanstack-query', 'cloudflare', 'biome'],
260 )
261 expect(loaded.addOns.sort()).toEqual([
262 'react:biome',
263 'react:cloudflare',
264 'react:tanstack-query',
265 ])
266​
267 const addOnOptions =
268 workerCreate.populateAddOnOptionsDefaults(chosenAddOns)
269 const { environment, output } = createMemoryEnvironment('/worker-app')
270​
271 await workerCreate.createApp(environment, {
272 projectName: 'worker-app',
273 targetDir: '/worker-app',
274 framework: framework!,
275 mode: 'file-router',
276 typescript: true,
277 tailwind: true,
278 packageManager: 'pnpm',
279 git: false,
280 install: false,
281 intent: false,
282 chosenAddOns,
283 addOnOptions,
284 includeExamples: false,
285 } satisfies Options)
286​
287 expect(loaded.frameworks).toEqual(['react'])
288​
289 const edgeFramework = getEdgeFrameworkById('react')
290 expect(edgeFramework).toBeDefined()
291 const edgeChosenAddOns = await finalizeEdgeAddOns(
292 edgeFramework!,
293 'file-router',
294 ['tanstack-query', 'cloudflare', 'biome'],
295 )
296 const edgeAddOnOptions =
297 populateEdgeAddOnOptionsDefaults(edgeChosenAddOns)
298 const { environment: edgeEnvironment, output: edgeOutput } =
299 createEdgeMemoryEnvironment('/worker-app')
300​
301 await createEdgeApp(edgeEnvironment, {
302 projectName: 'worker-app',
303 targetDir: '/worker-app',
304 framework: edgeFramework!,
305 mode: 'file-router',
306 typescript: true,
307 tailwind: true,
308 packageManager: 'pnpm',
309 git: false,
310 install: false,
311 intent: false,
312 chosenAddOns: edgeChosenAddOns,
313 addOnOptions: edgeAddOnOptions,
314 includeExamples: false,
315 } satisfies Options)
316​
317 expect(output.files).toEqual(edgeOutput.files)
318 } finally {
319 vi.unstubAllGlobals()
320 }
321 })
322​
323 it('keeps Rsbuild rendering equal between worker and edge manifests', async () => {
324 try {
325 vi.stubGlobal(
326 'fetch',
327 vi.fn(
328 async () =>
329 new Response(JSON.stringify({ version: '1.0.0' }), {
330 status: 200,
331 }),
332 ),
333 )
334​
335 const { loader } = createTrackedLoader()
336 const workerCreate = createWorkerCreate(loader)
337 const framework = await workerCreate.getFrameworkById('react')
338 const options = {
339 projectName: 'rsbuild-worker-app',
340 targetDir: '/rsbuild-worker-app',
341 framework: framework!,
342 mode: 'file-router',
343 bundler: 'rsbuild',
344 typescript: true,
345 tailwind: true,
346 packageManager: 'pnpm',
347 git: false,
348 install: false,
349 intent: false,
350 chosenAddOns: [],
351 addOnOptions: {},
352 includeExamples: false,
353 } satisfies Options
354 const { environment, output } = createMemoryEnvironment(options.targetDir)
355​
356 await workerCreate.createApp(environment, options)
357​
358 const edgeFramework = getEdgeFrameworkById('react')
359 const { environment: edgeEnvironment, output: edgeOutput } =
360 createEdgeMemoryEnvironment(options.targetDir)
361 await createEdgeApp(edgeEnvironment, {
362 ...options,
363 framework: edgeFramework!,
364 })
365​
366 expect(output.files).toEqual(edgeOutput.files)
367 expect(output.files).toHaveProperty('rsbuild.config.ts')
368 expect(output.files).not.toHaveProperty('vite.config.ts')
369 } finally {
370 vi.unstubAllGlobals()
371 }
372 })
373})