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