@taserjs/router 0.1.6 → 0.1.8

package/dist/esm/types/index.d.ts

@@ -1,14 +1,14 @@
 import { Awaitable, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { RouterRegister } from '../index.js';
+import { RouterMiddlewaresRegister, RouterRegister, RouterRoutesRegister } from '../index.js';
 import { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnionToIntersection, UnitRuntimeContext } from './type-utils.js';
 import { ReturnsMap, ValidHandlerReply } from './returns.js';
 import { Schema } from './schema.js';
-import { EmptyAppContext, ExtractState, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, ValidatorParts } from './units.js';
+import { EmptyAppContext, ExtractState, Method, MiddlewareDefinition, MiddlewareRequirements, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, ValidatorParts } from './units.js';
 export type { Awaitable } from '@taserjs/router-core';
 export type { SchemaRequestShape, InferInput, InferOutput, Schema, StandardSchemaV1, } from './schema.js';
 export type { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart, } from './type-utils.js';
 export type { EmptyReturns, EnforceHandlerReply, HandlerReply, HasReturns, MergeReturns, ReplyFor, ReturnsMap, StatusCode, ValidHandlerReply, } from './returns.js';
-export type { EmptyAppContext, ExtractState, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
+export type { EmptyAppContext, ExtractState, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareRequirements, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
 export type AppContext = RouterRegister extends {
     AppContext: infer C;
 } ? C : EmptyAppContext;
@@ -21,7 +21,14 @@ export type LayoutId = RouterRegister extends {
 export type LayoutTree = RouterRegister extends {
     LayoutTree: infer T;
 } ? T : Record<never, never>;
-export type RouteByPathMethod = RouterRegister extends {
+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 : RouterRegister extends {
     RouteByPathMethod: infer R;
 } ? R : Record<never, never>;
 export type LayoutBuilder<TAppContext extends Record<string, unknown> = AppContext> = <const Layout extends LayoutId>(layout: Layout) => MiddlewareBuilder<Layout, readonly [], TAppContext>;
@@ -33,19 +40,16 @@ type ParseParam<Segment extends string> = Segment extends "*" ? {
 type ParseParamsFromSegments<S extends string> = S extends `${infer Segment}/${infer Rest}` ? ParseParam<Segment> & ParseParamsFromSegments<Rest> : ParseParam<S>;
 export type PathParams<Path extends string> = Path extends `/${infer Rest}` ? ParseParamsFromSegments<Rest> : {};
 export type ResolveParams<TPathParams, TSchemaParams> = TSchemaParams extends Record<string, unknown> ? [keyof TSchemaParams] extends [never] ? TPathParams : 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] : null : LayoutTree[Layout] extends {
-    parent: infer Parent extends LayoutId | null;
-} ? Parent : null;
-type LayoutMiddlewares<Layout extends LayoutId> = LayoutTree[Layout]["middlewares"] extends {
+type LayoutParent<Layout extends LayoutId> = Layout extends keyof LayoutTree ? LayoutTree[Layout] extends {
+    parent: infer P extends LayoutId;
+} ? P : null : null;
+type LayoutMiddlewares<Layout extends LayoutId> = [Layout] extends [keyof LayoutMiddlewaresMap] ? LayoutMiddlewaresMap[Layout] extends {
     readonly __acc?: infer Acc extends readonly unknown[];
-} ? Acc : LayoutTree[Layout]["middlewares"] extends infer Acc extends readonly unknown[] ? Acc : 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]>,
+} ? Acc : 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] ? LayoutParent<Layout> extends infer Parent extends LayoutId ? readonly [
+    ...ResolveLayoutMiddlewares<Parent, [...Depth, unknown]>,
     ...LayoutMiddlewares<Layout>
-] : readonly [];
+] : readonly [...LayoutMiddlewares<Layout>] : readonly [];
 export type ResolveLayoutIdChain<L extends LayoutId | null, Depth extends readonly unknown[] = []> = Depth["length"] extends 10 ? readonly [] : L extends LayoutId ? readonly [...ResolveLayoutIdChain<LayoutParent<L>, [...Depth, unknown]>, L] : readonly [];
 export type ResolveLayoutMiddlewaresState<Layout extends LayoutId | null> = Layout extends LayoutId ? MergeMiddlewareField<ResolveLayoutMiddlewares<Layout>, "state"> : {};
 export type ResolveLayoutsState<Layouts extends LayoutId | readonly LayoutId[]> = Layouts extends LayoutId ? ResolveLayoutMiddlewaresState<Layouts> : Layouts extends readonly LayoutId[] ? UnionToIntersection<Layouts[number] extends infer L extends LayoutId ? ResolveLayoutMiddlewaresState<L> : never> : {};
@@ -60,21 +64,18 @@ type ResolveLayoutChainMiddlewares<Chain extends readonly LayoutId[]> = Chain ex
 type RouteEntry<Path extends RoutePath, TMethod extends Method> = RouteByPathMethod[Path] extends {
     [K in TMethod]: infer Entry;
 } ? 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[];
-} ? Chain : RouteParent<Path, TMethod> extends LayoutId ? readonly [RouteParent<Path, TMethod>] : readonly [];
+    layouts: infer Chain extends readonly LayoutId[];
+} ? Chain : readonly [];
 export type RouteLayoutMiddlewares<Path extends RoutePath, TMethod extends Method> = ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>;
 export type RouteLayoutField<Path extends RoutePath, TMethod extends Method, Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<RouteLayoutMiddlewares<Path, TMethod>, Field>;
 export type RouteLayoutInputField<Path extends RoutePath, TMethod extends Method, Field extends "query" | "params" | "body"> = MergeMiddlewareInputField<RouteLayoutMiddlewares<Path, TMethod>, Field>;
 type RouteResolvedField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = RouteLayoutField<Path, TMethod, Field> & MergeMiddlewareField<Acc, Field>;
 export type RouteChainContext<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TQuery, TParams, TBody, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>>;
-    params: Simplify<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">>;
+    query: MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>;
+    params: ResolveParams<PathParams<Path>, MergePart<TParams, RouteResolvedField<Path, TMethod, Acc, "params">>>;
+    body: MergePart<TBody, RouteResolvedField<Path, TMethod, Acc, "body">>;
+    state: RouteResolvedField<Path, TMethod, Acc, "state">;
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
@@ -121,7 +122,25 @@ type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
 export type IsLayoutAllowed<TRequiredLayouts, TChain extends readonly LayoutId[]> = [
     TRequiredLayouts
 ] extends [never] ? true : [unknown] extends [TRequiredLayouts] ? true : [null] extends [TRequiredLayouts] ? true : [undefined] extends [TRequiredLayouts] ? true : TRequiredLayouts extends LayoutId ? TRequiredLayouts extends TChain[number] ? true : false : TRequiredLayouts extends readonly LayoutId[] ? [TRequiredLayouts[number] & TChain[number]] extends [never] ? false : true : true;
-export type IsStateSatisfied<TActualState, TRequiredState> = [TRequiredState] extends [never] ? true : [unknown] extends [TRequiredState] ? true : [null] extends [TRequiredState] ? true : [undefined] extends [TRequiredState] ? true : [IsEmptyObject<TRequiredState>] extends [true] ? true : [TActualState] extends [TRequiredState] ? true : false;
+export type IsRequirementsSatisfied<TActual extends {
+    query?: unknown;
+    params?: unknown;
+    body?: unknown;
+    state?: unknown;
+}, TRequires extends MiddlewareRequirements> = [TRequires] extends [never] ? true : [unknown] extends [TRequires] ? true : [null] extends [TRequires] ? true : [undefined] extends [TRequires] ? true : [IsEmptyObject<TRequires>] extends [true] ? true : (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;
 };
@@ -149,36 +168,43 @@ export type InferRouteInputFromPath<Path extends RoutePath, TMethod extends Meth
         Input: infer I;
     };
 } ? I : never : never;
-export type MiddlewareLayoutField<Layout extends LayoutId, Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<ResolveLayoutMiddlewares<LayoutParent<Layout>>, Field>;
+export type MiddlewareLayoutField<Layout extends LayoutId, Field extends "query" | "params" | "body" | "state"> = [LayoutParent<Layout>] extends [infer Parent extends LayoutId] ? MergeMiddlewareField<ResolveLayoutMiddlewares<Parent>, Field> : {};
 type MiddlewareChainField<Layout extends LayoutId, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = MiddlewareLayoutField<Layout, Field> & MergeMiddlewareField<Acc, Field>;
-export type MiddlewareChainContext<Layout extends LayoutId, Acc extends readonly unknown[], TQuery, TParams, TBody, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
+export type MiddlewareChainContext<Layout extends LayoutId, Acc extends readonly unknown[], TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = AppContext> = Simplify<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">>;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
 }>;
 export type MiddlewareBuilder<Layout extends LayoutId, Acc extends readonly unknown[] = readonly [], TAppContext extends Record<string, unknown> = AppContext> = {
     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>
-    ] extends [true, true] ? [] : [
-        {
-            error: "Middleware cannot be attached to this layout";
-            requiredLayouts: TRequiredLayouts;
-            layoutChain: ResolveLayoutIdChain<Layout>;
-            requiredState: TRequiredState;
-            actualState: MiddlewareChainField<Layout, Acc, "state">;
-        }
-    ]): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
-    use<R = unknown>(fn: (ctx: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>, next: NextFn) => Awaitable<R>): MiddlewareBuilder<Layout, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], TAppContext>;
+        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] ? MiddlewareUnit<TAcc, TReturns, TRequiredLayouts, TRequires> : never): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
+    use<R = unknown>(fn: (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<Layout, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], TAppContext>;
 };
 export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TReturns extends ReturnsMap = {}, TOutput = Response> = {
     readonly path: Path;
@@ -205,7 +231,7 @@ type RouteHandleResult<Path extends RoutePath, TMethod extends Method, Acc exten
         Output: TOutput;
     };
 };
-export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
+export type RouteContractBuilderBase<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
     readonly path: Path;
     readonly method: TMethod;
     readonly $Infer: {
@@ -213,28 +239,15 @@ export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc
         Input: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleInputWithoutBody<Path, TMethod, Acc, Validators> : RouteHandleInput<Path, TMethod, Acc, Validators>;
         Output: TReturns;
     };
-    query<TQuery, TQueryIn = unknown>(schema: Schema<TQuery, TQueryIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "query" | "queryIn"> & {
+    query<TQuery, TQueryIn = unknown>(schema: Schema<TQuery, TQueryIn>): RouteContractBuilder<Path, TMethod, Acc, Omit<Validators, "query" | "queryIn"> & {
         query: TQuery;
         queryIn: TQueryIn;
     }, TReturns, TAppContext>;
-    params<TParams, TParamsIn = unknown>(schema: Schema<TParams, TParamsIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "params" | "paramsIn"> & {
+    params<TParams, TParamsIn = unknown>(schema: Schema<TParams, TParamsIn>): RouteContractBuilder<Path, TMethod, Acc, Omit<Validators, "params" | "paramsIn"> & {
         params: TParams;
         paramsIn: TParamsIn;
     }, TReturns, TAppContext>;
-    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>;
+    returns<const M extends ReturnsMap>(map: M): RouteContractBuilder<Path, TMethod, Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
     handler<R extends Response = Response>(fn: (ctx: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleContextWithoutBody<Path, TMethod, Acc, Validators, TAppContext> : RouteHandleContext<Path, TMethod, Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
         {
             expected: ValidHandlerReply<R, TReturns>;
@@ -242,16 +255,29 @@ export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc
         }
     ]): RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, R, 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> = RouteBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> & (TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? {} : {
-    body<TBody, TBodyIn = unknown>(schema: Schema<TBody, TBodyIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
+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> = RouteContractBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> & (TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? {} : {
+    body<TBody, TBodyIn = unknown>(schema: Schema<TBody, TBodyIn>): RouteContractBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
         body: TBody;
         bodyIn: TBodyIn;
     }, TReturns, TAppContext>;
-    body<Mode extends "json" | "form" | "urlencoded", TBody, TBodyIn = unknown>(mode: Mode, schema: Schema<TBody, TBodyIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
+    body<Mode extends "json" | "form" | "urlencoded", TBody, TBodyIn = unknown>(mode: Mode, schema: Schema<TBody, TBodyIn>): RouteContractBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
         body: TBody;
         bodyIn: TBodyIn;
     }, TReturns, TAppContext>;
 });
+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, Acc extends readonly unknown[] = readonly unknown[], Validators extends ValidatorParts = ValidatorParts, TReturns extends ReturnsMap = ReturnsMap, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, TOutput, TAppContext>;
 export type InferRouteContext<R> = R extends {
     $Infer: {

package/dist/esm/types/type-utils.d.ts

@@ -7,9 +7,9 @@ export type MiddlewareInputFieldName = "query" | "params" | "body";
 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),
  * fall back to the validated output type.

package/dist/esm/types/units.d.ts

@@ -26,10 +26,10 @@ export type IsUnknown<T> = [unknown] extends [T] ? true : false;
 export type NextFn<TExpectedState = unknown> = IsUnknown<TExpectedState> extends true ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>> : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;
 export type MiddlewareDefinition = CoreMiddlewareDefinition<ReturnsMap>;
 export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody> = {
-    query: Simplify<UnwrapPart<TQuery>>;
-    params: Simplify<UnwrapPart<TParams>>;
-    body: Simplify<UnwrapPart<TBody>>;
-    state: Simplify<UnwrapPart<TState>>;
+    query: UnwrapPart<TQuery>;
+    params: UnwrapPart<TParams>;
+    body: UnwrapPart<TBody>;
+    state: UnwrapPart<TState>;
     /** Pre-parse shapes merged into route `$Infer.Input`. */
     input: {
         query: RequestShape<TQueryIn, TQuery>;
@@ -37,29 +37,35 @@ export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn =
         body: RequestShape<TBodyIn, TBody>;
     };
 };
-export type DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody, TReturns extends ReturnsMap = {}, TLayout = null, TRequires = {}> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TState> extends true ? ExtractState<R> : TState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TLayout, TRequires>;
-export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = EmptyAppContext, TState = {}> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<UnwrapPart<TQuery>>;
-    params: Simplify<UnwrapPart<TParams>>;
-    body: Simplify<UnwrapPart<TBody>>;
-    state: Simplify<UnwrapPart<TState>>;
+export type MiddlewareRequirements = {
+    query?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+    body?: unknown;
+    state?: Record<string, unknown>;
+};
+export type DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody, TReturns extends ReturnsMap = {}, TLayout = null, TRequires extends MiddlewareRequirements = {}> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TState> extends true ? ExtractState<R> : TState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TLayout, TRequires>;
+export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = EmptyAppContext, TState = {}, TRequires extends MiddlewareRequirements = {}> = Simplify<TAppContext & UnitRuntimeContext & {
+    query: Simplify<UnwrapPart<TQuery> & (TRequires["query"] extends Record<string, unknown> ? TRequires["query"] : {})>;
+    params: Simplify<UnwrapPart<TParams> & (TRequires["params"] extends Record<string, unknown> ? TRequires["params"] : {})>;
+    body: Simplify<UnwrapPart<TBody> & (unknown extends TRequires["body"] ? {} : [TRequires["body"]] extends [undefined] ? {} : TRequires["body"])>;
+    state: Simplify<UnwrapPart<TState> & (TRequires["state"] extends Record<string, unknown> ? TRequires["state"] : {})>;
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
 export declare const MiddlewareUnitBrand: unique symbol;
-export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown> = MiddlewareDefinition & {
+export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequires extends MiddlewareRequirements = {}> = MiddlewareDefinition & {
     readonly [MiddlewareUnitBrand]: true;
     readonly __middlewareAcc: TAcc;
     readonly __returns?: TReturns;
     readonly __requiredLayouts?: TRequiredLayouts;
-    readonly __requiredState?: TRequiredState;
+    readonly __requirements?: TRequires;
 };
-export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = {}, TAppContext extends Record<string, unknown> = EmptyAppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, TExpectedState = unknown> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? {} : TExpectedState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TRequiredLayouts, TRequiredState> & {
-    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn, TExpectedState>;
-    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn, TExpectedState>;
-    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
-    body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(mode: Mode, schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
-    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
-    requires<Requires extends Record<string, unknown>>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
-    handler<R>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState & TRequiredState>, next: NextFn<TExpectedState>) => R): DefineMiddlewareResult<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? ExtractState<R> : TExpectedState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequiredState>;
+export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequires extends MiddlewareRequirements = {}, TAppContext extends Record<string, unknown> = EmptyAppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, TExpectedState = unknown> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? {} : TExpectedState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TRequiredLayouts, TRequires> & {
+    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn, TExpectedState>;
+    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn, TExpectedState>;
+    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
+    body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(mode: Mode, schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
+    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
+    requires<Requires extends MiddlewareRequirements>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequires & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
+    handler<R>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState, TRequires>, next: NextFn<TExpectedState>) => R): DefineMiddlewareResult<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? ExtractState<R> : TExpectedState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequires>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taserjs/router",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Type-safe Node.js router with runtime validation and middleware",
   "license": "ISC",
   "repository": {
@@ -147,8 +147,8 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "hono": "^4.10.3",
-    "@taserjs/router-core": "0.1.6",
-    "@taserjs/router-utils": "0.1.6"
+    "@taserjs/router-core": "0.1.8",
+    "@taserjs/router-utils": "0.1.8"
   },
   "devDependencies": {
     "@tanstack/vite-config": "^0.6.0",

package/src/builder/factories.ts

@@ -10,7 +10,7 @@ export type CreateWithoutBodyRoute<
 ) => RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
 
 export type CreateWithBodyRoute<
-  M extends "POST" | "PUT" | "PATCH",
+  M extends "POST" | "PUT" | "PATCH" | "QUERY",
   TAppContext extends Record<string, unknown> = AppContext,
 > = <const Path extends RoutePath>(
   path: Path,
@@ -37,7 +37,7 @@ function createWithoutBodyRoute<M extends "GET" | "DELETE" | "OPTIONS" | "HEAD">
     createRouteBuilder(path, method)) as unknown as CreateWithoutBodyRoute<M>;
 }
 
-function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH">(
+function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH" | "QUERY">(
   method: M,
 ): CreateWithBodyRoute<M> {
   return ((path: string) => createRouteBuilder(path, method)) as unknown as CreateWithBodyRoute<M>;
@@ -50,6 +50,7 @@ export const createHeadRoute = createWithoutBodyRoute("HEAD");
 export const createPostRoute = createWithBodyRoute("POST");
 export const createPutRoute = createWithBodyRoute("PUT");
 export const createPatchRoute = createWithBodyRoute("PATCH");
+export const createQueryRoute = createWithBodyRoute("QUERY");
 
 export const createAnyRoute: CreateAnyRoute = ((path: string, methods: readonly HttpMethod[]) =>
   createRouteBuilder(path, "ANY", methods)) as unknown as CreateAnyRoute;

package/src/builder/standalone.ts

@@ -9,6 +9,7 @@ import {
   createPatchRoute,
   createPostRoute,
   createPutRoute,
+  createQueryRoute,
   type CreateAllRoute,
   type CreateAnyRoute,
   type CreateWithBodyRoute,
@@ -35,6 +36,8 @@ export const options: CreateWithoutBodyRoute<"OPTIONS", AppContext> =
   createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", AppContext>;
 export const head: CreateWithoutBodyRoute<"HEAD", AppContext> =
   createHeadRoute as CreateWithoutBodyRoute<"HEAD", AppContext>;
+export const query: CreateWithBodyRoute<"QUERY", AppContext> =
+  createQueryRoute as CreateWithBodyRoute<"QUERY", AppContext>;
 export const any: CreateAnyRoute<AppContext> = createAnyRoute as CreateAnyRoute<AppContext>;
 export const all: CreateAllRoute<AppContext> = createAllRoute as CreateAllRoute<AppContext>;
 
@@ -49,6 +52,7 @@ export type TaserNamespace<TAppContext extends Record<string, unknown> = AppCont
   readonly delete: CreateWithoutBodyRoute<"DELETE", TAppContext>;
   readonly options: CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
   readonly head: CreateWithoutBodyRoute<"HEAD", TAppContext>;
+  readonly query: CreateWithBodyRoute<"QUERY", TAppContext>;
   readonly any: CreateAnyRoute<TAppContext>;
   readonly all: CreateAllRoute<TAppContext>;
   readonly layout: LayoutBuilder<TAppContext>;
@@ -63,6 +67,7 @@ export const t: TaserNamespace<AppContext> = {
   delete: del,
   options,
   head,
+  query,
   any,
   all,
   layout,

package/src/define/middleware.ts

@@ -3,6 +3,7 @@ import type {
   DefineMiddlewareResult,
   ExtractState,
   IsUnknown,
+  MiddlewareRequirements,
   MiddlewareUnitBuilder,
   NextFn,
   StandaloneMiddlewareContext,
@@ -16,66 +17,55 @@ import type {
 
 export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
   /**
-   * Constructs a fluent unscoped middleware builder, with optional explicit State generic.
+   * Defines a standalone, unscoped middleware using a short function signature.
    *
    * @example
    * ```ts
-   * const auth = middleware<{ user: string }>()
-   *   .query(z.object({ token: z.string() }))
-   *   .body("form", z.object({ file: z.instanceof(File) }))
-   *   .returns({ 401: z.string() })
-   *   .handler(async (ctx, next) => next({ user: "alice" }));
+   * const auth = middleware((ctx, next) => {
+   *   return next({ user: "alice" });
+   * });
    * ```
    */
-  <TState = unknown>(): MiddlewareUnitBuilder<
-    unknown,
-    unknown,
-    unknown,
-    {},
-    null,
-    {},
-    TAppContext,
-    {},
+  <TState = unknown, TRequires extends MiddlewareRequirements = {}, R = unknown>(
+    fn: (
+      ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, {}, TRequires>,
+      next: NextFn<NoInfer<TState>>,
+    ) => R,
+  ): DefineMiddlewareResult<
     unknown,
     unknown,
     unknown,
-    TState
-  >;
-
-  /**
-   * Constructs a fluent middleware builder scoped to a single layout branch, with optional explicit State generic.
-   */
-  <const Layout extends LayoutId, TState = unknown>(
-    layout: Layout,
-  ): MiddlewareUnitBuilder<
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    R,
     unknown,
     unknown,
     unknown,
     {},
-    Layout,
-    {},
-    TAppContext,
-    ResolveLayoutMiddlewaresState<Layout>,
-    unknown,
-    unknown,
-    unknown,
-    TState
+    null,
+    TRequires
   >;
 
   /**
-   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union), with optional explicit State generic.
+   * Constructs a fluent unscoped middleware builder, with optional explicit State generic.
+   *
+   * @example
+   * ```ts
+   * const auth = middleware<{ user: string }>()
+   *   .query(z.object({ token: z.string() }))
+   *   .body("form", z.object({ file: z.instanceof(File) }))
+   *   .returns({ 401: z.string() })
+   *   .handler(async (ctx, next) => next({ user: "alice" }));
+   * ```
    */
-  <const Layouts extends readonly [LayoutId, ...LayoutId[]], TState = unknown>(
-    layouts: Layouts,
-  ): MiddlewareUnitBuilder<
+  <TState = unknown>(): MiddlewareUnitBuilder<
     unknown,
     unknown,
     unknown,
     {},
-    Layouts,
+    null,
     {},
     TAppContext,
-    ResolveLayoutsState<Layouts>,
+    {},
     unknown,
     unknown,
     unknown,
@@ -85,7 +75,12 @@ export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppC
   /**
    * Defines a standalone middleware scoped to a single layout branch using a short function signature.
    */
-  <const Layout extends LayoutId, TState = unknown, TRequires = {}, R = unknown>(
+  <
+    const Layout extends LayoutId,
+    TState = unknown,
+    TRequires extends MiddlewareRequirements = {},
+    R = unknown,
+  >(
     layout: Layout,
     fn: (
       ctx: StandaloneMiddlewareContext<
@@ -93,7 +88,8 @@ export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppC
         unknown,
         unknown,
         TAppContext,
-        ResolveLayoutMiddlewaresState<Layout> & TRequires
+        ResolveLayoutMiddlewaresState<Layout>,
+        TRequires
       >,
       next: NextFn<NoInfer<TState>>,
     ) => R,
@@ -117,7 +113,7 @@ export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppC
   <
     const Layouts extends readonly [LayoutId, ...LayoutId[]],
     TState = unknown,
-    TRequires = {},
+    TRequires extends MiddlewareRequirements = {},
     R = unknown,
   >(
     layouts: Layouts,
@@ -127,7 +123,8 @@ export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppC
         unknown,
         unknown,
         TAppContext,
-        ResolveLayoutsState<Layouts> & TRequires
+        ResolveLayoutsState<Layouts>,
+        TRequires
       >,
       next: NextFn<NoInfer<TState>>,
     ) => R,
@@ -146,32 +143,43 @@ export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppC
   >;
 
   /**
-   * Defines a standalone, unscoped middleware using a short function signature.
-   *
-   * @example
-   * ```ts
-   * const auth = middleware((ctx, next) => {
-   *   return next({ user: "alice" });
-   * });
-   * ```
+   * Constructs a fluent middleware builder scoped to a single layout branch, with optional explicit State generic.
    */
-  <TState = unknown, TRequires = {}, R = unknown>(
-    fn: (
-      ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, TRequires>,
-      next: NextFn<NoInfer<TState>>,
-    ) => R,
-  ): DefineMiddlewareResult<
+  <const Layout extends LayoutId, TState = unknown>(
+    layout: Layout,
+  ): MiddlewareUnitBuilder<
     unknown,
     unknown,
     unknown,
-    IsUnknown<TState> extends true ? ExtractState<R> : TState,
-    R,
+    {},
+    Layout,
+    {},
+    TAppContext,
+    ResolveLayoutMiddlewaresState<Layout>,
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
+
+  /**
+   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union), with optional explicit State generic.
+   */
+  <const Layouts extends readonly [LayoutId, ...LayoutId[]], TState = unknown>(
+    layouts: Layouts,
+  ): MiddlewareUnitBuilder<
     unknown,
     unknown,
     unknown,
     {},
-    null,
-    TRequires
+    Layouts,
+    {},
+    TAppContext,
+    ResolveLayoutsState<Layouts>,
+    unknown,
+    unknown,
+    unknown,
+    TState
   >;
 }