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

createMiddleware.ts

798 lines20.1 KB

1import type { StartInstanceOptions } from './createStart'
2import type { AnyServerFn, ConstrainValidator, Method } from './createServerFn'
3import type {
4 AnyContext,
5 Assign,
6 Constrain,
7 Expand,
8 IntersectAssign,
9 Register,
10 ResolveValidatorInput,
11 ResolveValidatorOutput,
12 ValidateSerializableInput,
13} from '@tanstack/router-core'
14​
15export type CreateMiddlewareFn<TRegister> = <TType extends MiddlewareType>(
16 options?: {
17 type?: TType
18 },
19 __opts?: FunctionMiddlewareOptions<
20 TRegister,
21 unknown,
22 undefined,
23 undefined,
24 undefined
25 >,
26) => CreateMiddlewareResult<TRegister, TType>
27​
28export const createMiddleware: CreateMiddlewareFn<{}> = (options, __opts) => {
29 const resolvedOptions = {
30 type: 'request',
31 ...(__opts || options),
32 }
33​
34 return {
35 options: resolvedOptions,
36 middleware: (middleware: any) => {
37 return createMiddleware(
38 {} as any,
39 Object.assign(resolvedOptions, { middleware }),
40 ) as any
41 },
42 inputValidator: (inputValidator: any) => {
43 return createMiddleware(
44 {} as any,
45 Object.assign(resolvedOptions, { inputValidator }),
46 ) as any
47 },
48 client: (client: any) => {
49 return createMiddleware(
50 {} as any,
51 Object.assign(resolvedOptions, { client }),
52 ) as any
53 },
54 server: (server: any) => {
55 return createMiddleware(
56 {} as any,
57 Object.assign(resolvedOptions, { server }),
58 ) as any
59 },
60 } as any
62​
63export type MiddlewareType = 'request' | 'function'
64​
65export type CreateMiddlewareResult<
66 TRegister,
67 TType extends MiddlewareType,
68> = 'request' extends TType
69 ? RequestMiddleware<TRegister>
70 : FunctionMiddleware<TRegister>
71​
72export interface FunctionMiddleware<TRegister>
73 extends FunctionMiddlewareAfterMiddleware<TRegister, unknown> {
74 middleware: <const TNewMiddlewares = undefined>(
75 middlewares: Constrain<
76 TNewMiddlewares,
77 ReadonlyArray<AnyRequestMiddleware | AnyFunctionMiddleware>
78 >,
79 ) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares>
81​
82export interface FunctionMiddlewareAfterMiddleware<TRegister, TMiddlewares>
83 extends FunctionMiddlewareWithTypes<
84 TRegister,
85 TMiddlewares,
86 undefined,
87 undefined,
88 undefined,
89 undefined,
90 undefined
91 >,
92 FunctionMiddlewareServer<
93 TRegister,
94 TMiddlewares,
95 undefined,
96 undefined,
97 undefined
98 >,
99 FunctionMiddlewareClient<TRegister, TMiddlewares, undefined>,
100 FunctionMiddlewareValidator<TRegister, TMiddlewares> {}
101​
102export interface FunctionMiddlewareWithTypes<
103 TRegister,
104 TMiddlewares,
105 TInputValidator,
106 TServerContext,
107 TServerSendContext,
108 TClientContext,
109 TClientSendContext,
110> {
111 _types: FunctionMiddlewareTypes<
112 TRegister,
113 TMiddlewares,
114 TInputValidator,
115 TServerContext,
116 TServerSendContext,
117 TClientContext,
118 TClientSendContext
119 >
120 options: FunctionMiddlewareOptions<
121 TRegister,
122 TMiddlewares,
123 TInputValidator,
124 TServerContext,
125 TClientContext
126 >
128​
129export interface FunctionMiddlewareTypes<
130 in out TRegister,
131 in out TMiddlewares,
132 in out TInputValidator,
133 in out TServerContext,
134 in out TServerSendContext,
135 in out TClientContext,
136 in out TClientSendContext,
137> {
138 type: 'function'
139 middlewares: TMiddlewares
140 input: ResolveValidatorInput<TInputValidator>
141 allInput: IntersectAllValidatorInputs<TMiddlewares, TInputValidator>
142 output: ResolveValidatorOutput<TInputValidator>
143 allOutput: IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>
144 clientContext: TClientContext
145 allClientContextBeforeNext: AssignAllClientContextBeforeNext<
146 TMiddlewares,
147 TClientContext
148 >
149 allClientContextAfterNext: AssignAllClientContextAfterNext<
150 TMiddlewares,
151 TClientContext,
152 TClientSendContext
153 >
154 serverContext: TServerContext
155 serverSendContext: TServerSendContext
156 allServerSendContext: AssignAllServerSendContext<
157 TMiddlewares,
158 TServerSendContext
159 >
160 allServerContext: AssignAllServerFnContext<
161 TRegister,
162 TMiddlewares,
163 TServerSendContext,
164 TServerContext
165 >
166 clientSendContext: TClientSendContext
167 allClientSendContext: AssignAllClientSendContext<
168 TMiddlewares,
169 TClientSendContext
170 >
171 inputValidator: TInputValidator
173​
174/**
175 * Recursively resolve the input type produced by a sequence of middleware
176 */
177export type IntersectAllValidatorInputs<TMiddlewares, TInputValidator> =
178 unknown extends TInputValidator
179 ? TInputValidator
180 : TInputValidator extends undefined
181 ? IntersectAllMiddleware<TMiddlewares, 'allInput'>
182 : IntersectAssign<
183 IntersectAllMiddleware<TMiddlewares, 'allInput'>,
184 ResolveValidatorInput<TInputValidator>
185 >
186​
187export type IntersectAllMiddleware<
188 TMiddlewares,
189 TType extends
190 | keyof AnyFunctionMiddleware['_types']
191 | keyof AnyRequestMiddleware['_types']
192 | keyof AnyServerFn['_types'],
193 TAcc = undefined,
194> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
195 ? TMiddleware extends
196 | AnyFunctionMiddleware
197 | AnyRequestMiddleware
198 | AnyServerFn
199 ? IntersectAllMiddleware<
200 TRest,
201 TType,
202 IntersectAssign<
203 TAcc,
204 TMiddleware['_types'][TType & keyof TMiddleware['_types']]
205 >
206 >
207 : TAcc
208 : TAcc
209​
210export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<
211 any,
212 any,
213 any,
214 any,
215 any,
216 any,
217 any
219​
220/**
221 * Recursively merge the output type produced by a sequence of middleware
222 */
223export type IntersectAllValidatorOutputs<TMiddlewares, TInputValidator> =
224 unknown extends TInputValidator
225 ? TInputValidator
226 : TInputValidator extends undefined
227 ? IntersectAllMiddleware<TMiddlewares, 'allOutput'>
228 : IntersectAssign<
229 IntersectAllMiddleware<TMiddlewares, 'allOutput'>,
230 ResolveValidatorOutput<TInputValidator>
231 >
232​
233/**
234 * Recursively resolve the client context type produced by a sequence of middleware
235 */
236export type AssignAllClientContextBeforeNext<
237 TMiddlewares,
238 TClientContext = undefined,
239> = unknown extends TClientContext
240 ? TClientContext
241 : Assign<
242 AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>,
243 TClientContext
244 >
245​
246export type AssignAllMiddleware<
247 TMiddlewares,
248 TType extends
249 | keyof AnyFunctionMiddleware['_types']
250 | keyof AnyRequestMiddleware['_types']
251 | keyof AnyServerFn['_types'],
252 TAcc = undefined,
253> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
254 ? TMiddleware extends
255 | AnyFunctionMiddleware
256 | AnyRequestMiddleware
257 | AnyServerFn
258 ? AssignAllMiddleware<
259 TRest,
260 TType,
261 Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>
262 >
263 : TAcc
264 : TAcc
265​
266export type AssignAllClientContextAfterNext<
267 TMiddlewares,
268 TClientContext = undefined,
269 TSendContext = undefined,
270> = unknown extends TClientContext
271 ? Assign<TClientContext, TSendContext>
272 : Assign<
273 AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>,
274 Assign<TClientContext, TSendContext>
275 >
276​
277export type AssignAllServerSendContext<
278 TMiddlewares,
279 TSendContext = undefined,
280> = unknown extends TSendContext
281 ? TSendContext
282 : Assign<
283 AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,
284 TSendContext
285 >
286​
287export type AssignAllServerRequestContext<
288 TRegister,
289 TMiddlewares,
290 TSendContext = undefined,
291 TServerContext = undefined,
292> = Assign<
293 // Fetch Request Context
294 GlobalFetchRequestContext,
295 // AnyContext,
296 Assign<
297 GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
298 // type inference, but creates a circular types issue. No idea how to fix this.
299 // AnyContext,
300 __AssignAllServerRequestContext<TMiddlewares, TSendContext, TServerContext>
301 >
303​
304// export type GlobalFetchRequestContext<TRegister> = AnyContext
305export type GlobalFetchRequestContext = Register extends {
306 server: { requestContext: infer TRequestContext }
308 ? TRequestContext
309 : AnyContext
310​
311export type GlobalServerRequestContext<TRegister> = TRegister extends {
312 config: StartInstanceOptions<any, any, infer TRequestMiddlewares, any>
314 ? AssignAllMiddleware<TRequestMiddlewares, 'allServerContext'>
315 : AnyContext
316​
317type __AssignAllServerRequestContext<
318 TMiddlewares,
319 TSendContext = undefined,
320 TServerContext = undefined,
321> = unknown extends TSendContext
322 ? Assign<TSendContext, TServerContext>
323 : Assign<
324 AssignAllMiddleware<TMiddlewares, 'allServerContext'>,
325 Assign<TSendContext, TServerContext>
326 >
327​
328export type AssignAllServerFnContext<
329 TRegister,
330 TMiddlewares,
331 TSendContext = undefined,
332 TServerContext = undefined,
333> = Assign<
334 GlobalFetchRequestContext,
335 Assign<
336 GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
337 // type inference, but creates a circular types issue. No idea how to fix this.
338 // AnyContext,
339 Assign<
340 GlobalServerFnContext<TRegister>, // TODO: This enabled global middleware
341 // type inference, but creates a circular types issue. No idea how to fix this.
342 // AnyContext,/
343 __AssignAllServerFnContext<TMiddlewares, TSendContext, TServerContext>
344 >
345 >
347​
348type GlobalServerFnContext<TRegister> = TRegister extends {
349 config: StartInstanceOptions<any, any, any, infer TFunctionMiddlewares>
351 ? AssignAllMiddleware<TFunctionMiddlewares, 'allServerContext'>
352 : AnyContext
353​
354type __AssignAllServerFnContext<
355 TMiddlewares,
356 TSendContext = undefined,
357 TServerContext = undefined,
358> = unknown extends TSendContext
359 ? Assign<TSendContext, TServerContext>
360 : Assign<
361 AssignAllMiddleware<TMiddlewares, 'allServerContext'>,
362 Assign<TSendContext, TServerContext>
363 >
364​
365export type AssignAllClientSendContext<
366 TMiddlewares,
367 TSendContext = undefined,
368> = unknown extends TSendContext
369 ? TSendContext
370 : Assign<
371 AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,
372 TSendContext
373 >
374​
375export interface FunctionMiddlewareOptions<
376 in out TRegister,
377 in out TMiddlewares,
378 in out TInputValidator,
379 in out TServerContext,
380 in out TClientContext,
381> {
382 middleware?: TMiddlewares
383 inputValidator?: ConstrainValidator<TRegister, 'GET', TInputValidator>
384 client?: FunctionMiddlewareClientFn<
385 TRegister,
386 TMiddlewares,
387 TInputValidator,
388 TServerContext,
389 TClientContext
390 >
391 server?: FunctionMiddlewareServerFn<
392 TRegister,
393 TMiddlewares,
394 TInputValidator,
395 TServerContext,
396 unknown,
397 unknown
398 >
400​
401export type FunctionMiddlewareClientNextFn<TRegister, TMiddlewares> = <
402 TSendContext = undefined,
403 TNewClientContext = undefined,
404>(ctx?: {
405 context?: TNewClientContext
406 sendContext?: ValidateSerializableInput<TRegister, TSendContext>
407 headers?: HeadersInit
408}) => Promise<
409 FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>
411​
412export interface FunctionMiddlewareServer<
413 TRegister,
414 TMiddlewares,
415 TInputValidator,
416 TServerSendContext,
417 TClientContext,
418> {
419 server: <TNewServerContext = undefined, TSendContext = undefined>(
420 server: FunctionMiddlewareServerFn<
421 TRegister,
422 TMiddlewares,
423 TInputValidator,
424 TServerSendContext,
425 TNewServerContext,
426 TSendContext
427 >,
428 ) => FunctionMiddlewareAfterServer<
429 TRegister,
430 TMiddlewares,
431 TInputValidator,
432 TNewServerContext,
433 TServerSendContext,
434 TClientContext,
435 TSendContext
436 >
438​
439export type FunctionMiddlewareServerFn<
440 TRegister,
441 TMiddlewares,
442 TInputValidator,
443 TServerSendContext,
444 TNewServerContext,
445 TSendContext,
446> = (
447 options: FunctionMiddlewareServerFnOptions<
448 TRegister,
449 TMiddlewares,
450 TInputValidator,
451 TServerSendContext
452 >,
453) => FunctionMiddlewareServerFnResult<
454 TRegister,
455 TMiddlewares,
456 TServerSendContext,
457 TNewServerContext,
458 TSendContext
460​
461export type FunctionMiddlewareServerNextFn<
462 TRegister,
463 TMiddlewares,
464 TServerSendContext,
465> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
466 context?: TNewServerContext
467 sendContext?: ValidateSerializableInput<TRegister, TSendContext>
468}) => Promise<
469 FunctionServerResultWithContext<
470 TRegister,
471 TMiddlewares,
472 TServerSendContext,
473 TNewServerContext,
474 TSendContext
475 >
477​
478export type FunctionServerResultWithContext<
479 in out TRegister,
480 in out TMiddlewares,
481 in out TServerSendContext,
482 in out TServerContext,
483 in out TSendContext,
484> = {
485 'use functions must return the result of next()': true
486 _types: {
487 context: TServerContext
488 sendContext: TSendContext
489 }
490 context: Expand<
491 AssignAllServerFnContext<
492 TRegister,
493 TMiddlewares,
494 TServerSendContext,
495 TServerContext
496 >
497 >
498 sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>
500​
501export interface FunctionMiddlewareServerFnOptions<
502 in out TRegister,
503 in out TMiddlewares,
504 in out TInputValidator,
505 in out TServerSendContext,
506> {
507 data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>>
508 context: Expand<
509 AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext>
510 >
511 next: FunctionMiddlewareServerNextFn<
512 TRegister,
513 TMiddlewares,
514 TServerSendContext
515 >
516 method: Method
517 filename: string
518 functionId: string
519 signal: AbortSignal
521​
522export type FunctionMiddlewareServerFnResult<
523 TRegister,
524 TMiddlewares,
525 TServerSendContext,
526 TServerContext,
527 TSendContext,
528> =
529 | Promise<
530 FunctionServerResultWithContext<
531 TRegister,
532 TMiddlewares,
533 TServerSendContext,
534 TServerContext,
535 TSendContext
536 >
537 >
538 | FunctionServerResultWithContext<
539 TRegister,
540 TMiddlewares,
541 TServerSendContext,
542 TServerContext,
543 TSendContext
544 >
545​
546export interface FunctionMiddlewareAfterServer<
547 TRegister,
548 TMiddlewares,
549 TInputValidator,
550 TServerContext,
551 TServerSendContext,
552 TClientContext,
553 TClientSendContext,
554> extends FunctionMiddlewareWithTypes<
555 TRegister,
556 TMiddlewares,
557 TInputValidator,
558 TServerContext,
559 TServerSendContext,
560 TClientContext,
561 TClientSendContext
562 > {}
563​
564export interface FunctionMiddlewareClient<
565 TRegister,
566 TMiddlewares,
567 TInputValidator,
568> {
569 client: <TSendServerContext = undefined, TNewClientContext = undefined>(
570 client: FunctionMiddlewareClientFn<
571 TRegister,
572 TMiddlewares,
573 TInputValidator,
574 TSendServerContext,
575 TNewClientContext
576 >,
577 ) => FunctionMiddlewareAfterClient<
578 TRegister,
579 TMiddlewares,
580 TInputValidator,
581 TSendServerContext,
582 TNewClientContext
583 >
585​
586export type FunctionMiddlewareClientFn<
587 TRegister,
588 TMiddlewares,
589 TInputValidator,
590 TSendContext,
591 TClientContext,
592> = (
593 options: FunctionMiddlewareClientFnOptions<
594 TRegister,
595 TMiddlewares,
596 TInputValidator
597 >,
598) => FunctionMiddlewareClientFnResult<
599 TMiddlewares,
600 TSendContext,
601 TClientContext
603​
604export interface FunctionMiddlewareClientFnOptions<
605 in out TRegister,
606 in out TMiddlewares,
607 in out TInputValidator,
608> {
609 data: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>
610 context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>
611 sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>
612 method: Method
613 signal: AbortSignal
614 next: FunctionMiddlewareClientNextFn<TRegister, TMiddlewares>
615 filename: string
616 functionId: string
618​
619export type FunctionMiddlewareClientFnResult<
620 TMiddlewares,
621 TSendContext,
622 TClientContext,
623> =
624 | Promise<
625 FunctionClientResultWithContext<
626 TMiddlewares,
627 TSendContext,
628 TClientContext
629 >
630 >
631 | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>
632​
633export type FunctionClientResultWithContext<
634 in out TMiddlewares,
635 in out TSendContext,
636 in out TClientContext,
637> = {
638 'use functions must return the result of next()': true
639 context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>
640 sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>
641 headers: HeadersInit
643​
644export interface FunctionMiddlewareAfterClient<
645 TRegister,
646 TMiddlewares,
647 TInputValidator,
648 TServerSendContext,
649 TClientContext,
650> extends FunctionMiddlewareWithTypes<
651 TRegister,
652 TMiddlewares,
653 TInputValidator,
654 undefined,
655 TServerSendContext,
656 TClientContext,
657 undefined
658 >,
659 FunctionMiddlewareServer<
660 TRegister,
661 TMiddlewares,
662 TInputValidator,
663 TServerSendContext,
664 TClientContext
665 > {}
666​
667export interface FunctionMiddlewareValidator<TRegister, TMiddlewares> {
668 inputValidator: <TNewValidator>(
669 inputValidator: ConstrainValidator<TRegister, 'GET', TNewValidator>,
670 ) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator>
672​
673export interface FunctionMiddlewareAfterValidator<
674 TRegister,
675 TMiddlewares,
676 TInputValidator,
677> extends FunctionMiddlewareWithTypes<
678 TRegister,
679 TMiddlewares,
680 TInputValidator,
681 undefined,
682 undefined,
683 undefined,
684 undefined
685 >,
686 FunctionMiddlewareServer<
687 TRegister,
688 TMiddlewares,
689 TInputValidator,
690 undefined,
691 undefined
692 >,
693 FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {}
694​
695export interface RequestMiddleware<TRegister>
696 extends RequestMiddlewareAfterMiddleware<TRegister, undefined> {
697 middleware: <const TMiddlewares = undefined>(
698 middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>,
699 ) => RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>
701​
702export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any, any>
703​
704export interface RequestMiddlewareWithTypes<
705 TRegister,
706 TMiddlewares,
707 TServerContext,
708> {
709 _types: RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext>
710 options: RequestMiddlewareOptions<TRegister, TMiddlewares, TServerContext>
712​
713export interface RequestMiddlewareOptions<
714 in out TRegister,
715 in out TMiddlewares,
716 in out TServerContext,
717> {
718 middleware?: TMiddlewares
719 server?: RequestServerFn<TRegister, TMiddlewares, TServerContext>
721export interface RequestMiddlewareTypes<
722 TRegister,
723 TMiddlewares,
724 TServerContext,
725> {
726 type: 'request'
727 // this only exists so we can use request middlewares in server functions
728 allInput: undefined
729 // this only exists so we can use request middlewares in server functions
730 allOutput: undefined
731 middlewares: TMiddlewares
732 serverContext: TServerContext
733 allServerContext: AssignAllServerRequestContext<
734 TRegister,
735 TMiddlewares,
736 undefined,
737 TServerContext
738 >
740​
741export interface RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>
742 extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, undefined>,
743 RequestMiddlewareServer<TRegister, TMiddlewares> {}
744​
745export interface RequestMiddlewareServer<TRegister, TMiddlewares> {
746 server: <TServerContext = undefined>(
747 fn: RequestServerFn<TRegister, TMiddlewares, TServerContext>,
748 ) => RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext>
750​
751export type RequestServerFn<TRegister, TMiddlewares, TServerContext> = (
752 options: RequestServerOptions<TRegister, TMiddlewares>,
753) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>
754​
755export interface RequestServerOptions<TRegister, TMiddlewares> {
756 request: Request
757 pathname: string
758 context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares>>
759 next: RequestServerNextFn<TRegister, TMiddlewares>
761​
762export type RequestServerNextFn<TRegister, TMiddlewares> = <
763 TServerContext = undefined,
764>(
765 options?: RequestServerNextFnOptions<TServerContext>,
766) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>
767​
768export interface RequestServerNextFnOptions<TServerContext> {
769 context?: TServerContext
771​
772export type RequestMiddlewareServerFnResult<
773 TRegister,
774 TMiddlewares,
775 TServerContext,
776> =
777 | Promise<RequestServerResult<TRegister, TMiddlewares, TServerContext>>
778 | RequestServerResult<TRegister, TMiddlewares, TServerContext>
779​
780export interface RequestServerResult<TRegister, TMiddlewares, TServerContext> {
781 request: Request
782 pathname: string
783 context: Expand<
784 AssignAllServerRequestContext<
785 TRegister,
786 TMiddlewares,
787 undefined,
788 TServerContext
789 >
790 >
791 response: Response
793​
794export interface RequestMiddlewareAfterServer<
795 TRegister,
796 TMiddlewares,
797 TServerContext,
798> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {}