@taserjs/router 0.1.13 → 0.2.0

package/src/context.ts

@@ -0,0 +1,11 @@
+import type { ContextDefinition, ContextOptions } from "./types.js";
+
+export function createContext<
+  TBoot extends Record<string, unknown> = {},
+  TRequest extends Record<string, unknown> = {},
+>(options: ContextOptions<TBoot, TRequest>): ContextDefinition<TBoot, TRequest> {
+  return {
+    kind: "context",
+    ...options,
+  };
+}

package/src/hono.ts

@@ -0,0 +1,75 @@
+import { Context } from "hono";
+import type { MiddlewareHandler as HonoMiddlewareHandler, Next as HonoNext } from "hono";
+import { mergeResponseCookies } from "@taserjs/utils";
+import type {
+  DistributeServices,
+  DistributeState,
+  MiddlewareDefinition,
+  MiddlewareResponse,
+  NextFunction,
+} from "./types.js";
+
+export function hono<
+  R extends
+    | Response
+    | Promise<Response>
+    | MiddlewareResponse<any, any>
+    | Promise<MiddlewareResponse<any, any>> = Promise<Response>,
+>(
+  honoMw: HonoMiddlewareHandler,
+  refine?: (c: Context, next: NextFunction) => R,
+): MiddlewareDefinition<
+  DistributeServices<Awaited<R>>,
+  DistributeState<Awaited<R>>,
+  unknown,
+  unknown,
+  unknown
+> {
+  return {
+    kind: "middleware",
+    handler: async (args, next) => {
+      let c = (args.ctx as Record<string, unknown>).context as Context | undefined;
+      if (!c) {
+        c = new Context(args.req.raw);
+        (args.ctx as Record<string, unknown>).context = c;
+      }
+
+      let nextCalled = false;
+      let downstreamResponse: Response | undefined;
+
+      const honoNext: HonoNext = async () => {
+        nextCalled = true;
+        void c.res;
+        downstreamResponse = refine ? await refine(c, next) : await next();
+        mergeResponseCookies(c, downstreamResponse);
+      };
+
+      let result: Response | void;
+      try {
+        result = await honoMw(c, honoNext);
+      } catch (err: any) {
+        if (typeof err?.getResponse === "function") {
+          return err.getResponse();
+        }
+        if (err?.res instanceof Response) {
+          return err.res;
+        }
+        throw err;
+      }
+
+      if (result instanceof Response) {
+        return result;
+      }
+
+      if (nextCalled) {
+        return c.res ?? downstreamResponse!;
+      }
+
+      if (c.res instanceof Response) {
+        return c.res;
+      }
+
+      throw new Error("Hono middleware did not call next() or return a Response");
+    },
+  };
+}

package/src/index.ts

@@ -1,54 +1,72 @@
-export interface RouterRegister {}
-export interface RouterMiddlewaresRegister {}
-export interface RouterRoutesRegister {}
-export type {
-  AppContext,
-  EmptyAppContext,
-  HttpMethod,
-  InferInput,
-  InferOutput,
-  InferRouteContext,
-  InferRouteInput,
-  InferRouteInputFromPath,
-  InferRouteOutput,
+export {
+  t,
+  layout,
+  RouteBuilder,
+  RouteValidationBuilder,
   LayoutBuilder,
-  LayoutId,
-  LayoutMiddlewaresMap,
-  LayoutParams,
-  LayoutTree,
-  Method,
   MiddlewareBuilder,
+  middleware,
+  toMiddlewareDefinition,
+} from "./builder.js";
+export { hono } from "./hono.js";
+export { createContext } from "./context.js";
+export { defineTaser, TaserBuilder } from "./taser.js";
+export {
+  ValidationError,
+  ResponseValidationError,
+  unsupportedMediaType,
+  UnsupportedMediaTypeError,
+  isStandardSchema,
+  validateStandardSchema,
+} from "@taserjs/utils";
+export type {
+  BodyMode,
+  ValidationFacet,
+  StatusCode,
+  RouteSchemas,
+  RouteBodySchema,
+  StandardSchemaV1,
+  ContextDefinition,
+  ContextOptions,
+  HttpMethod,
+  StandardHttpMethod,
+  HttpNoBodyMethod,
+  MiddlewarePreconditions,
+  LayoutDefinition,
+  MiddlewareArgs,
   MiddlewareDefinition,
-  MiddlewareUnit,
-  MiddlewareUnitBuilder,
-  PathParams,
-  ReturnsMap,
-  RouteByPathMethod,
+  MiddlewareHandler,
+  MiddlewareInput,
+  NextFunction,
+  RouteDefaultParams,
   RouteDefinition,
-  RouteExport,
-  RoutePath,
-  Schema,
+  RouteHandler,
+  RouteHandlerArgs,
+  TaserRequest,
+  RequestHeader,
+  HeaderKey,
+  TaserHeaders,
+  RouterRegister,
+  RegisteredRoutePath,
+  RegisteredLayoutId,
+  InferredAppContext,
   Simplify,
-  StatusCode,
-} from "./types/index.js";
-export type {
-  ContextDefinition,
-  CreateTaserAppOptions,
-  InferAppContext,
-  InferAppManifest,
-  OnErrorOptions,
-  RouteManifestShape,
-} from "./types/app.js";
-
-export { ValidationError, validationErrorSchema } from "@taserjs/router-utils";
-export type { ResponseValidationFailureHandler, SuccessStatusCode } from "@taserjs/router-utils";
-
-export { middleware, 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 { honoMw } from "./middleware/hono-mw.js";
-export type { MiddlewareFn } from "./define/middleware.js";
-
-export type { TaserCookieJar, TaserCookieOptions, TaserHeaders } from "@taserjs/router-core";
+  UnionToIntersection,
+  SafeIntersect,
+  ExtractServicesFromLayout,
+  ExtractStateFromLayout,
+  ExtractServicesFromMiddleware,
+  ExtractStateFromMiddleware,
+  InferEffectiveParams,
+  InferEffectiveQuery,
+  InferEffectiveBody,
+  InferRouteServices,
+  InferRouteState,
+  InferMiddlewareArgs,
+  InferReturnsResponse,
+  NotFoundHandler,
+  OnErrorHandler,
+  ResponseOptions,
+  TaserAppOptions,
+  TaserDefinition,
+} from "./types.js";

package/src/middleware/body-limit.ts

@@ -1,10 +1,22 @@
 import { bodyLimit as honoBodyLimit } from "hono/body-limit";
+import type { Context } from "hono";
+import { payloadTooLarge } from "@taserjs/utils";
+import { hono } from "../hono.js";
+import type { MiddlewareDefinition } from "../types.js";
 
-import { middleware } from "../define/middleware.js";
-import { honoMw } from "./hono-mw.js";
+export type OnError = (c: Context) => Response | Promise<Response>;
 
-export function bodyLimit(...args: Parameters<typeof honoBodyLimit>) {
-  return middleware(honoMw(honoBodyLimit(...args)));
+export interface BodyLimitOptions {
+  maxSize: number;
+  onError?: OnError;
 }
 
-export type BodyLimitOptions = Parameters<typeof honoBodyLimit>[0];
+export function bodyLimit(options: BodyLimitOptions): MiddlewareDefinition {
+  const onError = options.onError ?? (() => payloadTooLarge({ message: "Payload Too Large" }));
+  const honoMw = honoBodyLimit({
+    maxSize: options.maxSize,
+    onError,
+  });
+
+  return hono(honoMw);
+}

package/src/middleware/compress.ts

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

package/src/middleware/cookie.ts

@@ -0,0 +1,128 @@
+import { Context } from "hono";
+import { deleteCookie, getCookie, getSignedCookie, setCookie, setSignedCookie } from "hono/cookie";
+import type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from "hono/utils/cookie";
+import { mergeResponseCookies } from "@taserjs/utils";
+import { middleware } from "../builder.js";
+import type { MiddlewareDefinition } from "../types.js";
+
+export type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie };
+
+export type CookieJarOptions = CookieOptions & {
+  secret?: string | BufferSource | undefined;
+};
+
+export class TaserCookieJar {
+  readonly #c: Context;
+  readonly #defaultOptions: CookieJarOptions;
+  #dirty = false;
+
+  constructor(c: Context, defaultOptions?: CookieJarOptions) {
+    this.#c = c;
+    this.#defaultOptions = defaultOptions ?? {};
+  }
+
+  get(name: string, prefixOptions?: CookiePrefixOptions): string | undefined;
+  get(): Cookie;
+  get(name?: string, prefixOptions?: CookiePrefixOptions): string | Cookie | undefined {
+    if (typeof name === "string") {
+      return getCookie(this.#c, name, prefixOptions);
+    }
+    return getCookie(this.#c);
+  }
+
+  async getSigned(
+    name: string,
+    secret?: string | BufferSource,
+    prefixOptions?: CookiePrefixOptions,
+  ): Promise<string | undefined | false>;
+  async getSigned(secret?: string | BufferSource): Promise<SignedCookie>;
+  async getSigned(
+    nameOrSecret?: string | BufferSource,
+    maybeSecret?: string | BufferSource,
+    prefixOptions?: CookiePrefixOptions,
+  ): Promise<string | SignedCookie | undefined | false> {
+    if (
+      typeof nameOrSecret === "string" &&
+      (maybeSecret !== undefined || this.#defaultOptions.secret !== undefined)
+    ) {
+      const secret = maybeSecret ?? this.#defaultOptions.secret!;
+      return await getSignedCookie(this.#c, secret, nameOrSecret, prefixOptions);
+    }
+
+    const secret =
+      (nameOrSecret as string | BufferSource | undefined) ?? this.#defaultOptions.secret;
+    if (!secret) {
+      throw new Error("Secret is required to read signed cookies");
+    }
+    return await getSignedCookie(this.#c, secret);
+  }
+
+  set(name: string, value: string, opt?: CookieOptions): this {
+    this.#dirty = true;
+    const mergedOpt = opt ? { ...this.#defaultOptions, ...opt } : this.#defaultOptions;
+    setCookie(this.#c, name, value, mergedOpt);
+    return this;
+  }
+
+  async setSigned(
+    name: string,
+    value: string,
+    secretOrOpt?: string | BufferSource | CookieOptions,
+    opt?: CookieOptions,
+  ): Promise<this> {
+    this.#dirty = true;
+    let secret: string | BufferSource;
+    let options: CookieOptions | undefined;
+
+    if (typeof secretOrOpt === "string" || (secretOrOpt && "byteLength" in secretOrOpt)) {
+      secret = secretOrOpt;
+      options = opt;
+    } else {
+      secret = this.#defaultOptions.secret!;
+      options = secretOrOpt;
+    }
+
+    if (!secret) {
+      throw new Error("Secret is required to set signed cookies");
+    }
+
+    const mergedOpt = { ...this.#defaultOptions, ...options };
+    await setSignedCookie(this.#c, name, value, secret, mergedOpt);
+    return this;
+  }
+
+  delete(name: string, opt?: CookieOptions): string | undefined {
+    this.#dirty = true;
+    const mergedOpt = opt ? { ...this.#defaultOptions, ...opt } : this.#defaultOptions;
+    return deleteCookie(this.#c, name, mergedOpt);
+  }
+
+  getSetCookieHeaders(): string[] {
+    void this.#c.res;
+    return typeof this.#c.res?.headers?.getSetCookie === "function"
+      ? this.#c.res.headers.getSetCookie()
+      : [];
+  }
+
+  flush<TRes extends Response>(res: TRes): TRes {
+    if (!this.#dirty) {
+      return res;
+    }
+    return mergeResponseCookies(this.#c, res) as TRes;
+  }
+}
+
+export function cookie(
+  options?: CookieJarOptions,
+): MiddlewareDefinition<{ cookies: TaserCookieJar }> {
+  return middleware(async ({ req, ctx }, next) => {
+    let c = (ctx as Record<string, unknown>).context as Context | undefined;
+    if (!c) {
+      c = new Context(req.raw);
+      (ctx as Record<string, unknown>).context = c;
+    }
+    const jar = new TaserCookieJar(c, options);
+    const res = await next.provide({ cookies: jar });
+    return jar.flush(res);
+  });
+}

package/src/middleware/cors.ts

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

package/src/middleware/csrf.ts

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

package/src/middleware/etag.ts

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

package/src/middleware/index.ts

@@ -0,0 +1,35 @@
+export {
+  cookie,
+  TaserCookieJar,
+  type CookieJarOptions,
+  type Cookie,
+  type CookieOptions,
+  type CookiePrefixOptions,
+  type SignedCookie,
+} from "./cookie.js";
+export { cors, type CORSOptions } from "./cors.js";
+export {
+  jwt,
+  sign,
+  verify,
+  decode,
+  verifyWithJwks,
+  AlgorithmTypes,
+  type JWTOptions,
+  type HonoJWTOptions,
+} from "./jwt.js";
+export { jwk, type JWKOptions } from "./jwk.js";
+export { secureHeaders, NONCE, type SecureHeadersOptions } from "./secure-headers.js";
+export { bodyLimit, type BodyLimitOptions, type OnError } from "./body-limit.js";
+export { csrf, type CSRFOptions } from "./csrf.js";
+export { etag, RETAINED_304_HEADERS, type ETagOptions } from "./etag.js";
+export {
+  timing,
+  startTime,
+  endTime,
+  setMetric,
+  wrapTime,
+  type TimingOptions,
+  type TimingVariables,
+} from "./timing.js";
+export { compress, COMPRESSIBLE_CONTENT_TYPE_REGEX, type CompressionOptions } from "./compress.js";

package/src/middleware/jwk.ts

@@ -1,51 +1,17 @@
 import { jwk as honoJwk } from "hono/jwk";
+import { hono } from "../hono.js";
+import type { MiddlewareDefinition } from "../types.js";
 
-import { middleware } from "../define/middleware.js";
-import { honoMw } from "./hono-mw.js";
-import type { JwtMiddlewareUnit, JwtPayloadState } from "./jwt.js";
+export type JWKOptions = Parameters<typeof honoJwk>[0];
 
-export type JwkOptions = Parameters<typeof honoJwk>[0];
+export function jwk<TClaims = Record<string, unknown>>(
+  options: JWKOptions,
+  init?: RequestInit,
+): MiddlewareDefinition<unknown, { jwtPayload: TClaims }, unknown, unknown, unknown> {
+  const honoMw = honoJwk(options, init);
 
-export type JwkRequestInit = Pick<RequestInit, "headers">;
-
-export type JwkMiddlewareOptions = JwkOptions & {
-  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */
-  allowInsecure?: boolean;
-};
-
-function assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {
-  const scheme = new URL(jwksUri).protocol.replace(":", "");
-  if (scheme === "https") {
-    return;
-  }
-  if (scheme === "http" && allowInsecure) {
-    return;
-  }
-  throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`);
-}
-
-/**
- * JWK auth middleware. Invalid or missing tokens return **401** (Hono).
- * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
- * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
- */
-export function jwk<TPayload = Record<string, unknown>>(
-  options: JwkMiddlewareOptions,
-  init?: JwkRequestInit,
-): 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;
-  const mw = honoMw(honoJwk(honoOptions, safeInit));
-
-  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 });
-    }),
-  );
+  return hono(honoMw, (c, next) => {
+    const jwtPayload = c.get("jwtPayload") as TClaims;
+    return next({ jwtPayload });
+  });
 }

package/src/middleware/jwt.ts

@@ -1,31 +1,26 @@
-import { jwt as honoJwt } from "hono/jwt";
+import { jwt as honoJwt, sign, verify, decode, verifyWithJwks, AlgorithmTypes } from "hono/jwt";
+import { hono } from "../hono.js";
+import type { MiddlewareDefinition } from "../types.js";
 
-import { middleware } from "../define/middleware.js";
-import type { MiddlewareReturnFromParts, MiddlewareUnit } from "../types/units.js";
-import { honoMw } from "./hono-mw.js";
+export type HonoJWTOptions = Parameters<typeof honoJwt>[0];
 
-export type JwtPayloadState<TPayload> = {
-  jwtPayload: TPayload;
-};
-
-export type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<
-  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>
->;
+export interface JWTOptions extends Omit<HonoJWTOptions, "alg"> {
+  alg?: HonoJWTOptions["alg"];
+}
 
-export type JwtOptions = Parameters<typeof honoJwt>[0];
+export function jwt<TClaims = Record<string, unknown>>(
+  options: JWTOptions,
+): MiddlewareDefinition<unknown, { jwtPayload: TClaims }, unknown, unknown, unknown> {
+  const { alg = "HS256", ...rest } = options;
+  const honoMw = honoJwt({
+    alg,
+    ...rest,
+  });
 
-/**
- * JWT auth middleware. Invalid or missing tokens return **401** (Hono).
- * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
- */
-export function jwt<TPayload = Record<string, unknown>>(
-  options: JwtOptions,
-): JwtMiddlewareUnit<TPayload> {
-  const mw = honoMw(honoJwt(options));
-  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 });
-    }),
-  );
+  return hono(honoMw, (c, next) => {
+    const jwtPayload = c.get("jwtPayload") as TClaims;
+    return next({ jwtPayload });
+  });
 }
+
+export { sign, verify, decode, verifyWithJwks, AlgorithmTypes };

package/src/middleware/secure-headers.ts

@@ -1,10 +1,11 @@
-import { secureHeaders as honoSecureHeaders } from "hono/secure-headers";
+import { secureHeaders as honoSecureHeaders, NONCE } from "hono/secure-headers";
+import { hono } from "../hono.js";
+import type { MiddlewareDefinition } from "../types.js";
 
-import { middleware } from "../define/middleware.js";
-import { honoMw } from "./hono-mw.js";
+export type SecureHeadersOptions = Parameters<typeof honoSecureHeaders>[0];
 
-export function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {
-  return middleware(honoMw(honoSecureHeaders(...args)));
+export function secureHeaders(options?: SecureHeadersOptions): MiddlewareDefinition {
+  return hono(honoSecureHeaders(options));
 }
 
-export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;
+export { NONCE };

package/src/middleware/timing.ts

@@ -1,10 +1,13 @@
-import { timing as honoTiming } from "hono/timing";
+import { timing as honoTiming, startTime, endTime, setMetric, wrapTime } from "hono/timing";
+import type { TimingVariables } from "hono/timing";
+import { hono } from "../hono.js";
+import type { MiddlewareDefinition } from "../types.js";
 
-import { middleware } from "../define/middleware.js";
-import { honoMw } from "./hono-mw.js";
+export type TimingOptions = Parameters<typeof honoTiming>[0];
 
-export function timing(...args: Parameters<typeof honoTiming>) {
-  return middleware(honoMw(honoTiming(...args)));
+export function timing(config?: TimingOptions): MiddlewareDefinition {
+  return hono(honoTiming(config));
 }
 
-export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;
+export { startTime, endTime, setMetric, wrapTime };
+export type { TimingVariables };

package/src/reply.ts

@@ -1 +1,26 @@
-export * from "@taserjs/router-utils/reply";
+export {
+  accepted,
+  badRequest,
+  conflict,
+  created,
+  createReply,
+  createTypedResponse,
+  forbidden,
+  html,
+  internalServerError,
+  isPlainObjectOrArray,
+  json,
+  methodNotAllowed,
+  noContent,
+  notFound,
+  ok,
+  payloadTooLarge,
+  redirect,
+  text,
+  tooManyRequests,
+  unauthorized,
+  unprocessable,
+  type ExtractStatus,
+  type JsonResponse,
+  type TypedResponse,
+} from "@taserjs/utils";

package/src/stream.ts

@@ -1 +1,10 @@
-export * from "@taserjs/router-utils/stream";
+export {
+  blob,
+  buffer,
+  formatSSE,
+  pipe,
+  sse,
+  type SSEController,
+  type SSEInit,
+  type SSEMessage,
+} from "@taserjs/utils/stream";