@taserjs/router 0.1.3 → 0.1.4

package/dist/esm/middleware/secure-headers.js.map

@@ -1 +1 @@
-{"version":3,"file":"secure-headers.js","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoSecureHeaders);\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return wrapped(...args);\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;AAIA,IAAM,UAAU,mBAAmB,eAAiB;AAEpD,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"secure-headers.js","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return defineMiddleware(honoMw(honoSecureHeaders(...args)));\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;;AAKA,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,iBAAiB,OAAO,gBAAkB,GAAG,IAAI,CAAC,CAAC;AAC5D"}

package/dist/esm/middleware/timing.d.ts

@@ -1,3 +1,3 @@
 import { timing as honoTiming } from 'hono/timing';
-export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/dist/esm/middleware/timing.js

@@ -1,9 +1,9 @@
-import { wrapHonoMiddleware } from "./wrap-hono.js";
+import { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 import { timing as timing$1 } from "hono/timing";
 //#region src/middleware/timing.ts
-var wrapped = wrapHonoMiddleware(timing$1);
 function timing(...args) {
-	return wrapped(...args);
+	return defineMiddleware(honoMw(timing$1(...args)));
 }
 //#endregion
 export { timing };

package/dist/esm/middleware/timing.js.map

@@ -1 +1 @@
-{"version":3,"file":"timing.js","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoTiming);\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return wrapped(...args);\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;AAIA,IAAM,UAAU,mBAAmB,QAAU;AAE7C,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"timing.js","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return defineMiddleware(honoMw(honoTiming(...args)));\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;;AAKA,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,iBAAiB,OAAO,SAAW,GAAG,IAAI,CAAC,CAAC;AACrD"}

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

@@ -3,13 +3,13 @@ import { RouterRegister } from '../register.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 { AppContext, ExtractState, HandlerContext, HandlerUnit, InlineMiddlewareOptions, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, ValidatorParts } from './units.js';
+import { AppContext, ExtractState, Method, MiddlewareDefinition, 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 { RouterRegister } from '../register.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 { AppContext, ExtractState, HandlerContext, HandlerUnit, HttpMethod, InlineMiddlewareOptions, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
+export type { AppContext, ExtractState, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
 export type RoutePath = RouterRegister extends {
     RoutePath: infer P;
 } ? P : never;
@@ -169,17 +169,13 @@ export type MiddlewareBuilder<Layout extends LayoutId, Acc extends readonly unkn
             actualState: MiddlewareChainField<Layout, Acc, "state">;
         }
     ]): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<MiddlewareChainContext<Layout, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, TReturns, TQueryIn, TParamsIn, TBodyIn, R>): MiddlewareBuilder<Layout, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], 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>;
 };
 export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TReturns extends ReturnsMap = {}, TOutput = Response> = Acc & {
     readonly path: Path;
     readonly method: TMethod | "ANY" | "ALL";
     readonly methods?: readonly Method[];
     readonly middlewares: readonly MiddlewareDefinition[];
-    readonly handlerMiddlewares: readonly MiddlewareDefinition[];
     readonly returns?: TReturns;
     readonly bodyMode?: "json" | "form" | "urlencoded";
     handler: (ctx: unknown) => Awaitable<Response>;
@@ -191,9 +187,6 @@ export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc exte
     query?: Schema<unknown>;
     params?: Schema<unknown>;
     body?: Schema<unknown>;
-    handlerQuery?: Schema<unknown>;
-    handlerParams?: Schema<unknown>;
-    handlerBody?: Schema<unknown>;
 };
 type RouteHandleResult<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = Omit<RouteExport<Path, TMethod, Acc, TReturns, TOutput>, "$Infer"> & {
     readonly $Infer: {
@@ -231,17 +224,13 @@ export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc
             actualState: RouteResolvedField<Path, TMethod, Acc, "state">;
         }
     ]): RouteBuilder<Path, TMethod, readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<RouteChainContext<Path, TMethod, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): RouteBuilder<Path, TMethod, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], 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>;
     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>;
             actual: R;
         }
     ]): RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, R, TAppContext>;
-    handler<HandlerAcc extends readonly unknown[] = readonly [], HandlerValidators extends ValidatorParts = ValidatorParts, HReturns extends ReturnsMap = {}, HOutput = Response>(unit: HandlerUnit<HandlerAcc, HandlerValidators, HReturns, HOutput>): RouteHandleResult<Path, TMethod, readonly [...Acc, ...HandlerAcc], Validators, Omit<TReturns, keyof HReturns> & HReturns, HOutput, 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"> & {
@@ -253,32 +242,6 @@ export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc ext
         bodyIn: TBodyIn;
     }, TReturns, TAppContext>;
 });
-export type HandlerBuilder<Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
-    returns<const M extends ReturnsMap>(map: M): HandlerBuilder<Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
-    use<TAcc, UReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(unit: MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequiredState>, ..._assert: [IsStateSatisfied<MergeMiddlewareField<Acc, "state">, TRequiredState>] extends [
-        true
-    ] ? [] : [
-        {
-            error: "Middleware cannot be attached to this handler";
-            requiredState: TRequiredState;
-            actualState: MergeMiddlewareField<Acc, "state">;
-        }
-    ]): HandlerBuilder<readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<HandlerContext<Acc, {
-        query: TQuery;
-        params: TParams;
-        body: TBody;
-    }, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): HandlerBuilder<readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    handler<R extends Response = Response>(fn: (ctx: HandlerContext<Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
-        {
-            expected: ValidHandlerReply<R, TReturns>;
-            actual: R;
-        }
-    ]): HandlerUnit<Acc, Validators, TReturns, R>;
-};
 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/units.d.ts

@@ -1,5 +1,5 @@
 import { Awaitable, MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { MergeMiddlewareField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
+import { RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
 import { ReturnsMap } from './returns.js';
 import { Schema } from './schema.js';
 export type { HttpMethod, Method } from './type-utils.js';
@@ -50,43 +50,18 @@ export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBo
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
-export type HandlerContext<Acc extends readonly unknown[], Validators extends ValidatorParts, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<MergePart<Validators extends {
-        query?: infer Q;
-    } ? Q : unknown, MergeMiddlewareField<Acc, "query">>>;
-    params: Simplify<MergePart<Validators extends {
-        params?: infer P;
-    } ? P : unknown, MergeMiddlewareField<Acc, "params">>>;
-    body: Simplify<MergePart<Validators extends {
-        body?: infer B;
-    } ? B : unknown, MergeMiddlewareField<Acc, "body">>>;
-    state: Simplify<MergeMiddlewareField<Acc, "state">>;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
-}>;
 export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown> = MiddlewareDefinition & {
     readonly __middlewareAcc: TAcc;
     readonly __returns?: TReturns;
     readonly __requiredLayouts?: TRequiredLayouts;
     readonly __requiredState?: TRequiredState;
 };
-export type HandlerUnit<_Acc extends readonly unknown[], _Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response> = {
-    readonly __returns?: TReturns;
-    readonly $Infer: {
-        Output: TOutput;
-    };
-    middlewares: readonly MiddlewareDefinition[];
-    handler: (ctx: unknown) => Awaitable<Response>;
-    returns?: ReturnsMap;
-    query?: Schema<unknown>;
-    params?: Schema<unknown>;
-    body?: Schema<unknown>;
-};
-export type InlineMiddlewareOptions<Ctx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown> = {
-    query?: Schema<TQuery, TQueryIn>;
-    params?: Schema<TParams, TParamsIn>;
-    body?: Schema<TBody, TBodyIn>;
-    returns?: TReturns;
-    handler: (ctx: Ctx, next: NextFn) => Awaitable<R>;
+export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = {}, TAppContext extends Record<string, unknown> = AppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown> = {
+    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn>;
+    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn>;
+    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn>;
+    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>;
+    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
+    requires<Requires extends Record<string, unknown>>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
+    handler<TState = unknown, R = unknown>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState & TRequiredState>, next: NextFn<NoInfer<TState>>) => Awaitable<R>): DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequiredState>;
 };
-export declare function isHandlerUnit(value: unknown): value is HandlerUnit<readonly unknown[], ValidatorParts>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taserjs/router",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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.3",
-    "@taserjs/router-utils": "0.1.3"
+    "@taserjs/router-utils": "0.1.4",
+    "@taserjs/router-core": "0.1.4"
   },
   "devDependencies": {
     "@tanstack/vite-config": "^0.6.0",

package/src/builder/constants.ts

@@ -2,9 +2,3 @@
 export const SCHEMA_KEYS = ["query", "params", "body"] as const;
 
 export type SchemaKey = (typeof SCHEMA_KEYS)[number];
-
-export const HANDLER_SCHEMA_KEY_MAP = {
-  query: "handlerQuery",
-  params: "handlerParams",
-  body: "handlerBody",
-} as const satisfies Record<SchemaKey, string>;

package/src/builder/middleware-unit.ts

@@ -0,0 +1,55 @@
+import type { BodyMode } from "@taserjs/router-core";
+
+import type { ReturnsMap } from "../types/returns.js";
+import type { Schema } from "../types/schema.js";
+import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
+
+export function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly string[]) {
+  const validators: SchemaValidators = {};
+  let bodyMode: BodyMode | undefined;
+  let returnsMap: ReturnsMap | undefined;
+
+  const builder = {
+    query(schema: Schema<unknown>) {
+      validators.query = schema;
+      return builder;
+    },
+    params(schema: Schema<unknown>) {
+      validators.params = schema;
+      return builder;
+    },
+    body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>) {
+      if (typeof modeOrSchema === "string") {
+        bodyMode = modeOrSchema as BodyMode;
+        if (schema !== undefined) {
+          validators.body = schema;
+        }
+      } else {
+        bodyMode = "json";
+        validators.body = modeOrSchema;
+      }
+      return builder;
+    },
+    returns(map: ReturnsMap) {
+      returnsMap = { ...returnsMap, ...map };
+      return builder;
+    },
+    requires() {
+      return builder;
+    },
+    handler(fn: (ctx: any, next: any) => any) {
+      const schemas = pickDefinedSchemas(validators);
+      const unit = {
+        handler: fn,
+        ...schemas,
+        ...(bodyMode ? { bodyMode } : {}),
+        ...(returnsMap ? { returns: returnsMap, __returns: returnsMap } : {}),
+        ...(requiredLayouts !== undefined ? { __requiredLayouts: requiredLayouts } : {}),
+        __middlewareAcc: undefined as unknown,
+      };
+      return unit;
+    },
+  };
+
+  return builder;
+}

package/src/builder/middleware.ts

@@ -9,8 +9,12 @@ export function createMiddleware<const Layout extends LayoutId>(
   const chain = {
     layout,
     middlewares: entries,
-    use(definition: MiddlewareDefinition) {
-      entries.push(definition);
+    use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)) {
+      if (typeof definition === "function") {
+        entries.push({ handler: definition as any });
+      } else {
+        entries.push(definition);
+      }
       return chain;
     },
   };

package/src/builder/route.ts

@@ -16,8 +16,6 @@ import type {
   Schema,
 } from "../types/index.js";
 import type { HttpMethod, MiddlewareDefinition } from "../types/units.js";
-import { isHandlerUnit } from "../types/units.js";
-import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
 import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
@@ -36,24 +34,16 @@ function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV
 function buildEffectiveReturns(args: {
   middlewareReturns: ReturnsMap;
   routeReturns: ReturnsMap;
-  handlerMiddlewareReturns: ReturnsMap;
-  handlerReturns: ReturnsMap | undefined;
   schemas: {
     query?: unknown;
     params?: unknown;
     body?: unknown;
-    handlerQuery?: unknown;
-    handlerParams?: unknown;
-    handlerBody?: unknown;
     middlewares?: readonly MiddlewareDefinition[];
-    handlerMiddlewares?: readonly MiddlewareDefinition[];
   };
 }): Record<number, StandardSchemaV1> | undefined {
   const merged = mergeReturnsMaps(
     toUtilsMap(args.middlewareReturns),
     toUtilsMap(args.routeReturns),
-    toUtilsMap(args.handlerMiddlewareReturns),
-    toUtilsMap(args.handlerReturns),
   );
   const with422 = withAuto422(merged, hasInputSchemas(args.schemas));
   return Object.keys(with422).length > 0 ? with422 : undefined;
@@ -111,47 +101,31 @@ export function createRouteBuilder(
       routeReturns = { ...routeReturns, ...toUtilsMap(map) };
       return builder;
     },
-    use(definition: MiddlewareDefinition) {
-      middlewares.push(definition);
+    use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)) {
+      if (typeof definition === "function") {
+        middlewares.push({ handler: definition as any });
+      } else {
+        middlewares.push(definition);
+      }
       return builder;
     },
-    handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {
+    handler(fn: (ctx: unknown) => Response | Promise<Response>) {
       const routeSchemas = pickDefinedSchemas(validators);
       const base = buildRouteBase(path, method, methods, middlewares);
 
-      const unit = isHandlerUnit(fnOrUnit)
-        ? fnOrUnit
-        : {
-            handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
-            middlewares: [] as MiddlewareDefinition[],
-            returns: undefined as ReturnsMap | undefined,
-          };
-
-      const handlerSchemas = isHandlerUnit(fnOrUnit)
-        ? pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
-        : {};
-
       const returns = buildEffectiveReturns({
         middlewareReturns: collectReturnsFromDefinitions(middlewares),
         routeReturns,
-        handlerMiddlewareReturns: collectReturnsFromDefinitions(unit.middlewares),
-        handlerReturns: unit.returns,
         schemas: {
           ...validators,
-          handlerQuery: (unit as any).query,
-          handlerParams: (unit as any).params,
-          handlerBody: (unit as any).body,
           middlewares,
-          handlerMiddlewares: unit.middlewares,
         },
       });
 
       return {
         ...base,
-        handlerMiddlewares: [...unit.middlewares],
-        handler: unit.handler,
+        handler: fn,
         ...routeSchemas,
-        ...handlerSchemas,
         ...(bodyMode ? { bodyMode } : {}),
         ...(returns ? { returns } : {}),
       };

package/src/builder/router.ts

@@ -17,15 +17,13 @@ import {
   createPostRoute,
   createPutRoute,
 } from "./factories.js";
-import { defineHandler } from "../define/handler.js";
 import { defineMiddleware, type DefineMiddlewareFn } from "../define/middleware.js";
 import { createMiddleware } from "./middleware.js";
 import { TaserApp } from "./app.js";
 import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "../types/app.js";
 import type { AppContext } from "../types/units.js";
-import type { HandlerBuilder, LayoutId, MiddlewareBuilder } from "../types/index.js";
+import type { LayoutId, MiddlewareBuilder } from "../types/index.js";
 import type { ReturnsMap } from "../types/returns.js";
-import type { Schema } from "../types/schema.js";
 import type {
   CreateAllRoute,
   CreateAnyRoute,
@@ -117,21 +115,6 @@ export class TaserRouter<
     return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>;
   }
 
-  defineHandler<TQuery = unknown, TParams = unknown, TBody = unknown>(options?: {
-    query?: Schema<TQuery>;
-    params?: Schema<TParams>;
-    body?: Schema<TBody>;
-  }): HandlerBuilder<
-    readonly [],
-    { query: TQuery; params: TParams; body: TBody },
-    {},
-    TAppContext
-  > {
-    return options === undefined
-      ? defineHandler<TAppContext>()
-      : defineHandler<TAppContext>(options);
-  }
-
   defineMiddleware: DefineMiddlewareFn<TAppContext> =
     defineMiddleware as DefineMiddlewareFn<TAppContext>;