hono 4.6.19 → 4.7.0

package/dist/adapter/lambda-edge/handler.js

@@ -5,7 +5,10 @@ globalThis.crypto ??= crypto;
 var convertHeaders = (headers) => {
   const cfHeaders = {};
   headers.forEach((value, key) => {
-    cfHeaders[key.toLowerCase()] = [{ key: key.toLowerCase(), value }];
+    cfHeaders[key.toLowerCase()] = [
+      ...cfHeaders[key.toLowerCase()] || [],
+      { key: key.toLowerCase(), value }
+    ];
   });
   return cfHeaders;
 };
@@ -36,7 +39,8 @@ var createResult = async (res) => {
 };
 var createRequest = (event) => {
   const queryString = event.Records[0].cf.request.querystring;
-  const urlPath = `https://${event.Records[0].cf.config.distributionDomainName}${event.Records[0].cf.request.uri}`;
+  const host = event.Records[0].cf.request.headers?.host?.[0]?.value || event.Records[0].cf.config.distributionDomainName;
+  const urlPath = `https://${host}${event.Records[0].cf.request.uri}`;
   const url = queryString ? `${urlPath}?${queryString}` : urlPath;
   const headers = new Headers();
   Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {

package/dist/cjs/adapter/lambda-edge/handler.js

@@ -35,7 +35,10 @@ globalThis.crypto ??= import_node_crypto.default;
 const convertHeaders = (headers) => {
   const cfHeaders = {};
   headers.forEach((value, key) => {
-    cfHeaders[key.toLowerCase()] = [{ key: key.toLowerCase(), value }];
+    cfHeaders[key.toLowerCase()] = [
+      ...cfHeaders[key.toLowerCase()] || [],
+      { key: key.toLowerCase(), value }
+    ];
   });
   return cfHeaders;
 };
@@ -66,7 +69,8 @@ const createResult = async (res) => {
 };
 const createRequest = (event) => {
   const queryString = event.Records[0].cf.request.querystring;
-  const urlPath = `https://${event.Records[0].cf.config.distributionDomainName}${event.Records[0].cf.request.uri}`;
+  const host = event.Records[0].cf.request.headers?.host?.[0]?.value || event.Records[0].cf.config.distributionDomainName;
+  const urlPath = `https://${host}${event.Records[0].cf.request.uri}`;
   const url = queryString ? `${urlPath}?${queryString}` : urlPath;
   const headers = new Headers();
   Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {

package/dist/cjs/helper/accepts/accepts.js

@@ -19,31 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var accepts_exports = {};
 __export(accepts_exports, {
   accepts: () => accepts,
-  defaultMatch: () => defaultMatch,
-  parseAccept: () => parseAccept
+  defaultMatch: () => defaultMatch
 });
 module.exports = __toCommonJS(accepts_exports);
-const parseAccept = (acceptHeader) => {
-  const accepts2 = acceptHeader.split(",");
-  return accepts2.map((accept) => {
-    const parts = accept.trim().split(";");
-    const type = parts[0];
-    const params = parts.slice(1);
-    const q = params.find((param) => param.startsWith("q="));
-    const paramsObject = params.reduce((acc, param) => {
-      const keyValue = param.split("=");
-      const key = keyValue[0].trim();
-      const value = keyValue[1].trim();
-      acc[key] = value;
-      return acc;
-    }, {});
-    return {
-      type,
-      params: paramsObject,
-      q: q ? parseFloat(q.split("=")[1]) : 1
-    };
-  });
-};
+var import_accept = require("../../utils/accept");
 const defaultMatch = (accepts2, config) => {
   const { supports, default: defaultSupport } = config;
   const accept = accepts2.sort((a, b) => b.q - a.q).find((accept2) => supports.includes(accept2.type));
@@ -54,13 +33,12 @@ const accepts = (c, options) => {
   if (!acceptHeader) {
     return options.default;
   }
-  const accepts2 = parseAccept(acceptHeader);
+  const accepts2 = (0, import_accept.parseAccept)(acceptHeader);
   const match = options.match || defaultMatch;
   return match(accepts2, options);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   accepts,
-  defaultMatch,
-  parseAccept
+  defaultMatch
 });

package/dist/cjs/helper/factory/index.js

@@ -26,11 +26,15 @@ module.exports = __toCommonJS(factory_exports);
 var import_hono = require("../../hono");
 class Factory {
   initApp;
+  #defaultAppOptions;
   constructor(init) {
     this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
   }
-  createApp = () => {
-    const app = new import_hono.Hono();
+  createApp = (options) => {
+    const app = new import_hono.Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
     if (this.initApp) {
       this.initApp(app);
     }

package/dist/cjs/helper/proxy/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  proxy: () => proxy
+});
+module.exports = __toCommonJS(proxy_exports);
+const hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding"
+];
+const buildRequestInitFromRequest = (request) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers
+  };
+};
+const proxy = async (input, proxyInit) => {
+  const { raw, ...requestInit } = proxyInit ?? {};
+  const req = new Request(
+    input,
+    {
+      ...buildRequestInitFromRequest(raw),
+      ...requestInit
+    }
+  );
+  req.headers.delete("accept-encoding");
+  const res = await fetch(req);
+  const resHeaders = new Headers(res.headers);
+  hopByHopHeaders.forEach((header) => {
+    resHeaders.delete(header);
+  });
+  if (resHeaders.has("content-encoding")) {
+    resHeaders.delete("content-encoding");
+    resHeaders.delete("content-length");
+  }
+  return new Response(res.body, {
+    ...res,
+    headers: resHeaders
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxy
+});

package/dist/cjs/helper/streaming/sse.js

@@ -24,6 +24,7 @@ __export(sse_exports, {
 module.exports = __toCommonJS(sse_exports);
 var import_html = require("../../utils/html");
 var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
 class SSEStreamingApi extends import_stream.StreamingApi {
   constructor(writable, readable) {
     super(writable, readable);
@@ -63,11 +64,13 @@ const contextStash = /* @__PURE__ */ new WeakMap();
 const streamSSE = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream = new SSEStreamingApi(writable, readable);
-  c.req.raw.signal.addEventListener("abort", () => {
-    if (!stream.closed) {
-      stream.abort();
-    }
-  });
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
   contextStash.set(stream.responseReadable, c);
   c.header("Transfer-Encoding", "chunked");
   c.header("Content-Type", "text/event-stream");

package/dist/cjs/helper/streaming/stream.js

@@ -22,15 +22,18 @@ __export(stream_exports, {
 });
 module.exports = __toCommonJS(stream_exports);
 var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
 const contextStash = /* @__PURE__ */ new WeakMap();
 const stream = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream2 = new import_stream.StreamingApi(writable, readable);
-  c.req.raw.signal.addEventListener("abort", () => {
-    if (!stream2.closed) {
-      stream2.abort();
-    }
-  });
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
   contextStash.set(stream2.responseReadable, c);
   (async () => {
     try {

package/dist/cjs/helper/streaming/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  isOldBunVersion: () => isOldBunVersion
+});
+module.exports = __toCommonJS(utils_exports);
+let isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isOldBunVersion
+});

package/dist/cjs/middleware/etag/digest.js

@@ -30,7 +30,7 @@ const mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
-const generateDigest = async (stream) => {
+const generateDigest = async (stream, generator) => {
   if (!stream || !crypto || !crypto.subtle) {
     return null;
   }
@@ -41,12 +41,7 @@ const generateDigest = async (stream) => {
     if (done) {
       break;
     }
-    result = await crypto.subtle.digest(
-      {
-        name: "SHA-1"
-      },
-      mergeBuffers(result, value)
-    );
+    result = await generator(mergeBuffers(result, value));
   }
   if (!result) {
     return null;

package/dist/cjs/middleware/etag/index.js

@@ -37,20 +37,25 @@ function etagMatches(etag2, ifNoneMatch) {
 const etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
+  const generator = options?.generateDigest ?? ((body) => crypto.subtle.digest(
+    {
+      name: "SHA-1"
+    },
+    body
+  ));
   return async function etag2(c, next) {
     const ifNoneMatch = c.req.header("If-None-Match") ?? null;
     await next();
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await (0, import_digest.generateDigest)(res.clone().body);
+      const hash = await (0, import_digest.generateDigest)(res.clone().body, generator);
       if (hash === null) {
         return;
       }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {
-      await c.res.blob();
       c.res = new Response(null, {
         status: 304,
         statusText: "Not Modified",

package/dist/cjs/middleware/jwk/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => import_jwk.jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_jwk = require("./jwk");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

package/dist/cjs/middleware/jwk/jwk.js

@@ -0,0 +1,124 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_cookie = require("../../helper/cookie");
+var import_http_exception = require("../../http-exception");
+var import_jwt = require("../../utils/jwt");
+var import_context = require("../../context");
+const jwk = (options, init) => {
+  if (!options || !(options.keys || options.jwks_uri)) {
+    throw new Error('JWK auth middleware requires options for either "keys" or "jwks_uri" or both');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWK auth middleware requires it.");
+  }
+  return async function jwk2(ctx, next) {
+    const credentials = ctx.req.raw.headers.get("Authorization");
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2) {
+        const errDescription = "invalid credentials structure";
+        throw new import_http_exception.HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = (0, import_cookie.getCookie)(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await (0, import_cookie.getSignedCookie)(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await (0, import_cookie.getSignedCookie)(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new import_http_exception.HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await import_jwt.Jwt.verifyFromJwks(token, options, init);
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new import_http_exception.HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure"
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

package/dist/cjs/middleware/language/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var language_exports = {};
+__export(language_exports, {
+  detectFromCookie: () => import_language.detectFromCookie,
+  detectFromHeader: () => import_language.detectFromHeader,
+  detectFromPath: () => import_language.detectFromPath,
+  detectFromQuery: () => import_language.detectFromQuery,
+  languageDetector: () => import_language.languageDetector
+});
+module.exports = __toCommonJS(language_exports);
+var import_language = require("./language");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+});