hono 4.6.19 → 4.7.0

package/dist/types/middleware/etag/digest.d.ts

@@ -1 +1 @@
-export declare const generateDigest: (stream: ReadableStream<Uint8Array> | null) => Promise<string | null>;
+export declare const generateDigest: (stream: ReadableStream<Uint8Array> | null, generator: (body: Uint8Array) => ArrayBuffer | Promise<ArrayBuffer>) => Promise<string | null>;

package/dist/types/middleware/etag/index.d.ts

@@ -6,6 +6,7 @@ import type { MiddlewareHandler } from '../../types';
 type ETagOptions = {
     retainedHeaders?: string[];
     weak?: boolean;
+    generateDigest?: (body: Uint8Array) => ArrayBuffer | Promise<ArrayBuffer>;
 };
 /**
  * Default headers to pass through on 304 responses. From the spec:
@@ -22,6 +23,9 @@ export declare const RETAINED_304_HEADERS: string[];
  * @param {ETagOptions} [options] - The options for the ETag middleware.
  * @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
  * @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
+ * @param {function(Uint8Array): ArrayBuffer | Promise<ArrayBuffer>} [options.generateDigest] -
+ * A custom digest generation function. By default, it uses 'SHA-1'
+ * This function is called with the response body as a `Uint8Array` and should return a hash as an `ArrayBuffer` or a Promise of one.
  * @returns {MiddlewareHandler} The middleware handler function.
  *
  * @example

package/dist/types/middleware/jwk/index.d.ts

@@ -0,0 +1 @@
+export { jwk } from './jwk';

package/dist/types/middleware/jwk/jwk.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module
+ * JWK Auth Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+import type { CookiePrefixOptions } from '../../utils/cookie';
+import '../../context';
+import type { HonoJsonWebKey } from '../../utils/jwt/jws';
+/**
+ * JWK Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/jwk}
+ *
+ * @param {object} options - The options for the JWK middleware.
+ * @param {HonoJsonWebKey[] | (() => Promise<HonoJsonWebKey[]>)} [options.keys] - The values of your public keys, or a function that returns them.
+ * @param {string} [options.jwks_uri] - If this value is set, attempt to fetch JWKs from this URI, expecting a JSON response with `keys` which are added to the provided options.keys
+ * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
+ * @param {RequestInit} [init] - Optional initialization options for the `fetch` request when retrieving JWKS from a URI.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use("/auth/*", jwk({ jwks_uri: "https://example-backend.hono.dev/.well-known/jwks.json" }))
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
+export declare const jwk: (options: {
+    keys?: HonoJsonWebKey[] | (() => Promise<HonoJsonWebKey[]>);
+    jwks_uri?: string;
+    cookie?: string | {
+        key: string;
+        secret?: string | BufferSource;
+        prefixOptions?: CookiePrefixOptions;
+    };
+}, init?: RequestInit) => MiddlewareHandler;

package/dist/types/middleware/language/index.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageVariables, DetectorOptions, DetectorType, CacheType } from './language';
+export type { LanguageVariables, DetectorOptions, DetectorType, CacheType };
+export { languageDetector, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, } from './language';
+declare module '../..' {
+    interface ContextVariableMap extends LanguageVariables {
+    }
+}

package/dist/types/middleware/language/language.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @module
+ * Language module for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+export type DetectorType = "path" | "querystring" | "cookie" | "header";
+export type CacheType = "cookie";
+export interface DetectorOptions {
+    /** Order of language detection strategies */
+    order: DetectorType[];
+    /** Query parameter name for language */
+    lookupQueryString: string;
+    /** Cookie name for language */
+    lookupCookie: string;
+    /** Index in URL path where language code appears */
+    lookupFromPathIndex: number;
+    /** Header key for language detection */
+    lookupFromHeaderKey: string;
+    /** Caching strategies */
+    caches: CacheType[] | false;
+    /** Cookie configuration options */
+    cookieOptions?: {
+        domain?: string;
+        path?: string;
+        sameSite?: "Strict" | "Lax" | "None";
+        secure?: boolean;
+        maxAge?: number;
+        httpOnly?: boolean;
+    };
+    /** Whether to ignore case in language codes */
+    ignoreCase: boolean;
+    /** Default language if none detected */
+    fallbackLanguage: string;
+    /** List of supported language codes */
+    supportedLanguages: string[];
+    /** Optional function to transform detected language codes */
+    convertDetectedLanguage?: (lang: string) => string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+export interface LanguageVariables {
+    language: string;
+}
+export declare const DEFAULT_OPTIONS: DetectorOptions;
+/**
+ * Parse Accept-Language header values with quality scores
+ * @param header Accept-Language header string
+ * @returns Array of parsed languages with quality scores
+ */
+export declare function parseAcceptLanguage(header: string): Array<{
+    lang: string;
+    q: number;
+}>;
+/**
+ * Validate and normalize language codes
+ * @param lang Language code to normalize
+ * @param options Detector options
+ * @returns Normalized language code or undefined
+ */
+export declare const normalizeLanguage: (lang: string | null | undefined, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from query parameter
+ */
+export declare const detectFromQuery: (c: Context, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from cookie
+ */
+export declare const detectFromCookie: (c: Context, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from Accept-Language header
+ */
+export declare function detectFromHeader(c: Context, options: DetectorOptions): string | undefined;
+/**
+ * Detects language from URL path
+ */
+export declare function detectFromPath(c: Context, options: DetectorOptions): string | undefined;
+/**
+ * Collection of all language detection strategies
+ */
+export declare const detectors: {
+    readonly querystring: (c: Context, options: DetectorOptions) => string | undefined;
+    readonly cookie: (c: Context, options: DetectorOptions) => string | undefined;
+    readonly header: typeof detectFromHeader;
+    readonly path: typeof detectFromPath;
+};
+/** Type for detector functions */
+export type DetectorFunction = (c: Context, options: DetectorOptions) => string | undefined;
+/** Type-safe detector map */
+export type Detectors = Record<keyof typeof detectors, DetectorFunction>;
+/**
+ * Validate detector options
+ * @param options Detector options to validate
+ * @throws Error if options are invalid
+ */
+export declare function validateOptions(options: DetectorOptions): void;
+/**
+ * Language detector middleware factory
+ * @param userOptions Configuration options for the language detector
+ * @returns Hono middleware function
+ */
+export declare const languageDetector: (userOptions: Partial<DetectorOptions>) => MiddlewareHandler;

package/dist/types/utils/accept.d.ts

@@ -0,0 +1,11 @@
+export interface Accept {
+    type: string;
+    params: Record<string, string>;
+    q: number;
+}
+/**
+ * Parse an Accept header into an array of objects with type, parameters, and quality score.
+ * @param acceptHeader The Accept header string
+ * @returns An array of parsed Accept values
+ */
+export declare const parseAccept: (acceptHeader: string) => Accept[];

package/dist/types/utils/jwt/index.d.ts

@@ -9,4 +9,8 @@ export declare const Jwt: {
         header: import("./jwt").TokenHeader;
         payload: import("./types").JWTPayload;
     };
+    verifyFromJwks: (token: string, options: {
+        keys?: import("./jws").HonoJsonWebKey[] | (() => Promise<import("./jws").HonoJsonWebKey[]>);
+        jwks_uri?: string;
+    }, init?: RequestInit) => Promise<import("./types").JWTPayload>;
 };

package/dist/types/utils/jwt/jws.d.ts

@@ -4,6 +4,9 @@
  * https://datatracker.ietf.org/doc/html/rfc7515
  */
 import type { SignatureAlgorithm } from './jwa';
-export type SignatureKey = string | JsonWebKey | CryptoKey;
+export interface HonoJsonWebKey extends JsonWebKey {
+    kid?: string;
+}
+export type SignatureKey = string | HonoJsonWebKey | CryptoKey;
 export declare function signing(privateKey: SignatureKey, alg: SignatureAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
 export declare function verifying(publicKey: SignatureKey, alg: SignatureAlgorithm, signature: BufferSource, data: BufferSource): Promise<boolean>;

package/dist/types/utils/jwt/jwt.d.ts

@@ -4,16 +4,22 @@
  * https://datatracker.ietf.org/doc/html/rfc7519
  */
 import type { SignatureAlgorithm } from './jwa';
-import type { SignatureKey } from './jws';
+import type { HonoJsonWebKey, SignatureKey } from './jws';
 import type { JWTPayload } from './types';
 export interface TokenHeader {
     alg: SignatureAlgorithm;
     typ?: "JWT";
+    kid?: string;
 }
 export declare function isTokenHeader(obj: unknown): obj is TokenHeader;
 export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
 export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<JWTPayload>;
+export declare const verifyFromJwks: (token: string, options: {
+    keys?: HonoJsonWebKey[] | (() => Promise<HonoJsonWebKey[]>);
+    jwks_uri?: string;
+}, init?: RequestInit) => Promise<JWTPayload>;
 export declare const decode: (token: string) => {
     header: TokenHeader;
     payload: JWTPayload;
 };
+export declare const decodeHeader: (token: string) => TokenHeader;

package/dist/types/utils/jwt/types.d.ts

@@ -20,6 +20,9 @@ export declare class JwtTokenIssuedAt extends Error {
 export declare class JwtHeaderInvalid extends Error {
     constructor(header: object);
 }
+export declare class JwtHeaderRequiresKid extends Error {
+    constructor(header: object);
+}
 export declare class JwtTokenSignatureMismatched extends Error {
     constructor(token: string);
 }
@@ -51,3 +54,4 @@ export type JWTPayload = {
      */
     iat?: number;
 };
+export type { HonoJsonWebKey } from './jws';

package/dist/types/utils/url.d.ts

@@ -9,7 +9,7 @@ export type Pattern = readonly [
 ] | "*";
 export declare const splitPath: (path: string) => string[];
 export declare const splitRoutingPath: (routePath: string) => string[];
-export declare const getPattern: (label: string) => Pattern | null;
+export declare const getPattern: (label: string, next?: string) => Pattern | null;
 type Decoder = (str: string) => string;
 export declare const tryDecode: (str: string, decoder: Decoder) => string;
 export declare const getPath: (request: Request) => string;

package/dist/utils/accept.js

@@ -0,0 +1,63 @@
+// src/utils/accept.ts
+var parseAccept = (acceptHeader) => {
+  if (!acceptHeader) {
+    return [];
+  }
+  const acceptValues = acceptHeader.split(",").map((value, index) => ({ value, index }));
+  return acceptValues.map(parseAcceptValue).filter((item) => Boolean(item)).sort(sortByQualityAndIndex).map(({ type, params, q }) => ({ type, params, q }));
+};
+var parseAcceptValueRegex = /;(?=(?:(?:[^"]*"){2})*[^"]*$)/;
+var parseAcceptValue = ({ value, index }) => {
+  const parts = value.trim().split(parseAcceptValueRegex).map((s) => s.trim());
+  const type = parts[0];
+  if (!type) {
+    return null;
+  }
+  const params = parseParams(parts.slice(1));
+  const q = parseQuality(params.q);
+  return { type, params, q, index };
+};
+var parseParams = (paramParts) => {
+  return paramParts.reduce((acc, param) => {
+    const [key, val] = param.split("=").map((s) => s.trim());
+    if (key && val) {
+      acc[key] = val;
+    }
+    return acc;
+  }, {});
+};
+var parseQuality = (qVal) => {
+  if (qVal === void 0) {
+    return 1;
+  }
+  if (qVal === "") {
+    return 1;
+  }
+  if (qVal === "NaN") {
+    return 0;
+  }
+  const num = Number(qVal);
+  if (num === Infinity) {
+    return 1;
+  }
+  if (num === -Infinity) {
+    return 0;
+  }
+  if (Number.isNaN(num)) {
+    return 1;
+  }
+  if (num < 0 || num > 1) {
+    return 1;
+  }
+  return num;
+};
+var sortByQualityAndIndex = (a, b) => {
+  const qDiff = b.q - a.q;
+  if (qDiff !== 0) {
+    return qDiff;
+  }
+  return a.index - b.index;
+};
+export {
+  parseAccept
+};

package/dist/utils/jwt/index.js

@@ -1,6 +1,6 @@
 // src/utils/jwt/index.ts
-import { decode, sign, verify } from "./jwt.js";
-var Jwt = { sign, verify, decode };
+import { decode, sign, verify, verifyFromJwks } from "./jwt.js";
+var Jwt = { sign, verify, decode, verifyFromJwks };
 export {
   Jwt
 };

package/dist/utils/jwt/jwt.js

@@ -4,6 +4,7 @@ import { AlgorithmTypes } from "./jwa.js";
 import { signing, verifying } from "./jws.js";
 import {
   JwtHeaderInvalid,
+  JwtHeaderRequiresKid,
   JwtTokenExpired,
   JwtTokenInvalid,
   JwtTokenIssuedAt,
@@ -23,7 +24,13 @@ function isTokenHeader(obj) {
 }
 var sign = async (payload, privateKey, alg = "HS256") => {
   const encodedPayload = encodeJwtPart(payload);
-  const encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  let encodedHeader;
+  if (typeof privateKey === "object" && "alg" in privateKey) {
+    alg = privateKey.alg;
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT", kid: privateKey.kid });
+  } else {
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  }
   const partialToken = `${encodedHeader}.${encodedPayload}`;
   const signaturePart = await signing(privateKey, alg, utf8Encoder.encode(partialToken));
   const signature = encodeSignaturePart(signaturePart);
@@ -60,6 +67,41 @@ var verify = async (token, publicKey, alg = "HS256") => {
   }
   return payload;
 };
+var verifyFromJwks = async (token, options, init) => {
+  const header = decodeHeader(token);
+  if (!isTokenHeader(header)) {
+    throw new JwtHeaderInvalid(header);
+  }
+  if (!header.kid) {
+    throw new JwtHeaderRequiresKid(header);
+  }
+  let keys = typeof options.keys === "function" ? await options.keys() : options.keys;
+  if (options.jwks_uri) {
+    const response = await fetch(options.jwks_uri, init);
+    if (!response.ok) {
+      throw new Error(`failed to fetch JWKS from ${options.jwks_uri}`);
+    }
+    const data = await response.json();
+    if (!data.keys) {
+      throw new Error('invalid JWKS response. "keys" field is missing');
+    }
+    if (!Array.isArray(data.keys)) {
+      throw new Error('invalid JWKS response. "keys" field is not an array');
+    }
+    if (keys) {
+      keys.push(...data.keys);
+    } else {
+      keys = data.keys;
+    }
+  } else if (!keys) {
+    throw new Error('verifyFromJwks requires options for either "keys" or "jwks_uri" or both');
+  }
+  const matchingKey = keys.find((key) => key.kid === header.kid);
+  if (!matchingKey) {
+    throw new JwtTokenInvalid(token);
+  }
+  return await verify(token, matchingKey, matchingKey.alg);
+};
 var decode = (token) => {
   try {
     const [h, p] = token.split(".");
@@ -73,9 +115,19 @@ var decode = (token) => {
     throw new JwtTokenInvalid(token);
   }
 };
+var decodeHeader = (token) => {
+  try {
+    const [h] = token.split(".");
+    return decodeJwtPart(h);
+  } catch {
+    throw new JwtTokenInvalid(token);
+  }
+};
 export {
   decode,
+  decodeHeader,
   isTokenHeader,
   sign,
-  verify
+  verify,
+  verifyFromJwks
 };

package/dist/utils/jwt/types.js

@@ -35,6 +35,12 @@ var JwtHeaderInvalid = class extends Error {
     this.name = "JwtHeaderInvalid";
   }
 };
+var JwtHeaderRequiresKid = class extends Error {
+  constructor(header) {
+    super(`required "kid" in jwt header: ${JSON.stringify(header)}`);
+    this.name = "JwtHeaderRequiresKid";
+  }
+};
 var JwtTokenSignatureMismatched = class extends Error {
   constructor(token) {
     super(`token(${token}) signature mismatched`);
@@ -56,6 +62,7 @@ export {
   CryptoKeyUsage,
   JwtAlgorithmNotImplemented,
   JwtHeaderInvalid,
+  JwtHeaderRequiresKid,
   JwtTokenExpired,
   JwtTokenInvalid,
   JwtTokenIssuedAt,

package/dist/utils/url.js

@@ -33,20 +33,21 @@ var replaceGroupMarks = (paths, groups) => {
   return paths;
 };
 var patternCache = {};
-var getPattern = (label) => {
+var getPattern = (label, next) => {
   if (label === "*") {
     return "*";
   }
   const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
   if (match) {
-    if (!patternCache[label]) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
       if (match[2]) {
-        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
       } else {
-        patternCache[label] = [label, match[1], true];
+        patternCache[cacheKey] = [label, match[1], true];
       }
     }
-    return patternCache[label];
+    return patternCache[cacheKey];
   }
   return null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.6.19",
+  "version": "4.7.0",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -204,6 +204,11 @@
       "import": "./dist/middleware/jwt/index.js",
       "require": "./dist/cjs/middleware/jwt/index.js"
     },
+    "./jwk": {
+      "types": "./dist/types/middleware/jwk/index.d.ts",
+      "import": "./dist/middleware/jwk/index.js",
+      "require": "./dist/cjs/middleware/jwk/index.js"
+    },
     "./timeout": {
       "types": "./dist/types/middleware/timeout/index.d.ts",
       "import": "./dist/middleware/timeout/index.js",
@@ -239,6 +244,11 @@
       "import": "./dist/middleware/request-id/index.js",
       "require": "./dist/cjs/middleware/request-id/index.js"
     },
+    "./language": {
+      "types": "./dist/types/middleware/language/index.d.ts",
+      "import": "./dist/middleware/language/index.js",
+      "require": "./dist/cjs/middleware/language/index.js"
+    },
     "./secure-headers": {
       "types": "./dist/types/middleware/secure-headers/index.d.ts",
       "import": "./dist/middleware/secure-headers/index.js",
@@ -388,6 +398,11 @@
       "types": "./dist/types/helper/conninfo/index.d.ts",
       "import": "./dist/helper/conninfo/index.js",
       "require": "./dist/cjs/helper/conninfo/index.js"
+    },
+    "./proxy": {
+      "types": "./dist/types/helper/proxy/index.d.ts",
+      "import": "./dist/helper/proxy/index.js",
+      "require": "./dist/cjs/helper/proxy/index.js"
     }
   },
   "typesVersions": {
@@ -506,6 +521,9 @@
       "request-id": [
         "./dist/types/middleware/request-id"
       ],
+      "language": [
+        "./dist/types/middleware/language"
+      ],
       "streaming": [
         "./dist/types/helper/streaming"
       ],
@@ -595,6 +613,9 @@
       ],
       "conninfo": [
         "./dist/types/helper/conninfo"
+      ],
+      "proxy": [
+        "./dist/types/helper/proxy"
       ]
     }
   },
@@ -632,21 +653,21 @@
     "@types/jsdom": "^21.1.7",
     "@types/node": "20.11.4",
     "@types/supertest": "^2.0.16",
-    "@vitest/coverage-v8": "^2.0.5",
+    "@vitest/coverage-v8": "^3.0.5",
     "arg": "^5.0.2",
-    "bun-types": "^1.1.34",
+    "bun-types": "^1.1.39",
     "esbuild": "^0.15.18",
     "eslint": "^9.10.0",
     "glob": "^11.0.0",
     "jsdom": "^22.1.0",
     "msw": "^2.6.0",
-    "np": "7.7.0",
+    "np": "10.2.0",
     "prettier": "^2.6.2",
     "publint": "^0.1.16",
     "supertest": "^6.3.4",
     "typescript": "^5.3.3",
     "vite-plugin-fastly-js-compute": "^0.4.2",
-    "vitest": "^2.0.5",
+    "vitest": "^3.0.5",
     "wrangler": "3.58.0",
     "ws": "^8.18.0",
     "zod": "^3.23.8"