@taserjs/router 0.1.3 → 0.1.4

package/src/define/middleware.ts

@@ -1,11 +1,12 @@
-import { createTaserCompatHandler, type Awaitable } from "@taserjs/router-core";
+import { type Awaitable } from "@taserjs/router-core";
 
-import type { ReturnsMap } from "../types/returns.js";
+import { createMiddlewareUnitBuilder } from "../builder/middleware-unit.js";
 import type {
   AppContext,
   DefineMiddlewareResult,
-  MiddlewareReturnFromParts,
-  MiddlewareUnit,
+  ExtractState,
+  IsUnknown,
+  MiddlewareUnitBuilder,
   NextFn,
   StandaloneMiddlewareContext,
 } from "../types/units.js";
@@ -14,268 +15,172 @@ import type {
   ResolveLayoutMiddlewaresState,
   ResolveLayoutsState,
 } from "../types/index.js";
-import type { Schema } from "../types/schema.js";
 
-export type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
-
-export type HonoMiddlewareUnit = MiddlewareUnit<
-  MiddlewareReturnFromParts<unknown, unknown, unknown, {}>,
-  {},
-  null,
-  {}
->;
-
-export type DefineMiddlewareOptions<
-  TState = unknown,
-  TRequires = {},
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  TAppContext extends Record<string, unknown> = AppContext,
-  R = unknown,
-> = {
-  query?: Schema<TQuery, TQueryIn>;
-  params?: Schema<TParams, TParamsIn>;
-  body?: Schema<TBody, TBodyIn>;
-  returns?: TReturns;
-  handler: (
-    ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TRequires>,
-    next: NextFn<NoInfer<TState>>,
-  ) => Awaitable<R>;
-};
-
-export type ScopedMiddlewareOptions<
-  Layout extends LayoutId,
-  TState = unknown,
-  TRequires = {},
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  TAppContext extends Record<string, unknown> = AppContext,
-  R = unknown,
-> = {
-  query?: Schema<TQuery, TQueryIn>;
-  params?: Schema<TParams, TParamsIn>;
-  body?: Schema<TBody, TBodyIn>;
-  returns?: TReturns;
-  handler: (
-    ctx: StandaloneMiddlewareContext<
-      TQuery,
-      TParams,
-      TBody,
-      TAppContext,
-      ResolveLayoutMiddlewaresState<Layout> & TRequires
-    >,
-    next: NextFn<NoInfer<TState>>,
-  ) => Awaitable<R>;
-};
+export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
+  /**
+   * Constructs a fluent unscoped middleware builder.
+   *
+   * @example
+   * ```ts
+   * const auth = defineMiddleware()
+   *   .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" }));
+   * ```
+   */
+  (): MiddlewareUnitBuilder<unknown, unknown, unknown, {}, null, {}, TAppContext>;
 
-export type MultiScopedMiddlewareOptions<
-  Layouts extends readonly LayoutId[],
-  TState = unknown,
-  TRequires = {},
-  TQuery = unknown,
-  TParams = unknown,
-  TBody = unknown,
-  TReturns extends ReturnsMap = {},
-  TQueryIn = unknown,
-  TParamsIn = unknown,
-  TBodyIn = unknown,
-  TAppContext extends Record<string, unknown> = AppContext,
-  R = unknown,
-> = {
-  query?: Schema<TQuery, TQueryIn>;
-  params?: Schema<TParams, TParamsIn>;
-  body?: Schema<TBody, TBodyIn>;
-  returns?: TReturns;
-  handler: (
-    ctx: StandaloneMiddlewareContext<
-      TQuery,
-      TParams,
-      TBody,
-      TAppContext,
-      ResolveLayoutsState<Layouts> & TRequires
-    >,
-    next: NextFn<NoInfer<TState>>,
-  ) => Awaitable<R>;
-};
+  /**
+   * Constructs a fluent middleware builder scoped to a single layout branch.
+   */
+  <const Layout extends LayoutId>(
+    layout: Layout,
+  ): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    Layout,
+    {},
+    TAppContext,
+    ResolveLayoutMiddlewaresState<Layout>
+  >;
 
-export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
-  (middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
+  /**
+   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union).
+   */
+  <const Layouts extends readonly [LayoutId, ...LayoutId[]]>(
+    layouts: Layouts,
+  ): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    Layouts,
+    {},
+    TAppContext,
+    ResolveLayoutsState<Layouts>
+  >;
 
-  <
-    const Layout extends LayoutId,
-    TState = unknown,
-    TRequires = {},
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TReturns extends ReturnsMap = {},
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
-    R = unknown,
-  >(
+  /**
+   * Defines a standalone middleware scoped to a single layout branch using a short function signature.
+   */
+  <const Layout extends LayoutId, TState = unknown, TRequires = {}, R = unknown>(
     layout: Layout,
-    options: ScopedMiddlewareOptions<
-      Layout,
-      TState,
-      TRequires,
-      TQuery,
-      TParams,
-      TBody,
-      TReturns,
-      TQueryIn,
-      TParamsIn,
-      TBodyIn,
-      TAppContext,
-      R
-    >,
+    fn: (
+      ctx: StandaloneMiddlewareContext<
+        unknown,
+        unknown,
+        unknown,
+        TAppContext,
+        ResolveLayoutMiddlewaresState<Layout> & TRequires
+      >,
+      next: NextFn<NoInfer<TState>>,
+    ) => Awaitable<R>,
   ): DefineMiddlewareResult<
-    TQuery,
-    TParams,
-    TBody,
-    TState,
+    unknown,
+    unknown,
+    unknown,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
     R,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TReturns,
+    unknown,
+    unknown,
+    unknown,
+    {},
     Layout,
     TRequires
   >;
 
+  /**
+   * Defines a standalone middleware scoped to multiple layout branches using a short function signature.
+   */
   <
     const Layouts extends readonly [LayoutId, ...LayoutId[]],
     TState = unknown,
     TRequires = {},
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TReturns extends ReturnsMap = {},
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
     R = unknown,
   >(
     layouts: Layouts,
-    options: MultiScopedMiddlewareOptions<
-      Layouts,
-      TState,
-      TRequires,
-      TQuery,
-      TParams,
-      TBody,
-      TReturns,
-      TQueryIn,
-      TParamsIn,
-      TBodyIn,
-      TAppContext,
-      R
-    >,
+    fn: (
+      ctx: StandaloneMiddlewareContext<
+        unknown,
+        unknown,
+        unknown,
+        TAppContext,
+        ResolveLayoutsState<Layouts> & TRequires
+      >,
+      next: NextFn<NoInfer<TState>>,
+    ) => Awaitable<R>,
   ): DefineMiddlewareResult<
-    TQuery,
-    TParams,
-    TBody,
-    TState,
+    unknown,
+    unknown,
+    unknown,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
     R,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TReturns,
+    unknown,
+    unknown,
+    unknown,
+    {},
     Layouts,
     TRequires
   >;
 
-  <
-    TState = unknown,
-    TRequires = {},
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-    TReturns extends ReturnsMap = {},
-    TQueryIn = unknown,
-    TParamsIn = unknown,
-    TBodyIn = unknown,
-    R = unknown,
-  >(
-    options: DefineMiddlewareOptions<
-      TState,
-      TRequires,
-      TQuery,
-      TParams,
-      TBody,
-      TReturns,
-      TQueryIn,
-      TParamsIn,
-      TBodyIn,
-      TAppContext,
-      R
-    >,
+  /**
+   * Defines a standalone, unscoped middleware using a short function signature.
+   *
+   * @example
+   * ```ts
+   * const auth = defineMiddleware((ctx, next) => {
+   *   return next({ user: "alice" });
+   * });
+   * ```
+   */
+  <TState = unknown, TRequires = {}, R = unknown>(
+    fn: (
+      ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, TRequires>,
+      next: NextFn<NoInfer<TState>>,
+    ) => Awaitable<R>,
   ): DefineMiddlewareResult<
-    TQuery,
-    TParams,
-    TBody,
-    TState,
+    unknown,
+    unknown,
+    unknown,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
     R,
-    TQueryIn,
-    TParamsIn,
-    TBodyIn,
-    TReturns,
+    unknown,
+    unknown,
+    unknown,
+    {},
     null,
     TRequires
   >;
 }
 
 export const defineMiddleware: DefineMiddlewareFn<AppContext> = function defineMiddleware(
-  first: any,
+  first?: any,
   second?: any,
 ): any {
+  if (first === undefined) {
+    return createMiddlewareUnitBuilder();
+  }
+
   if (typeof first === "string" || Array.isArray(first)) {
-    const options = second!;
-    const unit = {
-      ...options,
-      __middlewareAcc: undefined as unknown,
-      ...(options?.returns ? { __returns: options.returns } : {}),
-      __requiredLayouts: first,
-    };
-    return unit;
+    if (typeof second === "function") {
+      return {
+        handler: second,
+        __middlewareAcc: undefined as unknown,
+        __requiredLayouts: first,
+      };
+    }
+    return createMiddlewareUnitBuilder(first);
   }
 
   if (typeof first === "function") {
-    const honoMiddleware = first as HonoMiddlewareHandler;
-    return defineMiddleware({
-      handler: (ctx: unknown, next: (state?: Record<string, unknown>) => unknown) =>
-        createTaserCompatHandler(honoMiddleware)(ctx, next),
-    });
+    return {
+      handler: first,
+      __middlewareAcc: undefined as unknown,
+    };
   }
 
-  const options = first as DefineMiddlewareOptions<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  >;
-  const unit = {
-    ...options,
-    __middlewareAcc: undefined as unknown,
-    ...(options.returns ? { __returns: options.returns } : {}),
-  };
-
-  return unit;
+  return createMiddlewareUnitBuilder();
 };

package/src/index.ts

@@ -8,6 +8,8 @@ export type {
   InferRouteOutput,
   Method,
   MiddlewareDefinition,
+  MiddlewareUnit,
+  MiddlewareUnitBuilder,
   PathParams,
   ReturnsMap,
   RouteDefinition,
@@ -32,7 +34,7 @@ export type { ResponseValidationFailureHandler, SuccessStatusCode } from "@taser
 export { createTaserApp, TaserRouter } from "./builder/router.js";
 export { TaserApp } from "./builder/app.js";
 export { createContext } from "./context/create-context.js";
-export { defineHandler } from "./define/handler.js";
 export { defineMiddleware } from "./define/middleware.js";
+export { honoMw } from "./middleware/hono-mw.js";
 
 export type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";

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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function bodyLimit(...args: Parameters<typeof honoBodyLimit>) {
-  return wrapped(...args);
+  return defineMiddleware(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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function compress(...args: Parameters<typeof honoCompress>) {
-  return wrapped(...args);
+  return defineMiddleware(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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function cors(...args: Parameters<typeof honoCors>) {
-  return wrapped(...args);
+  return defineMiddleware(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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function csrf(...args: Parameters<typeof honoCsrf>) {
-  return wrapped(...args);
+  return defineMiddleware(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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function etag(...args: Parameters<typeof honoEtag>) {
-  return wrapped(...args);
+  return defineMiddleware(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 = defineMiddleware(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 { 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 defineMiddleware<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 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 defineMiddleware<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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
-  return wrapped(...args);
+  return defineMiddleware(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 { defineMiddleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 
 export function timing(...args: Parameters<typeof honoTiming>) {
-  return wrapped(...args);
+  return defineMiddleware(honoMw(honoTiming(...args)));
 }
 
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;