Open History to see the last commit
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 {
18 DeferredResponse,
19 handleServerAction,
20} from '../src/server-functions-handler'
21import { createServerEntry, setResponseStatus } from '../src/request-response'
22import { getStartEvent } from '../src/internal-request-response'
23import type * as StartClientCore from '@tanstack/start-client-core'
24β
25const mocks = vi.hoisted(() => ({
26 action: vi.fn(),
27}))
28β
29vi.mock('../src/getServerFnById', () => ({
30 getServerFnById: () => mocks.action,
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})
46β
47function callServerAction(options: Parameters<typeof handleServerAction>[0]) {
48 return createServerEntry({
49 fetch: async () => {
50 const result = await handleServerAction(options)
51 return result instanceof DeferredResponse
52 ? result.createResponse(getStartEvent())
53 : result
54 },
55 }).fetch(options.request)
56}
57β
58async function readFrames(response: Response) {
59 const frames: Array<{ type: number; payload: Uint8Array }> = []
60 const reader = response.body!.getReader()
61 for (;;) {
62 const { done, value } = await reader.read()
63 if (done) {
64 return frames
65 }
66 frames.push({
67 type: value[0]!,
68 payload: value.slice(FRAME_HEADER_SIZE),
69 })
70 }
71}
72β
73function expectRawReferenceBeforeChunk(
74 frames: Array<{ type: number; payload: Uint8Array }>,
75) {
76 const chunkIndex = frames.findIndex(
77 (frame) => frame.type === FRAME_TYPE_CHUNK,
78 )
79 const referenceIndex = frames.findIndex(
80 (frame) =>
81 frame.type === FRAME_TYPE_JSON &&
82 new TextDecoder().decode(frame.payload).includes('tss/RawStream'),
83 )
84 expect(referenceIndex).toBeGreaterThanOrEqual(0)
85 expect(chunkIndex).toBeGreaterThan(referenceIndex)
86}
87β
88test.each([false, 0, '', null])(
89 'preserves the direct server-function result %j',
90 async (result) => {
91 mocks.action.mockResolvedValue({ result })
92β
93 await expect(
94 handleServerAction({
95 request: new Request('http://localhost/_serverFn/test', {
96 method: 'POST',
97 }),
98 serverFnId: 'test',
99 }),
100 ).resolves.toBe(result)
101 },
102)
103β
104test('serializes a complete direct JSON record without LF', async () => {
105 mocks.action.mockResolvedValue({ result: { value: 'complete' } })
106β
107 const response = await callServerAction({
108 request: new Request('http://localhost/_serverFn/test', {
109 method: 'POST',
110 headers: { 'x-tsr-serverFn': 'true' },
111 }),
112 serverFnId: 'test',
113 })
114β
115 const encoded = await response.text()
116 const parsed = JSON.parse(encoded)
117 expect(encoded).toBe(JSON.stringify(parsed))
118 expect(encoded).not.toContain('\n')
119})
120β
121test('cancelling a framed response disposes its serializer', async () => {
122 const cancel = vi.fn()
123 const source = new ReadableStream({
124 cancel,
125 })
126 mocks.action.mockResolvedValue({ result: source })
127β
128 const response = await callServerAction({
129 request: new Request('http://localhost/_serverFn/test', {
130 method: 'POST',
131 headers: { 'x-tsr-serverFn': 'true' },
132 }),
133 serverFnId: 'test',
134 })
135β
136 expect(source.locked).toBe(true)
137 await response.body!.cancel('client disconnected')
138 expect(cancel).toHaveBeenCalledOnce()
139 expect(source.locked).toBe(false)
140})
141β
142test('aborting the request disposes a handed-off framed response', async () => {
143 const abortController = new AbortController()
144 const reason = new Error('request aborted')
145 const cancel = vi.fn()
146 const source = new ReadableStream({ cancel })
147 mocks.action.mockResolvedValue({ result: new RawStream(source) })
148β
149 const response = await callServerAction({
150 request: new Request('http://localhost/_serverFn/test', {
151 method: 'POST',
152 headers: { 'x-tsr-serverFn': 'true' },
153 signal: abortController.signal,
154 }),
155 serverFnId: 'test',
156 })
157β
158 await vi.waitFor(() => {
159 expect(source.locked).toBe(true)
160 })
161 abortController.abort(reason)
162 await vi.waitFor(() => {
163 expect(cancel).toHaveBeenCalledOnce()
164 expect(cancel).toHaveBeenCalledWith(reason)
165 expect(source.locked).toBe(false)
166 })
167 await expect(response.body!.getReader().read()).rejects.toBe(reason)
168})
169β
170test('cancels synchronous RawStreams without pulling when the request is already aborted', async () => {
171 const abortController = new AbortController()
172 const reason = new Error('request already aborted')
173 abortController.abort(reason)
174 const sources = Array.from({ length: 3 }, () => {
175 const cancel = vi.fn(() => new Promise<void>(() => {}))
176 const pull = vi.fn()
177 const stream = new ReadableStream<Uint8Array>(
178 { pull, cancel },
179 { highWaterMark: 0 },
180 )
181 return { stream, pull, cancel }
182 })
183 mocks.action.mockResolvedValue({
184 result: sources.map(({ stream }) => new RawStream(stream)),
185 })
186β
187 const response = await callServerAction({
188 request: new Request('http://localhost/_serverFn/test', {
189 method: 'POST',
190 headers: { 'x-tsr-serverFn': 'true' },
191 signal: abortController.signal,
192 }),
193 serverFnId: 'test',
194 })
195β
196 await expect(response.body!.getReader().read()).rejects.toBe(reason)
197 await new Promise((resolve) => setTimeout(resolve, 0))
198 for (const { stream, pull, cancel } of sources) {
199 expect(pull).not.toHaveBeenCalled()
200 expect(cancel).toHaveBeenCalledExactlyOnceWith(reason)
201 expect(stream.locked).toBe(false)
202 }
203})
204β
205test('bounds and cancels synchronous RawStreams when their response remains unread', async () => {
206 const sources = Array.from({ length: 3 }, () => {
207 const cancel = vi.fn()
208 const pull = vi.fn(
209 (controller: ReadableStreamDefaultController<Uint8Array>) => {
210 controller.enqueue(new Uint8Array(64 * 1024))
211 },
212 )
213 const stream = new ReadableStream<Uint8Array>(
214 { pull, cancel },
215 { highWaterMark: 0 },
216 )
217 return { stream, pull, cancel }
218 })
219 mocks.action.mockResolvedValue({
220 result: sources.map(({ stream }) => new RawStream(stream)),
221 })
222β
223 const response = await callServerAction({
224 request: new Request('http://localhost/_serverFn/test', {
225 method: 'POST',
226 headers: { 'x-tsr-serverFn': 'true' },
227 }),
228 serverFnId: 'test',
229 })
230β
231 await new Promise((resolve) => setTimeout(resolve, 0))
232 expect(sources.map(({ pull }) => pull.mock.calls.length)).toEqual([1, 1, 1])
233 const reason = new Error('client disconnected')
234 await response.body!.cancel(reason)
235 await new Promise((resolve) => setTimeout(resolve, 0))
236 for (const { stream, pull, cancel } of sources) {
237 expect(pull).toHaveBeenCalledOnce()
238 expect(cancel).toHaveBeenCalledExactlyOnceWith(reason)
239 expect(stream.locked).toBe(false)
240 }
241})
242β
243test('a synchronous serialization failure cancels registered raw streams', async () => {
244 const cancel = vi.fn()
245 const source = new ReadableStream<Uint8Array>({ cancel })
246 mocks.action.mockResolvedValue({
247 result: {
248 raw: new RawStream(source),
249 unsupported: () => {},
250 },
251 })
252 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
253 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
254β
255 try {
256 const response = await callServerAction({
257 request: new Request('http://localhost/_serverFn/test', {
258 method: 'POST',
259 headers: { 'x-tsr-serverFn': 'true' },
260 }),
261 serverFnId: 'test',
262 })
263β
264 expect(cancel).toHaveBeenCalledOnce()
265 expect(cancel).toHaveBeenCalledWith(expect.any(Error))
266 expect(source.locked).toBe(false)
267 expect(response.headers.get(X_TSS_SERIALIZED)).toBe('true')
268 expect(response.headers.get('content-type')).toBe('application/json')
269 expect(
270 fromCrossJSON<{ error: unknown }>(await response.json(), {
271 plugins: defaultSerovalDeserializerPlugins,
272 }).error,
273 ).toBeInstanceOf(Error)
274 } finally {
275 consoleInfo.mockRestore()
276 consoleError.mockRestore()
277 }
278})
279β
280test('admits replayed nested RawStream references before their chunks', async () => {
281 const source = new ReadableStream<Uint8Array>({
282 start(controller) {
283 controller.enqueue(new Uint8Array([1]))
284 controller.close()
285 },
286 })
287 const replayed = createStream<RawStream | undefined>()
288 replayed.next(new RawStream(source))
289 replayed.return(undefined)
290 mocks.action.mockResolvedValue({ result: { replayed } })
291β
292 const response = await callServerAction({
293 request: new Request('http://localhost/_serverFn/test', {
294 method: 'POST',
295 headers: { 'x-tsr-serverFn': 'true' },
296 }),
297 serverFnId: 'test',
298 })
299β
300 expectRawReferenceBeforeChunk(await readFrames(response))
301})
302β
303test('frames every record from a synchronously replayed Seroval stream', async () => {
304 const replayed = createStream<number | undefined>()
305 replayed.next(1)
306 replayed.return(undefined)
307 mocks.action.mockResolvedValue({ result: { replayed } })
308β
309 const response = await callServerAction({
310 request: new Request('http://localhost/_serverFn/test', {
311 method: 'POST',
312 headers: { 'x-tsr-serverFn': 'true' },
313 }),
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 callServerAction({
368 request: new Request('http://localhost/_serverFn/test', {
369 method: 'POST',
370 headers: { 'x-tsr-serverFn': 'true' },
371 }),
372 serverFnId: 'test',
373 })
374 resolveLate(
375 new RawStream(
376 new ReadableStream<Uint8Array>({
377 start(controller) {
378 controller.enqueue(new Uint8Array([1]))
379 controller.close()
380 },
381 }),
382 ),
383 )
384β
385 expectRawReferenceBeforeChunk(await readFrames(response))
386})
387β
388test('bounds synchronously replayed Seroval records before framing', async () => {
389 const replayed = createStream<number | undefined>()
390 for (let index = 0; index < 1025; index++) {
391 replayed.next(index)
392 }
393 replayed.return(undefined)
394 mocks.action.mockResolvedValue({ result: { replayed } })
395 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
396 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
397β
398 try {
399 const response = await callServerAction({
400 request: new Request('http://localhost/_serverFn/test', {
401 method: 'POST',
402 headers: { 'x-tsr-serverFn': 'true' },
403 }),
404 serverFnId: 'test',
405 })
406β
407 const { error } = fromCrossJSON<{ error: unknown }>(await response.json(), {
408 plugins: defaultSerovalDeserializerPlugins,
409 })
410 expect(error).toBeInstanceOf(Error)
411 expect((error as Error).message).toContain('pending output limit')
412 } finally {
413 consoleInfo.mockRestore()
414 consoleError.mockRestore()
415 }
416})
417β
418test('admits late RawStream references before their chunks', async () => {
419 let resolveRawStream!: (value: RawStream) => void
420 const lateRawStream = new Promise<RawStream>((resolve) => {
421 resolveRawStream = resolve
422 })
423 mocks.action.mockResolvedValue({ result: { lateRawStream } })
424β
425 const response = await callServerAction({
426 request: new Request('http://localhost/_serverFn/test', {
427 method: 'POST',
428 headers: { 'x-tsr-serverFn': 'true' },
429 }),
430 serverFnId: 'test',
431 })
432 resolveRawStream(
433 new RawStream(
434 new ReadableStream<Uint8Array>({
435 start(controller) {
436 controller.enqueue(new Uint8Array([2]))
437 controller.close()
438 },
439 }),
440 ),
441 )
442β
443 expectRawReferenceBeforeChunk(await readFrames(response))
444})
445β
446test('rejects a non-ASCII JSON record larger than the wire limit', async () => {
447 const cancel = vi.fn()
448 const source = new ReadableStream<Uint8Array>({ cancel })
449 mocks.action.mockResolvedValue({
450 result: {
451 // UTF-16 length is within the old limit, but UTF-8 is over 16 MiB.
452 value: 'Γ©'.repeat(8 * 1024 * 1024),
453 raw: new RawStream(source),
454 },
455 })
456β
457 const response = await callServerAction({
458 request: new Request('http://localhost/_serverFn/test', {
459 method: 'POST',
460 headers: { 'x-tsr-serverFn': 'true' },
461 }),
462 serverFnId: 'test',
463 })
464β
465 expect(cancel).toHaveBeenCalledOnce()
466 expect(source.locked).toBe(false)
467 // Nothing reached the client yet, so the whole call fails.
468 expect(response.status).toBe(500)
469 expect(response.headers.get('content-type')).toBe('application/json')
470 expect(await response.text()).toContain('pending output limit')
471})
472β
473test.each(['RawStream', 'ReadableStream'])(
474 'serializes %s results despite a bodyless helper status',
475 async (kind) => {
476 const cancel = vi.fn()
477 const source = new ReadableStream<Uint8Array>({ cancel })
478 mocks.action.mockImplementation(() => {
479 setResponseStatus(204, 'No Content')
480 return {
481 result: kind === 'RawStream' ? new RawStream(source) : source,
482 }
483 })
484 const consoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {})
485 const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
486 const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {})
487β
488 try {
489 const response = await callServerAction({
490 request: new Request('http://localhost/_serverFn/test', {
491 method: 'POST',
492 headers: { 'x-tsr-serverFn': 'true' },
493 }),
494 serverFnId: 'test',
495 })
496β
497 // Serialized replies always carry a body for the client to decode.
498 expect(response.status).toBe(200)
499 expect(response.statusText).toBe('')
500 expect(response.headers.get('x-tss-serialized')).toBe('true')
501 expect(consoleWarn).toHaveBeenCalledOnce()
502 const reason = new Error('client disconnected')
503 await response.body!.cancel(reason)
504 await vi.waitFor(() => expect(cancel).toHaveBeenCalledOnce())
505 } finally {
506 consoleInfo.mockRestore()
507 consoleError.mockRestore()
508 consoleWarn.mockRestore()
509 }
510 },
511)
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 callServerAction({
539 request: new Request('http://localhost/_serverFn/test', {
540 method: 'POST',
541 headers: { 'x-tsr-serverFn': 'true' },
542 }),
543 serverFnId: 'test',
544 })
545β
546 expect(response.headers.get('content-type')).toBe('application/json')
547 expect(pullCount).toBe(0)
548 expect(cancelCount).toBe(MAX_FRAMED_STREAMS + 1)
549 expect(sources.every((source) => !source.locked)).toBe(true)
550 } finally {
551 consoleInfo.mockRestore()
552 consoleError.mockRestore()
553 }
554})