perf(start): reduce instantiations of server fn and middleware (again) (

#3168) * perf: reduce instantiations of server fns * perf(start): reduce instantiations of middleware
TanStack · Jan 14, 2025 · 8ea6a7a · 8ea6a7a
1 parent 13b76f7
commit 8ea6a7a
Show file tree

Hide file tree

Showing 4 changed files with 109 additions and 222 deletions.
diff --git a/packages/start/src/client/createMiddleware.ts b/packages/start/src/client/createMiddleware.ts
@@ -242,18 +242,16 @@ export type ClientResultWithContext<TServerContext, TClientContext> = {
   headers: HeadersInit
 }
 
-export type AnyMiddleware = MiddlewareTypes<any, any, any, any, any, any>
+export type AnyMiddleware = MiddlewareTypes<any, any, any, any, any>
 
 export interface MiddlewareTypes<
-  TId,
   TMiddlewares,
   TValidator,
   TServerContext,
   TClientContext,
   TClientAfterContext,
 > {
   _types: {
-    id: TId
     middlewares: TMiddlewares
     input: ResolveValidatorInput<TValidator>
     allInput: MergeAllValidatorInputs<TMiddlewares, TValidator>
@@ -279,28 +277,24 @@ export interface MiddlewareTypes<
   >
 }
 
-export interface MiddlewareValidator<
-  TId,
-  TMiddlewares,
-  TValidator,
-  TServerContext,
-  TClientContext,
-  TClientAfterContext,
-> {
+export interface MiddlewareAfterValidator<TMiddlewares, TValidator>
+  extends MiddlewareTypes<
+      TMiddlewares,
+      TValidator,
+      undefined,
+      undefined,
+      undefined
+    >,
+    MiddlewareServer<TMiddlewares, TValidator, undefined, undefined>,
+    MiddlewareClient<TMiddlewares, TValidator> {}
+
+export interface MiddlewareValidator<TMiddlewares> {
   validator: <TNewValidator>(
     input: ConstrainValidator<TNewValidator>,
-  ) => MiddlewareAfterMiddleware<
-    TId,
-    TMiddlewares,
-    NonNullable<TValidator> | TNewValidator,
-    TServerContext,
-    TClientContext,
-    TClientAfterContext
-  >
+  ) => MiddlewareAfterValidator<TMiddlewares, TNewValidator>
 }
 
 export interface MiddlewareClientAfter<
-  TId,
   TMiddlewares,
   TValidator,
   TServerContext,
@@ -316,7 +310,6 @@ export interface MiddlewareClientAfter<
       TNewClientAfterContext
     >,
   ) => MiddlewareAfterServer<
-    TId,
     TMiddlewares,
     TValidator,
     TServerContext,
@@ -326,22 +319,19 @@ export interface MiddlewareClientAfter<
 }
 
 export interface MiddlewareAfterServer<
-  TId,
   TMiddlewares,
   TValidator,
   TServerContext,
   TClientContext,
   TClientAfterContext,
 > extends MiddlewareTypes<
-      TId,
       TMiddlewares,
       TValidator,
       TServerContext,
       TClientContext,
       TClientAfterContext
     >,
     MiddlewareClientAfter<
-      TId,
       TMiddlewares,
       TValidator,
       TServerContext,
@@ -350,12 +340,10 @@ export interface MiddlewareAfterServer<
     > {}
 
 export interface MiddlewareServer<
-  TId,
   TMiddlewares,
   TValidator,
   TServerContext,
   TClientContext,
-  TClientAfterContext,
 > {
   server: <TNewServerContext = undefined, TNewClientAfterContext = undefined>(
     server: MiddlewareServerFn<
@@ -366,47 +354,34 @@ export interface MiddlewareServer<
       TNewClientAfterContext
     >,
   ) => MiddlewareAfterServer<
-    TId,
     TMiddlewares,
     TValidator,
     Assign<TServerContext, TNewServerContext>,
     TClientContext,
-    Assign<TClientAfterContext, TNewClientAfterContext>
+    TNewClientAfterContext
   >
 }
 
 export interface MiddlewareAfterClient<
-  TId,
   TMiddlewares,
   TValidator,
   TServerContext,
   TClientContext,
-  TClientAfterContext,
 > extends MiddlewareTypes<
-      TId,
       TMiddlewares,
       TValidator,
       TServerContext,
       TClientContext,
-      TClientAfterContext
+      undefined
     >,
     MiddlewareServer<
-      TId,
       TMiddlewares,
       TValidator,
       TServerContext,
-      TClientContext,
-      TClientAfterContext
+      TClientContext
     > {}
 
-export interface MiddlewareClient<
-  TId,
-  TMiddlewares,
-  TValidator,
-  TServerContext,
-  TClientContext,
-  TClientAfterContext,
-> {
+export interface MiddlewareClient<TMiddlewares, TValidator> {
   client: <TNewServerContext = undefined, TNewClientContext = undefined>(
     client: MiddlewareClientFn<
       TMiddlewares,
@@ -415,170 +390,78 @@ export interface MiddlewareClient<
       TNewClientContext
     >,
   ) => MiddlewareAfterClient<
-    TId,
     TMiddlewares,
     TValidator,
-    Assign<TServerContext, TNewServerContext>,
-    Assign<TClientContext, TNewClientContext>,
-    TClientAfterContext
+    TNewServerContext,
+    TNewClientContext
   >
 }
 
-export interface MiddlewareAfterMiddleware<
-  TId,
-  TMiddlewares,
-  TValidator,
-  TServerContext,
-  TClientContext,
-  TClientAfterContext,
-> extends MiddlewareTypes<
-      TId,
-      TMiddlewares,
-      TValidator,
-      TServerContext,
-      TClientContext,
-      TClientAfterContext
-    >,
-    MiddlewareServer<
-      TId,
-      TMiddlewares,
-      TValidator,
-      TServerContext,
-      TClientContext,
-      TClientAfterContext
-    >,
-    MiddlewareClient<
-      TId,
+export interface MiddlewareAfterMiddleware<TMiddlewares>
+  extends MiddlewareTypes<
       TMiddlewares,
-      TValidator,
-      TServerContext,
-      TClientContext,
-      TClientAfterContext
+      undefined,
+      undefined,
+      undefined,
+      undefined
     >,
-    MiddlewareValidator<
-      TId,
-      TMiddlewares,
-      TValidator,
-      TServerContext,
-      TClientContext,
-      TClientAfterContext
-    > {}
+    MiddlewareServer<TMiddlewares, undefined, undefined, undefined>,
+    MiddlewareClient<TMiddlewares, undefined>,
+    MiddlewareValidator<TMiddlewares> {}
 
-export interface Middleware<
-  TId,
-  TMiddlewares,
-  TValidator,
-  TServerContext,
-  TClientContext,
-  TClientAfterContext,
-> extends MiddlewareAfterMiddleware<
-    TId,
-    TMiddlewares,
-    TValidator,
-    TServerContext,
-    TClientContext,
-    TClientAfterContext
-  > {
+export interface Middleware extends MiddlewareAfterMiddleware<unknown> {
   middleware: <const TNewMiddlewares = undefined>(
     middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,
-  ) => MiddlewareAfterMiddleware<
-    TId,
-    TNewMiddlewares,
-    TValidator,
-    TServerContext,
-    TClientContext,
-    TClientAfterContext
-  >
+  ) => MiddlewareAfterMiddleware<TNewMiddlewares>
 }
 
-export function createMiddleware<
-  const TId,
-  const TMiddlewares,
-  TValidator = undefined,
-  TServerContext = undefined,
-  TClientContext = undefined,
-  TClientAfterContext = undefined,
->(
+export function createMiddleware(
   options?: {
     validateClient?: boolean
   },
-  __opts?: MiddlewareOptions<
-    TMiddlewares,
-    TValidator,
-    TServerContext,
-    TClientContext
-  >,
-): Middleware<
-  TId,
-  TMiddlewares,
-  TValidator,
-  TServerContext,
-  TClientContext,
-  TClientAfterContext
-> {
+  __opts?: MiddlewareOptions<unknown, undefined, undefined, undefined>,
+): Middleware {
   // const resolvedOptions = (__opts || options) as MiddlewareOptions<
   const resolvedOptions =
     __opts ||
     ((options || {}) as MiddlewareOptions<
-      TMiddlewares,
-      TValidator,
-      TServerContext,
-      TClientContext
+      unknown,
+      undefined,
+      undefined,
+      undefined
     >)
 
   return {
     options: resolvedOptions as any,
     middleware: (middleware: any) => {
-      return createMiddleware<
-        TId,
-        TMiddlewares,
-        TValidator,
-        TServerContext,
-        TClientContext
-      >(undefined, Object.assign(resolvedOptions, { middleware })) as any
+      return createMiddleware(
+        undefined,
+        Object.assign(resolvedOptions, { middleware }),
+      ) as any
     },
     validator: (validator: any) => {
-      return createMiddleware<
-        TId,
-        TMiddlewares,
-        TValidator,
-        TServerContext,
-        TClientContext
-      >(undefined, Object.assign(resolvedOptions, { validator })) as any
+      return createMiddleware(
+        undefined,
+        Object.assign(resolvedOptions, { validator }),
+      ) as any
     },
     client: (client: any) => {
-      return createMiddleware<
-        TId,
-        TMiddlewares,
-        TValidator,
-        TServerContext,
-        TClientContext
-      >(undefined, Object.assign(resolvedOptions, { client })) as any
+      return createMiddleware(
+        undefined,
+        Object.assign(resolvedOptions, { client }),
+      ) as any
     },
     server: (server: any) => {
-      return createMiddleware<
-        TId,
-        TMiddlewares,
-        TValidator,
-        TServerContext,
-        TClientContext
-      >(undefined, Object.assign(resolvedOptions, { server })) as any
+      return createMiddleware(
+        undefined,
+        Object.assign(resolvedOptions, { server }),
+      ) as any
     },
     clientAfter: (clientAfter: any) => {
-      return createMiddleware<
-        TId,
-        TMiddlewares,
-        TValidator,
-        TServerContext,
-        TClientContext
-      >(undefined, Object.assign(resolvedOptions, { clientAfter })) as any
+      return createMiddleware(
+        undefined,
+        Object.assign(resolvedOptions, { clientAfter }),
+      ) as any
     },
-  } as unknown as Middleware<
-    TId,
-    TMiddlewares,
-    TValidator,
-    TServerContext,
-    TClientContext,
-    TClientAfterContext
-  >
+  } as unknown as Middleware
 }