@depup/hono 4.12.8-depup.0

package/dist/middleware/cors/index.js

@@ -0,0 +1,87 @@
+// src/middleware/cors/index.ts
+var cors = (options) => {
+  const defaults = {
+    origin: "*",
+    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowHeaders: [],
+    exposeHeaders: []
+  };
+  const opts = {
+    ...defaults,
+    ...options
+  };
+  const findAllowOrigin = ((optsOrigin) => {
+    if (typeof optsOrigin === "string") {
+      if (optsOrigin === "*") {
+        return () => optsOrigin;
+      } else {
+        return (origin) => optsOrigin === origin ? origin : null;
+      }
+    } else if (typeof optsOrigin === "function") {
+      return optsOrigin;
+    } else {
+      return (origin) => optsOrigin.includes(origin) ? origin : null;
+    }
+  })(opts.origin);
+  const findAllowMethods = ((optsAllowMethods) => {
+    if (typeof optsAllowMethods === "function") {
+      return optsAllowMethods;
+    } else if (Array.isArray(optsAllowMethods)) {
+      return () => optsAllowMethods;
+    } else {
+      return () => [];
+    }
+  })(opts.allowMethods);
+  return async function cors2(c, next) {
+    function set(key, value) {
+      c.res.headers.set(key, value);
+    }
+    const allowOrigin = await findAllowOrigin(c.req.header("origin") || "", c);
+    if (allowOrigin) {
+      set("Access-Control-Allow-Origin", allowOrigin);
+    }
+    if (opts.credentials) {
+      set("Access-Control-Allow-Credentials", "true");
+    }
+    if (opts.exposeHeaders?.length) {
+      set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
+    }
+    if (c.req.method === "OPTIONS") {
+      if (opts.origin !== "*") {
+        set("Vary", "Origin");
+      }
+      if (opts.maxAge != null) {
+        set("Access-Control-Max-Age", opts.maxAge.toString());
+      }
+      const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
+      if (allowMethods.length) {
+        set("Access-Control-Allow-Methods", allowMethods.join(","));
+      }
+      let headers = opts.allowHeaders;
+      if (!headers?.length) {
+        const requestHeaders = c.req.header("Access-Control-Request-Headers");
+        if (requestHeaders) {
+          headers = requestHeaders.split(/\s*,\s*/);
+        }
+      }
+      if (headers?.length) {
+        set("Access-Control-Allow-Headers", headers.join(","));
+        c.res.headers.append("Vary", "Access-Control-Request-Headers");
+      }
+      c.res.headers.delete("Content-Length");
+      c.res.headers.delete("Content-Type");
+      return new Response(null, {
+        headers: c.res.headers,
+        status: 204,
+        statusText: "No Content"
+      });
+    }
+    await next();
+    if (opts.origin !== "*") {
+      c.header("Vary", "Origin", { append: true });
+    }
+  };
+};
+export {
+  cors
+};

package/dist/middleware/csrf/index.js

@@ -0,0 +1,55 @@
+// src/middleware/csrf/index.ts
+import { HTTPException } from "../../http-exception.js";
+var secFetchSiteValues = ["same-origin", "same-site", "none", "cross-site"];
+var isSecFetchSite = (value) => secFetchSiteValues.includes(value);
+var isSafeMethodRe = /^(GET|HEAD)$/;
+var isRequestedByFormElementRe = /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i;
+var csrf = (options) => {
+  const originHandler = ((optsOrigin) => {
+    if (!optsOrigin) {
+      return (origin, c) => origin === new URL(c.req.url).origin;
+    } else if (typeof optsOrigin === "string") {
+      return (origin) => origin === optsOrigin;
+    } else if (typeof optsOrigin === "function") {
+      return optsOrigin;
+    } else {
+      return (origin) => optsOrigin.includes(origin);
+    }
+  })(options?.origin);
+  const isAllowedOrigin = async (origin, c) => {
+    if (origin === void 0) {
+      return false;
+    }
+    return await originHandler(origin, c);
+  };
+  const secFetchSiteHandler = ((optsSecFetchSite) => {
+    if (!optsSecFetchSite) {
+      return (secFetchSite) => secFetchSite === "same-origin";
+    } else if (typeof optsSecFetchSite === "string") {
+      return (secFetchSite) => secFetchSite === optsSecFetchSite;
+    } else if (typeof optsSecFetchSite === "function") {
+      return optsSecFetchSite;
+    } else {
+      return (secFetchSite) => optsSecFetchSite.includes(secFetchSite);
+    }
+  })(options?.secFetchSite);
+  const isAllowedSecFetchSite = async (secFetchSite, c) => {
+    if (secFetchSite === void 0) {
+      return false;
+    }
+    if (!isSecFetchSite(secFetchSite)) {
+      return false;
+    }
+    return await secFetchSiteHandler(secFetchSite, c);
+  };
+  return async function csrf2(c, next) {
+    if (!isSafeMethodRe.test(c.req.method) && isRequestedByFormElementRe.test(c.req.header("content-type") || "text/plain") && !await isAllowedSecFetchSite(c.req.header("sec-fetch-site"), c) && !await isAllowedOrigin(c.req.header("origin"), c)) {
+      const res = new Response("Forbidden", { status: 403 });
+      throw new HTTPException(403, { res });
+    }
+    await next();
+  };
+};
+export {
+  csrf
+};

package/dist/middleware/etag/digest.js

@@ -0,0 +1,33 @@
+// src/middleware/etag/digest.ts
+var mergeBuffers = (buffer1, buffer2) => {
+  if (!buffer1) {
+    return buffer2;
+  }
+  const merged = new Uint8Array(
+    new ArrayBuffer(buffer1.byteLength + buffer2.byteLength)
+  );
+  merged.set(new Uint8Array(buffer1), 0);
+  merged.set(buffer2, buffer1.byteLength);
+  return merged;
+};
+var generateDigest = async (stream, generator) => {
+  if (!stream) {
+    return null;
+  }
+  let result = void 0;
+  const reader = stream.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    result = await generator(mergeBuffers(result, value));
+  }
+  if (!result) {
+    return null;
+  }
+  return Array.prototype.map.call(new Uint8Array(result), (x) => x.toString(16).padStart(2, "0")).join("");
+};
+export {
+  generateDigest
+};

package/dist/middleware/etag/index.js

@@ -0,0 +1,72 @@
+// src/middleware/etag/index.ts
+import { generateDigest } from "./digest.js";
+var RETAINED_304_HEADERS = [
+  "cache-control",
+  "content-location",
+  "date",
+  "etag",
+  "expires",
+  "vary"
+];
+var stripWeak = (tag) => tag.replace(/^W\//, "");
+function etagMatches(etag2, ifNoneMatch) {
+  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).some((t) => stripWeak(t) === stripWeak(etag2));
+}
+function initializeGenerator(generator) {
+  if (!generator) {
+    if (crypto && crypto.subtle) {
+      generator = (body) => crypto.subtle.digest(
+        {
+          name: "SHA-1"
+        },
+        body
+      );
+    }
+  }
+  return generator;
+}
+var etag = (options) => {
+  const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
+  const weak = options?.weak ?? false;
+  const generator = initializeGenerator(options?.generateDigest);
+  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) {
+      if (!generator) {
+        return;
+      }
+      const hash = await generateDigest(
+        // This type casing avoids the type error for `deno publish`
+        res.clone().body,
+        generator
+      );
+      if (hash === null) {
+        return;
+      }
+      etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
+    }
+    if (etagMatches(etag3, ifNoneMatch)) {
+      c.res = new Response(null, {
+        status: 304,
+        statusText: "Not Modified",
+        headers: {
+          ETag: etag3
+        }
+      });
+      c.res.headers.forEach((_, key) => {
+        if (retainedHeaders.indexOf(key.toLowerCase()) === -1) {
+          c.res.headers.delete(key);
+        }
+      });
+    } else {
+      c.res.headers.set("ETag", etag3);
+    }
+  };
+};
+export {
+  RETAINED_304_HEADERS,
+  etag
+};

package/dist/middleware/ip-restriction/index.js

@@ -0,0 +1,107 @@
+// src/middleware/ip-restriction/index.ts
+import { HTTPException } from "../../http-exception.js";
+import {
+  convertIPv4ToBinary,
+  convertIPv6BinaryToString,
+  convertIPv6ToBinary,
+  distinctRemoteAddr
+} from "../../utils/ipaddr.js";
+var IS_CIDR_NOTATION_REGEX = /\/[0-9]{0,3}$/;
+var buildMatcher = (rules) => {
+  const functionRules = [];
+  const staticRules = /* @__PURE__ */ new Set();
+  const cidrRules = [];
+  for (let rule of rules) {
+    if (rule === "*") {
+      return () => true;
+    } else if (typeof rule === "function") {
+      functionRules.push(rule);
+    } else {
+      if (IS_CIDR_NOTATION_REGEX.test(rule)) {
+        const separatedRule = rule.split("/");
+        const addrStr = separatedRule[0];
+        const type2 = distinctRemoteAddr(addrStr);
+        if (type2 === void 0) {
+          throw new TypeError(`Invalid rule: ${rule}`);
+        }
+        const isIPv4 = type2 === "IPv4";
+        const prefix = parseInt(separatedRule[1]);
+        if (isIPv4 ? prefix === 32 : prefix === 128) {
+          rule = addrStr;
+        } else {
+          const addr = (isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary)(addrStr);
+          const mask = (1n << BigInt(prefix)) - 1n << BigInt((isIPv4 ? 32 : 128) - prefix);
+          cidrRules.push([isIPv4, addr & mask, mask]);
+          continue;
+        }
+      }
+      const type = distinctRemoteAddr(rule);
+      if (type === void 0) {
+        throw new TypeError(`Invalid rule: ${rule}`);
+      }
+      staticRules.add(
+        type === "IPv4" ? rule : convertIPv6BinaryToString(convertIPv6ToBinary(rule))
+        // normalize IPv6 address (e.g. 0000:0000:0000:0000:0000:0000:0000:0001 => ::1)
+      );
+    }
+  }
+  return (remote) => {
+    if (staticRules.has(remote.addr)) {
+      return true;
+    }
+    for (const [isIPv4, addr, mask] of cidrRules) {
+      if (isIPv4 !== remote.isIPv4) {
+        continue;
+      }
+      const remoteAddr = remote.binaryAddr ||= (isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary)(remote.addr);
+      if ((remoteAddr & mask) === addr) {
+        return true;
+      }
+    }
+    for (const rule of functionRules) {
+      if (rule({ addr: remote.addr, type: remote.type })) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+var ipRestriction = (getIP, { denyList = [], allowList = [] }, onError) => {
+  const allowLength = allowList.length;
+  const denyMatcher = buildMatcher(denyList);
+  const allowMatcher = buildMatcher(allowList);
+  const blockError = (c) => new HTTPException(403, {
+    res: c.text("Forbidden", {
+      status: 403
+    })
+  });
+  return async function ipRestriction2(c, next) {
+    const connInfo = getIP(c);
+    const addr = typeof connInfo === "string" ? connInfo : connInfo.remote.address;
+    if (!addr) {
+      throw blockError(c);
+    }
+    const type = typeof connInfo !== "string" && connInfo.remote.addressType || distinctRemoteAddr(addr);
+    const remoteData = { addr, type, isIPv4: type === "IPv4" };
+    if (denyMatcher(remoteData)) {
+      if (onError) {
+        return onError({ addr, type }, c);
+      }
+      throw blockError(c);
+    }
+    if (allowMatcher(remoteData)) {
+      return await next();
+    }
+    if (allowLength === 0) {
+      return await next();
+    } else {
+      if (onError) {
+        return await onError({ addr, type }, c);
+      }
+      throw blockError(c);
+    }
+  };
+};
+export {
+  ipRestriction
+};

package/dist/middleware/jsx-renderer/index.js

@@ -0,0 +1,58 @@
+// src/middleware/jsx-renderer/index.ts
+import { html, raw } from "../../helper/html/index.js";
+import { Fragment, createContext, jsx, useContext } from "../../jsx/index.js";
+import { renderToReadableStream } from "../../jsx/streaming.js";
+var RequestContext = createContext(null);
+var createRenderer = (c, Layout, component, options) => (children, props) => {
+  options = typeof options === "function" ? options(c) : options;
+  const docType = typeof options?.docType === "string" ? options.docType : options?.docType === false ? "" : "<!DOCTYPE html>";
+  const currentLayout = component ? jsx(
+    (props2) => component(props2, c),
+    {
+      Layout,
+      ...props
+    },
+    children
+  ) : children;
+  const body = html`${raw(docType)}${jsx(
+    RequestContext.Provider,
+    { value: c },
+    currentLayout
+  )}`;
+  if (options?.stream) {
+    if (options.stream === true) {
+      c.header("Transfer-Encoding", "chunked");
+      c.header("Content-Type", "text/html; charset=UTF-8");
+      c.header("Content-Encoding", "Identity");
+    } else {
+      for (const [key, value] of Object.entries(options.stream)) {
+        c.header(key, value);
+      }
+    }
+    return c.body(renderToReadableStream(body));
+  } else {
+    return c.html(body);
+  }
+};
+var jsxRenderer = (component, options) => function jsxRenderer2(c, next) {
+  const Layout = c.getLayout() ?? Fragment;
+  if (component) {
+    c.setLayout((props) => {
+      return component({ ...props, Layout }, c);
+    });
+  }
+  c.setRenderer(createRenderer(c, Layout, component, options));
+  return next();
+};
+var useRequestContext = () => {
+  const c = useContext(RequestContext);
+  if (!c) {
+    throw new Error("RequestContext is not provided.");
+  }
+  return c;
+};
+export {
+  RequestContext,
+  jsxRenderer,
+  useRequestContext
+};

package/dist/middleware/jwk/index.js

@@ -0,0 +1,5 @@
+// src/middleware/jwk/index.ts
+import { jwk } from "./jwk.js";
+export {
+  jwk
+};

package/dist/middleware/jwk/jwk.js

@@ -0,0 +1,112 @@
+// src/middleware/jwk/jwk.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.js";
+import { Jwt } from "../../utils/jwt/index.js";
+import "../../context.js";
+var jwk = (options, init) => {
+  const verifyOpts = options.verification || {};
+  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 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) {
+        const errDescription = "invalid credentials structure";
+        throw new 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 = 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) {
+      if (options.allow_anon) {
+        return next();
+      }
+      const errDescription = "no authorization included in request";
+      throw new HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      const keys = typeof options.keys === "function" ? await options.keys(ctx) : options.keys;
+      const jwks_uri = typeof options.jwks_uri === "function" ? await options.jwks_uri(ctx) : options.jwks_uri;
+      payload = await Jwt.verifyWithJwks(
+        token,
+        { keys, jwks_uri, verification: verifyOpts, allowedAlgorithms: options.alg },
+        init
+      );
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new 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}"`
+    }
+  });
+}
+export {
+  jwk
+};

package/dist/middleware/jwt/index.js

@@ -0,0 +1,11 @@
+// src/middleware/jwt/index.ts
+import { jwt, verifyWithJwks, verify, decode, sign } from "./jwt.js";
+import { AlgorithmTypes } from "../../utils/jwt/jwa.js";
+export {
+  AlgorithmTypes,
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+};

package/dist/middleware/jwt/jwt.js

@@ -0,0 +1,114 @@
+// src/middleware/jwt/jwt.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.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) {
+        const errDescription = "invalid credentials structure";
+        throw new 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 = 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
+        })
+      });
+    }
+    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"
+        }),
+        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}"`
+    }
+  });
+}
+var verifyWithJwks = Jwt.verifyWithJwks;
+var verify = Jwt.verify;
+var decode = Jwt.decode;
+var sign = Jwt.sign;
+export {
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+};

package/dist/middleware/language/index.js

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