@depup/h3 2.0.1-depup.0

package/dist/match.d.mts

@@ -0,0 +1,123 @@
+import { MatchResult, MatchedRouteRule, MatchedRouteRules, NormalizedRouteRules, RuleHandlers } from "./h3.mjs";
+
+interface PreMergedRouteRules {
+  /** The pattern this layer is registered at (params lookup key). */
+  route: string;
+  /**
+   * Containment depth of {@link route}: how many patterns of the rule set
+   * strictly subsume it. Any set of simultaneously matched patterns is a
+   * containment chain (partial overlaps are rejected below), and depth
+   * strictly increases along a chain — if `a` subsumes `b` then every subsumer
+   * of `a` also subsumes `b`, plus `a` itself — so the most specific matched
+   * layer is the one with the highest rank.
+   *
+   * Layer *position* cannot be used for this — see {@link RouteRuleEntry.rank}
+   * for rou3's documented optional-syntax carve-out and what taking the last
+   * layer costs. The chain-cleanliness check below cannot catch that case
+   * either: those pairs are `subset`, not `partial`, so nothing throws and the
+   * compiler's fail-safe fallback never fires.
+   */
+  rank: number;
+  rules: PreMergedRouteRuleEntry[];
+  /**
+   * Rule names this chain reset with `false`, when any. The reset itself is
+   * applied here at build time, so the resolved `rules` cannot show it — but the
+   * cross-reading union has to tell "reset by this path" apart from "never
+   * matched" to stop a broader alternate reading resurrecting a permission
+   * (`mergeMatchedRouteRules`). Plain mode reads the same information off the
+   * `false` entries it merges per request; recording it keeps both modes — and
+   * the compiled table — resolving alike. The pattern that reset a rule is not
+   * kept: the union records the reset at this layer's {@link route}, which is
+   * inside every pattern of its chain, so only a pattern at least that specific
+   * may reinstate the rule — never more than plain mode allows.
+   */
+  resets?: string[];
+}
+interface PreMergedRouteRuleEntry extends RouteRuleEntry {
+  /**
+   * Patterns whose layers contributed to this rule (chain order), when different
+   * from `[route]` — used to merge exact per-rule `params` from only the layers
+   * that carried the rule.
+   */
+  paramRoutes?: string[];
+}
+/** Decide whether an alternate path reading may override a matched rule. */
+type RouteOverridePredicate = (currentRoute: string, incomingRoute: string) => boolean;
+/** One normalized rule registered for a route pattern. */
+export interface RouteRuleEntry {
+  name: string;
+  route: string;
+  options: unknown;
+  handler?: MatchedRouteRule["handler"];
+  /**
+   * Pattern-containment depth. Required because rou3 result order is not
+   * containment order for optional/modifier parameters.
+   */
+  rank?: number;
+}
+/** A matched route layer containing rule data and route parameters. */
+export interface RouteRuleLayer {
+  data: RouteRuleEntry[] | PreMergedRouteRules;
+  params?: Record<string, string>;
+}
+/**
+ * Merge served-path and alternate-reading layers. Alternate readings may add
+ * rules but override existing ones only when `canOverride` permits it.
+ */
+export declare function mergeMatchedRouteRules(rawLayers: RouteRuleLayer[] | undefined, altLayers?: readonly (RouteRuleLayer[] | undefined)[], canOverride?: RouteOverridePredicate): MatchedRouteRules;
+export interface RouteRulesMatcherOptions {
+  /**
+   * Base URL prefix for all rule patterns (trailing slash trimmed).
+   */
+  baseURL?: string;
+  /**
+   * Add or override rule handler constructors by name.
+   * Registry defaults are `headers`, `redirect`, `cors`; `cache` and
+   * `proxy` are opt-in (register them from `h3/rules/cache` / `h3/rules/proxy`).
+   * Setting a name to `undefined` makes that rule data-only.
+   */
+  handlers?: RuleHandlers;
+  /**
+   * Pre-merge compatible pattern chains at startup. Throws for partial overlaps
+   * or patterns that cannot be analyzed, such as regex parameters.
+   */
+  preMerge?: boolean;
+}
+export interface MatcherMemoizeOptions {
+  /**
+   * Maximum number of memoized `method + pathname` entries. On overflow the
+   * oldest entry not hit since the eviction hand last passed it is evicted
+   * (SIEVE). `0` (or negative) disables memoization.
+   * @default 1024
+   */
+  max?: number;
+}
+export type RouteRulesMatcher = (method: string, pathname: string) => MatchResult;
+/** A `findAllRoutes`-compatible lookup, as produced by `rou3/compiler` codegen. */
+export type FindRouteRules = (method: string, pathname: string) => RouteRuleLayer[];
+/**
+ * Create a route-rules matcher from a **normalized** rule set (see {@link normalizeRouteRules}).
+ * Returns `(method, pathname) => { routeRules, matchedRules, routeRuleMiddleware }`.
+ */
+export declare function createRouteRulesMatcher(rules: Record<string, NormalizedRouteRules>, opts?: RouteRulesMatcherOptions): RouteRulesMatcher;
+/**
+ * Create a matcher from a `findAllRoutes`-compatible lookup, typically generated
+ * by `h3/rules/compiler`.
+ *
+ * Results are not memoized. The default override guard fails closed when route
+ * specificity is ambiguous.
+ */
+export declare function createMatcherFromFind(findRouteRules: FindRouteRules, canOverride?: RouteOverridePredicate): RouteRulesMatcher;
+/**
+ * Memoize matches by method and pathname with a 1024-entry cap by default.
+ * Returned objects are shared and must be treated as immutable.
+ *
+ * Eviction is SIEVE: insertion-ordered like a FIFO, but an entry hit since the
+ * hand last passed it survives that pass. Plain FIFO evicts a hot static path
+ * on the same schedule as the one-shot dynamic paths that displaced it, so a
+ * mixed workload (a small hot set plus high-cardinality `/:id` traffic) loses
+ * cached entries it is about to ask for again. Unlike LRU this costs no map
+ * mutation on a hit — only a boolean store — which keeps the hot path the
+ * single lookup the memo exists to provide.
+ */
+export declare function memoizeRouteRulesMatcher(matcher: RouteRulesMatcher, opts?: MatcherMemoizeOptions): RouteRulesMatcher;

package/dist/middleware.mjs

@@ -0,0 +1,123 @@
+import { kNotFound, normalizeRoute } from "./response.mjs";
+import { addRoute, createRouter, findRoute } from "rou3";
+const LITERAL_ROUTE_RE = /^(?:\/[^/:*(){}\\?^\0- "#<>`\x7F-\uFFFF]+)*\/?$/;
+const LITERAL_PREFIX_ROUTE_RE = /^((?:\/[^/:*(){}\\?^\0- "#<>`\x7F-\uFFFF]+)*)\/\*\*\/?$/;
+function createRouteMatcher(route) {
+	if (route.charCodeAt(0) !== 47) route = `/${route}`;
+	const prefixMatch = LITERAL_PREFIX_ROUTE_RE.exec(route);
+	if (prefixMatch) {
+		const base = prefixMatch[1];
+		const prefix = `${base}/`;
+		return (pathname) => {
+			if (pathname === base || pathname === prefix) return;
+			if (!pathname.startsWith(prefix)) return false;
+			const rest = trimTrailingSlash(pathname.slice(prefix.length));
+			return {
+				0: rest,
+				_: rest
+			};
+		};
+	}
+	if (LITERAL_ROUTE_RE.test(route)) {
+		const base = route.endsWith("/") ? route.slice(0, -1) : route;
+		return (pathname) => pathname === base || pathname === `${base}/` ? void 0 : false;
+	}
+	const router = createRouter();
+	addRoute(router, "", route, true);
+	return (pathname) => {
+		const match = findRoute(router, "", pathname);
+		return match ? match.params : false;
+	};
+}
+function trimTrailingSlash(rest) {
+	return rest.endsWith("/") ? rest.slice(0, -1) : rest;
+}
+function defineMiddleware(input) {
+	return input;
+}
+function normalizeMiddleware(input, opts = {}) {
+	const matcher = createMatcher(opts);
+	if (!matcher && (input.length > 1 || input.constructor?.name === "AsyncFunction")) return input;
+	return (event, next) => {
+		if (matcher && !matcher(event)) return next();
+		const res = input(event, next);
+		return res === void 0 || res === kNotFound ? next() : res;
+	};
+}
+function createMatcher(opts) {
+	if (!opts.route && !opts.method && !opts.match) return;
+	const routeMatcher = opts.route ? createRouteMatcher(normalizeRoute(opts.route)) : void 0;
+	const method = opts.method?.toUpperCase();
+	return function _middlewareMatcher(event) {
+		if (method) {
+			const reqMethod = event.req.method.toUpperCase();
+			if (reqMethod !== method && !(method === "GET" && reqMethod === "HEAD")) return false;
+		}
+		if (opts.match && !opts.match(event)) return false;
+		if (!routeMatcher) return true;
+		const params = routeMatcher(event.url.pathname);
+		if (params === false) return false;
+		if (params) event.context.middlewareParams = {
+			...event.context.middlewareParams,
+			...params
+		};
+		return true;
+	};
+}
+function composeMiddleware(middleware) {
+	let chain = (event, handler) => handler(event);
+	for (let i = middleware.length - 1; i >= 0; i--) {
+		const fn = middleware[i];
+		const inner = chain;
+		chain = (event, handler) => callLayer(fn, event, handler, inner);
+	}
+	return chain;
+}
+function composeHandler(middleware, handler) {
+	const chain = composeMiddleware(middleware);
+	return function _composedHandler(event) {
+		return chain(event, handler);
+	};
+}
+function callMiddleware(event, middleware, handler, index = 0) {
+	return index === middleware.length ? handler(event) : callLayer(middleware[index], event, handler, (_event, _handler) => callMiddleware(_event, middleware, _handler, index + 1));
+}
+function callLayer(fn, event, handler, inner) {
+	let nextCalled;
+	let nextResult;
+	const next = () => {
+		if (nextCalled) return nextResult;
+		nextCalled = true;
+		nextResult = inner(event, handler);
+		return nextResult;
+	};
+	const ret = fn(event, next);
+	return isUnhandledResponse(ret) ? next() : typeof ret?.then === "function" ? ret.then((resolved) => isUnhandledResponse(resolved) ? next() : resolved) : ret;
+}
+function isUnhandledResponse(val) {
+	return val === void 0 || val === kNotFound;
+}
+function toMiddleware(input) {
+	let h = input.handler || input;
+	let isFunction = typeof h === "function";
+	if (!isFunction && typeof input?.fetch === "function") {
+		isFunction = true;
+		h = function _fetchHandler(event) {
+			return input.fetch(event.req);
+		};
+	}
+	if (!isFunction) return function noopMiddleware(event, next) {
+		return next();
+	};
+	if (h.length === 2) return h;
+	return function _middlewareHandler(event, next) {
+		const res = h(event);
+		return typeof res?.then === "function" ? res.then((r) => {
+			return is404(r) ? next() : r;
+		}) : is404(res) ? next() : res;
+	};
+}
+function is404(val) {
+	return isUnhandledResponse(val) || val?.status === 404 && val instanceof Response;
+}
+export { callMiddleware, composeHandler, composeMiddleware, defineMiddleware, normalizeMiddleware, toMiddleware };