@withbuddi/buddi 0.1.0-pre.21 → 0.1.0-pre.22

package/node_modules/hono/dist/cjs/middleware/cache/index.js

@@ -1,219 +1,173 @@
-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 cache_exports = {};
-__export(cache_exports, {
-  cache: () => cache
-});
-module.exports = __toCommonJS(cache_exports);
-var import_request = require("../../request");
-var import_crypto = require("../../utils/crypto");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils_crypto = require("../../utils/crypto.js");
+const require_request = require("../../request.js");
+//#region src/middleware/cache/index.ts
+/**
+* status codes that can be cached by default.
+*/
 const defaultCacheableStatusCodes = [200];
-const defaultMaxQueryBodySize = 64 * 1024;
+const defaultMaxQueryBodySize = 65536;
 const cacheKeyPath = "/.hono/cache";
 const cacheKeyParameter = "__hono_cache_key";
 const cacheMethodKeyParameter = "__hono_cache_method";
 const queryDigestKeyParameter = "__hono_query_digest";
 const cacheVaryKeyParameter = "__hono_cache_vary";
 const queryRepresentationMetadataHeaders = [
-  "content-type",
-  "content-encoding",
-  "content-language",
-  "content-location"
+	"content-type",
+	"content-encoding",
+	"content-language",
+	"content-location"
 ];
 const shouldSkipCacheControl = (cacheControl) => !!cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl);
 const parseVaryDirectives = (vary) => {
-  if (vary == null) {
-    return [];
-  }
-  return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
+	if (vary == null) return [];
+	return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
 };
 const createCacheKey = (key, requestUrl, request, varyHeaders) => {
-  const url = new URL(cacheKeyPath, requestUrl);
-  url.searchParams.append(cacheKeyParameter, key);
-  url.searchParams.append(cacheMethodKeyParameter, request.method);
-  if (request.method === "QUERY") {
-    url.searchParams.append(queryDigestKeyParameter, request.digest);
-  }
-  for (const header of varyHeaders) {
-    url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
-  }
-  return url.href;
+	const url = new URL(cacheKeyPath, requestUrl);
+	url.searchParams.append(cacheKeyParameter, key);
+	url.searchParams.append(cacheMethodKeyParameter, request.method);
+	if (request.method === "QUERY") url.searchParams.append(queryDigestKeyParameter, request.digest);
+	for (const header of varyHeaders) url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
+	return url.href;
 };
 const shouldSkipCache = (res, optionsVaryDirectives, responseVary) => responseVary.length && (!optionsVaryDirectives || responseVary.some((name) => !optionsVaryDirectives.has(name))) || shouldSkipCacheControl(res.headers.get("Cache-Control")) || res.headers.has("Set-Cookie");
 const reportCacheNotAvailable = (onCacheNotAvailable, reason) => {
-  if (onCacheNotAvailable === false) {
-  } else if (onCacheNotAvailable) {
-    onCacheNotAvailable(reason);
-  } else {
-    console.log(reason);
-  }
+	if (onCacheNotAvailable === false) {} else if (onCacheNotAvailable) onCacheNotAvailable(reason);
+	else console.log(reason);
 };
 const createQueryDigest = async (c, maxQueryBodySize) => {
-  if (!globalThis.crypto?.subtle) {
-    return void 0;
-  }
-  if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") {
-    return void 0;
-  }
-  try {
-    const requestHeaders = c.req.raw.headers;
-    const metadata = new TextEncoder().encode(
-      JSON.stringify(
-        queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])
-      )
-    );
-    const body = (await (0, import_request.cloneRawRequest)(c.req)).body;
-    const chunks = [];
-    let bodySize = 0;
-    if (body) {
-      const reader = body.getReader();
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        bodySize += value.byteLength;
-        if (bodySize > maxQueryBodySize) {
-          void reader.cancel().catch(() => {
-          });
-          return void 0;
-        }
-        chunks.push(value);
-      }
-    }
-    const data = new Uint8Array(metadata.byteLength + bodySize);
-    data.set(metadata);
-    let offset = metadata.byteLength;
-    for (const chunk of chunks) {
-      data.set(chunk, offset);
-      offset += chunk.byteLength;
-    }
-    return await (0, import_crypto.sha256)(data) ?? void 0;
-  } catch {
-    return void 0;
-  }
+	if (!globalThis.crypto?.subtle) return;
+	if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") return;
+	try {
+		const requestHeaders = c.req.raw.headers;
+		const metadata = new TextEncoder().encode(JSON.stringify(queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])));
+		const body = (await require_request.cloneRawRequest(c.req)).body;
+		const chunks = [];
+		let bodySize = 0;
+		if (body) {
+			const reader = body.getReader();
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				bodySize += value.byteLength;
+				if (bodySize > maxQueryBodySize) {
+					reader.cancel().catch(() => {});
+					return;
+				}
+				chunks.push(value);
+			}
+		}
+		const data = new Uint8Array(metadata.byteLength + bodySize);
+		data.set(metadata);
+		let offset = metadata.byteLength;
+		for (const chunk of chunks) {
+			data.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return await require_utils_crypto.sha256(data) ?? void 0;
+	} catch {
+		return;
+	}
 };
+/**
+* Cache Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/cache}
+*
+* @param {Object} options - The options for the cache middleware.
+* @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+* @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+* @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+* @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+* @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters. QUERY keys additionally include a digest of the request content and its representation metadata.
+* @param {number} [options.maxQueryBodySize=65536] - The maximum QUERY request body size in bytes that can be cached. Larger QUERY requests bypass the cache.
+* @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
+* @param {Function | false} [options.onCacheNotAvailable] - A callback invoked with the reason when `globalThis.caches` is not available or QUERY caching cannot use Web Crypto. By default, the reason is logged to the console. Set to `false` to suppress the log, or provide a custom function.
+* @returns {MiddlewareHandler} The middleware handler function.
+* @throws {Error} If the `vary` option includes "*".
+*
+* @example
+* ```ts
+* app.use(
+*   '*',
+*   cache({
+*     cacheName: 'my-app',
+*     cacheControl: 'max-age=3600',
+*   })
+* )
+* ```
+*/
 const cache = (options) => {
-  if (!globalThis.caches) {
-    reportCacheNotAvailable(
-      options.onCacheNotAvailable,
-      "Cache Middleware is not enabled because caches is not defined."
-    );
-    return async (_c, next) => await next();
-  }
-  if (!globalThis.crypto?.subtle) {
-    reportCacheNotAvailable(
-      options.onCacheNotAvailable,
-      "Cache Middleware cannot cache QUERY requests because Web Crypto is not available."
-    );
-  }
-  if (options.wait === void 0) {
-    options.wait = false;
-  }
-  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
-  const optionsVaryList = parseVaryDirectives(options.vary);
-  const varyDirectives = optionsVaryList.length ? new Set(optionsVaryList) : void 0;
-  if (varyDirectives?.has("*")) {
-    throw new Error(
-      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
-    );
-  }
-  const cacheableStatusCodes = new Set(
-    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
-  );
-  const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
-  const addHeader = (c, responseVary) => {
-    if (cacheControlDirectives) {
-      const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
-      for (const directive of cacheControlDirectives) {
-        let [name, value] = directive.trim().split("=", 2);
-        name = name.toLowerCase();
-        if (!existingDirectives.includes(name)) {
-          c.header("Cache-Control", `${name}${value ? `=${value}` : ""}`, { append: true });
-        }
-      }
-    }
-    if (varyDirectives) {
-      if (responseVary.length === 0) {
-        c.header("Vary", Array.from(varyDirectives).join(", "));
-      } else {
-        const merged = new Set(varyDirectives);
-        for (const directive of responseVary) {
-          merged.add(directive);
-        }
-        if (merged.has("*")) {
-          c.header("Vary", "*");
-        } else {
-          c.header("Vary", Array.from(merged).join(", "));
-        }
-      }
-    }
-  };
-  return async function cache2(c, next) {
-    if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
-      await next();
-      return;
-    }
-    let cacheKeyRequest = { method: "GET" };
-    if (c.req.method === "QUERY") {
-      const digest = await createQueryDigest(c, maxQueryBodySize);
-      if (digest === void 0) {
-        await next();
-        return;
-      }
-      cacheKeyRequest = { method: "QUERY", digest };
-    }
-    let key = c.req.url;
-    if (options.keyGenerator) {
-      key = await options.keyGenerator(c);
-    }
-    const varyHeaders = [];
-    if (varyDirectives) {
-      for (const directive of varyDirectives) {
-        const value = c.req.raw.headers.get(directive) ?? "";
-        varyHeaders.push([directive, value]);
-      }
-    }
-    key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
-    const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
-    const cache3 = await caches.open(cacheName);
-    const response = await cache3.match(key);
-    if (response) {
-      return new Response(response.body, response);
-    }
-    await next();
-    if (!cacheableStatusCodes.has(c.res.status)) {
-      return;
-    }
-    const responseVary = parseVaryDirectives(c.res.headers.get("Vary"));
-    addHeader(c, responseVary);
-    if (shouldSkipCache(c.res, varyDirectives, responseVary)) {
-      return;
-    }
-    const res = c.res.clone();
-    if (options.wait) {
-      await cache3.put(key, res);
-    } else {
-      c.executionCtx.waitUntil(cache3.put(key, res));
-    }
-  };
+	if (!globalThis.caches) {
+		reportCacheNotAvailable(options.onCacheNotAvailable, "Cache Middleware is not enabled because caches is not defined.");
+		return async (_c, next) => await next();
+	}
+	if (!globalThis.crypto?.subtle) reportCacheNotAvailable(options.onCacheNotAvailable, "Cache Middleware cannot cache QUERY requests because Web Crypto is not available.");
+	if (options.wait === void 0) options.wait = false;
+	const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+	const optionsVaryList = parseVaryDirectives(options.vary);
+	const varyDirectives = optionsVaryList.length ? new Set(optionsVaryList) : void 0;
+	if (varyDirectives?.has("*")) throw new Error("Middleware vary configuration cannot include \"*\", as it disallows effective caching.");
+	const cacheableStatusCodes = new Set(options.cacheableStatusCodes ?? defaultCacheableStatusCodes);
+	const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
+	const addHeader = (c, responseVary) => {
+		if (cacheControlDirectives) {
+			const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
+			for (const directive of cacheControlDirectives) {
+				let [name, value] = directive.trim().split("=", 2);
+				name = name.toLowerCase();
+				if (!existingDirectives.includes(name)) c.header("Cache-Control", `${name}${value ? `=${value}` : ""}`, { append: true });
+			}
+		}
+		if (varyDirectives) {
+			if (responseVary.length === 0) c.header("Vary", Array.from(varyDirectives).join(", "));
+			else {
+				const merged = new Set(varyDirectives);
+				for (const directive of responseVary) merged.add(directive);
+				if (merged.has("*")) c.header("Vary", "*");
+				else c.header("Vary", Array.from(merged).join(", "));
+			}
+		}
+	};
+	return async function cache(c, next) {
+		if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
+			await next();
+			return;
+		}
+		let cacheKeyRequest = { method: "GET" };
+		if (c.req.method === "QUERY") {
+			const digest = await createQueryDigest(c, maxQueryBodySize);
+			if (digest === void 0) {
+				await next();
+				return;
+			}
+			cacheKeyRequest = {
+				method: "QUERY",
+				digest
+			};
+		}
+		let key = c.req.url;
+		if (options.keyGenerator) key = await options.keyGenerator(c);
+		const varyHeaders = [];
+		if (varyDirectives) for (const directive of varyDirectives) {
+			const value = c.req.raw.headers.get(directive) ?? "";
+			varyHeaders.push([directive, value]);
+		}
+		key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
+		const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
+		const cache = await caches.open(cacheName);
+		const response = await cache.match(key);
+		if (response) return new Response(response.body, response);
+		await next();
+		if (!cacheableStatusCodes.has(c.res.status)) return;
+		const responseVary = parseVaryDirectives(c.res.headers.get("Vary"));
+		addHeader(c, responseVary);
+		if (shouldSkipCache(c.res, varyDirectives, responseVary)) return;
+		const res = c.res.clone();
+		if (options.wait) await cache.put(key, res);
+		else c.executionCtx.waitUntil(cache.put(key, res));
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cache
-});
+//#endregion
+exports.cache = cache;

package/node_modules/hono/dist/cjs/middleware/combine/index.js

@@ -1,101 +1,139 @@
-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, except2, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except2)
-        __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 combine_exports = {};
-__export(combine_exports, {
-  every: () => every,
-  except: () => except,
-  some: () => some
-});
-module.exports = __toCommonJS(combine_exports);
-var import_compose = require("../../compose");
-var import_router = require("../../router");
-var import_trie_router = require("../../router/trie-router");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_compose = require("../../compose.js");
+require("../../router.js");
+const require_router_trie_router_router = require("../../router/trie-router/router.js");
+require("../../router/trie-router/index.js");
+//#region src/middleware/combine/index.ts
+/**
+* @module
+* Combine Middleware for Hono.
+*/
+/**
+* Create a composed middleware that runs the first middleware that returns true.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware exits without returning
+* an exception first, subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns true
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client has a valid token, then skip rate limiting.
+* // Otherwise, apply rate limiting.
+* app.use('/api/*', some(
+*   bearerAuth({ token }),
+*   myRateLimit({ limit: 100 }),
+* ));
+* ```
+*/
 const some = (...middleware) => {
-  return async function some2(c, next) {
-    let isNextCalled = false;
-    const wrappedNext = () => {
-      isNextCalled = true;
-      return next();
-    };
-    let lastError;
-    for (const handler of middleware) {
-      try {
-        const result = await handler(c, wrappedNext);
-        if (result === true && !c.finalized) {
-          await wrappedNext();
-        } else if (result === false) {
-          lastError = new Error("No successful middleware found");
-          continue;
-        }
-        lastError = void 0;
-        break;
-      } catch (error) {
-        lastError = error;
-        if (isNextCalled) {
-          break;
-        }
-      }
-    }
-    if (lastError) {
-      throw lastError;
-    }
-  };
+	return async function some(c, next) {
+		let isNextCalled = false;
+		const wrappedNext = () => {
+			isNextCalled = true;
+			return next();
+		};
+		let lastError;
+		for (const handler of middleware) try {
+			const result = await handler(c, wrappedNext);
+			if (result === true && !c.finalized) await wrappedNext();
+			else if (result === false) {
+				lastError = /* @__PURE__ */ new Error("No successful middleware found");
+				continue;
+			}
+			lastError = void 0;
+			break;
+		} catch (error) {
+			lastError = error;
+			if (isNextCalled) break;
+		}
+		if (lastError) throw lastError;
+	};
 };
+/**
+* Create a composed middleware that runs all middleware and throws an error if any of them fail.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware throws an error,
+* subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns false
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some, every } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+* import { myCheckLocalNetwork } from '@/check-local-network'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client is in local network, then skip authentication and rate limiting.
+* // Otherwise, apply authentication and rate limiting.
+* app.use('/api/*', some(
+*   myCheckLocalNetwork(),
+*   every(
+*     bearerAuth({ token }),
+*     myRateLimit({ limit: 100 }),
+*   ),
+* ));
+* ```
+*/
 const every = (...middleware) => {
-  return async function every2(c, next) {
-    const currentRouteIndex = c.req.routeIndex;
-    await (0, import_compose.compose)(
-      middleware.map((m) => [
-        [
-          async (c2, next2) => {
-            c2.req.routeIndex = currentRouteIndex;
-            const res = await m(c2, next2);
-            if (res === false) {
-              throw new Error("Unmet condition");
-            }
-            return res;
-          }
-        ]
-      ])
-    )(c, next);
-  };
+	return async function every(c, next) {
+		const currentRouteIndex = c.req.routeIndex;
+		await require_compose.compose(middleware.map((m) => [[async (c, next) => {
+			c.req.routeIndex = currentRouteIndex;
+			const res = await m(c, next);
+			if (res === false) throw new Error("Unmet condition");
+			return res;
+		}]]))(c, next);
+	};
 };
+/**
+* Create a composed middleware that runs all middleware except when the condition is met.
+*
+* @param condition - A string or Condition function.
+* If there are multiple targets to match any of them, they can be passed as an array.
+* If a string is passed, it will be treated as a path pattern to match.
+* If a Condition function is passed, it will be evaluated against the request context.
+* @param middleware - Middleware to run when the condition is not met.
+* Multiple middleware can be passed, and they are applied in the order they are passed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { except } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+*
+* // If client is accessing public API, then skip authentication.
+* // Otherwise, require a valid token.
+* app.use('/api/*', except(
+*   '/api/public/*',
+*   bearerAuth({ token }),
+* ));
+* ```
+*/
 const except = (condition, ...middleware) => {
-  let router = void 0;
-  const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition2) => {
-    if (typeof condition2 === "string") {
-      router ||= new import_trie_router.TrieRouter();
-      router.add(import_router.METHOD_NAME_ALL, condition2, true);
-    } else {
-      return condition2;
-    }
-  }).filter(Boolean);
-  if (router) {
-    conditions.unshift((c) => !!router?.match(import_router.METHOD_NAME_ALL, c.req.path)?.[0]?.[0]?.[0]);
-  }
-  const handler = some((c) => conditions.some((cond) => cond(c)), every(...middleware));
-  return async function except2(c, next) {
-    await handler(c, next);
-  };
+	let router = void 0;
+	const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition) => {
+		if (typeof condition === "string") {
+			router ||= new require_router_trie_router_router.TrieRouter();
+			router.add("ALL", condition, true);
+		} else return condition;
+	}).filter(Boolean);
+	if (router) conditions.unshift((c) => !!router?.match("ALL", c.req.path)?.[0]?.[0]?.[0]);
+	const handler = some((c) => conditions.some((cond) => cond(c)), every(...middleware));
+	return async function except(c, next) {
+		await handler(c, next);
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  every,
-  except,
-  some
-});
+//#endregion
+exports.every = every;
+exports.except = except;
+exports.some = some;