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

createMiddleware.ts

818 lines20.6 KB

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