@taserjs/router 0.1.3 → 0.1.5

package/src/middleware/body-limit.ts

@@ -1,11 +1,10 @@
 import { bodyLimit as honoBodyLimit } from "hono/body-limit";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoBodyLimit);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function bodyLimit(...args: Parameters<typeof honoBodyLimit>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoBodyLimit(...args)));
 }
 
 export type BodyLimitOptions = Parameters<typeof honoBodyLimit>[0];

package/src/middleware/compress.ts

@@ -1,11 +1,10 @@
 import { compress as honoCompress } from "hono/compress";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoCompress);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function compress(...args: Parameters<typeof honoCompress>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoCompress(...args)));
 }
 
 export type CompressOptions = NonNullable<Parameters<typeof honoCompress>[0]>;

package/src/middleware/cors.ts

@@ -1,11 +1,10 @@
 import { cors as honoCors } from "hono/cors";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoCors);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function cors(...args: Parameters<typeof honoCors>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoCors(...args)));
 }
 
 export type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;

package/src/middleware/csrf.ts

@@ -1,11 +1,10 @@
 import { csrf as honoCsrf } from "hono/csrf";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoCsrf);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function csrf(...args: Parameters<typeof honoCsrf>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoCsrf(...args)));
 }
 
 export type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;

package/src/middleware/etag.ts

@@ -1,11 +1,10 @@
 import { etag as honoEtag } from "hono/etag";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoEtag);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function etag(...args: Parameters<typeof honoEtag>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoEtag(...args)));
 }
 
 export type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;

package/src/middleware/hono-mw.ts

@@ -0,0 +1,22 @@
+import { createTaserCompatHandler } from "@taserjs/router-core";
+import type { MiddlewareHandler } from "hono";
+
+/**
+ * Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`
+ * into a Taser-compatible middleware handler function `(ctx, next) => Promise<Response>`.
+ *
+ * @example
+ * ```ts
+ * import { honoMw } from "@taserjs/router";
+ * import { cors } from "hono/cors";
+ *
+ * const app = t.get("/hello").use(honoMw(cors()));
+ * // or
+ * const customCors = middleware(honoMw(cors()));
+ * ```
+ */
+export function honoMw(
+  middleware: MiddlewareHandler,
+): (ctx: unknown, next: any) => Promise<Response> {
+  return createTaserCompatHandler(middleware) as (ctx: unknown, next: any) => Promise<Response>;
+}

package/src/middleware/jwk.ts

@@ -1,9 +1,8 @@
-import type { MiddlewareHandler } from "hono";
 import { jwk as honoJwk } from "hono/jwk";
 
-import { defineMiddleware } from "../define/middleware.js";
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 import type { JwtMiddlewareUnit, JwtPayloadState } from "./jwt.js";
-import { extractJwtPayload } from "./wrap-hono.js";
 
 export type JwkOptions = Parameters<typeof honoJwk>[0];
 
@@ -41,9 +40,12 @@ export function jwk<TPayload = Record<string, unknown>>(
 
   const { allowInsecure: _allowInsecure, ...honoOptions } = options;
   const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined;
-  const honoMw: MiddlewareHandler = honoJwk(honoOptions, safeInit);
-
-  return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: extractJwtPayload<TPayload>(honoMw),
-  });
+  const mw = honoMw(honoJwk(honoOptions, safeInit));
+
+  return middleware<JwtPayloadState<TPayload>>((ctx, next) =>
+    mw(ctx, async () => {
+      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
+      return next({ jwtPayload: payload as TPayload });
+    }),
+  );
 }

package/src/middleware/jwt.ts

@@ -1,9 +1,8 @@
-import type { MiddlewareHandler } from "hono";
 import { jwt as honoJwt } from "hono/jwt";
 
-import { defineMiddleware } from "../define/middleware.js";
+import { middleware } from "../define/middleware.js";
 import type { MiddlewareReturnFromParts, MiddlewareUnit } from "../types/units.js";
-import { extractJwtPayload } from "./wrap-hono.js";
+import { honoMw } from "./hono-mw.js";
 
 export type JwtPayloadState<TPayload> = {
   jwtPayload: TPayload;
@@ -22,8 +21,11 @@ export type JwtOptions = Parameters<typeof honoJwt>[0];
 export function jwt<TPayload = Record<string, unknown>>(
   options: JwtOptions,
 ): JwtMiddlewareUnit<TPayload> {
-  const honoMw: MiddlewareHandler = honoJwt(options);
-  return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: extractJwtPayload<TPayload>(honoMw),
-  });
+  const mw = honoMw(honoJwt(options));
+  return middleware<JwtPayloadState<TPayload>>((ctx, next) =>
+    mw(ctx, async () => {
+      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
+      return next({ jwtPayload: payload as TPayload });
+    }),
+  );
 }

package/src/middleware/secure-headers.ts

@@ -1,11 +1,10 @@
 import { secureHeaders as honoSecureHeaders } from "hono/secure-headers";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoSecureHeaders);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoSecureHeaders(...args)));
 }
 
 export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/src/middleware/timing.ts

@@ -1,11 +1,10 @@
 import { timing as honoTiming } from "hono/timing";
 
-import { wrapHonoMiddleware } from "./wrap-hono.js";
-
-const wrapped = wrapHonoMiddleware(honoTiming);
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function timing(...args: Parameters<typeof honoTiming>) {
-  return wrapped(...args);
+  return middleware(honoMw(honoTiming(...args)));
 }
 
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/src/types/index.ts

@@ -1,5 +1,5 @@
 import type { Awaitable, TaserCookieJar, TaserHeaders } from "@taserjs/router-core";
-import type { RouterRegister } from "../register.js";
+import type { RouterRegister } from "../index.js";
 import type {
   MergeMiddlewareField,
   MergeMiddlewareInputField,
@@ -12,15 +12,13 @@ import type {
 import type { ReturnsMap, ValidHandlerReply } from "./returns.js";
 import type { Schema } from "./schema.js";
 import type {
-  AppContext,
+  EmptyAppContext,
   ExtractState,
-  HandlerContext,
-  HandlerUnit,
-  InlineMiddlewareOptions,
   Method,
   MiddlewareDefinition,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
+  NextFn,
   ValidatorParts,
 } from "./units.js";
 
@@ -32,7 +30,6 @@ export type {
   Schema,
   StandardSchemaV1,
 } from "./schema.js";
-export type { RouterRegister } from "../register.js";
 export type {
   MergeMiddlewareField,
   MergeMiddlewareInputField,
@@ -54,18 +51,15 @@ export type {
   ValidHandlerReply,
 } from "./returns.js";
 export type {
-  AppContext,
+  EmptyAppContext,
   ExtractState,
-  HandlerContext,
-  HandlerUnit,
   HttpMethod,
-  InlineMiddlewareOptions,
   IsUnknown,
   Method,
   MiddlewareDefinition,
-  MiddlewareNext,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
+  MiddlewareUnitBuilder,
   NextFn,
   NextResult,
   StandaloneMiddlewareContext,
@@ -73,6 +67,8 @@ export type {
   ValidatorParts,
 } from "./units.js";
 
+export type AppContext = RouterRegister extends { AppContext: infer C } ? C : EmptyAppContext;
+
 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>;
@@ -80,6 +76,12 @@ export type RouteByPathMethod = RouterRegister extends { RouteByPathMethod: infe
   ? R
   : Record<never, never>;
 
+export type LayoutBuilder<TAppContext extends Record<string, unknown> = AppContext> = <
+  const Layout extends LayoutId,
+>(
+  layout: Layout,
+) => MiddlewareBuilder<Layout, readonly [], TAppContext>;
+
 type ParseParam<Segment extends string> = Segment extends "*"
   ? { _splat: string }
   : Segment extends `:${infer Name extends string}`
@@ -103,25 +105,41 @@ export type ResolveParams<TPathParams, TSchemaParams> =
       : Simplify<Omit<TPathParams, keyof TSchemaParams> & TSchemaParams>
     : TPathParams;
 
-type LayoutParent<Layout extends LayoutId> = LayoutTree[Layout] extends {
-  parent: infer Parent extends LayoutId | null;
+type LayoutParentsMap = RouterRegister extends {
+  LayoutParents: infer LP extends Record<string, unknown>;
 }
-  ? Parent
-  : null;
+  ? LP
+  : {};
 
-type ResolveLayoutMiddlewares<Layout extends LayoutId | null> = Layout extends null
+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 ResolveLayoutMiddlewares<
+  Layout extends LayoutId | null,
+  Depth extends readonly unknown[] = [],
+> = Depth["length"] extends 10
   ? readonly []
   : Layout extends LayoutId
     ? readonly [
-        ...ResolveLayoutMiddlewares<LayoutParent<Layout>>,
+        ...ResolveLayoutMiddlewares<LayoutParent<Layout>, [...Depth, unknown]>,
         ...LayoutTree[Layout]["middlewares"],
       ]
     : readonly [];
 
-export type ResolveLayoutIdChain<L extends LayoutId | null> = L extends null
+export type ResolveLayoutIdChain<
+  L extends LayoutId | null,
+  Depth extends readonly unknown[] = [],
+> = Depth["length"] extends 10
   ? readonly []
   : L extends LayoutId
-    ? readonly [...ResolveLayoutIdChain<LayoutParent<L>>, L]
+    ? readonly [...ResolveLayoutIdChain<LayoutParent<L>, [...Depth, unknown]>, L]
     : readonly [];
 
 export type ResolveLayoutMiddlewaresState<Layout extends LayoutId | null> = Layout extends LayoutId
@@ -192,13 +210,6 @@ type RouteResolvedField<
   Field extends "query" | "params" | "body" | "state",
 > = RouteLayoutField<Path, TMethod, Field> & MergeMiddlewareField<Acc, Field>;
 
-type RouteChainField<
-  Path extends RoutePath,
-  TMethod extends Method,
-  Acc extends readonly unknown[],
-  Field extends "query" | "params" | "body" | "state",
-> = RouteResolvedField<Path, TMethod, Acc, Field>;
-
 export type RouteChainContext<
   Path extends RoutePath,
   TMethod extends Method,
@@ -210,15 +221,15 @@ export type RouteChainContext<
 > = Simplify<
   TAppContext &
     UnitRuntimeContext & {
-      query: Simplify<MergePart<TQuery, RouteChainField<Path, TMethod, Acc, "query">>>;
+      query: Simplify<MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>>;
       params: Simplify<
         ResolveParams<
           PathParams<Path>,
-          MergePart<TParams, RouteChainField<Path, TMethod, Acc, "params">>
+          MergePart<TParams, RouteResolvedField<Path, TMethod, Acc, "params">>
         >
       >;
-      body: Simplify<MergePart<TBody, RouteChainField<Path, TMethod, Acc, "body">>>;
-      state: Simplify<RouteChainField<Path, TMethod, Acc, "state">>;
+      body: Simplify<MergePart<TBody, RouteResolvedField<Path, TMethod, Acc, "body">>>;
+      state: Simplify<RouteResolvedField<Path, TMethod, Acc, "state">>;
       headers: TaserHeaders;
       cookies: TaserCookieJar;
     }
@@ -482,41 +493,14 @@ export type MiddlewareBuilder<
           },
         ]
   ): 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
-    >,
+  use<R = unknown>(
+    fn: (
+      ctx: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>,
+      next: NextFn,
+    ) => Awaitable<R>,
   ): MiddlewareBuilder<
     Layout,
-    readonly [
-      ...Acc,
-      MiddlewareReturnFromParts<
-        TQuery,
-        TParams,
-        TBody,
-        ExtractState<R>,
-        TQueryIn,
-        TParamsIn,
-        TBodyIn
-      >,
-    ],
+    readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>],
     TAppContext
   >;
 };
@@ -532,7 +516,6 @@ export type RouteExport<
   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>;
@@ -548,9 +531,6 @@ export type RouteExport<
   query?: Schema<unknown>;
   params?: Schema<unknown>;
   body?: Schema<unknown>;
-  handlerQuery?: Schema<unknown>;
-  handlerParams?: Schema<unknown>;
-  handlerBody?: Schema<unknown>;
 };
 
 type RouteHandleResult<
@@ -639,44 +619,17 @@ export type RouteBuilderBase<
     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
-    >,
+  use<R = unknown>(
+    fn: (
+      ctx: RouteChainContext<Path, TMethod, Acc, unknown, unknown, unknown, TAppContext>,
+      next: NextFn,
+    ) => Awaitable<R>,
   ): RouteBuilder<
     Path,
     TMethod,
-    readonly [
-      ...Acc,
-      MiddlewareReturnFromParts<
-        TQuery,
-        TParams,
-        TBody,
-        ExtractState<R>,
-        TQueryIn,
-        TParamsIn,
-        TBodyIn
-      >,
-    ],
+    readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>],
     Validators,
-    Omit<TReturns, keyof UReturns> & UReturns,
+    TReturns,
     TAppContext
   >;
   handler<R extends Response = Response>(
@@ -694,22 +647,6 @@ export type RouteBuilderBase<
           },
         ]
   ): 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<
@@ -746,85 +683,6 @@ export type RouteBuilder<
         >;
       });
 
-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,

package/src/types/type-utils.ts

@@ -63,16 +63,20 @@ export type MiddlewareInputField<
 export type MergeMiddlewareField<
   Middlewares extends readonly unknown[],
   Field extends MiddlewareFieldName,
-> = [Middlewares] extends [readonly []]
+> = Middlewares extends readonly []
   ? {}
-  : UnionToIntersection<MiddlewareField<Middlewares[number], Field>>;
+  : Middlewares extends readonly [infer Head, ...infer Tail]
+    ? MiddlewareField<Head, Field> & MergeMiddlewareField<Tail, Field>
+    : MiddlewareField<Middlewares[number], Field>;
 
 export type MergeMiddlewareInputField<
   Middlewares extends readonly unknown[],
   Field extends MiddlewareInputFieldName,
-> = [Middlewares] extends [readonly []]
+> = Middlewares extends readonly []
   ? {}
-  : UnionToIntersection<MiddlewareInputField<Middlewares[number], Field>>;
+  : Middlewares extends readonly [infer Head, ...infer Tail]
+    ? MiddlewareInputField<Head, Field> & MergeMiddlewareInputField<Tail, Field>
+    : MiddlewareInputField<Middlewares[number], Field>;
 
 export type RuntimeContextFields = {
   request: Request;