@ubean/server 0.1.13 → 0.2.0

package/dist/fetch-memo-rbkxxnW4.js

@@ -0,0 +1,338 @@
+//#region src/fetch-memo.ts
+const MEMO_TTL_MS = 0;
+/**
+* 生成 memoization key
+*/
+function memoKey(input, init) {
+	let url;
+	let method = "GET";
+	if (typeof input === "string") url = input;
+	else if (input instanceof URL) url = input.toString();
+	else if (input instanceof Request) {
+		url = input.url;
+		method = input.method;
+	} else url = String(input);
+	if (init?.method) method = init.method.toUpperCase();
+	if (method !== "GET" && method !== "HEAD") return "";
+	if (init?.body) return "";
+	return `${method}:${url}`;
+}
+/**
+* 创建 fetch memoization 中间件
+*
+* 在请求作用域内包装 globalThis.fetch,对相同 GET URL 自动去重
+*/
+function createFetchMemoizationMiddleware(options = {}) {
+	const { exclude } = options;
+	return async function fetchMemoizationMiddleware(c, next) {
+		const ctx = {
+			cache: /* @__PURE__ */ new Map(),
+			originalFetch: globalThis.fetch,
+			patched: false
+		};
+		const patchedFetch = async (input, init) => {
+			const key = memoKey(input, init);
+			if (!key || exclude && exclude(typeof input === "string" ? input : input.toString())) return ctx.originalFetch(input, init);
+			const existing = ctx.cache.get(key);
+			if (existing) return existing.promise.then((res) => res.clone());
+			const promise = ctx.originalFetch(input, init).then((res) => {
+				if (!res.ok && res.status >= 500) ctx.cache.delete(key);
+				return res;
+			});
+			ctx.cache.set(key, {
+				promise,
+				timestamp: Date.now()
+			});
+			return promise;
+		};
+		const prevFetch = globalThis.fetch;
+		globalThis.fetch = patchedFetch;
+		ctx.patched = true;
+		try {
+			await next();
+		} finally {
+			globalThis.fetch = prevFetch;
+			ctx.cache.clear();
+		}
+	};
+}
+/**
+* 手动创建一个 memoized fetch 函数(不依赖中间件/AsyncLocalStorage)
+*
+* 适用于在非请求上下文中手动使用 memoization
+*/
+function createMemoizedFetch(options = {}) {
+	const originalFetch = options.originalFetch || globalThis.fetch.bind(globalThis);
+	const ttl = options.ttl ?? MEMO_TTL_MS;
+	const cache = /* @__PURE__ */ new Map();
+	const memoizedFetch = async (input, init) => {
+		const key = memoKey(input, init);
+		if (!key) return originalFetch(input, init);
+		if (ttl > 0) {
+			const existing = cache.get(key);
+			if (existing && Date.now() - existing.timestamp > ttl) cache.delete(key);
+		}
+		const existing = cache.get(key);
+		if (existing) return existing.promise.then((res) => res.clone());
+		const promise = originalFetch(input, init).then((res) => {
+			if (!res.ok && res.status >= 500) cache.delete(key);
+			return res;
+		});
+		cache.set(key, {
+			promise,
+			timestamp: Date.now()
+		});
+		return promise;
+	};
+	return {
+		fetch: memoizedFetch,
+		clear: () => cache.clear(),
+		size: () => cache.size
+	};
+}
+const DATA_CACHE_MAX_ENTRIES = 1e3;
+/** 不参与缓存键的 header(自动设置、易变)。 */
+const SKIP_HEADER_KEYS = /* @__PURE__ */ new Set([
+	"user-agent",
+	"accept-encoding",
+	"connection",
+	"host",
+	"content-length"
+]);
+/** Data Cache 存储:key → entry */
+const dataCacheStore = /* @__PURE__ */ new Map();
+/** tag → 关联的缓存键集合(反向索引,加速 revalidateTag) */
+const dataCacheTagIndex = /* @__PURE__ */ new Map();
+function dataCacheAddToTagIndex(key, tags) {
+	for (const tag of tags) {
+		let set = dataCacheTagIndex.get(tag);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			dataCacheTagIndex.set(tag, set);
+		}
+		set.add(key);
+	}
+}
+function dataCacheRemoveFromTagIndex(key, tags) {
+	for (const tag of tags) {
+		const set = dataCacheTagIndex.get(tag);
+		if (set) {
+			set.delete(key);
+			if (set.size === 0) dataCacheTagIndex.delete(tag);
+		}
+	}
+}
+function dataCacheEvict() {
+	if (dataCacheStore.size <= DATA_CACHE_MAX_ENTRIES) return;
+	const entries = Array.from(dataCacheStore.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+	const removeCount = Math.ceil(entries.length * .2);
+	for (let i = 0; i < removeCount; i++) {
+		const [key, entry] = entries[i];
+		dataCacheRemoveFromTagIndex(key, entry.tags);
+		dataCacheStore.delete(key);
+	}
+}
+function isDevMode() {
+	return process.env.NODE_ENV !== "production";
+}
+/**
+* 生成 Data Cache 键:`method:url:sorted(headers)`。
+*
+* 排除自动设置/易变的 header(User-Agent / Accept-Encoding / Connection / Host /
+* Content-Length),保证相同语义的请求命中同一缓存键。
+*/
+function dataCacheKey(input, init) {
+	let url;
+	let method = "GET";
+	let headers;
+	if (typeof input === "string") {
+		url = input;
+		headers = new Headers(init?.headers);
+	} else if (input instanceof URL) {
+		url = input.toString();
+		headers = new Headers(init?.headers);
+	} else if (input instanceof Request) {
+		url = input.url;
+		method = input.method;
+		headers = new Headers(input.headers);
+		if (init?.headers) new Headers(init.headers).forEach((v, k) => headers.set(k, v));
+	} else {
+		url = String(input);
+		headers = new Headers(init?.headers);
+	}
+	if (init?.method) method = init.method.toUpperCase();
+	const headerEntries = [];
+	headers.forEach((value, key) => {
+		if (SKIP_HEADER_KEYS.has(key.toLowerCase())) return;
+		headerEntries.push(`${key.toLowerCase()}:${value}`);
+	});
+	headerEntries.sort();
+	return `${method}:${url}:${headerEntries.join("|")}`;
+}
+/**
+* 从 init 中提取 Data Cache 选项。返回 `null` 表示该请求不应被缓存。
+*
+* 规则:
+* - 无 `next` 选项 → 不缓存(默认行为不变)
+* - `next.noStore: true` → 不缓存
+* - `next.revalidate: 0` → 不缓存
+* - `next.revalidate > 0` 或 `next.tags` 非空 → 缓存
+* - 仅 `next: {}`(无 revalidate/tags) → 永久缓存(对齐 Next.js 行为)
+*/
+function extractCacheOptions(init) {
+	if (!init?.next) return null;
+	const { revalidate, tags, noStore } = init.next;
+	if (noStore) return null;
+	if (revalidate === 0) return null;
+	return {
+		revalidate,
+		tags,
+		noStore
+	};
+}
+/** 序列化 Response 为可存储格式(消费 body 一次)。 */
+async function serializeResponse(res) {
+	const body = await res.arrayBuffer();
+	const headers = {};
+	res.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	return {
+		status: res.status,
+		statusText: res.statusText,
+		headers,
+		body
+	};
+}
+/** 从序列化数据重建 Response(每次返回新的可消费实例)。 */
+function deserializeResponse(serialized) {
+	return new Response(serialized.body.slice(0), {
+		status: serialized.status,
+		statusText: serialized.statusText,
+		headers: new Headers(serialized.headers)
+	});
+}
+/**
+* 创建 fetch Data Cache 中间件(Task 4)。
+*
+* 在请求作用域内包装 `globalThis.fetch`,对带 `next: { revalidate, tags }` 选项的
+* GET/HEAD 请求按 TTL 跨请求缓存响应。无 `next` 选项的请求走原始路径(默认行为不变)。
+*
+* 行为:
+* - 仅缓存 2xx 响应(4xx/5xx 不缓存,允许后续重试)
+* - dev 模式默认 no-cache(可通过 `forceDevCache` 强制启用,用于测试)
+* - 与 `revalidateTag` / `revalidatePath` 集成,失效对应缓存条目
+*
+* @example
+* ```ts
+* import { createDataCacheMiddleware } from '@ubean/server';
+* app.use('*', createDataCacheMiddleware());
+*
+* // 路由处理器中:
+* const res = await fetch('https://api.example.com/data', {
+*   next: { revalidate: 60, tags: ['data'] }
+* });
+* ```
+*/
+function createDataCacheMiddleware(options = {}) {
+	const skipCache = (options.dev ?? isDevMode()) && !options.forceDevCache;
+	const { exclude } = options;
+	return async function dataCacheMiddleware(c, next) {
+		const originalFetch = globalThis.fetch;
+		const patchedFetch = async (input, init) => {
+			const cacheOpts = extractCacheOptions(init);
+			if (!cacheOpts || skipCache) return originalFetch(input, init);
+			const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+			if (method !== "GET" && method !== "HEAD") return originalFetch(input, init);
+			if (exclude && exclude(typeof input === "string" ? input : input.toString())) return originalFetch(input, init);
+			const key = dataCacheKey(input, init);
+			const now = Date.now();
+			const existing = dataCacheStore.get(key);
+			if (existing && now <= existing.expiresAt) return deserializeResponse(existing.response);
+			if (existing) {
+				dataCacheRemoveFromTagIndex(key, existing.tags);
+				dataCacheStore.delete(key);
+			}
+			const res = await originalFetch(input, init);
+			if (!res.ok) return res;
+			const ttl = cacheOpts.revalidate === void 0 ? Infinity : cacheOpts.revalidate;
+			const tags = cacheOpts.tags ?? [];
+			const serialized = await serializeResponse(res);
+			dataCacheStore.set(key, {
+				response: serialized,
+				tags,
+				createdAt: now,
+				expiresAt: ttl === Infinity ? Number.MAX_SAFE_INTEGER : now + ttl * 1e3
+			});
+			dataCacheAddToTagIndex(key, tags);
+			dataCacheEvict();
+			return deserializeResponse(serialized);
+		};
+		const prevFetch = globalThis.fetch;
+		globalThis.fetch = patchedFetch;
+		try {
+			await next();
+		} finally {
+			globalThis.fetch = prevFetch;
+		}
+	};
+}
+/**
+* 失效所有带指定标签的 Data Cache 条目。返回删除数量。
+*
+* 用户通常无需直接调用 —— `cache-directive.ts` 的 `revalidateTag` 会自动调用此函数。
+*/
+async function revalidateDataCacheTag(tag) {
+	const set = dataCacheTagIndex.get(tag);
+	if (!set) return 0;
+	const keys = Array.from(set);
+	for (const key of keys) {
+		const entry = dataCacheStore.get(key);
+		if (entry) {
+			dataCacheRemoveFromTagIndex(key, entry.tags);
+			dataCacheStore.delete(key);
+		}
+	}
+	return keys.length;
+}
+/**
+* 失效缓存键匹配指定模式的 Data Cache 条目。返回删除数量。
+*
+* 用户通常无需直接调用 —— `cache-directive.ts` 的 `revalidatePath` 会自动调用此函数。
+*/
+async function revalidateDataCachePath(pattern) {
+	const regex = pattern instanceof RegExp ? pattern : dataCacheGlobToRegex(pattern);
+	let deleted = 0;
+	for (const key of Array.from(dataCacheStore.keys())) if (regex.test(key)) {
+		const entry = dataCacheStore.get(key);
+		if (entry) {
+			dataCacheRemoveFromTagIndex(key, entry.tags);
+			dataCacheStore.delete(key);
+			deleted++;
+		}
+	}
+	return deleted;
+}
+/** 清空所有 fetch Data Cache 条目(主要用于测试)。 */
+function clearFetchDataCache() {
+	dataCacheStore.clear();
+	dataCacheTagIndex.clear();
+}
+/** 返回 Data Cache 当前条目数(主要用于测试)。 */
+function getDataCacheSize() {
+	return dataCacheStore.size;
+}
+/** 将 glob 模式转换为正则表达式(与 cache-directive.ts 保持一致)。 */
+function dataCacheGlobToRegex(pattern) {
+	const DOUBLE = "__DWC__";
+	const SINGLE = "__SWC__";
+	let s = pattern;
+	s = s.replace(/\/\*\*/g, `/${DOUBLE}`);
+	s = s.replace(/\*/g, SINGLE);
+	s = s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	s = s.replace(new RegExp(SINGLE, "g"), "[^/]*");
+	s = s.replace(new RegExp(`/${DOUBLE}`, "g"), "(?:/.*)?");
+	return new RegExp(`^${s}$`);
+}
+//#endregion
+export { getDataCacheSize as a, createMemoizedFetch as i, createDataCacheMiddleware as n, revalidateDataCachePath as o, createFetchMemoizationMiddleware as r, revalidateDataCacheTag as s, clearFetchDataCache as t };