@taserjs/router 0.0.1 → 0.0.3

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

@@ -0,0 +1,11 @@
+export { errorReply, reply, successReply } from "@taserjs/router-utils/reply";
+export type {
+  BinaryBody,
+  BodyKind,
+  FileReplyInit,
+  RedirectInit,
+  ReplyBodyKind,
+  ReplyInit,
+  ReplyOf,
+  SuccessReplyData,
+} from "@taserjs/router-utils/reply";

package/src/route.ts

@@ -1,62 +1,59 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import {
   collectReturnsFromDefinitions,
   hasInputSchemas,
   mergeReturnsMaps,
   withAuto422,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 
-import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from './types/index.js'
-import type { HttpMethod, MiddlewareDefinition } from './types/units.js'
-import { isHandlerUnit } from './types/units.js'
-import { HANDLER_SCHEMA_KEY_MAP } from './constants.js'
-import {
-  pickDefinedSchemas,
-  type SchemaValidators,
-} from './define/validators.js'
+import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from "./types/index.js";
+import type { HttpMethod, MiddlewareDefinition } from "./types/units.js";
+import { isHandlerUnit } from "./types/units.js";
+import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
+import { pickDefinedSchemas, type SchemaValidators } from "./define/validators.js";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
   if (!map) {
-    return {}
+    return {};
   }
-  const out: Record<number, StandardSchemaV1> = {}
+  const out: Record<number, StandardSchemaV1> = {};
   for (const [key, schema] of Object.entries(map)) {
     if (schema !== undefined) {
-      out[Number(key)] = schema
+      out[Number(key)] = schema;
     }
   }
-  return out
+  return out;
 }
 
 function buildEffectiveReturns(args: {
-  middlewareReturns: ReturnsMap
-  routeReturns: ReturnsMap
-  handlerMiddlewareReturns: ReturnsMap
-  handlerReturns: ReturnsMap | undefined
+  middlewareReturns: ReturnsMap;
+  routeReturns: ReturnsMap;
+  handlerMiddlewareReturns: ReturnsMap;
+  handlerReturns: ReturnsMap | undefined;
   schemas: {
-    query?: unknown
-    params?: unknown
-    body?: unknown
-    handlerQuery?: unknown
-    handlerParams?: unknown
-    handlerBody?: unknown
-    middlewares?: readonly MiddlewareDefinition[]
-    handlerMiddlewares?: readonly MiddlewareDefinition[]
-  }
+    query?: unknown;
+    params?: unknown;
+    body?: unknown;
+    handlerQuery?: unknown;
+    handlerParams?: unknown;
+    handlerBody?: unknown;
+    middlewares?: readonly MiddlewareDefinition[];
+    handlerMiddlewares?: readonly MiddlewareDefinition[];
+  };
 }): Record<number, StandardSchemaV1> | undefined {
   const merged = mergeReturnsMaps(
     toUtilsMap(args.middlewareReturns),
     toUtilsMap(args.routeReturns),
     toUtilsMap(args.handlerMiddlewareReturns),
     toUtilsMap(args.handlerReturns),
-  )
-  const with422 = withAuto422(merged, hasInputSchemas(args.schemas))
-  return Object.keys(with422).length > 0 ? with422 : undefined
+  );
+  const with422 = withAuto422(merged, hasInputSchemas(args.schemas));
+  return Object.keys(with422).length > 0 ? with422 : undefined;
 }
 
 function buildRouteBase(
   path: string,
-  method: HttpMethod | 'ANY' | 'ALL',
+  method: HttpMethod | "ANY" | "ALL",
   methods: readonly HttpMethod[] | undefined,
   middlewares: MiddlewareDefinition[],
 ) {
@@ -65,36 +62,36 @@ function buildRouteBase(
     method,
     ...(methods ? { methods: [...methods] } : {}),
     middlewares: [...middlewares],
-  }
+  };
 }
 
 /** Shared internal builder — not part of the public `@taserjs/router` API. */
 export function createRouteBuilder(
   path: string,
-  method: HttpMethod | 'ANY' | 'ALL',
+  method: HttpMethod | "ANY" | "ALL",
   validators: SchemaValidators = {},
   methods?: readonly HttpMethod[],
 ): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {
-  const middlewares: MiddlewareDefinition[] = []
-  let routeReturns: Record<number, StandardSchemaV1> = {}
+  const middlewares: MiddlewareDefinition[] = [];
+  let routeReturns: Record<number, StandardSchemaV1> = {};
 
   const builder = {
     path,
     method,
     returns(map: ReturnsMap) {
-      routeReturns = { ...routeReturns, ...toUtilsMap(map) }
-      return builder
+      routeReturns = { ...routeReturns, ...toUtilsMap(map) };
+      return builder;
     },
     use(definition: MiddlewareDefinition) {
-      middlewares.push(definition)
-      return builder
+      middlewares.push(definition);
+      return builder;
     },
     handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {
-      const routeSchemas = pickDefinedSchemas(validators)
-      const base = buildRouteBase(path, method, methods, middlewares)
+      const routeSchemas = pickDefinedSchemas(validators);
+      const base = buildRouteBase(path, method, methods, middlewares);
 
       if (isHandlerUnit(fnOrUnit)) {
-        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
+        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP);
         const returns = buildEffectiveReturns({
           middlewareReturns: collectReturnsFromDefinitions(middlewares),
           routeReturns: routeReturns,
@@ -108,7 +105,7 @@ export function createRouteBuilder(
             middlewares,
             handlerMiddlewares: fnOrUnit.middlewares,
           },
-        })
+        });
 
         return {
           ...base,
@@ -117,7 +114,7 @@ export function createRouteBuilder(
           ...routeSchemas,
           ...handlerSchemas,
           ...(returns ? { returns } : {}),
-        }
+        };
       }
 
       const returns = buildEffectiveReturns({
@@ -129,7 +126,7 @@ export function createRouteBuilder(
           ...validators,
           middlewares,
         },
-      })
+      });
 
       return {
         ...base,
@@ -137,9 +134,9 @@ export function createRouteBuilder(
         handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
         ...routeSchemas,
         ...(returns ? { returns } : {}),
-      }
+      };
     },
-  }
+  };
 
-  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>
+  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>;
 }

package/src/stream.ts

@@ -0,0 +1 @@
+export { blob, buffer, file, pipe, stream } from "@taserjs/router-utils";

package/src/taser-app.ts

@@ -1,15 +1,15 @@
-import type { TaserRuntime } from '@taserjs/router-core'
-import type { RouteManifestShape } from '@taserjs/router-core'
+import type { TaserRuntime } from "@taserjs/router-core";
+import type { RouteManifestShape } from "@taserjs/router-core";
 
 class TaserServeView {
-  constructor(protected readonly runtime: TaserRuntime) { }
+  constructor(protected readonly runtime: TaserRuntime) {}
 
   fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
-    return this.runtime.fetch(request, env, executionCtx as never)
+    return this.runtime.fetch(request, env, executionCtx as never);
   }
 
   native(native: unknown): TaserNativeBound {
-    return new TaserNativeBound(this.runtime, native)
+    return new TaserNativeBound(this.runtime, native);
   }
 }
 
@@ -17,27 +17,22 @@ export class TaserNativeBound {
   constructor(
     private readonly runtime: TaserRuntime,
     private readonly boundNative: unknown,
-  ) { }
+  ) {}
 
   fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
-    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never)
+    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never);
   }
 }
 
-export class TaserMountedApp extends TaserServeView { }
-
-export class TaserApp<TManifest extends RouteManifestShape = RouteManifestShape> extends TaserServeView {
-  readonly __manifest?: TManifest
+export class TaserApp<
+  TManifest extends RouteManifestShape = RouteManifestShape,
+> extends TaserServeView {
+  readonly __manifest?: TManifest;
 
   constructor(runtime: TaserRuntime, manifest?: TManifest) {
-    super(runtime)
+    super(runtime);
     if (manifest !== undefined) {
-      this.__manifest = manifest
+      this.__manifest = manifest;
     }
   }
-
-  base(prefix: string): TaserMountedApp {
-    this.runtime.registerRoutePrefix(prefix)
-    return new TaserMountedApp(this.runtime)
-  }
 }