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

server-functions-handler.test.ts

555 lines16.4 KB

1// @vitest-environment node
2​
3import { beforeEach, expect, test, vi } from 'vitest'
4import { createStream, fromCrossJSON } from 'seroval'
5import {
6 TSS_CONTENT_TYPE_FRAMED_VERSIONED,
7 X_TSS_SERIALIZED,
8} from '@tanstack/start-client-core'
9import {
10 FRAME_HEADER_SIZE,
11 FRAME_TYPE_CHUNK,
12 FRAME_TYPE_JSON,
13 MAX_FRAMED_STREAMS,
14} from '@tanstack/start-client-core/client-rpc'
15import { RawStream } from '@tanstack/router-core'
16import { defaultSerovalDeserializerPlugins } from '@tanstack/router-core/ssr/server'
17import { handleServerAction } from '../src/server-functions-handler'
18import type * as StartClientCore from '@tanstack/start-client-core'
19​
20const mocks = vi.hoisted(() => ({
21 action: vi.fn(),
22 response: { status: 200, statusText: 'OK' },
23}))
24​
25vi.mock('../src/getServerFnById', () => ({
26 getServerFnById: () => mocks.action,
27}))
28​
29vi.mock('../src/request-response', () => ({
30 getResponse: () => mocks.response,
31}))
32​
33vi.mock('@tanstack/start-client-core', async (importOriginal) => {
34 const actual = await importOriginal<typeof StartClientCore>()
35 const { defaultSerovalDeserializerPlugins } =
36 await import('@tanstack/router-core/ssr/server')
37 return {
38 ...actual,
39 getSerovalPlugins: () => defaultSerovalDeserializerPlugins,
40 }
41})
42​
43beforeEach(() => {
44 mocks.action.mockReset()
45 mocks.response.status = 200
46 mocks.response.statusText = 'OK'
47})
48​
49async function readFrames(response: Response) {
50 const frames: Array<{ type: number; payload: Uint8Array }> = []
51 const reader = response.body!.getReader()
52 for (;;) {
53 const { done, value } = await reader.read()
54 if (done) {
55 return frames
56 }
57 frames.push({
58 type: value[0]!,
59 payload: value.slice(FRAME_HEADER_SIZE),
60 })
61 }
63​
64function expectRawReferenceBeforeChunk(
65 frames: Array<{ type: number; payload: Uint8Array }>,
66) {
67 const chunkIndex = frames.findIndex(
68 (frame) => frame.type === FRAME_TYPE_CHUNK,
69 )
70 const referenceIndex = frames.findIndex(
71 (frame) =>
72 frame.type === FRAME_TYPE_JSON &&
73 new TextDecoder().decode(frame.payload).includes('tss/RawStream'),
74 )
75 expect(referenceIndex).toBeGreaterThanOrEqual(0)
76 expect(chunkIndex).toBeGreaterThan(referenceIndex)
78​
79test.each([false, 0, '', null])(
80 'preserves the direct server-function result %j',
81 async (result) => {
82 mocks.action.mockResolvedValue({ result })
83​
84 await expect(
85 handleServerAction({
86 request: new Request('http://localhost/_serverFn/test', {
87 method: 'POST',
88 }),
89 context: {},
90 serverFnId: 'test',
91 }),
92 ).resolves.toBe(result)
93 },
95​
96test('serializes a complete direct JSON record without LF', async () => {
97 mocks.action.mockResolvedValue({ result: { value: 'complete' } })
98​
99 const response = await handleServerAction({
100 request: new Request('http://localhost/_serverFn/test', {
101 method: 'POST',
102 headers: { 'x-tsr-serverFn': 'true' },
103 }),
104 context: {},
105 serverFnId: 'test',
106 })
107​
108 const encoded = await response.text()
109 const parsed = JSON.parse(encoded)
110 expect(encoded).toBe(JSON.stringify(parsed))
111 expect(encoded).not.toContain('\n')
112})
113​
114test('cancelling a framed response disposes its serializer', async () => {
115 const cancel = vi.fn()
116 const source = new ReadableStream({
117 cancel,
118 })
119 mocks.action.mockResolvedValue({ result: source })
120​
121 const response = await handleServerAction({
122 request: new Request('http://localhost/_serverFn/test', {
123 method: 'POST',
124 headers: { 'x-tsr-serverFn': 'true' },
125 }),
126 context: {},
127 serverFnId: 'test',
128 })
129​
130 expect(source.locked).toBe(true)
131 await response.body!.cancel('client disconnected')
132 expect(cancel).toHaveBeenCalledOnce()
133 expect(source.locked).toBe(false)
134})
135​
136test('aborting the request disposes a handed-off framed response', async () => {
137 const abortController = new AbortController()
138 const reason = new Error('request aborted')
139 const cancel = vi.fn()
140 const source = new ReadableStream({ cancel })
141 mocks.action.mockResolvedValue({ result: new RawStream(source) })
142​
143 const response = await handleServerAction({
144 request: new Request('http://localhost/_serverFn/test', {
145 method: 'POST',
146 headers: { 'x-tsr-serverFn': 'true' },
147 signal: abortController.signal,
148 }),
149 context: {},
150 serverFnId: 'test',
151 })
152​
153 await vi.waitFor(() => {
154 expect(source.locked).toBe(true)
155 })
156 abortController.abort(reason)
157 await vi.waitFor(() => {
158 expect(cancel).toHaveBeenCalledOnce()
159 expect(cancel).toHaveBeenCalledWith(reason)
160 expect(source.locked).toBe(false)
161 })
162 await expect(response.body!.getReader().read()).rejects.toBe(reason)
163})
164​
165test('cancels synchronous RawStreams without pulling when the request is already aborted', async () => {
166 const abortController = new AbortController()
167 const reason = new Error('request already aborted')
168 abortController.abort(reason)
169 const sources = Array.from({ length: 3 }, () => {
170 const cancel = vi.fn(() => new Promise<void>(() => {}))
171 const pull = vi.fn()
172 const stream = new ReadableStream<Uint8Array>(
173 { pull, cancel },
174 { highWaterMark: 0 },
175 )
176 return { stream, pull, cancel }
177 })
178 mocks.action.mockResolvedValue({
179 result: sources.map(({ stream }) => new RawStream(stream)),
180 })
181​
182 const response = await handleServerAction({
183 request: new Request('http://localhost/_serverFn/test', {
184 method: 'POST',
185 headers: { 'x-tsr-serverFn': 'true' },
186 signal: abortController.signal,
187 }),
188 context: {},
189 serverFnId: 'test',
190 })
191​
192 await expect(response.body!.getReader().read()).rejects.toBe(reason)
193 await new Promise((resolve) => setTimeout(resolve, 0))
194 for (const { stream, pull, cancel } of sources) {
195 expect(pull).not.toHaveBeenCalled()
196 expect(cancel).toHaveBeenCalledExactlyOnceWith(reason)
197 expect(stream.locked).toBe(false)
198 }
199})
200​
201test('bounds and cancels synchronous RawStreams when their response remains unread', async () => {
202 const sources = Array.from({ length: 3 }, () => {
203 const cancel = vi.fn()
204 const pull = vi.fn(
205 (controller: ReadableStreamDefaultController<Uint8Array>) => {
206 controller.enqueue(new Uint8Array(64 * 1024))
207 },
208 )
209 const stream = new ReadableStream<Uint8Array>(
210 { pull, cancel },
211 { highWaterMark: 0 },
212 )
213 return { stream, pull, cancel }
214 })
215 mocks.action.mockResolvedValue({
216 result: sources.map(({ stream }) => new RawStream(stream)),
217 })
218​
219 const response = await handleServerAction({
220 request: new Request('http://localhost/_serverFn/test', {
221 method: 'POST',
222 headers: { 'x-tsr-serverFn': 'true' },
223 }),
224 context: {},
225 serverFnId: 'test',
226 })
227​
228 await new Promise((resolve) => setTimeout(resolve, 0))
229 expect(sources.map(({ pull }) => pull.mock.calls.length)).toEqual([1, 1, 1])
230 const reason = new Error('client disconnected')
231 await response.body!.cancel(reason)
232 await new Promise((resolve) => setTimeout(resolve, 0))
233 for (const { stream, pull, cancel } of sources) {
234 expect(pull).toHaveBeenCalledOnce()
235 expect(cancel).toHaveBeenCalledExactlyOnceWith(reason)
236 expect(stream.locked).toBe(false)
237 }
238})
239​
240test('a synchronous serialization failure cancels registered raw streams', async () => {
241 const cancel = vi.fn()
242 const source = new ReadableStream<Uint8Array>({ cancel })
243 mocks.action.mockResolvedValue({
244 result: {
245 raw: new RawStream(source),
246 unsupported: () => {},
247 },
248 })
249 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
250 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
251​
252 try {
253 const response = await handleServerAction({
254 request: new Request('http://localhost/_serverFn/test', {
255 method: 'POST',
256 headers: { 'x-tsr-serverFn': 'true' },
257 }),
258 context: {},
259 serverFnId: 'test',
260 })
261​
262 expect(cancel).toHaveBeenCalledOnce()
263 expect(cancel).toHaveBeenCalledWith(expect.any(Error))
264 expect(source.locked).toBe(false)
265 expect(response.headers.get(X_TSS_SERIALIZED)).toBe('true')
266 expect(response.headers.get('content-type')).toBe('application/json')
267 expect(
268 fromCrossJSON(await response.json(), {
269 plugins: defaultSerovalDeserializerPlugins,
270 }),
271 ).toBeInstanceOf(Error)
272 } finally {
273 consoleInfo.mockRestore()
274 consoleError.mockRestore()
275 }
276})
277​
278test('admits replayed nested RawStream references before their chunks', async () => {
279 const source = new ReadableStream<Uint8Array>({
280 start(controller) {
281 controller.enqueue(new Uint8Array([1]))
282 controller.close()
283 },
284 })
285 const replayed = createStream<RawStream | undefined>()
286 replayed.next(new RawStream(source))
287 replayed.return(undefined)
288 mocks.action.mockResolvedValue({ result: { replayed } })
289​
290 const response = await handleServerAction({
291 request: new Request('http://localhost/_serverFn/test', {
292 method: 'POST',
293 headers: { 'x-tsr-serverFn': 'true' },
294 }),
295 context: {},
296 serverFnId: 'test',
297 })
298​
299 expectRawReferenceBeforeChunk(await readFrames(response))
300})
301​
302test('frames every record from a synchronously replayed Seroval stream', async () => {
303 const replayed = createStream<number | undefined>()
304 replayed.next(1)
305 replayed.return(undefined)
306 mocks.action.mockResolvedValue({ result: { replayed } })
307​
308 const response = await handleServerAction({
309 request: new Request('http://localhost/_serverFn/test', {
310 method: 'POST',
311 headers: { 'x-tsr-serverFn': 'true' },
312 }),
313 context: {},
314 serverFnId: 'test',
315 })
316​
317 expect(response.headers.get('content-type')).toBe(
318 TSS_CONTENT_TYPE_FRAMED_VERSIONED,
319 )
320 const frames = await readFrames(response)
321 expect(frames.every((frame) => frame.type === FRAME_TYPE_JSON)).toBe(true)
322 expect(frames.length).toBeGreaterThan(1)
323​
324 const refs = new Map()
325 let result: any
326 for (let index = 0; index < frames.length; index++) {
327 const encoded = new TextDecoder().decode(frames[index]!.payload)
328 const parsed = JSON.parse(encoded)
329 expect(encoded).toBe(JSON.stringify(parsed))
330 expect(encoded).not.toContain('\n')
331 const value = fromCrossJSON(parsed, {
332 refs,
333 plugins: defaultSerovalDeserializerPlugins,
334 })
335 if (index === 0) {
336 result = value
337 }
338 }
339​
340 const events: Array<[string, unknown]> = []
341 result.result.replayed.on({
342 next(value: unknown) {
343 events.push(['next', value])
344 },
345 throw(error: unknown) {
346 events.push(['throw', error])
347 },
348 return(value: unknown) {
349 events.push(['return', value])
350 },
351 })
352 expect(events).toEqual([
353 ['next', 1],
354 ['return', undefined],
355 ])
356})
357​
358test('keeps work discovered after a transient synchronous completion', async () => {
359 const replayed = createStream<undefined>()
360 replayed.return(undefined)
361 let resolveLate!: (value: RawStream) => void
362 const late = new Promise<RawStream>((resolve) => {
363 resolveLate = resolve
364 })
365 mocks.action.mockResolvedValue({ result: { replayed, late } })
366​
367 const response = await handleServerAction({
368 request: new Request('http://localhost/_serverFn/test', {
369 method: 'POST',
370 headers: { 'x-tsr-serverFn': 'true' },
371 }),
372 context: {},
373 serverFnId: 'test',
374 })
375 resolveLate(
376 new RawStream(
377 new ReadableStream<Uint8Array>({
378 start(controller) {
379 controller.enqueue(new Uint8Array([1]))
380 controller.close()
381 },
382 }),
383 ),
384 )
385​
386 expectRawReferenceBeforeChunk(await readFrames(response))
387})
388​
389test('bounds synchronously replayed Seroval records before framing', async () => {
390 const replayed = createStream<number | undefined>()
391 for (let index = 0; index < 1025; index++) {
392 replayed.next(index)
393 }
394 replayed.return(undefined)
395 mocks.action.mockResolvedValue({ result: { replayed } })
396 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
397 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
398​
399 try {
400 const response = await handleServerAction({
401 request: new Request('http://localhost/_serverFn/test', {
402 method: 'POST',
403 headers: { 'x-tsr-serverFn': 'true' },
404 }),
405 context: {},
406 serverFnId: 'test',
407 })
408​
409 const error = fromCrossJSON(await response.json(), {
410 plugins: defaultSerovalDeserializerPlugins,
411 })
412 expect(error).toBeInstanceOf(Error)
413 expect((error as Error).message).toContain('pending output limit')
414 } finally {
415 consoleInfo.mockRestore()
416 consoleError.mockRestore()
417 }
418})
419​
420test('admits late RawStream references before their chunks', async () => {
421 let resolveRawStream!: (value: RawStream) => void
422 const lateRawStream = new Promise<RawStream>((resolve) => {
423 resolveRawStream = resolve
424 })
425 mocks.action.mockResolvedValue({ result: { lateRawStream } })
426​
427 const response = await handleServerAction({
428 request: new Request('http://localhost/_serverFn/test', {
429 method: 'POST',
430 headers: { 'x-tsr-serverFn': 'true' },
431 }),
432 context: {},
433 serverFnId: 'test',
434 })
435 resolveRawStream(
436 new RawStream(
437 new ReadableStream<Uint8Array>({
438 start(controller) {
439 controller.enqueue(new Uint8Array([2]))
440 controller.close()
441 },
442 }),
443 ),
444 )
445​
446 expectRawReferenceBeforeChunk(await readFrames(response))
447})
448​
449test('rejects a non-ASCII JSON record larger than the wire limit', async () => {
450 const cancel = vi.fn()
451 const source = new ReadableStream<Uint8Array>({ cancel })
452 // h3 leaves the status unset until a handler sets one.
453 mocks.response.status = undefined as unknown as number
454 mocks.action.mockResolvedValue({
455 result: {
456 // UTF-16 length is within the old limit, but UTF-8 is over 16 MiB.
457 value: 'Γ©'.repeat(8 * 1024 * 1024),
458 raw: new RawStream(source),
459 },
460 })
461​
462 const response = await handleServerAction({
463 request: new Request('http://localhost/_serverFn/test', {
464 method: 'POST',
465 headers: { 'x-tsr-serverFn': 'true' },
466 }),
467 context: {},
468 serverFnId: 'test',
469 })
470​
471 expect(cancel).toHaveBeenCalledOnce()
472 expect(source.locked).toBe(false)
473 // Nothing reached the client yet, so the whole call fails.
474 expect(response.status).toBe(500)
475 expect(response.headers.get('content-type')).toBe('application/json')
476 expect(await response.text()).toContain('pending output limit')
477})
478​
479test.each(['RawStream', 'ReadableStream'])(
480 'cancels %s serialization when Response construction rejects it',
481 async (kind) => {
482 const cancel = vi.fn()
483 const source = new ReadableStream<Uint8Array>({ cancel })
484 mocks.response.status = 204
485 mocks.response.statusText = 'No Content'
486 mocks.action.mockResolvedValue({
487 result: kind === 'RawStream' ? new RawStream(source) : source,
488 })
489 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
490 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
491​
492 try {
493 const response = await handleServerAction({
494 request: new Request('http://localhost/_serverFn/test', {
495 method: 'POST',
496 headers: { 'x-tsr-serverFn': 'true' },
497 }),
498 context: {},
499 serverFnId: 'test',
500 })
501​
502 expect(response.status).toBe(500)
503 expect(response.statusText).toBe('')
504 expect(cancel).toHaveBeenCalledOnce()
505 expect(source.locked).toBe(false)
506 } finally {
507 consoleInfo.mockRestore()
508 consoleError.mockRestore()
509 }
510 },
512​
513test('rejects excess RawStreams before starting their readers', async () => {
514 let pullCount = 0
515 let cancelCount = 0
516 const sources = Array.from(
517 { length: MAX_FRAMED_STREAMS + 1 },
518 () =>
519 new ReadableStream<Uint8Array>(
520 {
521 pull() {
522 pullCount++
523 },
524 cancel() {
525 cancelCount++
526 },
527 },
528 { highWaterMark: 0 },
529 ),
530 )
531 mocks.action.mockResolvedValue({
532 result: sources.map((source) => new RawStream(source)),
533 })
534 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
535 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
536​
537 try {
538 const response = await handleServerAction({
539 request: new Request('http://localhost/_serverFn/test', {
540 method: 'POST',
541 headers: { 'x-tsr-serverFn': 'true' },
542 }),
543 context: {},
544 serverFnId: 'test',
545 })
546​
547 expect(response.headers.get('content-type')).toBe('application/json')
548 expect(pullCount).toBe(0)
549 expect(cancelCount).toBe(MAX_FRAMED_STREAMS + 1)
550 expect(sources.every((source) => !source.locked)).toBe(true)
551 } finally {
552 consoleInfo.mockRestore()
553 consoleError.mockRestore()
554 }
555})