Open History to see the last commit
1import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
2import { parse } from 'yaml'
3
4import {
5 finalizeAddOns,
6 getAllAddOns,
7 populateAddOnOptionsDefaults,
8} from '../src/add-ons.js'
9import { createApp } from '../src/create-app.js'
10import { createMemoryEnvironment } from '../src/environment.js'
11import { createFrameworkDefinition as createReactFrameworkDefinition } from '../src/frameworks/react/index.js'
12import { createFrameworkDefinition as createSolidFrameworkDefinition } from '../src/frameworks/solid/index.js'
13
14import type { PackageManager } from '../src/package-manager.js'
15import type { Framework, FrameworkDefinition, Options } from '../src/types.js'
16
17function frameworkFromDefinition(definition: FrameworkDefinition): Framework {
18 const { addOns, base, ...framework } = definition
19
20 return {
21 ...framework,
22 getFiles: () => Promise.resolve(Object.keys(base)),
23 getFileContents: (path: string) => Promise.resolve(base[path]),
24 getDeletedFiles: () => Promise.resolve([]),
25 getAddOns: () => addOns,
26 }
27}
28
29async function generateApp(
30 definition: FrameworkDefinition,
31 addOnIds: Array<string>,
32 addOnOptions: Options['addOnOptions'] = {},
33 packageManager: PackageManager = 'pnpm',
34) {
35 const framework = frameworkFromDefinition(definition)
36 const chosenAddOns = await finalizeAddOns(framework, 'file-router', addOnIds)
37 const defaultAddOnOptions = populateAddOnOptionsDefaults(chosenAddOns)
38 const targetDir = '/partner-app'
39 const { environment, output } = createMemoryEnvironment(targetDir)
40
41 await createApp(environment, {
42 projectName: 'partner-app',
43 targetDir,
44 framework,
45 mode: 'file-router',
46 typescript: true,
47 tailwind: true,
48 packageManager,
49 git: false,
50 install: false,
51 intent: false,
52 chosenAddOns,
53 addOnOptions: {
54 ...defaultAddOnOptions,
55 ...addOnOptions,
56 },
57 includeExamples: true,
58 } satisfies Options)
59
60 return output
61}
62
63beforeEach(() => {
64 vi.stubGlobal(
65 'fetch',
66 vi.fn(
67 async () =>
68 new Response(JSON.stringify({ version: '1.0.0' }), { status: 200 }),
69 ),
70 )
71})
72
73afterEach(() => {
74 vi.unstubAllGlobals()
75})
76
77describe('partner add-on scaffolds', () => {
78 it('generates Clerk with its full-stack SDK and ordered middleware', async () => {
79 const output = await generateApp(createReactFrameworkDefinition(), [
80 'clerk',
81 ])
82 const packageJSON = JSON.parse(output.files['package.json'])
83 const envLocal = output.files['.env.local']
84 const envExample = output.files['.env.example']
85 const start = output.files['src/start.ts']
86 const header = output.files['src/integrations/clerk/header-user.tsx']
87 const demo = output.files['src/routes/demo/clerk.tsx']
88
89 expect(packageJSON.dependencies).toHaveProperty(
90 '@clerk/tanstack-react-start',
91 )
92 expect(packageJSON.dependencies).not.toHaveProperty('@clerk/clerk-react')
93 expect(envLocal).toContain('VITE_CLERK_PUBLISHABLE_KEY=')
94 expect(envLocal).toContain('CLERK_SECRET_KEY=')
95 expect(envExample).toContain('VITE_CLERK_PUBLISHABLE_KEY=')
96 expect(envExample).toContain('CLERK_SECRET_KEY=')
97 expect(start).toContain(
98 "import { clerkMiddleware } from '@clerk/tanstack-react-start/server'",
99 )
100 expect(start).toContain('clerkMiddleware()')
101 expect(start.indexOf('csrfMiddleware,')).toBeLessThan(
102 start.lastIndexOf('clerkMiddleware'),
103 )
104 expect(output.files['src/integrations/clerk/provider.tsx']).toContain(
105 "from '@clerk/tanstack-react-start'",
106 )
107 expect(header).toContain('<Show when="signed-in">')
108 expect(header).toContain('<Show when="signed-out">')
109 expect(header).not.toContain('<SignedIn>')
110 expect(header).not.toContain('<SignedOut>')
111 expect(demo).toContain("from '@clerk/tanstack-react-start'")
112 expect(demo).toContain('<Show when="signed-in">')
113 expect(demo).toContain('<Show when="signed-out">')
114 expect(demo).not.toContain('<SignedIn>')
115 expect(demo).not.toContain('<SignedOut>')
116 })
117
118 it('generates WorkOS with server auth, callback routes, and ordered middleware', async () => {
119 const output = await generateApp(createReactFrameworkDefinition(), [
120 'workos',
121 ])
122 const packageJSON = JSON.parse(output.files['package.json'])
123 const envLocal = output.files['.env.local']
124 const envExample = output.files['.env.example']
125 const start = output.files['src/start.ts']
126
127 expect(packageJSON.engines).toEqual({ node: '>=22.11.0' })
128 expect(packageJSON.dependencies).toHaveProperty(
129 '@workos/authkit-tanstack-react-start',
130 )
131 expect(packageJSON.dependencies).toHaveProperty('@workos-inc/node')
132 expect(packageJSON.dependencies).not.toHaveProperty(
133 '@workos-inc/authkit-react',
134 )
135 expect(envLocal).toContain('WORKOS_CLIENT_ID=')
136 expect(envLocal).toContain('WORKOS_API_KEY=')
137 expect(envLocal).toContain(
138 'WORKOS_REDIRECT_URI=http://localhost:3000/api/auth/callback',
139 )
140 expect(envLocal).toContain('WORKOS_COOKIE_PASSWORD=')
141 expect(envExample).toContain('WORKOS_CLIENT_ID=')
142 expect(envExample).toContain('WORKOS_API_KEY=')
143 expect(envExample).toContain('WORKOS_REDIRECT_URI=')
144 expect(envExample).toContain('WORKOS_COOKIE_PASSWORD=')
145 expect(start).toContain(
146 "import { authkitMiddleware } from '@workos/authkit-tanstack-react-start'",
147 )
148 expect(start).toContain('authkitMiddleware()')
149 expect(start.indexOf('csrfMiddleware,')).toBeLessThan(
150 start.lastIndexOf('authkitMiddleware'),
151 )
152 expect(output.files['src/routes/api/auth/callback.tsx']).toContain(
153 'handleCallbackRoute()',
154 )
155 expect(output.files['src/routes/api/auth/sign-in.tsx']).toContain(
156 'getSignInUrl(',
157 )
158 expect(output.files['src/integrations/workos/provider.tsx']).toContain(
159 "from '@workos/authkit-tanstack-react-start/client'",
160 )
161 })
162
163 it.each([
164 ['React', createReactFrameworkDefinition],
165 ['Solid', createSolidFrameworkDefinition],
166 ])(
167 'generates a Railpack-compatible %s deployment',
168 async (_name, createFrameworkDefinition) => {
169 const output = await generateApp(createFrameworkDefinition(), ['railway'])
170 const packageJSON = JSON.parse(output.files['package.json'])
171 const readme = output.files['README.md']
172
173 expect(packageJSON.dependencies).toHaveProperty(
174 'nitro',
175 '3.0.260610-beta',
176 )
177 expect(packageJSON.dependencies).not.toHaveProperty('nitro-nightly')
178 expect(Object.values(packageJSON.dependencies)).not.toContain(
179 'npm:nitro-nightly@latest',
180 )
181 expect(packageJSON.scripts.start).toBe('node .output/server/index.mjs')
182 expect(output.files['nixpacks.toml']).toBeUndefined()
183 expect(output.deletedFiles).toContain('nixpacks.toml')
184 expect(readme).toContain("Railway's Railpack builder")
185 expect(readme).toContain('node .output/server/index.mjs')
186 expect(readme).not.toContain('Nixpacks')
187 expect(readme).not.toContain('dist/client')
188 },
189 )
190
191 it.each([
192 ['React', createReactFrameworkDefinition],
193 ['Solid', createSolidFrameworkDefinition],
194 ])(
195 '%s partner deployment hosts only support file-router',
196 (_name, createFrameworkDefinition) => {
197 const definition = createFrameworkDefinition()
198 const framework = frameworkFromDefinition(definition)
199 const fileRouterIds = getAllAddOns(framework, 'file-router').map(
200 (addOn) => addOn.id,
201 )
202 const codeRouterIds = getAllAddOns(framework, 'code-router').map(
203 (addOn) => addOn.id,
204 )
205
206 for (const addOnId of ['render', 'vercel']) {
207 expect(
208 definition.addOns.find((addOn) => addOn.id === addOnId)?.modes,
209 ).toEqual(['file-router'])
210 expect(fileRouterIds).toContain(addOnId)
211 expect(codeRouterIds).not.toContain(addOnId)
212 }
213 },
214 )
215
216 it('rejects Deno for Render', async () => {
217 await expect(
218 generateApp(
219 createReactFrameworkDefinition(),
220 ['render'],
221 {},
222 'deno',
223 ),
224 ).rejects.toThrow(
225 'Render does not support the deno package manager. Choose npm, yarn, pnpm, bun.',
226 )
227 })
228
229 it('rejects Deno for Vercel', async () => {
230 await expect(
231 generateApp(
232 createReactFrameworkDefinition(),
233 ['vercel'],
234 {},
235 'deno',
236 ),
237 ).rejects.toThrow(
238 'Vercel does not support the deno package manager. Choose npm, yarn, pnpm, bun.',
239 )
240 })
241
242 it.each([
243 ['React', createReactFrameworkDefinition],
244 ['Solid', createSolidFrameworkDefinition],
245 ])(
246 'generates a Render Blueprint for %s',
247 async (_name, createFrameworkDefinition) => {
248 const output = await generateApp(createFrameworkDefinition(), ['render'])
249 const bunOutput = await generateApp(
250 createFrameworkDefinition(),
251 ['render'],
252 {},
253 'bun',
254 )
255 const packageJSON = JSON.parse(output.files['package.json'])
256 const renderYaml = output.files['render.yaml']
257 const bunRenderYaml = bunOutput.files['render.yaml']
258 const readme = output.files['README.md']
259
260 expect(packageJSON.dependencies).toHaveProperty(
261 'nitro',
262 '3.0.260610-beta',
263 )
264 expect(packageJSON.scripts.start).toBe('node .output/server/index.mjs')
265 expect(renderYaml).toContain('name: tanstack-start-app')
266 expect(renderYaml).toContain('buildCommand: pnpm install && pnpm build')
267 expect(renderYaml).toContain('startCommand: pnpm start')
268 expect(renderYaml).not.toContain('key: BUN_VERSION')
269 expect(bunRenderYaml).toContain('key: BUN_VERSION')
270 expect(bunRenderYaml).toContain("value: '1.3.14'")
271 expect(renderYaml).toContain('value: render-com')
272 expect(renderYaml).toContain('value: 0.0.0.0')
273 expect(output.files['render.yaml.ejs']).toBeUndefined()
274 expect(readme).toContain('New > Blueprint')
275 expect(readme).not.toContain('Deploy to Render button')
276 expect(readme).not.toContain('render.com/deploy')
277 },
278 )
279
280 it.each([
281 ['npm', 'npm install && npm run build', 'npm run start'],
282 ['yarn', 'yarn install && yarn run build', 'yarn run start'],
283 ['pnpm', 'pnpm install && pnpm build', 'pnpm start'],
284 ['bun', 'bun install && bun --bun run build', 'bun --bun run start'],
285 ] as const)(
286 'uses %s commands in the Render Blueprint',
287 async (packageManager, buildCommand, startCommand) => {
288 const output = await generateApp(
289 createReactFrameworkDefinition(),
290 ['render'],
291 {},
292 packageManager,
293 )
294 const renderYaml = output.files['render.yaml']
295
296 expect(renderYaml).toContain(`buildCommand: ${buildCommand}`)
297 expect(renderYaml).toContain(`startCommand: ${startCommand}`)
298 if (packageManager === 'bun') {
299 expect(renderYaml).toContain('key: BUN_VERSION')
300 expect(renderYaml).toContain("value: '1.3.14'")
301 } else {
302 expect(renderYaml).not.toContain('key: BUN_VERSION')
303 }
304 },
305 )
306
307 it.each([
308 ['React', createReactFrameworkDefinition],
309 ['Solid', createSolidFrameworkDefinition],
310 ])(
311 'generates a Vercel Build Output API deployment for %s',
312 async (_name, createFrameworkDefinition) => {
313 const definition = createFrameworkDefinition()
314 const vercel = definition.addOns.find((addOn) => addOn.id === 'vercel')
315 const output = await generateApp(definition, ['vercel'])
316 const packageJSON = JSON.parse(output.files['package.json'])
317 const vercelJSON = JSON.parse(output.files['vercel.json'])
318 const viteConfig = output.files['vite.config.ts']
319 const readme = output.files['README.md']
320
321 expect(vercel?.partner).toEqual({ id: 'vercel', tier: 'gold' })
322 expect(vercel?.supportedPackageManagers).toEqual([
323 'npm',
324 'yarn',
325 'pnpm',
326 'bun',
327 ])
328 expect(packageJSON.dependencies).toHaveProperty(
329 'nitro',
330 '3.0.260610-beta',
331 )
332 expect(vercelJSON).toEqual({
333 $schema: 'https://openapi.vercel.sh/vercel.json',
334 framework: 'tanstack-start',
335 })
336 expect(viteConfig).toContain("import { nitro } from 'nitro/vite'")
337 expect(viteConfig).toContain('nitro()')
338 expect(viteConfig).not.toContain('NITRO_PRESET')
339 expect(output.files['src/server.ts']).toBeUndefined()
340 expect(readme).toContain('Add New > Project')
341 expect(readme).not.toContain('vercel.com/new/clone')
342 },
343 )
344
345 it.each([
346 ['React', createReactFrameworkDefinition],
347 ['Solid', createSolidFrameworkDefinition],
348 ])(
349 'approves Netlify build dependencies for pnpm in %s projects',
350 async (_name, createFrameworkDefinition) => {
351 const output = await generateApp(createFrameworkDefinition(), ['netlify'])
352 const packageJSON = JSON.parse(output.files['package.json'])
353 const pnpmWorkspace = output.files['pnpm-workspace.yaml']
354
355 expect(packageJSON.pnpm.onlyBuiltDependencies).toContain('sharp')
356 expect(pnpmWorkspace).toContain('sharp: true')
357 expect(pnpmWorkspace).not.toContain('workerd: true')
358 },
359 )
360
361 it.each(['ai', 'events', 'resume'])(
362 'approves Gemini install scripts only when the %s integration is selected',
363 async (addOn) => {
364 const output = await generateApp(createReactFrameworkDefinition(), [addOn])
365 const packageJSON = JSON.parse(output.files['package.json'])
366 expect(packageJSON.pnpm.onlyBuiltDependencies).toEqual(
367 expect.arrayContaining(['@google/genai', 'protobufjs']),
368 )
369 expect(parse(output.files['pnpm-workspace.yaml']).allowBuilds).toEqual(
370 expect.objectContaining({ '@google/genai': true, protobufjs: true }),
371 )
372 },
373 )
374
375 it('does not approve Gemini scripts in projects without AI', async () => {
376 const output = await generateApp(createReactFrameworkDefinition(), [])
377 expect(output.files['pnpm-workspace.yaml']).not.toContain('@google/genai')
378 expect(output.files['pnpm-workspace.yaml']).not.toContain('protobufjs')
379 })
380
381 it.each(['postgres', 'mysql', 'sqlite'])(
382 'approves Prisma build dependencies for pnpm with %s',
383 async (database) => {
384 const output = await generateApp(
385 createReactFrameworkDefinition(),
386 ['prisma'],
387 { prisma: { database } },
388 )
389 const packageJSON = JSON.parse(output.files['package.json'])
390 const pnpmWorkspace = output.files['pnpm-workspace.yaml']
391
392 expect(packageJSON.pnpm.onlyBuiltDependencies).toEqual(
393 expect.arrayContaining(['@prisma/engines', 'prisma']),
394 )
395 expect(pnpmWorkspace).toContain("'@prisma/engines': true")
396 expect(pnpmWorkspace).toContain('prisma: true')
397
398 if (database === 'sqlite') {
399 expect(packageJSON.pnpm.onlyBuiltDependencies).toContain(
400 'better-sqlite3',
401 )
402 expect(pnpmWorkspace).toContain('better-sqlite3: true')
403 } else {
404 expect(packageJSON.pnpm.onlyBuiltDependencies).not.toContain(
405 'better-sqlite3',
406 )
407 expect(pnpmWorkspace).not.toContain('better-sqlite3: true')
408 }
409 },
410 )
411
412 it('generates a URL-driven, env-aware Prisma MySQL setup', async () => {
413 const output = await generateApp(
414 createReactFrameworkDefinition(),
415 ['prisma'],
416 { prisma: { database: 'mysql' } },
417 )
418 const databaseUrl = output.files['src/database-url.ts']
419 const db = output.files['src/db.ts']
420 const seed = output.files['prisma/seed.ts']
421 const demo = output.files['src/routes/demo/prisma.tsx']
422
423 expect(databaseUrl).toContain('process.env.DATABASE_URL')
424 expect(databaseUrl).toContain("throw new Error('DATABASE_URL is required')")
425 expect(db).toContain('new PrismaMariaDb(getDatabaseUrl())')
426 expect(seed).toContain('new PrismaMariaDb(getDatabaseUrl())')
427 expect(db).not.toContain('host: "localhost"')
428 expect(seed).not.toContain('host: "localhost"')
429 expect(demo).toContain('.validator(')
430 expect(demo).not.toContain('.inputValidator(')
431 expect(demo).toContain('pnpm db:generate')
432 expect(demo).toContain('pnpm db:push')
433 expect(demo).toContain('pnpm db:studio')
434 expect(demo).not.toContain('pnpm dlx prisma')
435 })
436
437 it.each([
438 ['React', createReactFrameworkDefinition],
439 ['Solid', createSolidFrameworkDefinition],
440 ])(
441 'approves Cloudflare build dependencies for pnpm in %s projects',
442 async (_name, createFrameworkDefinition) => {
443 const output = await generateApp(createFrameworkDefinition(), [
444 'cloudflare',
445 ])
446 const packageJSON = JSON.parse(output.files['package.json'])
447 const pnpmWorkspace = output.files['pnpm-workspace.yaml']
448
449 expect(packageJSON.pnpm.onlyBuiltDependencies).toEqual(
450 expect.arrayContaining(['sharp', 'workerd']),
451 )
452 expect(pnpmWorkspace).toContain('sharp: true')
453 expect(pnpmWorkspace).toContain('workerd: true')
454 },
455 )
456
457 it('uses Workers instrumentation instead of Node preload for Sentry on Cloudflare', async () => {
458 const output = await generateApp(createReactFrameworkDefinition(), [
459 'sentry',
460 'cloudflare',
461 ])
462 const manifest = JSON.parse(output.files['package.json'])
463
464 expect(manifest.dependencies).toHaveProperty('@sentry/cloudflare', '^10.67.0')
465 expect(manifest.scripts.build).toBe('vite build')
466 expect(manifest.scripts.dev).not.toContain('NODE_OPTIONS')
467 expect(manifest.scripts.start).toBe('vite preview')
468 expect(JSON.parse(output.files['wrangler.jsonc']).main).toBe('./src/worker.ts')
469 expect(output.files['src/worker.ts']).toContain('withSentry(')
470 expect(output.files['src/worker.ts']).toContain('wrapFetchWithSentry(')
471 expect(output.files['src/worker.ts']).toContain('env.VITE_SENTRY_DSN ??')
472 expect(output.files['src/worker.ts']).toContain(
473 'httpHeaders: { request: false, response: false }',
474 )
475 expect(output.files['src/worker.ts']).toContain('cookies: false')
476 expect(output.files['src/worker.ts']).toContain("maxRequestBodySize: 'none'")
477 expect(output.files['src/start.ts']).toContain('sentryGlobalRequestMiddleware,')
478 expect(output.files['src/start.ts']).toContain('functionMiddleware: [sentryGlobalFunctionMiddleware]')
479 expect(output.files['instrument.server.mjs']).toBeUndefined()
480 })
481
482 it('generates Sentry with privacy-conscious sampling defaults', async () => {
483 const output = await generateApp(createReactFrameworkDefinition(), [
484 'sentry',
485 ])
486 const packageJSON = JSON.parse(output.files['package.json'])
487 const instrumentation = output.files['instrument.server.mjs']
488
489 expect(packageJSON.dependencies).toHaveProperty(
490 '@sentry/tanstackstart-react',
491 '^10.67.0',
492 )
493 expect(packageJSON.scripts.build).toBe(
494 'vite build && cp instrument.server.mjs .output/server',
495 )
496 expect(packageJSON.scripts.dev).toBe(
497 `dotenv -e .env.local -- sh -c "NODE_OPTIONS='--import ./instrument.server.mjs' vite dev --port 3000"`,
498 )
499 expect(packageJSON.pnpm.onlyBuiltDependencies).toContain('@sentry/cli')
500 expect(output.files['pnpm-workspace.yaml']).toContain("'@sentry/cli': true")
501 expect(instrumentation).toContain('userInfo: false')
502 expect(instrumentation).toContain('httpBodies: []')
503 expect(instrumentation).toContain('tracesSampleRate: 0.1')
504 expect(instrumentation).not.toContain('sendDefaultPii')
505 expect(instrumentation).not.toContain('replaysSessionSampleRate')
506 expect(instrumentation).not.toContain('replaysOnErrorSampleRate')
507 })
508
509 it.each([[['clerk', 'sentry', 'railway']], [['railway', 'sentry', 'clerk']]])(
510 'composes Clerk, Sentry, and Railway independent of selection order: %j',
511 async (addOnIds) => {
512 const output = await generateApp(
513 createReactFrameworkDefinition(),
514 addOnIds,
515 )
516 const packageJSON = JSON.parse(output.files['package.json'])
517
518 expect(output.files['src/start.ts']).toContain('clerkMiddleware()')
519 expect(packageJSON.dependencies).toHaveProperty('nitro')
520 expect(packageJSON.dependencies).not.toHaveProperty('nitro-nightly')
521 expect(packageJSON.scripts.start).toContain(
522 '--import ./.output/server/instrument.server.mjs',
523 )
524 expect(packageJSON.scripts.start).toContain('.output/server/index.mjs')
525 expect(output.files['instrument.server.mjs']).toBeDefined()
526 expect(output.files['nixpacks.toml']).toBeUndefined()
527 },
528 )
529
530 it('starts Render through the Sentry-aware package script', async () => {
531 const output = await generateApp(createReactFrameworkDefinition(), [
532 'sentry',
533 'render',
534 ])
535 const packageJSON = JSON.parse(output.files['package.json'])
536
537 expect(packageJSON.scripts.start).toContain(
538 '--import ./.output/server/instrument.server.mjs',
539 )
540 expect(output.files['render.yaml']).toContain('startCommand: pnpm start')
541 })
542
543 it.each([[['sentry', 'vercel']], [['vercel', 'sentry']]])(
544 'composes Sentry with Vercel independent of selection order: %j',
545 async (addOnIds) => {
546 const output = await generateApp(
547 createReactFrameworkDefinition(),
548 addOnIds,
549 )
550 const packageJSON = JSON.parse(output.files['package.json'])
551 const serverEntry = output.files['src/server.ts']
552 const viteConfig = output.files['vite.config.ts']
553
554 expect(packageJSON.scripts.build).toBe('vite build')
555 expect(packageJSON.scripts.build).not.toContain('.output/server')
556 expect(packageJSON.scripts.dev).toBe(
557 'dotenv -e .env.local -- vite dev --port 3000',
558 )
559 expect(packageJSON.scripts.dev).not.toContain('NODE_OPTIONS')
560 expect(packageJSON.scripts.start).toBe('node .output/server/index.mjs')
561 expect(serverEntry).toContain("import '../instrument.server.mjs'")
562 expect(serverEntry).toContain('wrapFetchWithSentry')
563 expect(serverEntry).toContain('createServerEntry')
564 expect(viteConfig).not.toContain('rollupConfig')
565 expect(viteConfig).not.toContain('external:')
566 },
567 )
568})