@taserjs/router 0.1.3 → 0.1.5

package/src/builder/router.ts

@@ -6,32 +6,10 @@ import {
 } from "@taserjs/router-core";
 import { isPromise, normalizeOnError } from "@taserjs/router-utils";
 
-import {
-  createAllRoute,
-  createAnyRoute,
-  createDeleteRoute,
-  createGetRoute,
-  createHeadRoute,
-  createOptionsRoute,
-  createPatchRoute,
-  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 { EmptyAppContext } from "../types/units.js";
 import type { ReturnsMap } from "../types/returns.js";
-import type { Schema } from "../types/schema.js";
-import type {
-  CreateAllRoute,
-  CreateAnyRoute,
-  CreateWithBodyRoute,
-  CreateWithoutBodyRoute,
-} from "./factories.js";
 
 function toOnErrorHandler(
   onErrorOptions: OnErrorOptions | OnErrorOptions["handle"],
@@ -49,10 +27,13 @@ type RouterState = {
 const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
 
 export class TaserRouter<
-  TAppContext extends Record<string, unknown> = AppContext,
+  TAppContext extends Record<string, unknown> = EmptyAppContext,
   THasNotFound extends boolean = false,
 > {
   private readonly state: RouterState;
+  readonly $Infer!: {
+    Context: TAppContext;
+  };
 
   constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, "options">>) {
     this.state = {
@@ -84,57 +65,6 @@ export class TaserRouter<
     return this as unknown as TaserRouter<TAppContext, true>;
   }
 
-  get: CreateWithoutBodyRoute<"GET", TAppContext> = createGetRoute as CreateWithoutBodyRoute<
-    "GET",
-    TAppContext
-  >;
-  post: CreateWithBodyRoute<"POST", TAppContext> = createPostRoute as CreateWithBodyRoute<
-    "POST",
-    TAppContext
-  >;
-  put: CreateWithBodyRoute<"PUT", TAppContext> = createPutRoute as CreateWithBodyRoute<
-    "PUT",
-    TAppContext
-  >;
-  patch: CreateWithBodyRoute<"PATCH", TAppContext> = createPatchRoute as CreateWithBodyRoute<
-    "PATCH",
-    TAppContext
-  >;
-  delete: CreateWithoutBodyRoute<"DELETE", TAppContext> =
-    createDeleteRoute as CreateWithoutBodyRoute<"DELETE", TAppContext>;
-  options: CreateWithoutBodyRoute<"OPTIONS", TAppContext> =
-    createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
-  head: CreateWithoutBodyRoute<"HEAD", TAppContext> = createHeadRoute as CreateWithoutBodyRoute<
-    "HEAD",
-    TAppContext
-  >;
-  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>;
-  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>;
-
-  middleware<const Layout extends LayoutId>(
-    layout: Layout,
-  ): MiddlewareBuilder<Layout, readonly [], TAppContext> {
-    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>;
-
   create<const TManifest extends RouteManifestShape>(
     manifest: TManifest,
     runtimeOptions?: { basePath?: string },
@@ -209,6 +139,6 @@ export class TaserRouter<
 
 export function createTaserApp(
   options: CreateTaserAppOptions = {},
-): TaserRouter<AppContext, false> {
-  return new TaserRouter<AppContext, false>(options);
+): TaserRouter<EmptyAppContext, false> {
+  return new TaserRouter<EmptyAppContext, false>(options);
 }

package/src/builder/standalone.ts

@@ -0,0 +1,70 @@
+import type { AppContext, LayoutBuilder } from "../types/index.js";
+import {
+  createAllRoute,
+  createAnyRoute,
+  createDeleteRoute,
+  createGetRoute,
+  createHeadRoute,
+  createOptionsRoute,
+  createPatchRoute,
+  createPostRoute,
+  createPutRoute,
+  type CreateAllRoute,
+  type CreateAnyRoute,
+  type CreateWithBodyRoute,
+  type CreateWithoutBodyRoute,
+} from "./factories.js";
+import { createMiddleware } from "./middleware.js";
+import { middleware as createMiddlewareFn, type MiddlewareFn } from "../define/middleware.js";
+
+export const get: CreateWithoutBodyRoute<"GET", AppContext> =
+  createGetRoute as CreateWithoutBodyRoute<"GET", AppContext>;
+export const post: CreateWithBodyRoute<"POST", AppContext> = createPostRoute as CreateWithBodyRoute<
+  "POST",
+  AppContext
+>;
+export const put: CreateWithBodyRoute<"PUT", AppContext> = createPutRoute as CreateWithBodyRoute<
+  "PUT",
+  AppContext
+>;
+export const patch: CreateWithBodyRoute<"PATCH", AppContext> =
+  createPatchRoute as CreateWithBodyRoute<"PATCH", AppContext>;
+export const del: CreateWithoutBodyRoute<"DELETE", AppContext> =
+  createDeleteRoute as CreateWithoutBodyRoute<"DELETE", AppContext>;
+export const options: CreateWithoutBodyRoute<"OPTIONS", AppContext> =
+  createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", AppContext>;
+export const head: CreateWithoutBodyRoute<"HEAD", AppContext> =
+  createHeadRoute as CreateWithoutBodyRoute<"HEAD", AppContext>;
+export const any: CreateAnyRoute<AppContext> = createAnyRoute as CreateAnyRoute<AppContext>;
+export const all: CreateAllRoute<AppContext> = createAllRoute as CreateAllRoute<AppContext>;
+
+export const layout: LayoutBuilder<AppContext> = createMiddleware as LayoutBuilder<AppContext>;
+export const middleware: MiddlewareFn<AppContext> = createMiddlewareFn as MiddlewareFn<AppContext>;
+
+export type TaserNamespace<TAppContext extends Record<string, unknown> = AppContext> = {
+  readonly get: CreateWithoutBodyRoute<"GET", TAppContext>;
+  readonly post: CreateWithBodyRoute<"POST", TAppContext>;
+  readonly put: CreateWithBodyRoute<"PUT", TAppContext>;
+  readonly patch: CreateWithBodyRoute<"PATCH", TAppContext>;
+  readonly delete: CreateWithoutBodyRoute<"DELETE", TAppContext>;
+  readonly options: CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
+  readonly head: CreateWithoutBodyRoute<"HEAD", TAppContext>;
+  readonly any: CreateAnyRoute<TAppContext>;
+  readonly all: CreateAllRoute<TAppContext>;
+  readonly layout: LayoutBuilder<TAppContext>;
+  readonly middleware: MiddlewareFn<TAppContext>;
+};
+
+export const t: TaserNamespace<AppContext> = {
+  get,
+  post,
+  put,
+  patch,
+  delete: del,
+  options,
+  head,
+  any,
+  all,
+  layout,
+  middleware,
+};

package/src/define/middleware.ts

@@ -1,281 +1,205 @@
-import { createTaserCompatHandler, 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";
 import type {
+  AppContext,
   LayoutId,
   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 MiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
+  /**
+   * 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" }));
+   * ```
+   */
+  <TState = unknown>(): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    null,
+    {},
+    TAppContext,
+    {},
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
 
-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, with optional explicit State generic.
+   */
+  <const Layout extends LayoutId, TState = unknown>(
+    layout: Layout,
+  ): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    Layout,
+    {},
+    TAppContext,
+    ResolveLayoutMiddlewaresState<Layout>,
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
 
-export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
-  (middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
+  /**
+   * 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,
+    {},
+    Layouts,
+    {},
+    TAppContext,
+    ResolveLayoutsState<Layouts>,
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
 
-  <
-    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>>,
+    ) => 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>>,
+    ) => 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 = middleware((ctx, next) => {
+   *   return next({ user: "alice" });
+   * });
+   * ```
+   */
+  <TState = unknown, TRequires = {}, R = unknown>(
+    fn: (
+      ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, TRequires>,
+      next: NextFn<NoInfer<TState>>,
+    ) => 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,
+export const middleware: MiddlewareFn<AppContext> = function middleware(
+  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

@@ -1,15 +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,
@@ -29,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 { defineHandler } from "./define/handler.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";