Open History to see the last commit
1import { expect, test } from 'vitest'
2import {
3 callProvider,
4 compileAll,
5 compileCode,
6 evaluateModule,
7 importSources,
8} from '../regression-helpers'
9β
10// The provider module runs the extracted handler: it must keep every module
11// binding the handler closes over, however the handler is written and
12// however its scopes shadow module names.
13β
14const head = `import { createServerFn } from '@tanstack/react-start'\n`
15const dbServer = `export const db = { x: () => 'x', y: () => 'y' }`
16β
17// Source: Next.js server-actions fixtures server-graph/5, /6, /16
18test('the provider keeps every kind of module binding the handler reads', async () => {
19 const { client, provider } =
20 await compileAll(`${head}import * as ns from './ns'
21var counter = 4
22class Repo {
23 static get() {
24 return 'repo'
25 }
26}
27enum Role {
28 Admin = 'admin',
29}
30export const fn = createServerFn().handler(async () => [ns.x, counter, Repo.get(), Role.Admin])`)
31 expect(importSources(client)).toEqual([])
32 expect(
33 await callProvider(provider, 'fn', { './ns': `export const x = 'ns'` }),
34 ).toEqual(['ns', 4, 'repo', 'admin'])
35})
36β
37test.each<{
38 name: string
39 code: string
40 expected: unknown
41 read?: (value: any) => Promise<unknown>
42}>([
43 {
44 // Source: Next.js server-actions fixtures server-graph/7, /44
45 name: 'a named function expression',
46 code: `export const fn = createServerFn().handler(async function deleteItem() {
47 return deleteItem.name + db.x()
48})`,
49 expected: 'deleteItemx',
50 },
51 {
52 // Source: Next.js server-actions fixtures server-graph/59
53 name: 'a function using this, arguments and new.target',
54 code: `export const fn = createServerFn().handler(async function (this: unknown) {
55 return [typeof this, arguments.length, new.target === undefined, db.x()]
56})`,
57 expected: ['undefined', 1, true, 'x'],
58 },
59 {
60 // Source: Next.js server-actions fixtures server-graph/14 (streaming)
61 name: 'an async generator',
62 code: `export const fn = createServerFn().handler(async function* () {
63 yield db.x()
64 yield 'done'
65})`,
66 read: async (iterator: AsyncIterable<unknown>) => {
67 const values: Array<unknown> = []
68 for await (const value of iterator) {
69 values.push(value)
70 }
71 return values
72 },
73 expected: ['x', 'done'],
74 },
75 {
76 // Source: Next.js server-actions fixtures server-graph/31
77 name: 'an object literal method',
78 code: `export const fn = createServerFn().handler({
79 async f() {
80 return db.x()
81 },
82}.f)`,
83 expected: 'x',
84 },
85 {
86 // Source: Next.js server-actions fixtures server-graph/21, /26
87 name: 'a wrapper call',
88 code: `import { withAuth } from './auth.server'
89export const fn = createServerFn().handler(withAuth(async () => db.x()))`,
90 expected: 'auth:x',
91 },
92 {
93 // Source: Next.js server-actions fixtures server-graph/25
94 name: 'a function declared after the server fn',
95 code: `export const fn = createServerFn().handler(impl)
96async function impl() {
97 return inner()
98 async function inner() {
99 return db.x()
100 }
101}`,
102 expected: 'x',
103 },
104 {
105 // Source: Next.js server-actions fixtures server-graph/28, /30
106 name: 'a call of a server fn declared later',
107 code: `export const fn = createServerFn().handler(async () => (await later()) + db.x())
108export const later = createServerFn().handler(async () => 'later:')`,
109 expected: 'later:x',
110 },
111 {
112 name: 'a parenthesized non-null initializer',
113 code: `export const fn = (createServerFn().handler(async () => db.x()))!`,
114 expected: 'x',
115 },
116 {
117 name: 'a createServerOnlyFn call',
118 code: `import { createServerOnlyFn } from '@tanstack/react-start'
119export const fn = createServerFn().handler(createServerOnlyFn(async () => db.x()))`,
120 expected: 'x',
121 },
122])(
123 'the handler can be $name',
124 async ({ code, expected, read = async (value) => value }) => {
125 const compiled = await compileAll(
126 `${head}import { db } from './db.server'\n${code}`,
127 )
128 // Callers call the server fn through its RPC.
129 for (const output of ['client', 'ssr'] as const) {
130 expect(importSources(compiled[output]), output).toEqual([])
131 expect((await evaluateModule(compiled[output])).fn, output).toEqual({
132 rpc: { [output]: expect.any(String) },
133 })
134 }
135 const value = await callProvider(compiled.provider, 'fn', {
136 './db.server': dbServer,
137 './auth.server': `export const withAuth = (fn) => async (opts) => 'auth:' + (await fn(opts))`,
138 })
139 expect(await read(value)).toEqual(expected)
140 },
141)
142β
143// Each handler reads the module binding `value` (or `key`) through a scope
144// that also declares, or seems to declare, the same name.
145test.each<{ name: string; code: string; data?: unknown; expected: unknown }>([
146 {
147 // Source: @vitejs/plugin-rsc hoist/function-hoist-block.js (block-level
148 // functions are block scoped in modules)
149 name: 'past a function declared in a nested block',
150 code: `const value = 'outer'
151export const fn = createServerFn().handler(async () => {
152 const seen = value
153 {
154 function value() {}
155 }
156 return seen
157})`,
158 expected: 'outer',
159 },
160 {
161 // Source: @vitejs/plugin-rsc hoist/catch-binding-shadow.js
162 name: 'past a catch parameter of the same name',
163 code: `const value = { message: 'outer' }
164export const fn = createServerFn().handler(async () => {
165 const readOuter = () => value.message
166 try {
167 throw new Error('inner')
168 } catch (value) {
169 return [value.message, readOuter()]
170 }
171})`,
172 expected: ['inner', 'outer'],
173 },
174 {
175 // Source: @vitejs/plugin-rsc hoist/class-declaration-in-body.js
176 name: 'from a class declared in the handler',
177 code: `const value = 'outer'
178export const fn = createServerFn().handler(async () => {
179 class Helper {
180 run() {
181 return value
182 }
183 }
184 return new Helper().run()
185})`,
186 expected: 'outer',
187 },
188 {
189 // Source: @vitejs/plugin-rsc hoist/computed-destructuring-key-captures-outer-binding.js
190 name: 'through a computed destructuring key',
191 code: `const key = 'value'
192export const fn = createServerFn().handler(async ({ data }) => {
193 const { [key]: picked } = data
194 return picked
195})`,
196 data: { value: 'picked' },
197 expected: 'picked',
198 },
199 {
200 // Source: @vitejs/plugin-rsc hoist/destructured-param-default-bound.js
201 name: 'from a destructured parameter default',
202 code: `const value = 'outer'
203export const fn = createServerFn().handler(async ({ data: { x = value } = {} }) => x)`,
204 expected: 'outer',
205 },
206 {
207 // Source: @vitejs/plugin-rsc scope/param-default-var-hoisting.js
208 // (parameter defaults do not see var declarations of the body)
209 name: 'from a parameter default next to a var of the same name',
210 code: `const value = 'outer'
211export const fn = createServerFn().handler(async ({ data = value }) => {
212 var value = 'inner'
213 return [data, value]
214})`,
215 expected: ['outer', 'inner'],
216 },
217 {
218 // Source: @vitejs/plugin-rsc hoist/shadow-partial-if-block-over-outer-local.js
219 name: 'past a block that shadows it in one branch',
220 code: `const value = 'outer'
221export const fn = createServerFn().handler(async () => {
222 const pick = (flag: boolean) => {
223 if (flag) {
224 const value = 'inner'
225 return value
226 }
227 return value
228 }
229 return [pick(true), pick(false)]
230})`,
231 expected: ['inner', 'outer'],
232 },
233 {
234 // Source: @vitejs/plugin-rsc scope/let-const-block.js;
235 // typescript-eslint class/declaration/static-block.js
236 name: 'next to loop, switch and static block locals of the same name',
237 code: `const value = 'outer'
238export const fn = createServerFn().handler(async ({ data }) => {
239 const out = []
240 for (let value = 0; value < 1; value++) out.push(value)
241 switch (data) {
242 case 1: {
243 const value = 'case'
244 out.push(value)
245 }
246 default:
247 out.push(value)
248 }
249 class Block {
250 static read
251 static {
252 Block.read = value
253 }
254 }
255 out.push(Block.read)
256 return out
257})`,
258 data: 1,
259 expected: [0, 'case', 'outer', 'outer'],
260 },
261 {
262 // Source: @vitejs/plugin-rsc hoist/self-ref-inner-shadow.js
263 name: 'next to an inner function expression named like the server fn',
264 code: `const value = 1
265export const fn = createServerFn().handler(async ({ data }) => {
266 const result = (function fn(m) {
267 return m > 0 ? fn(m - 1) : 0
268 })(data)
269 return value + result
270})`,
271 data: 3,
272 expected: 1,
273 },
274 {
275 // Source: @vitejs/plugin-rsc hoist/methods.js
276 name: 'as computed method names',
277 code: `const key = 'computed'
278export const fn = createServerFn().handler(async () => {
279 const api = { async [key]() {} }
280 class Actions {
281 static async [key]() {
282 return 'static'
283 }
284 }
285 return [Object.keys(api), await Actions[key]()]
286})`,
287 expected: [['computed'], 'static'],
288 },
289 {
290 // Source: @vitejs/plugin-rsc scope/label.js (labels are not references)
291 name: 'next to a label of the same name',
292 code: `const value = 'outer'
293export const fn = createServerFn().handler(async () => {
294 value: for (const item of [1, 2]) {
295 if (item) {
296 break value
297 }
298 }
299 return value
300})`,
301 expected: 'outer',
302 },
303 {
304 // Source: React Compiler fixtures (tagged templates)
305 name: 'as a template tag',
306 code: `const value = (strings: TemplateStringsArray, n: number) => strings[0] + n
307export const fn = createServerFn().handler(async () => value\`id-\${1}\`)`,
308 expected: 'id-1',
309 },
310 {
311 // Source: React Compiler fixtures (shorthand properties)
312 name: 'as a shorthand property',
313 code: `const value = 'outer'
314export const fn = createServerFn().handler(async () => ({ value }))`,
315 expected: { value: 'outer' },
316 },
317])(
318 'the provider keeps a module binding the handler reads $name',
319 async ({ code, data, expected }) => {
320 const provider = await compileCode('provider', `${head}${code}`)
321 expect(await callProvider(provider!, 'fn', {}, data)).toEqual(expected)
322 },
323)
324β
325// Source: @vitejs/plugin-rsc hoist/self-ref-nested-function.js,
326// hoist/direct-recursion-self-binding.js
327test('a handler can call its own server fn', async () => {
328 const provider = await compileCode(
329 'provider',
330 `${head}export const fn = createServerFn().handler(async ({ data }) =>
331 data > 0 ? fn({ data: data - 1 }) : 'done')`,
332 )
333 expect(await callProvider(provider!, 'fn', {}, 2)).toBe('done')
334})
335β
336// Source: @vitejs/plugin-rsc hoist/captured-local-assignment.js,
337// wrap-export.test.ts "preserve reference"
338test('a handler and client code can both update an exported let', async () => {
339 const compiled = await compileAll(`${head}export let count = 0
340export function changeCount() {
341 count += 1
342 return count
343}
344export const bump = createServerFn().handler(async () => ++count)`)
345 const client = await evaluateModule(compiled.client)
346 expect(client.changeCount()).toBe(1)
347 expect(client.count).toBe(1)
348 const provider = await evaluateModule(compiled.provider)
349 expect(await callProvider(provider, 'bump')).toBe(1)
350 expect(await callProvider(provider, 'bump')).toBe(2)
351})
352β
353// Source: Next.js server-actions fixtures server-graph/27
354test('exported helpers the handler uses stay declared in the provider', async () => {
355 const { provider } = await compileAll(`${head}import { db } from './db.server'
356export async function load() {
357 return db.x()
358}
359export default function helper() {
360 return db.y()
361}
362export class Repo {
363 static z() {
364 return 'z'
365 }
366}
367const local = () => 'w'
368export { local as alias }
369export const fn = createServerFn().handler(async () => [await load(), helper(), Repo.z(), local()])`)
370 expect(
371 await callProvider(provider, 'fn', { './db.server': dbServer }),
372 ).toEqual(['x', 'y', 'z', 'w'])
373})