hono 4.13.8 → 4.13.10

package/dist/middleware/jwt/jwt.js

@@ -1,119 +1,119 @@
-// src/middleware/jwt/jwt.ts
-import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
 import { HTTPException } from "../../http-exception.js";
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
 import { Jwt } from "../../utils/jwt/index.js";
-import "../../context.js";
-var jwt = (options) => {
-  const verifyOpts = options.verification || {};
-  if (!options || !options.secret) {
-    throw new Error('JWT auth middleware requires options for "secret"');
-  }
-  if (!options.alg) {
-    throw new Error('JWT auth middleware requires options for "alg"');
-  }
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
-  }
-  return async function jwt2(ctx, next) {
-    const headerName = options.headerName || "Authorization";
-    const credentials = ctx.req.raw.headers.get(headerName);
-    let token;
-    if (credentials) {
-      const parts = credentials.split(/\s+/);
-      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
-        const errDescription = "invalid credentials structure";
-        throw new HTTPException(401, {
-          message: errDescription,
-          res: unauthorizedResponse({
-            ctx,
-            error: "invalid_request",
-            errDescription,
-            realm: options.realm
-          })
-        });
-      } else {
-        token = parts[1];
-      }
-    } else if (options.cookie) {
-      if (typeof options.cookie == "string") {
-        token = getCookie(ctx, options.cookie);
-      } else if (options.cookie.secret) {
-        if (options.cookie.prefixOptions) {
-          token = await getSignedCookie(
-            ctx,
-            options.cookie.secret,
-            options.cookie.key,
-            options.cookie.prefixOptions
-          );
-        } else {
-          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
-        }
-      } else {
-        if (options.cookie.prefixOptions) {
-          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
-        } else {
-          token = getCookie(ctx, options.cookie.key);
-        }
-      }
-    }
-    if (!token) {
-      const errDescription = "no authorization included in request";
-      throw new HTTPException(401, {
-        message: errDescription,
-        res: unauthorizedResponse({
-          ctx,
-          error: "invalid_request",
-          errDescription,
-          realm: options.realm
-        })
-      });
-    }
-    let payload;
-    let cause;
-    try {
-      payload = await Jwt.verify(token, options.secret, {
-        alg: options.alg,
-        ...verifyOpts
-      });
-    } catch (e) {
-      cause = e;
-    }
-    if (!payload) {
-      throw new HTTPException(401, {
-        message: "Unauthorized",
-        res: unauthorizedResponse({
-          ctx,
-          error: "invalid_token",
-          statusText: "Unauthorized",
-          errDescription: "token verification failure",
-          realm: options.realm
-        }),
-        cause
-      });
-    }
-    ctx.set("jwtPayload", payload);
-    await next();
-  };
+//#region src/middleware/jwt/jwt.ts
+/**
+* JWT Auth Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/jwt}
+*
+* @param {object} options - The options for the JWT middleware.
+* @param {SignatureKey} options.secret - A value of your secret key.
+* @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 {SignatureAlgorithm} options.alg - An algorithm type that is used for verifying (required). Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
+* @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
+* @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
+* @param {VerifyOptions} [options.verification] - Additional options for JWT payload verification.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use(
+*   '/auth/*',
+*   jwt({
+*     secret: 'it-is-very-secret',
+*     alg: 'HS256',
+*     headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
+*   })
+* )
+*
+* app.get('/auth/page', (c) => {
+*   return c.text('You are authorized')
+* })
+* ```
+*/
+const jwt = (options) => {
+	const verifyOpts = options.verification || {};
+	if (!options || !options.secret) throw new Error("JWT auth middleware requires options for \"secret\"");
+	if (!options.alg) throw new Error("JWT auth middleware requires options for \"alg\"");
+	if (!crypto.subtle || !crypto.subtle.importKey) throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
+	return async function jwt(ctx, next) {
+		const headerName = options.headerName || "Authorization";
+		const credentials = ctx.req.raw.headers.get(headerName);
+		let token;
+		if (credentials) {
+			const parts = credentials.split(/\s+/);
+			if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+				const errDescription = "invalid credentials structure";
+				throw new HTTPException(401, {
+					message: errDescription,
+					res: unauthorizedResponse({
+						ctx,
+						error: "invalid_request",
+						errDescription,
+						realm: options.realm
+					})
+				});
+			} else token = parts[1];
+		} else if (options.cookie) {
+			if (typeof options.cookie == "string") token = getCookie(ctx, options.cookie);
+			else if (options.cookie.secret) {
+				if (options.cookie.prefixOptions) token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key, options.cookie.prefixOptions);
+				else token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
+			} else if (options.cookie.prefixOptions) token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
+			else token = getCookie(ctx, options.cookie.key);
+		}
+		if (!token) {
+			const errDescription = "no authorization included in request";
+			throw new HTTPException(401, {
+				message: errDescription,
+				res: unauthorizedResponse({
+					ctx,
+					error: "invalid_request",
+					errDescription,
+					realm: options.realm
+				})
+			});
+		}
+		let payload;
+		let cause;
+		try {
+			payload = await Jwt.verify(token, options.secret, {
+				alg: options.alg,
+				...verifyOpts
+			});
+		} catch (e) {
+			cause = e;
+		}
+		if (!payload) throw new HTTPException(401, {
+			message: "Unauthorized",
+			res: unauthorizedResponse({
+				ctx,
+				error: "invalid_token",
+				statusText: "Unauthorized",
+				errDescription: "token verification failure",
+				realm: options.realm
+			}),
+			cause
+		});
+		ctx.set("jwtPayload", payload);
+		await next();
+	};
 };
 function unauthorizedResponse(opts) {
-  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
-  const errDescription = opts.errDescription.replace(/"/g, '\\"');
-  return new Response("Unauthorized", {
-    status: 401,
-    statusText: opts.statusText,
-    headers: {
-      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
-    }
-  });
+	const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, "\\\"");
+	const errDescription = opts.errDescription.replace(/"/g, "\\\"");
+	return new Response("Unauthorized", {
+		status: 401,
+		statusText: opts.statusText,
+		headers: { "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"` }
+	});
 }
-var verifyWithJwks = Jwt.verifyWithJwks;
-var verify = Jwt.verify;
-var decode = Jwt.decode;
-var sign = Jwt.sign;
-export {
-  decode,
-  jwt,
-  sign,
-  verify,
-  verifyWithJwks
-};
+const verifyWithJwks = Jwt.verifyWithJwks;
+const verify = Jwt.verify;
+const decode = Jwt.decode;
+const sign = Jwt.sign;
+//#endregion
+export { decode, jwt, sign, verify, verifyWithJwks };

package/dist/middleware/language/index.js

@@ -1,15 +1,2 @@
-// src/middleware/language/index.ts
-import {
-  languageDetector,
-  detectFromCookie,
-  detectFromHeader,
-  detectFromPath,
-  detectFromQuery
-} from "./language.js";
-export {
-  detectFromCookie,
-  detectFromHeader,
-  detectFromPath,
-  detectFromQuery,
-  languageDetector
-};
+import { detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector } from "./language.js";
+export { detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector };

package/dist/middleware/language/language.js

@@ -1,175 +1,198 @@
-// src/middleware/language/language.ts
-import { setCookie, getCookie } from "../../helper/cookie/index.js";
+import { getCookie, setCookie } from "../../helper/cookie/index.js";
 import { parseAccept } from "../../utils/accept.js";
-var DEFAULT_OPTIONS = {
-  order: ["querystring", "cookie", "header"],
-  lookupQueryString: "lang",
-  lookupCookie: "language",
-  lookupFromHeaderKey: "accept-language",
-  lookupFromPathIndex: 0,
-  caches: ["cookie"],
-  ignoreCase: true,
-  fallbackLanguage: "en",
-  supportedLanguages: ["en"],
-  cookieOptions: {
-    sameSite: "Strict",
-    secure: true,
-    maxAge: 365 * 24 * 60 * 60,
-    httpOnly: true
-  },
-  debug: false
+//#region src/middleware/language/language.ts
+const DEFAULT_OPTIONS = {
+	order: [
+		"querystring",
+		"cookie",
+		"header"
+	],
+	lookupQueryString: "lang",
+	lookupCookie: "language",
+	lookupFromHeaderKey: "accept-language",
+	lookupFromPathIndex: 0,
+	caches: ["cookie"],
+	ignoreCase: true,
+	fallbackLanguage: "en",
+	supportedLanguages: ["en"],
+	cookieOptions: {
+		sameSite: "Strict",
+		secure: true,
+		maxAge: 31536e3,
+		httpOnly: true
+	},
+	debug: false
 };
+/**
+* Parse Accept-Language header values with quality scores
+* @param header Accept-Language header string
+* @returns Array of parsed languages with quality scores
+*/
 function parseAcceptLanguage(header) {
-  return parseAccept(header).map(({ type, q }) => ({ lang: type, q }));
+	return parseAccept(header).map(({ type, q }) => ({
+		lang: type,
+		q
+	}));
 }
-var normalizeLanguage = (lang, options) => {
-  if (!lang) {
-    return void 0;
-  }
-  try {
-    let normalizedLang = lang.trim();
-    if (options.convertDetectedLanguage) {
-      normalizedLang = options.convertDetectedLanguage(normalizedLang);
-    }
-    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
-    const compSupported = options.supportedLanguages.map(
-      (l) => options.ignoreCase ? l.toLowerCase() : l
-    );
-    const exactIndex = compSupported.indexOf(compLang);
-    if (exactIndex !== -1) {
-      return options.supportedLanguages[exactIndex];
-    }
-    let longestMatchIndex = -1;
-    let longestMatchLength = -1;
-    for (let i = 0; i < compSupported.length; i++) {
-      const candidate = compSupported[i];
-      if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
-        longestMatchIndex = i;
-        longestMatchLength = candidate.length;
-      }
-    }
-    if (longestMatchIndex !== -1) {
-      return options.supportedLanguages[longestMatchIndex];
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
+/**
+* Validate and normalize language codes
+* @param lang Language code to normalize
+* @param options Detector options
+* @returns Normalized language code or undefined
+*/
+const normalizeLanguage = (lang, options) => {
+	if (!lang) return;
+	try {
+		let normalizedLang = lang.trim();
+		if (options.convertDetectedLanguage) normalizedLang = options.convertDetectedLanguage(normalizedLang);
+		const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+		const compSupported = options.supportedLanguages.map((l) => options.ignoreCase ? l.toLowerCase() : l);
+		const exactIndex = compSupported.indexOf(compLang);
+		if (exactIndex !== -1) return options.supportedLanguages[exactIndex];
+		let longestMatchIndex = -1;
+		let longestMatchLength = -1;
+		for (let i = 0; i < compSupported.length; i++) {
+			const candidate = compSupported[i];
+			if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
+				longestMatchIndex = i;
+				longestMatchLength = candidate.length;
+			}
+		}
+		if (longestMatchIndex !== -1) return options.supportedLanguages[longestMatchIndex];
+		return;
+	} catch {
+		return;
+	}
 };
-var detectFromQuery = (c, options) => {
-  const query = c.req.query(options.lookupQueryString);
-  return normalizeLanguage(query, options);
+/**
+* Detects language from query parameter
+*/
+const detectFromQuery = (c, options) => {
+	const query = c.req.query(options.lookupQueryString);
+	return normalizeLanguage(query, options);
 };
-var detectFromCookie = (c, options) => {
-  const cookie = getCookie(c, options.lookupCookie);
-  return normalizeLanguage(cookie, options);
+/**
+* Detects language from cookie
+*/
+const detectFromCookie = (c, options) => {
+	const cookie = getCookie(c, options.lookupCookie);
+	return normalizeLanguage(cookie, options);
 };
+/**
+* Detects language from Accept-Language header
+*/
 function detectFromHeader(c, options) {
-  try {
-    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
-    if (!acceptLanguage) {
-      return void 0;
-    }
-    const languages = parseAcceptLanguage(acceptLanguage);
-    for (const { lang, q } of languages) {
-      if (q === 0) {
-        continue;
-      }
-      const normalizedLang = normalizeLanguage(lang, options);
-      if (normalizedLang) {
-        return normalizedLang;
-      }
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
+	try {
+		const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+		if (!acceptLanguage) return;
+		const languages = parseAcceptLanguage(acceptLanguage);
+		for (const { lang, q } of languages) {
+			if (q === 0) continue;
+			const normalizedLang = normalizeLanguage(lang, options);
+			if (normalizedLang) return normalizedLang;
+		}
+		return;
+	} catch {
+		return;
+	}
 }
+/**
+* Detects language from URL path
+*/
 function detectFromPath(c, options) {
-  const url = new URL(c.req.url);
-  const pathSegments = url.pathname.split("/").filter(Boolean);
-  const langSegment = pathSegments[options.lookupFromPathIndex];
-  return normalizeLanguage(langSegment, options);
+	const langSegment = new URL(c.req.url).pathname.split("/").filter(Boolean)[options.lookupFromPathIndex];
+	return normalizeLanguage(langSegment, options);
 }
-var detectors = {
-  querystring: detectFromQuery,
-  cookie: detectFromCookie,
-  header: detectFromHeader,
-  path: detectFromPath
+/**
+* Collection of all language detection strategies
+*/
+const detectors = {
+	querystring: detectFromQuery,
+	cookie: detectFromCookie,
+	header: detectFromHeader,
+	path: detectFromPath
 };
+/**
+* Validate detector options
+* @param options Detector options to validate
+* @throws Error if options are invalid
+*/
 function validateOptions(options) {
-  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
-    throw new Error("Fallback language must be included in supported languages");
-  }
-  if (options.lookupFromPathIndex < 0) {
-    throw new Error("Path index must be non-negative");
-  }
-  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
-    throw new Error("Invalid detector type in order array");
-  }
+	if (!options.supportedLanguages.includes(options.fallbackLanguage)) throw new Error("Fallback language must be included in supported languages");
+	if (options.lookupFromPathIndex < 0) throw new Error("Path index must be non-negative");
+	if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) throw new Error("Invalid detector type in order array");
 }
+/**
+* Cache detected language
+*/
 function cacheLanguage(c, language, options) {
-  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
-    return;
-  }
-  try {
-    setCookie(c, options.lookupCookie, language, options.cookieOptions);
-  } catch (error) {
-    if (options.debug) {
-      console.error("Failed to cache language:", error);
-    }
-  }
+	if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) return;
+	try {
+		setCookie(c, options.lookupCookie, language, options.cookieOptions);
+	} catch (error) {
+		if (options.debug) console.error("Failed to cache language:", error);
+	}
 }
-var detectLanguage = (c, options) => {
-  let detectedLang;
-  for (const detectorName of options.order) {
-    const detector = detectors[detectorName];
-    try {
-      detectedLang = detector(c, options);
-      if (detectedLang) {
-        if (options.debug) {
-          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
-        }
-        break;
-      }
-    } catch (error) {
-      if (options.debug) {
-        console.error(`Error in ${detectorName} detector:`, error);
-      }
-      continue;
-    }
-  }
-  const finalLang = detectedLang || options.fallbackLanguage;
-  if (detectedLang && options.caches) {
-    cacheLanguage(c, finalLang, options);
-  }
-  return finalLang;
+/**
+* Detect language from request
+*/
+const detectLanguage = (c, options) => {
+	let detectedLang;
+	for (const detectorName of options.order) {
+		const detector = detectors[detectorName];
+		try {
+			detectedLang = detector(c, options);
+			if (detectedLang) {
+				if (options.debug) console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+				break;
+			}
+		} catch (error) {
+			if (options.debug) console.error(`Error in ${detectorName} detector:`, error);
+			continue;
+		}
+	}
+	const finalLang = detectedLang || options.fallbackLanguage;
+	if (detectedLang && options.caches) cacheLanguage(c, finalLang, options);
+	return finalLang;
 };
-var languageDetector = (userOptions) => {
-  const options = {
-    ...DEFAULT_OPTIONS,
-    ...userOptions,
-    cookieOptions: {
-      ...DEFAULT_OPTIONS.cookieOptions,
-      ...userOptions.cookieOptions
-    }
-  };
-  validateOptions(options);
-  return async function languageDetector2(ctx, next) {
-    const lang = detectLanguage(ctx, options);
-    ctx.set("language", lang);
-    await next();
-  };
-};
-export {
-  DEFAULT_OPTIONS,
-  detectFromCookie,
-  detectFromHeader,
-  detectFromPath,
-  detectFromQuery,
-  detectors,
-  languageDetector,
-  normalizeLanguage,
-  parseAcceptLanguage,
-  validateOptions
+/**
+* Language detector middleware factory
+* @param userOptions Configuration options for the language detector
+* @returns Hono middleware function
+*
+* @example
+* ```ts
+* type Variables = LanguageVariables
+* const app = new Hono<{ Variables: Variables }>()
+*
+* app.use(
+*   languageDetector({
+*     supportedLanguages: ['en', 'ja'], // Must include fallback
+*     fallbackLanguage: 'en', // Required
+*   })
+* )
+*
+* app.get('/', (c) => {
+*   const lang = c.get('language')
+*   return c.text(`Current language: ${lang}`)
+* })
+* ```
+*/
+const languageDetector = (userOptions) => {
+	const options = {
+		...DEFAULT_OPTIONS,
+		...userOptions,
+		cookieOptions: {
+			...DEFAULT_OPTIONS.cookieOptions,
+			...userOptions.cookieOptions
+		}
+	};
+	validateOptions(options);
+	return async function languageDetector(ctx, next) {
+		const lang = detectLanguage(ctx, options);
+		ctx.set("language", lang);
+		await next();
+	};
 };
+//#endregion
+export { DEFAULT_OPTIONS, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, detectors, languageDetector, normalizeLanguage, parseAcceptLanguage, validateOptions };