@taserjs/router 0.1.4 → 0.1.6

package/src/define/middleware.ts

@@ -1,8 +1,5 @@
-import { type Awaitable } from "@taserjs/router-core";
-
 import { createMiddlewareUnitBuilder } from "../builder/middleware-unit.js";
 import type {
-  AppContext,
   DefineMiddlewareResult,
   ExtractState,
   IsUnknown,
@@ -11,30 +8,44 @@ import type {
   StandaloneMiddlewareContext,
 } from "../types/units.js";
 import type {
+  AppContext,
   LayoutId,
   ResolveLayoutMiddlewaresState,
   ResolveLayoutsState,
 } from "../types/index.js";
 
-export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
+export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
   /**
-   * Constructs a fluent unscoped middleware builder.
+   * Constructs a fluent unscoped middleware builder, with optional explicit State generic.
    *
    * @example
    * ```ts
-   * const auth = defineMiddleware()
+   * 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" }));
    * ```
    */
-  (): MiddlewareUnitBuilder<unknown, unknown, unknown, {}, null, {}, TAppContext>;
+  <TState = unknown>(): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    null,
+    {},
+    TAppContext,
+    {},
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
 
   /**
-   * Constructs a fluent middleware builder scoped to a single layout branch.
+   * Constructs a fluent middleware builder scoped to a single layout branch, with optional explicit State generic.
    */
-  <const Layout extends LayoutId>(
+  <const Layout extends LayoutId, TState = unknown>(
     layout: Layout,
   ): MiddlewareUnitBuilder<
     unknown,
@@ -44,13 +55,17 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     Layout,
     {},
     TAppContext,
-    ResolveLayoutMiddlewaresState<Layout>
+    ResolveLayoutMiddlewaresState<Layout>,
+    unknown,
+    unknown,
+    unknown,
+    TState
   >;
 
   /**
-   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union).
+   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union), with optional explicit State generic.
    */
-  <const Layouts extends readonly [LayoutId, ...LayoutId[]]>(
+  <const Layouts extends readonly [LayoutId, ...LayoutId[]], TState = unknown>(
     layouts: Layouts,
   ): MiddlewareUnitBuilder<
     unknown,
@@ -60,7 +75,11 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     Layouts,
     {},
     TAppContext,
-    ResolveLayoutsState<Layouts>
+    ResolveLayoutsState<Layouts>,
+    unknown,
+    unknown,
+    unknown,
+    TState
   >;
 
   /**
@@ -77,7 +96,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
         ResolveLayoutMiddlewaresState<Layout> & TRequires
       >,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -111,7 +130,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
         ResolveLayoutsState<Layouts> & TRequires
       >,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -131,7 +150,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
    *
    * @example
    * ```ts
-   * const auth = defineMiddleware((ctx, next) => {
+   * const auth = middleware((ctx, next) => {
    *   return next({ user: "alice" });
    * });
    * ```
@@ -140,7 +159,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     fn: (
       ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, TRequires>,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -156,7 +175,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
   >;
 }
 
-export const defineMiddleware: DefineMiddlewareFn<AppContext> = function defineMiddleware(
+export const middleware: MiddlewareFn<AppContext> = function middleware(
   first?: any,
   second?: any,
 ): any {

package/src/index.ts

@@ -1,17 +1,25 @@
-export type { RouterRegister } from "./register.js";
+export interface RouterRegister {}
 export type {
+  AppContext,
+  EmptyAppContext,
   HttpMethod,
   InferInput,
   InferOutput,
   InferRouteContext,
   InferRouteInput,
+  InferRouteInputFromPath,
   InferRouteOutput,
+  LayoutBuilder,
+  LayoutId,
+  LayoutTree,
   Method,
+  MiddlewareBuilder,
   MiddlewareDefinition,
   MiddlewareUnit,
   MiddlewareUnitBuilder,
   PathParams,
   ReturnsMap,
+  RouteByPathMethod,
   RouteDefinition,
   RouteExport,
   RoutePath,
@@ -31,10 +39,26 @@ export type {
 export { ValidationError, validationErrorSchema } from "@taserjs/router-utils";
 export type { ResponseValidationFailureHandler, SuccessStatusCode } from "@taserjs/router-utils";
 
+export {
+  all,
+  any,
+  del,
+  get,
+  head,
+  layout,
+  middleware,
+  options,
+  patch,
+  post,
+  put,
+  t,
+  type TaserNamespace,
+} from "./builder/standalone.js";
+
 export { createTaserApp, TaserRouter } from "./builder/router.js";
 export { TaserApp } from "./builder/app.js";
 export { createContext } from "./context/create-context.js";
-export { defineMiddleware } from "./define/middleware.js";
 export { honoMw } from "./middleware/hono-mw.js";
+export type { MiddlewareFn } from "./define/middleware.js";
 
 export type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";

package/src/middleware/body-limit.ts

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

package/src/middleware/compress.ts

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

package/src/middleware/cors.ts

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

package/src/middleware/csrf.ts

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

package/src/middleware/etag.ts

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

package/src/middleware/hono-mw.ts

@@ -12,7 +12,7 @@ import type { MiddlewareHandler } from "hono";
  *
  * const app = t.get("/hello").use(honoMw(cors()));
  * // or
- * const customCors = defineMiddleware(honoMw(cors()));
+ * const customCors = middleware(honoMw(cors()));
  * ```
  */
 export function honoMw(

package/src/middleware/jwk.ts

@@ -1,6 +1,6 @@
 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";
 
@@ -42,7 +42,7 @@ export function jwk<TPayload = Record<string, unknown>>(
   const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined;
   const mw = honoMw(honoJwk(honoOptions, safeInit));
 
-  return defineMiddleware<JwtPayloadState<TPayload>>((ctx, next) =>
+  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,6 +1,6 @@
 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 { honoMw } from "./hono-mw.js";
 
@@ -22,7 +22,7 @@ export function jwt<TPayload = Record<string, unknown>>(
   options: JwtOptions,
 ): JwtMiddlewareUnit<TPayload> {
   const mw = honoMw(honoJwt(options));
-  return defineMiddleware<JwtPayloadState<TPayload>>((ctx, next) =>
+  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,10 +1,10 @@
 import { secureHeaders as honoSecureHeaders } from "hono/secure-headers";
 
-import { defineMiddleware } from "../define/middleware.js";
+import { middleware } from "../define/middleware.js";
 import { honoMw } from "./hono-mw.js";
 
 export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
-  return defineMiddleware(honoMw(honoSecureHeaders(...args)));
+  return middleware(honoMw(honoSecureHeaders(...args)));
 }
 
 export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/src/middleware/timing.ts

@@ -1,10 +1,10 @@
 import { timing as honoTiming } from "hono/timing";
 
-import { defineMiddleware } from "../define/middleware.js";
+import { middleware } from "../define/middleware.js";
 import { honoMw } from "./hono-mw.js";
 
 export function timing(...args: Parameters<typeof honoTiming>) {
-  return defineMiddleware(honoMw(honoTiming(...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,7 +12,7 @@ import type {
 import type { ReturnsMap, ValidHandlerReply } from "./returns.js";
 import type { Schema } from "./schema.js";
 import type {
-  AppContext,
+  EmptyAppContext,
   ExtractState,
   Method,
   MiddlewareDefinition,
@@ -30,7 +30,6 @@ export type {
   Schema,
   StandardSchemaV1,
 } from "./schema.js";
-export type { RouterRegister } from "../register.js";
 export type {
   MergeMiddlewareField,
   MergeMiddlewareInputField,
@@ -52,13 +51,12 @@ export type {
   ValidHandlerReply,
 } from "./returns.js";
 export type {
-  AppContext,
+  EmptyAppContext,
   ExtractState,
   HttpMethod,
   IsUnknown,
   Method,
   MiddlewareDefinition,
-  MiddlewareNext,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
   MiddlewareUnitBuilder,
@@ -69,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>;
@@ -76,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}`
@@ -99,25 +105,49 @@ 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 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 {
+  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> = Layout extends null
+type ResolveLayoutMiddlewares<
+  Layout extends LayoutId | null,
+  Depth extends readonly unknown[] = [],
+> = Depth["length"] extends 10
   ? readonly []
   : Layout extends LayoutId
     ? readonly [
-        ...ResolveLayoutMiddlewares<LayoutParent<Layout>>,
-        ...LayoutTree[Layout]["middlewares"],
+        ...ResolveLayoutMiddlewares<LayoutParent<Layout>, [...Depth, unknown]>,
+        ...LayoutMiddlewares<Layout>,
       ]
     : 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
@@ -141,7 +171,7 @@ type ResolveLayoutChainMiddlewares<Chain extends readonly LayoutId[]> = Chain ex
   ...infer Rest,
 ]
   ? readonly [
-      ...LayoutTree[Head]["middlewares"],
+      ...LayoutMiddlewares<Head>,
       ...ResolveLayoutChainMiddlewares<Rest extends readonly LayoutId[] ? Rest : readonly []>,
     ]
   : readonly [];
@@ -188,13 +218,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,
@@ -206,15 +229,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;
     }
@@ -455,9 +478,10 @@ export type MiddlewareBuilder<
   Layout extends LayoutId,
   Acc extends readonly unknown[] = readonly [],
   TAppContext extends Record<string, unknown> = AppContext,
-> = Acc & {
+> = {
   readonly layout: Layout;
   readonly middlewares: readonly MiddlewareDefinition[];
+  readonly __acc?: Acc;
   readonly $Infer: {
     Context: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>;
   };
@@ -496,11 +520,12 @@ export type RouteExport<
   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 __acc?: Acc;
   readonly returns?: TReturns;
   readonly bodyMode?: "json" | "form" | "urlencoded";
   handler: (ctx: unknown) => Awaitable<Response>;

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;