@taserjs/router 0.0.2 → 0.0.4

package/src/factories.ts

@@ -1,11 +1,11 @@
-import { createRouteBuilder } from './route.js'
-import type { RouteBuilder, RoutePath, Schema } from './types/index.js'
-import type { AppContext, HttpMethod } from './types/units.js'
+import { createRouteBuilder } from "./route.js";
+import type { RouteBuilder, RoutePath, Schema } from "./types/index.js";
+import type { AppContext, HttpMethod } from "./types/units.js";
 
 type WithoutBodyOptions<TQuery, TParams, TQueryIn = unknown, TParamsIn = unknown> = {
-  query?: Schema<TQuery, TQueryIn>
-  params?: Schema<TParams, TParamsIn>
-}
+  query?: Schema<TQuery, TQueryIn>;
+  params?: Schema<TParams, TParamsIn>;
+};
 
 type WithBodyOptions<
   TQuery,
@@ -15,14 +15,16 @@ type WithBodyOptions<
   TParamsIn = unknown,
   TBodyIn = unknown,
 > = WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn> & {
-  body?: Schema<TBody, TBodyIn>
-}
+  body?: Schema<TBody, TBodyIn>;
+};
 
 export type CreateWithoutBodyRoute<
-  M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD',
+  M extends "GET" | "DELETE" | "OPTIONS" | "HEAD",
   TAppContext extends Record<string, unknown> = AppContext,
 > = {
-  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>
+  <const Path extends RoutePath>(
+    path: Path,
+  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -37,21 +39,23 @@ export type CreateWithoutBodyRoute<
     M,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
+      query: TQuery;
+      params: TParams;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
 export type CreateWithBodyRoute<
-  M extends 'POST' | 'PUT' | 'PATCH',
+  M extends "POST" | "PUT" | "PATCH",
   TAppContext extends Record<string, unknown> = AppContext,
 > = {
-  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>
+  <const Path extends RoutePath>(
+    path: Path,
+  ): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -68,23 +72,23 @@ export type CreateWithBodyRoute<
     M,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      query: TQuery;
+      params: TParams;
+      body: TBody;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
+      bodyIn: TBodyIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
 export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = {
   <const Path extends RoutePath, const Methods extends readonly HttpMethod[]>(
     path: Path,
     methods: Methods,
-  ): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>
+  ): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     const Methods extends readonly HttpMethod[],
@@ -103,20 +107,22 @@ export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppCont
     Methods[number],
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      query: TQuery;
+      params: TParams;
+      body: TBody;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
+      bodyIn: TBodyIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
 export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = {
-  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>
+  <const Path extends RoutePath>(
+    path: Path,
+  ): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
   <
     const Path extends RoutePath,
     TQuery = unknown,
@@ -133,51 +139,47 @@ export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppCont
     HttpMethod,
     readonly [],
     {
-      query: TQuery
-      params: TParams
-      body: TBody
-      queryIn: TQueryIn
-      paramsIn: TParamsIn
-      bodyIn: TBodyIn
+      query: TQuery;
+      params: TParams;
+      body: TBody;
+      queryIn: TQueryIn;
+      paramsIn: TParamsIn;
+      bodyIn: TBodyIn;
     },
     {},
     TAppContext
-  >
-}
+  >;
+};
 
-function createWithoutBodyRoute<M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD'>(
+function createWithoutBodyRoute<M extends "GET" | "DELETE" | "OPTIONS" | "HEAD">(
   method: M,
 ): CreateWithoutBodyRoute<M> {
   return ((path: string, options?: WithoutBodyOptions<unknown, unknown>) =>
-    createRouteBuilder(path, method, options)
-  ) as unknown as CreateWithoutBodyRoute<M>
+    createRouteBuilder(path, method, options)) as unknown as CreateWithoutBodyRoute<M>;
 }
 
-function createWithBodyRoute<M extends 'POST' | 'PUT' | 'PATCH'>(
+function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH">(
   method: M,
 ): CreateWithBodyRoute<M> {
   return ((path: string, options?: WithBodyOptions<unknown, unknown, unknown>) =>
-    createRouteBuilder(path, method, options)
-  ) as unknown as CreateWithBodyRoute<M>
+    createRouteBuilder(path, method, options)) as unknown as CreateWithBodyRoute<M>;
 }
 
-export const createGetRoute = createWithoutBodyRoute('GET')
-export const createDeleteRoute = createWithoutBodyRoute('DELETE')
-export const createOptionsRoute = createWithoutBodyRoute('OPTIONS')
-export const createHeadRoute = createWithoutBodyRoute('HEAD')
-export const createPostRoute = createWithBodyRoute('POST')
-export const createPutRoute = createWithBodyRoute('PUT')
-export const createPatchRoute = createWithBodyRoute('PATCH')
+export const createGetRoute = createWithoutBodyRoute("GET");
+export const createDeleteRoute = createWithoutBodyRoute("DELETE");
+export const createOptionsRoute = createWithoutBodyRoute("OPTIONS");
+export const createHeadRoute = createWithoutBodyRoute("HEAD");
+export const createPostRoute = createWithBodyRoute("POST");
+export const createPutRoute = createWithBodyRoute("PUT");
+export const createPatchRoute = createWithBodyRoute("PATCH");
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 export const createAnyRoute: CreateAnyRoute = ((
   path: string,
   methods: readonly HttpMethod[],
   options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, 'ANY', options, methods)) as unknown as CreateAnyRoute
+) => createRouteBuilder(path, "ANY", options, methods)) as unknown as CreateAnyRoute;
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 export const createAllRoute: CreateAllRoute = ((
   path: string,
   options?: WithBodyOptions<unknown, unknown, unknown>,
-) => createRouteBuilder(path, 'ALL', options)) as unknown as CreateAllRoute
+) => createRouteBuilder(path, "ALL", options)) as unknown as CreateAllRoute;

package/src/index.ts

@@ -1,4 +1,4 @@
-export type { RouterRegister } from './register.js'
+export type { RouterRegister } from "./register.js";
 export type {
   InferInput,
   InferOutput,
@@ -8,7 +8,7 @@ export type {
   RoutePath,
   Schema,
   Simplify,
-} from './types/index.js'
+} from "./types/index.js";
 export type {
   ContextDefinition,
   CreateContextArgs,
@@ -18,7 +18,7 @@ export type {
   OnErrorOptions,
   RouteManifestShape,
   TaserHandler,
-} from './types/app.js'
+} from "./types/app.js";
 
 export {
   isReplyResult,
@@ -26,20 +26,20 @@ export {
   stream,
   ValidationError,
   validationErrorSchema,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 export type {
   ReplyBodyKind,
   ReplyOf,
   ResponseValidationFailureHandler,
   SuccessReplyData,
   SuccessStatusCode,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 
-export { createAnyRoute, createAllRoute } from './factories.js'
-export { createTaserApp, TaserRouter } from './taser-router.js'
-export { TaserApp, TaserMountedApp, TaserNativeBound } from './taser-app.js'
-export { createContext } from './create-context.js'
-export { defineHandler } from './define/handler.js'
-export { defineMiddleware } from './define/middleware.js'
+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 { defineHandler } from "./define/handler.js";
+export { defineMiddleware } from "./define/middleware.js";
 
-export type { TaserCookieJar, TaserHeaders } from '@taserjs/router-core'
+export type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";

package/src/middleware/body-limit.ts

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

package/src/middleware/compress.ts

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

package/src/middleware/cors.ts

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

package/src/middleware/csrf.ts

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

package/src/middleware/etag.ts

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

package/src/middleware/jwk.ts

@@ -1,47 +1,54 @@
-import { jwk as honoJwk } from 'hono/jwk'
+import { createTaserCompatHandler } from "@taserjs/router-core";
+import type { MiddlewareHandler } from "hono";
+import { jwk as honoJwk } from "hono/jwk";
 
-import { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'
-import type { InferOutput, Schema } from '../types/schema.js'
+import { defineMiddleware } from "../define/middleware.js";
+import type { JwtMiddlewareUnit, JwtPayloadState } from "./jwt.js";
 
-export type JwkOptions = Parameters<typeof honoJwk>[0]
+export type JwkOptions = Parameters<typeof honoJwk>[0];
 
-export type JwkRequestInit = Pick<RequestInit, 'headers'>
+export type JwkRequestInit = Pick<RequestInit, "headers">;
 
 export type JwkMiddlewareOptions = JwkOptions & {
   /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */
-  allowInsecure?: boolean
-}
+  allowInsecure?: boolean;
+};
 
 function assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {
-  const scheme = new URL(jwksUri).protocol.replace(':', '')
-  if (scheme === 'https') {
-    return
+  const scheme = new URL(jwksUri).protocol.replace(":", "");
+  if (scheme === "https") {
+    return;
   }
-  if (scheme === 'http' && allowInsecure) {
-    return
+  if (scheme === "http" && allowInsecure) {
+    return;
   }
-  throw new Error(
-    `JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`,
-  )
+  throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`);
 }
 
 /**
  * JWK auth middleware. Invalid or missing tokens return **401** (Hono).
- * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
  * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
  */
-export function jwk<TPayload>(
-  payloadSchema: Schema<TPayload>,
+export function jwk<TPayload = Record<string, unknown>>(
   options: JwkMiddlewareOptions,
   init?: JwkRequestInit,
-): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {
-  const jwksUri = options.jwks_uri
-  if (typeof jwksUri === 'string') {
-    assertJwksScheme(jwksUri, options.allowInsecure ?? false)
+): JwtMiddlewareUnit<TPayload> {
+  const jwksUri = options.jwks_uri;
+  if (typeof jwksUri === "string") {
+    assertJwksScheme(jwksUri, options.allowInsecure ?? false);
   }
 
-  const { allowInsecure: _allowInsecure, ...honoOptions } = options
-  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined
-
-  return createAuthMiddleware(payloadSchema, honoJwk(honoOptions, safeInit))
+  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: (ctx, next) => {
+      return createTaserCompatHandler(honoMw)(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,18 +1,34 @@
-import { jwt as honoJwt } from 'hono/jwt'
+import { createTaserCompatHandler } from "@taserjs/router-core";
+import type { MiddlewareHandler } from "hono";
+import { jwt as honoJwt } from "hono/jwt";
 
-import { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'
-import type { InferOutput, Schema } from '../types/schema.js'
+import { defineMiddleware } from "../define/middleware.js";
+import type { MiddlewareReturnFromParts, MiddlewareUnit } from "../types/units.js";
 
-export type JwtOptions = Parameters<typeof honoJwt>[0]
+export type JwtPayloadState<TPayload> = {
+  jwtPayload: TPayload;
+};
+
+export type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<
+  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>
+>;
+
+export type JwtOptions = Parameters<typeof honoJwt>[0];
 
 /**
  * JWT auth middleware. Invalid or missing tokens return **401** (Hono).
- * Valid tokens whose payload fails `payloadSchema` return **403**.
- * Use optional schema fields for intentionally optional claims.
+ * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
  */
-export function jwt<TPayload>(
-  payloadSchema: Schema<TPayload>,
+export function jwt<TPayload = Record<string, unknown>>(
   options: JwtOptions,
-): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {
-  return createAuthMiddleware(payloadSchema, honoJwt(options))
+): 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 });
+      });
+    },
+  });
 }

package/src/middleware/secure-headers.ts

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

package/src/middleware/timing.ts

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

package/src/middleware/wrap-hono.ts

@@ -0,0 +1,12 @@
+import type { MiddlewareHandler } from "hono";
+
+import { defineMiddleware } from "../define/middleware.js";
+import type { MiddlewareReturnFromParts, MiddlewareUnit } from "../types/units.js";
+
+export function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHandler>(
+  honoFactory: F,
+): (
+  ...args: Parameters<F>
+) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {
+  return (...args) => defineMiddleware(honoFactory(...args));
+}

package/src/middleware.ts

@@ -1,19 +1,19 @@
-import type { LayoutId, MiddlewareBuilder } from './types/index.js'
-import type { MiddlewareDefinition } from './types/units.js'
+import type { LayoutId, MiddlewareBuilder } from "./types/index.js";
+import type { MiddlewareDefinition } from "./types/units.js";
 
 export function createMiddleware<const Layout extends LayoutId>(
   layout: Layout,
 ): MiddlewareBuilder<Layout, readonly []> {
-  const entries: MiddlewareDefinition[] = []
+  const entries: MiddlewareDefinition[] = [];
 
   const chain = {
     layout,
     middlewares: entries,
     use(definition: MiddlewareDefinition) {
-      entries.push(definition)
-      return chain
+      entries.push(definition);
+      return chain;
     },
-  }
+  };
 
-  return chain as unknown as MiddlewareBuilder<Layout, readonly []>
+  return chain as unknown as MiddlewareBuilder<Layout, readonly []>;
 }

package/src/reply.ts

@@ -1,8 +1,4 @@
-export {
-  errorReply,
-  reply,
-  successReply,
-} from '@taserjs/router-utils/reply'
+export { errorReply, reply, successReply } from "@taserjs/router-utils/reply";
 export type {
   BinaryBody,
   BodyKind,
@@ -12,4 +8,4 @@ export type {
   ReplyInit,
   ReplyOf,
   SuccessReplyData,
-} from '@taserjs/router-utils/reply'
+} from "@taserjs/router-utils/reply";