@taserjs/router 0.0.3 → 0.0.5

package/src/define/middleware.ts

@@ -10,14 +10,25 @@ import type {
   NextFn,
   StandaloneMiddlewareContext,
 } from "../types/units.js";
+import type {
+  LayoutId,
+  ResolveLayoutMiddlewaresState,
+  ResolveLayoutsState,
+} from "../types/index.js";
 import type { Schema } from "../types/schema.js";
 
 type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
 
-type HonoMiddlewareUnit = MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+type HonoMiddlewareUnit = MiddlewareUnit<
+  MiddlewareReturnFromParts<unknown, unknown, unknown, {}>,
+  {},
+  null,
+  {}
+>;
 
 export type DefineMiddlewareOptions<
   TState = unknown,
+  TRequires = {},
   TQuery = unknown,
   TParams = unknown,
   TBody = unknown,
@@ -33,7 +44,67 @@ export type DefineMiddlewareOptions<
   body?: Schema<TBody, TBodyIn>;
   returns?: TReturns;
   handler: (
-    ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,
+    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 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>;
 };
@@ -41,7 +112,96 @@ export type DefineMiddlewareOptions<
 export function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
 
 export function defineMiddleware<
+  const Layout extends LayoutId,
+  TState = unknown,
+  TRequires = {},
+  TAppContext extends Record<string, unknown> = AppContext,
+  TQuery = unknown,
+  TParams = unknown,
+  TBody = unknown,
+  TReturns extends ReturnsMap = {},
+  TQueryIn = unknown,
+  TParamsIn = unknown,
+  TBodyIn = unknown,
+  R = unknown,
+>(
+  layout: Layout,
+  options: ScopedMiddlewareOptions<
+    Layout,
+    TState,
+    TRequires,
+    TQuery,
+    TParams,
+    TBody,
+    TReturns,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn,
+    TAppContext,
+    R
+  >,
+): MiddlewareUnit<
+  MiddlewareReturnFromParts<
+    TQuery,
+    TParams,
+    TBody,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn
+  >,
+  TReturns,
+  Layout,
+  TRequires
+>;
+
+export function defineMiddleware<
+  const Layouts extends readonly [LayoutId, ...LayoutId[]],
   TState = unknown,
+  TRequires = {},
+  TAppContext extends Record<string, unknown> = AppContext,
+  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
+  >,
+): MiddlewareUnit<
+  MiddlewareReturnFromParts<
+    TQuery,
+    TParams,
+    TBody,
+    IsUnknown<TState> extends true ? ExtractState<R> : TState,
+    TQueryIn,
+    TParamsIn,
+    TBodyIn
+  >,
+  TReturns,
+  Layouts,
+  TRequires
+>;
+
+export function defineMiddleware<
+  TState = unknown,
+  TRequires = {},
   TAppContext extends Record<string, unknown> = AppContext,
   TQuery = unknown,
   TParams = unknown,
@@ -54,6 +214,7 @@ export function defineMiddleware<
 >(
   options: DefineMiddlewareOptions<
     TState,
+    TRequires,
     TQuery,
     TParams,
     TBody,
@@ -74,21 +235,50 @@ export function defineMiddleware<
     TParamsIn,
     TBodyIn
   >,
-  TReturns
+  TReturns,
+  null,
+  TRequires
 >;
 
 export function defineMiddleware(
-  options:
+  first:
+    | string
+    | readonly string[]
     | HonoMiddlewareHandler
-    | DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any>,
+    | DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any, any>,
+  second?: DefineMiddlewareOptions<any, any, any, any, any, any, any, any, any, any, any>,
 ): unknown {
-  if (typeof options === "function") {
-    const honoMiddleware = options as HonoMiddlewareHandler;
+  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 first === "function") {
+    const honoMiddleware = first as HonoMiddlewareHandler;
     return defineMiddleware({
       handler: (ctx, next) => createTaserCompatHandler(honoMiddleware)(ctx, next),
     });
   }
 
+  const options = first as DefineMiddlewareOptions<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >;
   const unit = {
     ...options,
     __middlewareAcc: undefined as unknown,

package/src/define/validators.ts

@@ -1,5 +1,5 @@
 import type { Schema } from "../types/schema.js";
-import { SCHEMA_KEYS, type SchemaKey } from "../constants.js";
+import { SCHEMA_KEYS, type SchemaKey } from "../builder/constants.js";
 
 export type SchemaValidators = {
   query?: Schema<unknown>;

package/src/index.ts

@@ -2,16 +2,20 @@ export type { RouterRegister } from "./register.js";
 export type {
   InferInput,
   InferOutput,
+  InferRouteContext,
+  InferRouteInput,
+  InferRouteOutput,
   Method,
   PathParams,
   ReturnsMap,
+  RouteDefinition,
+  RouteExport,
   RoutePath,
   Schema,
   Simplify,
 } from "./types/index.js";
 export type {
   ContextDefinition,
-  CreateContextArgs,
   CreateTaserAppOptions,
   InferAppContext,
   InferAppManifest,
@@ -20,13 +24,7 @@ export type {
   TaserHandler,
 } from "./types/app.js";
 
-export {
-  isReplyResult,
-  reply,
-  stream,
-  ValidationError,
-  validationErrorSchema,
-} from "@taserjs/router-utils";
+export { reply, stream, ValidationError, validationErrorSchema } from "@taserjs/router-utils";
 export type {
   ReplyBodyKind,
   ReplyOf,
@@ -35,10 +33,9 @@ export type {
   SuccessStatusCode,
 } from "@taserjs/router-utils";
 
-export { createAnyRoute, createAllRoute } from "./factories.js";
-export { createTaserApp, TaserRouter } from "./taser-router.js";
-export { TaserApp, TaserNativeBound } from "./taser-app.js";
-export { createContext } from "./create-context.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";
 

package/src/middleware/body-limit.ts

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

package/src/middleware/compress.ts

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

package/src/middleware/cors.ts

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

package/src/middleware/csrf.ts

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

package/src/middleware/etag.ts

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

package/src/middleware/jwk.ts

@@ -1,9 +1,9 @@
-import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 import { jwk as honoJwk } from "hono/jwk";
 
 import { defineMiddleware } from "../define/middleware.js";
 import type { JwtMiddlewareUnit, JwtPayloadState } from "./jwt.js";
+import { extractJwtPayload } from "./wrap-hono.js";
 
 export type JwkOptions = Parameters<typeof honoJwk>[0];
 
@@ -44,11 +44,6 @@ export function jwk<TPayload = Record<string, unknown>>(
   const honoMw: MiddlewareHandler = honoJwk(honoOptions, safeInit);
 
   return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: (ctx, next) => {
-      return createTaserCompatHandler(honoMw)(ctx, async () => {
-        const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
-        return next({ jwtPayload: payload as TPayload });
-      });
-    },
+    handler: extractJwtPayload<TPayload>(honoMw),
   });
 }

package/src/middleware/jwt.ts

@@ -1,9 +1,9 @@
-import { createTaserCompatHandler } from "@taserjs/router-core";
 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";
 
 export type JwtPayloadState<TPayload> = {
   jwtPayload: TPayload;
@@ -24,11 +24,6 @@ export function jwt<TPayload = Record<string, unknown>>(
 ): JwtMiddlewareUnit<TPayload> {
   const honoMw: MiddlewareHandler = honoJwt(options);
   return defineMiddleware<JwtPayloadState<TPayload>>({
-    handler: (ctx, next) => {
-      return createTaserCompatHandler(honoMw)(ctx, async () => {
-        const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
-        return next({ jwtPayload: payload as TPayload });
-      });
-    },
+    handler: extractJwtPayload<TPayload>(honoMw),
   });
 }

package/src/middleware/secure-headers.ts

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

package/src/middleware/timing.ts

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

package/src/middleware/wrap-hono.ts

@@ -1,3 +1,4 @@
+import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 
 import { defineMiddleware } from "../define/middleware.js";
@@ -10,3 +11,15 @@ export function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHan
 ) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {
   return (...args) => defineMiddleware(honoFactory(...args));
 }
+
+/** Extracts the jwtPayload from Hono's variable bag and forwards it into Taser's state via next(). */
+export function extractJwtPayload<TPayload>(
+  honoMw: MiddlewareHandler,
+): (ctx: unknown, next: (state: { jwtPayload: TPayload }) => unknown) => unknown {
+  const taserHandler = createTaserCompatHandler(honoMw);
+  return (ctx, next) =>
+    taserHandler(ctx, async () => {
+      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
+      return next({ jwtPayload: payload as TPayload });
+    });
+}

package/src/types/app.ts

@@ -1,6 +1,7 @@
+import type { RouteManifestShape } from "@taserjs/router-core";
 import type { ResponseValidationFailureHandler } from "@taserjs/router-utils";
 
-import type { TaserApp } from "../taser-app.js";
+import type { TaserApp } from "../builder/app.js";
 import type { ReturnsMap } from "./returns.js";
 import type { Schema } from "./schema.js";
 
@@ -24,16 +25,12 @@ export type CreateTaserAppOptions = {
   };
 };
 
-export type CreateContextArgs = {
-  native?: import("./units.js").NativeContext;
-};
-
 export type ContextDefinition<
   TBoot extends Record<string, unknown> = Record<string, never>,
   TReq extends Record<string, unknown> = Record<string, never>,
 > = {
   boot?: () => TBoot | Promise<TBoot>;
-  request?: (args: CreateContextArgs) => TReq | Promise<TReq>;
+  request?: (req: Request) => TReq | Promise<TReq>;
 };
 
 export type InferAppContext<
@@ -45,7 +42,14 @@ export type OnErrorOptions<TResponses extends ReturnsMap = ReturnsMap> = {
   handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
 };
 
-export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never;
+export type InferAppManifest<TApp> =
+  TApp extends TaserApp<infer TManifest>
+    ? TManifest
+    : TApp extends { manifest: infer TManifest }
+      ? TManifest
+      : TApp extends RouteManifestShape
+        ? TApp
+        : never;
 
 export type TaserHandler<TFrameworkApp> = {
   /**
@@ -60,4 +64,4 @@ export type { RouteManifestShape } from "@taserjs/router-core";
 
 export type { Schema };
 
-export type { TaserApp, TaserNativeBound } from "../taser-app.js";
+export type { TaserApp } from "../builder/app.js";