@taserjs/router 0.1.6 → 0.1.8

package/src/index.ts

@@ -1,4 +1,6 @@
 export interface RouterRegister {}
+export interface RouterMiddlewaresRegister {}
+export interface RouterRoutesRegister {}
 export type {
   AppContext,
   EmptyAppContext,
@@ -11,6 +13,7 @@ export type {
   InferRouteOutput,
   LayoutBuilder,
   LayoutId,
+  LayoutMiddlewaresMap,
   LayoutTree,
   Method,
   MiddlewareBuilder,
@@ -51,6 +54,7 @@ export {
   patch,
   post,
   put,
+  query,
   t,
   type TaserNamespace,
 } from "./builder/standalone.js";

package/src/middleware/hono-mw.ts

@@ -1,6 +1,8 @@
 import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 
+import type { NextFn } from "../types/units.js";
+
 /**
  * Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`
  * into a Taser-compatible middleware handler function `(ctx, next) => Promise<Response>`.
@@ -15,8 +17,8 @@ import type { MiddlewareHandler } from "hono";
  * const customCors = middleware(honoMw(cors()));
  * ```
  */
-export function honoMw(
+export function honoMw<TState extends Record<string, unknown> = {}>(
   middleware: MiddlewareHandler,
-): (ctx: unknown, next: any) => Promise<Response> {
-  return createTaserCompatHandler(middleware) as (ctx: unknown, next: any) => Promise<Response>;
+): (ctx: unknown, next: NextFn<TState>) => Promise<Response> {
+  return createTaserCompatHandler(middleware) as (ctx: unknown, next: NextFn<TState>) => Promise<Response>;
 }

package/src/types/index.ts

@@ -1,5 +1,9 @@
 import type { Awaitable, TaserCookieJar, TaserHeaders } from "@taserjs/router-core";
-import type { RouterRegister } from "../index.js";
+import type {
+  RouterMiddlewaresRegister,
+  RouterRegister,
+  RouterRoutesRegister,
+} from "../index.js";
 import type {
   MergeMiddlewareField,
   MergeMiddlewareInputField,
@@ -16,6 +20,7 @@ import type {
   ExtractState,
   Method,
   MiddlewareDefinition,
+  MiddlewareRequirements,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
   NextFn,
@@ -57,6 +62,7 @@ export type {
   IsUnknown,
   Method,
   MiddlewareDefinition,
+  MiddlewareRequirements,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
   MiddlewareUnitBuilder,
@@ -72,9 +78,18 @@ export type AppContext = RouterRegister extends { AppContext: infer C } ? C : Em
 export type RoutePath = RouterRegister extends { RoutePath: infer P } ? P : never;
 export type LayoutId = RouterRegister extends { LayoutId: infer L } ? L : never;
 export type LayoutTree = RouterRegister extends { LayoutTree: infer T } ? T : Record<never, never>;
-export type RouteByPathMethod = RouterRegister extends { RouteByPathMethod: infer R }
+export type LayoutMiddlewaresMap = RouterMiddlewaresRegister extends {
+  LayoutMiddlewares: infer M;
+}
+  ? M
+  : RouterRegister extends { LayoutMiddlewares: infer M }
+    ? M
+    : Record<never, never>;
+export type RouteByPathMethod = RouterRoutesRegister extends { RouteByPathMethod: infer R }
   ? R
-  : Record<never, never>;
+  : RouterRegister extends { RouteByPathMethod: infer R }
+    ? R
+    : Record<never, never>;
 
 export type LayoutBuilder<TAppContext extends Record<string, unknown> = AppContext> = <
   const Layout extends LayoutId,
@@ -105,40 +120,32 @@ export type ResolveParams<TPathParams, TSchemaParams> =
       : Simplify<Omit<TPathParams, keyof TSchemaParams> & TSchemaParams>
     : TPathParams;
 
-type LayoutParentsMap = RouterRegister extends {
-  LayoutParents: infer LP extends Record<string, unknown>;
-}
-  ? LP
-  : {};
-
-type LayoutParent<Layout extends LayoutId> = Layout extends keyof LayoutParentsMap
-  ? LayoutParentsMap[Layout] extends LayoutId
-    ? LayoutParentsMap[Layout]
+type LayoutParent<Layout extends LayoutId> = Layout extends keyof LayoutTree
+  ? LayoutTree[Layout] extends { parent: infer P extends LayoutId }
+    ? P
     : null
-  : LayoutTree[Layout] extends {
-        parent: infer Parent extends LayoutId | null;
-      }
-    ? Parent
-    : null;
-
-type LayoutMiddlewares<Layout extends LayoutId> = LayoutTree[Layout]["middlewares"] extends {
-  readonly __acc?: infer Acc extends readonly unknown[];
-}
-  ? Acc
-  : LayoutTree[Layout]["middlewares"] extends infer Acc extends readonly unknown[]
+  : null;
+
+type LayoutMiddlewares<Layout extends LayoutId> = [Layout] extends [keyof LayoutMiddlewaresMap]
+  ? LayoutMiddlewaresMap[Layout] extends { readonly __acc?: infer Acc extends readonly unknown[] }
     ? Acc
-    : readonly [];
+    : LayoutMiddlewaresMap[Layout] extends readonly unknown[]
+      ? LayoutMiddlewaresMap[Layout]
+      : readonly []
+  : readonly [];
 
 type ResolveLayoutMiddlewares<
   Layout extends LayoutId | null,
   Depth extends readonly unknown[] = [],
 > = Depth["length"] extends 10
   ? readonly []
-  : Layout extends LayoutId
-    ? readonly [
-        ...ResolveLayoutMiddlewares<LayoutParent<Layout>, [...Depth, unknown]>,
-        ...LayoutMiddlewares<Layout>,
-      ]
+  : [Layout] extends [LayoutId]
+    ? LayoutParent<Layout> extends infer Parent extends LayoutId
+      ? readonly [
+          ...ResolveLayoutMiddlewares<Parent, [...Depth, unknown]>,
+          ...LayoutMiddlewares<Layout>,
+        ]
+      : readonly [...LayoutMiddlewares<Layout>]
     : readonly [];
 
 export type ResolveLayoutIdChain<
@@ -182,17 +189,10 @@ type RouteEntry<Path extends RoutePath, TMethod extends Method> = RouteByPathMet
   ? Entry
   : never;
 
-type RouteParent<Path extends RoutePath, TMethod extends Method> =
-  RouteEntry<Path, TMethod> extends { parent: infer Parent extends LayoutId | null }
-    ? Parent
-    : null;
-
 type RouteLayoutChain<Path extends RoutePath, TMethod extends Method> =
-  RouteEntry<Path, TMethod> extends { layoutChain: infer Chain extends readonly LayoutId[] }
+  RouteEntry<Path, TMethod> extends { layouts: infer Chain extends readonly LayoutId[] }
     ? Chain
-    : RouteParent<Path, TMethod> extends LayoutId
-      ? readonly [RouteParent<Path, TMethod>]
-      : readonly [];
+    : readonly [];
 
 export type RouteLayoutMiddlewares<
   Path extends RoutePath,
@@ -229,15 +229,13 @@ export type RouteChainContext<
 > = Simplify<
   TAppContext &
     UnitRuntimeContext & {
-      query: Simplify<MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>>;
-      params: Simplify<
-        ResolveParams<
-          PathParams<Path>,
-          MergePart<TParams, RouteResolvedField<Path, TMethod, Acc, "params">>
-        >
+      query: MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>;
+      params: ResolveParams<
+        PathParams<Path>,
+        MergePart<TParams, RouteResolvedField<Path, TMethod, Acc, "params">>
       >;
-      body: Simplify<MergePart<TBody, RouteResolvedField<Path, TMethod, Acc, "body">>>;
-      state: Simplify<RouteResolvedField<Path, TMethod, Acc, "state">>;
+      body: MergePart<TBody, RouteResolvedField<Path, TMethod, Acc, "body">>;
+      state: RouteResolvedField<Path, TMethod, Acc, "state">;
       headers: TaserHeaders;
       cookies: TaserCookieJar;
     }
@@ -352,19 +350,66 @@ export type IsLayoutAllowed<TRequiredLayouts, TChain extends readonly LayoutId[]
               : true
             : true;
 
-export type IsStateSatisfied<TActualState, TRequiredState> = [TRequiredState] extends [never]
+export type IsRequirementsSatisfied<
+  TActual extends {
+    query?: unknown;
+    params?: unknown;
+    body?: unknown;
+    state?: unknown;
+  },
+  TRequires extends MiddlewareRequirements,
+> = [TRequires] extends [never]
   ? true
-  : [unknown] extends [TRequiredState]
+  : [unknown] extends [TRequires]
     ? true
-    : [null] extends [TRequiredState]
+    : [null] extends [TRequires]
       ? true
-      : [undefined] extends [TRequiredState]
+      : [undefined] extends [TRequires]
         ? true
-        : [IsEmptyObject<TRequiredState>] extends [true]
+        : [IsEmptyObject<TRequires>] extends [true]
           ? true
-          : [TActualState] extends [TRequiredState]
-            ? true
-            : false;
+          : (
+                TRequires extends { state: infer S extends Record<string, unknown> }
+                  ? [TActual["state"]] extends [S]
+                    ? true
+                    : false
+                  : true
+              ) extends false
+            ? false
+            : (
+                  TRequires extends { query: infer Q extends Record<string, unknown> }
+                    ? [TActual["query"]] extends [Q]
+                      ? true
+                      : false
+                    : true
+                ) extends false
+              ? false
+              : (
+                    TRequires extends { params: infer P extends Record<string, unknown> }
+                      ? [TActual["params"]] extends [P]
+                        ? true
+                        : false
+                      : true
+                  ) extends false
+                ? false
+                : (
+                      TRequires extends { body: infer B }
+                        ? unknown extends B
+                          ? true
+                          : [TRequires["body"]] extends [undefined]
+                            ? true
+                            : [TActual["body"]] extends [B]
+                              ? true
+                              : false
+                        : true
+                    ) extends false
+                  ? false
+                  : true;
+
+export type IsStateSatisfied<TActualState, TRequiredState> = IsRequirementsSatisfied<
+  { state: TActualState },
+  { state: TRequiredState extends Record<string, unknown> ? TRequiredState : {} }
+>;
 
 type InputFacet<T, K extends string> =
   IsNever<T> extends true ? {} : IsEmptyObject<T> extends true ? {} : { [Key in K]: T };
@@ -447,7 +492,9 @@ export type InferRouteInputFromPath<Path extends RoutePath, TMethod extends Meth
 export type MiddlewareLayoutField<
   Layout extends LayoutId,
   Field extends "query" | "params" | "body" | "state",
-> = MergeMiddlewareField<ResolveLayoutMiddlewares<LayoutParent<Layout>>, Field>;
+> = [LayoutParent<Layout>] extends [infer Parent extends LayoutId]
+  ? MergeMiddlewareField<ResolveLayoutMiddlewares<Parent>, Field>
+  : {};
 
 type MiddlewareChainField<
   Layout extends LayoutId,
@@ -458,20 +505,22 @@ type MiddlewareChainField<
 export type MiddlewareChainContext<
   Layout extends LayoutId,
   Acc extends readonly unknown[],
-  TQuery,
-  TParams,
-  TBody,
+  TQuery = unknown,
+  TParams = unknown,
+  TBody = unknown,
   TAppContext extends Record<string, unknown> = AppContext,
 > = Simplify<
-  TAppContext &
-    UnitRuntimeContext & {
-      query: Simplify<MergePart<TQuery, MiddlewareChainField<Layout, Acc, "query">>>;
-      params: Simplify<MergePart<TParams, MiddlewareChainField<Layout, Acc, "params">>>;
-      body: Simplify<MergePart<TBody, MiddlewareChainField<Layout, Acc, "body">>>;
-      state: Simplify<MiddlewareChainField<Layout, Acc, "state">>;
-      headers: TaserHeaders;
-      cookies: TaserCookieJar;
-    }
+  TAppContext & {
+    readonly request: Request;
+    readonly method: Method;
+    readonly url: URL;
+    readonly headers: TaserHeaders;
+    readonly cookies: TaserCookieJar;
+    query: Simplify<MergePart<TQuery, MiddlewareChainField<Layout, Acc, "query">>>;
+    params: Simplify<MergePart<TParams, MiddlewareChainField<Layout, Acc, "params">>>;
+    body: Simplify<MergePart<TBody, MiddlewareChainField<Layout, Acc, "body">>>;
+    state: Simplify<MiddlewareChainField<Layout, Acc, "state">>;
+  }
 >;
 
 export type MiddlewareBuilder<
@@ -482,29 +531,42 @@ export type MiddlewareBuilder<
   readonly layout: Layout;
   readonly middlewares: readonly MiddlewareDefinition[];
   readonly __acc?: Acc;
-  readonly $Infer: {
-    Context: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>;
-  };
-  use<TAcc, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(
-    unit: MiddlewareUnit<TAcc, TReturns, TRequiredLayouts, TRequiredState>,
-    ..._assert: [
+  use<
+    TAcc,
+    TReturns extends ReturnsMap = {},
+    TRequiredLayouts = unknown,
+    TRequires extends MiddlewareRequirements = {},
+  >(
+    unit: [
       IsLayoutAllowed<TRequiredLayouts, ResolveLayoutIdChain<Layout>>,
-      IsStateSatisfied<MiddlewareChainField<Layout, Acc, "state">, TRequiredState>,
+      IsRequirementsSatisfied<
+        {
+          query: MiddlewareChainField<Layout, Acc, "query">;
+          params: MiddlewareChainField<Layout, Acc, "params">;
+          body: MiddlewareChainField<Layout, Acc, "body">;
+          state: MiddlewareChainField<Layout, Acc, "state">;
+        },
+        TRequires
+      >,
     ] extends [true, true]
-      ? []
-      : [
-          {
-            error: "Middleware cannot be attached to this layout";
-            requiredLayouts: TRequiredLayouts;
-            layoutChain: ResolveLayoutIdChain<Layout>;
-            requiredState: TRequiredState;
-            actualState: MiddlewareChainField<Layout, Acc, "state">;
-          },
-        ]
+      ? MiddlewareUnit<TAcc, TReturns, TRequiredLayouts, TRequires>
+      : never,
   ): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
   use<R = unknown>(
     fn: (
-      ctx: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>,
+      ctx: Simplify<
+        TAppContext & {
+          readonly request: Request;
+          readonly method: Method;
+          readonly url: URL;
+          readonly headers: TaserHeaders;
+          readonly cookies: TaserCookieJar;
+          query: Simplify<MergePart<unknown, MiddlewareChainField<Layout, Acc, "query">>>;
+          params: Simplify<MergePart<unknown, MiddlewareChainField<Layout, Acc, "params">>>;
+          body: Simplify<MergePart<unknown, MiddlewareChainField<Layout, Acc, "body">>>;
+          state: Simplify<MiddlewareChainField<Layout, Acc, "state">>;
+        }
+      >,
       next: NextFn,
     ) => Awaitable<R>,
   ): MiddlewareBuilder<
@@ -563,7 +625,7 @@ type RouteHandleResult<
   };
 };
 
-export type RouteBuilderBase<
+export type RouteContractBuilderBase<
   Path extends RoutePath,
   TMethod extends Method,
   Acc extends readonly unknown[] = readonly [],
@@ -584,7 +646,7 @@ export type RouteBuilderBase<
   };
   query<TQuery, TQueryIn = unknown>(
     schema: Schema<TQuery, TQueryIn>,
-  ): RouteBuilder<
+  ): RouteContractBuilder<
     Path,
     TMethod,
     Acc,
@@ -594,7 +656,7 @@ export type RouteBuilderBase<
   >;
   params<TParams, TParamsIn = unknown>(
     schema: Schema<TParams, TParamsIn>,
-  ): RouteBuilder<
+  ): RouteContractBuilder<
     Path,
     TMethod,
     Acc,
@@ -604,44 +666,7 @@ export type RouteBuilderBase<
   >;
   returns<const M extends ReturnsMap>(
     map: M,
-  ): RouteBuilder<Path, TMethod, Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
-  use<TAcc, UReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(
-    unit: MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequiredState>,
-    ..._assert: [
-      IsLayoutAllowed<TRequiredLayouts, RouteLayoutChain<Path, TMethod>>,
-      IsStateSatisfied<RouteResolvedField<Path, TMethod, Acc, "state">, TRequiredState>,
-    ] extends [true, true]
-      ? []
-      : [
-          {
-            error: "Middleware cannot be attached to this route";
-            requiredLayouts: TRequiredLayouts;
-            routeLayoutChain: RouteLayoutChain<Path, TMethod>;
-            requiredState: TRequiredState;
-            actualState: RouteResolvedField<Path, TMethod, Acc, "state">;
-          },
-        ]
-  ): RouteBuilder<
-    Path,
-    TMethod,
-    readonly [...Acc, TAcc],
-    Validators,
-    Omit<TReturns, keyof UReturns> & UReturns,
-    TAppContext
-  >;
-  use<R = unknown>(
-    fn: (
-      ctx: RouteChainContext<Path, TMethod, Acc, unknown, unknown, unknown, TAppContext>,
-      next: NextFn,
-    ) => Awaitable<R>,
-  ): RouteBuilder<
-    Path,
-    TMethod,
-    readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>],
-    Validators,
-    TReturns,
-    TAppContext
-  >;
+  ): RouteContractBuilder<Path, TMethod, Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
   handler<R extends Response = Response>(
     fn: (
       ctx: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS"
@@ -659,20 +684,20 @@ export type RouteBuilderBase<
   ): RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, R, TAppContext>;
 };
 
-export type RouteBuilder<
+export type RouteContractBuilder<
   Path extends RoutePath,
   TMethod extends Method,
   Acc extends readonly unknown[] = readonly [],
   Validators extends ValidatorParts = {},
   TReturns extends ReturnsMap = {},
   TAppContext extends Record<string, unknown> = AppContext,
-> = RouteBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> &
+> = RouteContractBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> &
   (TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS"
     ? {}
     : {
         body<TBody, TBodyIn = unknown>(
           schema: Schema<TBody, TBodyIn>,
-        ): RouteBuilder<
+        ): RouteContractBuilder<
           Path,
           TMethod,
           Acc,
@@ -683,7 +708,7 @@ export type RouteBuilder<
         body<Mode extends "json" | "form" | "urlencoded", TBody, TBodyIn = unknown>(
           mode: Mode,
           schema: Schema<TBody, TBodyIn>,
-        ): RouteBuilder<
+        ): RouteContractBuilder<
           Path,
           TMethod,
           Acc,
@@ -693,6 +718,66 @@ export type RouteBuilder<
         >;
       });
 
+export type RouteMiddlewareBuilder<
+  Path extends RoutePath,
+  TMethod extends Method,
+  Acc extends readonly unknown[] = readonly [],
+  Validators extends ValidatorParts = {},
+  TReturns extends ReturnsMap = {},
+  TAppContext extends Record<string, unknown> = AppContext,
+> = RouteContractBuilder<Path, TMethod, Acc, Validators, TReturns, TAppContext> & {
+  use<
+    TAcc,
+    UReturns extends ReturnsMap = {},
+    TRequiredLayouts = unknown,
+    TRequires extends MiddlewareRequirements = {},
+  >(
+    unit: [
+      IsLayoutAllowed<TRequiredLayouts, RouteLayoutChain<Path, TMethod>>,
+      IsRequirementsSatisfied<
+        {
+          query: RouteResolvedField<Path, TMethod, Acc, "query">;
+          params: ResolveParams<PathParams<Path>, RouteResolvedField<Path, TMethod, Acc, "params">>;
+          body: RouteResolvedField<Path, TMethod, Acc, "body">;
+          state: RouteResolvedField<Path, TMethod, Acc, "state">;
+        },
+        TRequires
+      >,
+    ] extends [true, true]
+      ? MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequires>
+      : never,
+  ): RouteMiddlewareBuilder<
+    Path,
+    TMethod,
+    readonly [...Acc, TAcc],
+    Validators,
+    Omit<TReturns, keyof UReturns> & UReturns,
+    TAppContext
+  >;
+  use<R = unknown>(
+    fn: (
+      ctx: RouteChainContext<Path, TMethod, Acc, unknown, unknown, unknown, TAppContext>,
+      next: NextFn,
+    ) => Awaitable<R>,
+  ): RouteMiddlewareBuilder<
+    Path,
+    TMethod,
+    readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>],
+    Validators,
+    TReturns,
+    TAppContext
+  >;
+};
+
+export type RouteBuilder<
+  Path extends RoutePath,
+  TMethod extends Method,
+  Acc extends readonly unknown[] = readonly [],
+  Validators extends ValidatorParts = {},
+  TReturns extends ReturnsMap = {},
+  TAppContext extends Record<string, unknown> = AppContext,
+> = RouteMiddlewareBuilder<Path, TMethod, Acc, Validators, TReturns, TAppContext>;
+
 export type RouteDefinition<
   Path extends RoutePath = RoutePath,
   TMethod extends Method = Method,

package/src/types/type-utils.ts

@@ -13,7 +13,7 @@ export type UnwrapPart<T> = unknown extends T ? {} : T;
 export type MergePart<T, Base> = unknown extends T ? Base : Base & T;
 
 /** Collapse intersections so `Omit`/`keyof` treat the result as one object type. */
-export type Simplify<T> = { [K in keyof T]: T[K] } & {};
+export type Simplify<T> = [T] extends [infer U] ? { [K in keyof U]: U[K] } : never;
 
 /**
  * Request prop: when schema input is `unknown` (e.g. zod coerce),