Open History to see the last commit
1import { describe, expect, test } from 'vitest'
2import { runWithStartContext } from '@tanstack/start-storage-context'
3import { createMiddleware } from '../src/createMiddleware'
4import { createServerFn, flattenMiddlewares } from '../src/createServerFn'
5β
6test('appends factory middleware in order without changing source builders', () => {
7 const first = createMiddleware({ type: 'function' })
8 const second = createMiddleware({ type: 'function' })
9 const third = createMiddleware({ type: 'function' })
10 const factory = createServerFn().middleware([second])
11 const base = createServerFn({ method: 'POST' }).middleware([first])
12 const middlewares = Object.freeze([factory, third, second])
13β
14 const combined = base.middleware(middlewares)
15β
16 expect(combined.options.middleware).toEqual([first, second, third, second])
17 expect(combined.options.method).toBe('POST')
18 expect(base.options.middleware).toEqual([first])
19 expect(factory.options.middleware).toEqual([second])
20 expect(middlewares).toEqual([factory, third, second])
21 expect(combined.middleware([]).options.middleware).toEqual([
22 first,
23 second,
24 third,
25 second,
26 ])
27})
28β
29test('ignores empty slots in a middleware array', () => {
30 const middleware = createMiddleware({ type: 'function' })
31 const middlewares: Array<typeof middleware> = []
32 middlewares[1] = middleware
33β
34 expect(createServerFn().middleware(middlewares).options.middleware).toEqual([
35 middleware,
36 ])
37 expect(0 in middlewares).toBe(false)
38})
39β
40test('does not register middleware appended while reading the input', () => {
41 const first = createMiddleware({ type: 'function' })
42 const second = createMiddleware({ type: 'function' })
43 const middlewares = [first]
44 Object.defineProperty(middlewares, 0, {
45 get() {
46 middlewares.push(second)
47 return first
48 },
49 })
50β
51 expect(createServerFn().middleware(middlewares).options.middleware).toEqual([
52 first,
53 ])
54 expect(middlewares).toHaveLength(2)
55})
56β
57describe('client-side throws', () => {
58 function runOnClient<T>(fn: () => Promise<T>) {
59 return runWithStartContext(
60 {
61 getRouter() {
62 throw new Error('Client middleware does not need a router')
63 },
64 request: new Request('http://localhost/'),
65 startOptions: {},
66 contextAfterGlobalMiddlewares: {},
67 executedRequestMiddlewares: new Set(),
68 handlerType: 'serverFn',
69 },
70 fn,
71 )
72 }
73β
74 test.each([undefined, null, 0, '', false])(
75 'rejects when client middleware throws %s',
76 async (value) => {
77 let fetched = false
78 const extractedFn = Object.assign(
79 async () => {
80 fetched = true
81 return { result: 'fetched' }
82 },
83 {
84 url: '/_serverFn/client-throw',
85 serverFnMeta: { id: 'client-throw' },
86 },
87 )
88 const fn = (
89 createServerFn().middleware([
90 createMiddleware({ type: 'function' }).client(() => {
91 throw value
92 }),
93 ]).handler as unknown as (
94 extractedFn: unknown,
95 ) => () => Promise<unknown>
96 )(extractedFn)
97β
98 const outcome = await runOnClient(() =>
99 fn().then(
100 (resolved) => ({ resolved }),
101 (rejected: unknown) => ({ rejected }),
102 ),
103 )
104β
105 expect(outcome).toStrictEqual({ rejected: value })
106 expect(fetched).toBe(false)
107 },
108 )
109})
110β
111describe('flattenMiddlewares', () => {
112 const inner = createMiddleware({ type: 'function' })
113 const middle = createMiddleware({ type: 'function' }).middleware([inner])
114 const outer = createMiddleware({ type: 'function' }).middleware([
115 inner,
116 middle,
117 ])
118 const sibling = createMiddleware({ type: 'function' })
119 const names = new Map<unknown, string>([
120 [inner, 'inner'],
121 [middle, 'middle'],
122 [outer, 'outer'],
123 [sibling, 'sibling'],
124 ])
125 const nameAll = (middlewares: Array<unknown>) =>
126 middlewares.map((middleware) => names.get(middleware))
127β
128 test('lists nested middleware before its parent and keeps first occurrences', () => {
129 expect(nameAll(flattenMiddlewares([outer, sibling, middle]))).toEqual([
130 'inner',
131 'middle',
132 'outer',
133 'sibling',
134 ])
135 })
136β
137 test('skips middleware in the seen set but still lists its children', () => {
138 expect(
139 nameAll(
140 flattenMiddlewares([outer, sibling], undefined, new Set([middle])),
141 ),
142 ).toEqual(['inner', 'outer', 'sibling'])
143 })
144β
145 test('skips empty slots in nested middleware arrays', () => {
146 const sparse: Array<typeof inner> = []
147 sparse[1] = inner
148 const parent = createMiddleware({ type: 'function' }).middleware(sparse)
149 names.set(parent, 'parent')
150β
151 expect(nameAll(flattenMiddlewares([parent]))).toEqual(['inner', 'parent'])
152 })
153β
154 test('throws for a nested middleware list that is not an array', () => {
155 const guard = createMiddleware({ type: 'function' })
156 const parent = createMiddleware({ type: 'function' }).middleware(
157 guard as never,
158 )
159β
160 expect(() => flattenMiddlewares([parent])).toThrow(TypeError)
161 })
162β
163 test('throws for nesting deeper than the limit', () => {
164 const looped = createMiddleware({ type: 'function' })
165 looped.middleware([looped])
166β
167 expect(() => flattenMiddlewares([looped], 3)).toThrow(
168 'Middleware nesting depth exceeded maximum of 3. Check for circular references.',
169 )
170 })
171})