@ubean/server 0.1.13 → 0.2.1

package/dist/analytics-entry.d.ts

@@ -0,0 +1,2 @@
+import { $ as getGlobalAnalyticsProvider, A as removeExperiment, B as AnalyticsProvider, C as extractFlagContext, D as getVariantFromContext, E as getVariantAssignment, F as useFlags, G as createAnalyticsMiddleware, H as AnalyticsRecord, I as AnalyticsContext, J as createMockAnalyticsProvider, K as createLogAnalyticsProvider, L as AnalyticsEvent, M as setGlobalFeatureFlagStore, N as useExperiments, O as listExperimentNames, P as useFlagContext, Q as getAnalyticsProvider, R as AnalyticsMiddlewareOptions, S as evaluateFlagWithReason, T as getVariant, U as AnalyticsTrackOptions, V as AnalyticsProviderOptions, W as clearAnalyticsProviders, X as defineAnalyticsProvider, Y as defineAnalytics, Z as extractAnalyticsContext, _ as createMemoryFeatureFlagStore, a as FeatureFlagOptions, at as trackRaw, b as evaluateFlag, c as FlagContext, d as FlagValue, et as listAnalyticsProviders, f as Segment, g as createFeatureFlagsMiddleware, h as clearFeatureFlags, i as FeatureFlagDefinition, it as trackPageView, j as removeFeatureFlag, k as listFlagNames, l as FlagEvaluation, m as Variant, n as ExperimentDefinition, nt as setGlobalAnalyticsProvider, o as FeatureFlagStore, ot as unregisterAnalyticsProvider, p as SegmentRule, q as createMemoryAnalyticsProvider, r as ExperimentOptions, rt as trackEvent, s as FeatureFlagsMiddlewareOptions, st as useAnalytics, t as ExperimentAssignment, tt as registerAnalyticsProvider, u as FlagKind, v as defineExperiment, w as getGlobalFeatureFlagStore, x as evaluateFlagFromContext, y as defineFeatureFlag, z as AnalyticsProperties } from "./feature-flags-DWkS6p0D.js";
+export { AnalyticsContext, AnalyticsEvent, AnalyticsMiddlewareOptions, AnalyticsProperties, AnalyticsProvider, AnalyticsProviderOptions, AnalyticsRecord, AnalyticsTrackOptions, ExperimentAssignment, ExperimentDefinition, ExperimentOptions, FeatureFlagDefinition, FeatureFlagOptions, FeatureFlagStore, FeatureFlagsMiddlewareOptions, FlagContext, FlagEvaluation, FlagKind, FlagValue, Segment, SegmentRule, Variant, clearAnalyticsProviders, clearFeatureFlags, createAnalyticsMiddleware, createFeatureFlagsMiddleware, createLogAnalyticsProvider, createMemoryAnalyticsProvider, createMemoryFeatureFlagStore, createMockAnalyticsProvider, defineAnalytics, defineAnalyticsProvider, defineExperiment, defineFeatureFlag, evaluateFlag, evaluateFlagFromContext, evaluateFlagWithReason, extractAnalyticsContext, extractFlagContext, getAnalyticsProvider, getGlobalAnalyticsProvider, getGlobalFeatureFlagStore, getVariant, getVariantAssignment, getVariantFromContext, listAnalyticsProviders, listExperimentNames, listFlagNames, registerAnalyticsProvider, removeExperiment, removeFeatureFlag, setGlobalAnalyticsProvider, setGlobalFeatureFlagStore, trackEvent, trackPageView, trackRaw, unregisterAnalyticsProvider, useAnalytics, useExperiments, useFlagContext, useFlags };

package/dist/analytics-entry.js

@@ -0,0 +1,2 @@
+import { A as getAnalyticsProvider, C as createAnalyticsMiddleware, D as defineAnalytics, E as createMockAnalyticsProvider, F as trackEvent, I as trackPageView, L as trackRaw, M as listAnalyticsProviders, N as registerAnalyticsProvider, O as defineAnalyticsProvider, P as setGlobalAnalyticsProvider, R as unregisterAnalyticsProvider, S as clearAnalyticsProviders, T as createMemoryAnalyticsProvider, _ as removeFeatureFlag, a as defineFeatureFlag, b as useFlagContext, c as evaluateFlagWithReason, d as getVariant, f as getVariantAssignment, g as removeExperiment, h as listFlagNames, i as defineExperiment, j as getGlobalAnalyticsProvider, k as extractAnalyticsContext, l as extractFlagContext, m as listExperimentNames, n as createFeatureFlagsMiddleware, o as evaluateFlag, p as getVariantFromContext, r as createMemoryFeatureFlagStore, s as evaluateFlagFromContext, t as clearFeatureFlags, u as getGlobalFeatureFlagStore, v as setGlobalFeatureFlagStore, w as createLogAnalyticsProvider, x as useFlags, y as useExperiments, z as useAnalytics } from "./feature-flags-CdLwsMD2.js";
+export { clearAnalyticsProviders, clearFeatureFlags, createAnalyticsMiddleware, createFeatureFlagsMiddleware, createLogAnalyticsProvider, createMemoryAnalyticsProvider, createMemoryFeatureFlagStore, createMockAnalyticsProvider, defineAnalytics, defineAnalyticsProvider, defineExperiment, defineFeatureFlag, evaluateFlag, evaluateFlagFromContext, evaluateFlagWithReason, extractAnalyticsContext, extractFlagContext, getAnalyticsProvider, getGlobalAnalyticsProvider, getGlobalFeatureFlagStore, getVariant, getVariantAssignment, getVariantFromContext, listAnalyticsProviders, listExperimentNames, listFlagNames, registerAnalyticsProvider, removeExperiment, removeFeatureFlag, setGlobalAnalyticsProvider, setGlobalFeatureFlagStore, trackEvent, trackPageView, trackRaw, unregisterAnalyticsProvider, useAnalytics, useExperiments, useFlagContext, useFlags };

package/dist/cache-C84ix1Vq.js

@@ -0,0 +1,173 @@
+//#region src/cache.ts
+function createMemoryStore(maxEntries = 200) {
+	const store = /* @__PURE__ */ new Map();
+	function evict() {
+		if (store.size <= maxEntries) return;
+		const entries = Array.from(store.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+		const removeCount = Math.ceil(entries.length * .2);
+		for (let i = 0; i < removeCount; i++) store.delete(entries[i][0]);
+	}
+	return {
+		store,
+		async get(key) {
+			const entry = store.get(key);
+			if (!entry) return void 0;
+			if (Date.now() > entry.expiresAt) return;
+			return entry;
+		},
+		async peek(key) {
+			return store.get(key);
+		},
+		async set(key, entry, ttl) {
+			const now = Date.now();
+			store.set(key, {
+				...entry,
+				createdAt: now,
+				expiresAt: now + ttl * 1e3
+			});
+			evict();
+		},
+		async delete(key) {
+			return store.delete(key);
+		},
+		async clear() {
+			store.clear();
+		}
+	};
+}
+let globalStore = null;
+function useCacheStore(store) {
+	if (store) {
+		globalStore = store;
+		return store;
+	}
+	if (!globalStore) globalStore = createMemoryStore();
+	return globalStore;
+}
+function clearCacheStore() {
+	globalStore = null;
+}
+function buildCacheKey(c) {
+	const url = new URL(c.req.url);
+	return `${c.req.method}:${url.pathname}${url.search}`;
+}
+function serializeResponse(res) {
+	return res.arrayBuffer().then((body) => {
+		const headers = {};
+		res.headers.forEach((v, k) => {
+			const kl = k.toLowerCase();
+			if (kl !== "set-cookie" && kl !== "authorization") headers[k] = v;
+		});
+		return {
+			body,
+			headers,
+			status: res.status,
+			statusText: res.statusText
+		};
+	});
+}
+function entryToResponse(entry) {
+	const headers = new Headers(entry.headers);
+	headers.set("X-Cache", "HIT");
+	headers.set("Age", String(Math.max(0, Math.floor((Date.now() - entry.createdAt) / 1e3))));
+	return new Response(entry.body, {
+		status: entry.status,
+		statusText: entry.statusText,
+		headers
+	});
+}
+function isCacheableRequest(c) {
+	if (c.req.method !== "GET" && c.req.method !== "HEAD") return false;
+	if (c.req.header("authorization")) return false;
+	if (c.req.header("cookie")) {
+		if (!(c.req.header("cache-control") || "").includes("public")) return false;
+	}
+	const cc = c.req.header("cache-control");
+	if (cc && (cc.includes("no-cache") || cc.includes("no-store"))) return false;
+	return true;
+}
+function isCacheableResponse(res) {
+	if (res.status !== 200) return false;
+	if (res.headers.get("set-cookie")) return false;
+	const cc = res.headers.get("cache-control");
+	if (cc && (cc.includes("private") || cc.includes("no-store"))) return false;
+	return true;
+}
+function matchPath(pattern, path) {
+	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}$`).test(path);
+}
+function createCacheMiddleware(options = {}) {
+	const store = options.store || useCacheStore();
+	function findTtl(path) {
+		if (!options.rules) return null;
+		const patterns = Object.keys(options.rules);
+		for (const pattern of patterns) if (matchPath(pattern, path)) return options.rules[pattern].ttl;
+		return null;
+	}
+	return async function cacheMiddleware(c, next) {
+		const path = new URL(c.req.url).pathname;
+		const ttl = findTtl(path);
+		if (ttl != null && ttl > 0 && isCacheableRequest(c)) {
+			const key = buildCacheKey(c);
+			const existing = await store.get(key);
+			if (existing) return entryToResponse(existing);
+		}
+		await next();
+		if (ttl == null || ttl <= 0) return;
+		const res = c.res;
+		if (!res || !isCacheableRequest(c) || !isCacheableResponse(res)) return;
+		const serialized = await serializeResponse(res.clone());
+		await store.set(buildCacheKey(c), serialized, ttl);
+	};
+}
+function cachedEventHandler(handler, options = { ttl: 60 }) {
+	const store = useCacheStore();
+	const ttl = options.ttl;
+	const keyBase = options.name;
+	return (async (c) => {
+		const key = keyBase || buildCacheKey(c);
+		if (ttl > 0 && isCacheableRequest(c)) {
+			const existing = await store.get(key);
+			if (existing) return entryToResponse(existing);
+		}
+		const res = await handler(c);
+		if (ttl > 0 && isCacheableResponse(res)) {
+			const serialized = await serializeResponse(res.clone());
+			await store.set(key, serialized, ttl);
+		}
+		return res;
+	});
+}
+async function invalidateRouteCache(keyPattern) {
+	const store = useCacheStore();
+	if (!keyPattern) {
+		await store.clear();
+		return;
+	}
+	if (typeof keyPattern === "string") {
+		await store.delete(keyPattern);
+		return;
+	}
+	const memStore = store;
+	if (memStore.store) {
+		for (const k of Array.from(memStore.store.keys())) if (keyPattern.test(k)) await store.delete(k);
+	}
+}
+function resolveRouteCacheRules(routeRules) {
+	const result = {};
+	for (const [path, rule] of Object.entries(routeRules)) if (rule.cache && rule.cache.ttl != null) result[path] = {
+		ttl: rule.cache.ttl,
+		swr: rule.cache.swr
+	};
+	return result;
+}
+//#endregion
+export { invalidateRouteCache as a, createMemoryStore as i, clearCacheStore as n, resolveRouteCacheRules as o, createCacheMiddleware as r, useCacheStore as s, cachedEventHandler as t };

package/dist/cache-b-MZlyv0.d.ts

@@ -0,0 +1,48 @@
+import { Context, Next } from "hono";
+import { RouteRule } from "@ubean/shared";
+//#region src/cache.d.ts
+interface CacheEntry {
+  body: ArrayBuffer;
+  headers: Record<string, string>;
+  status: number;
+  statusText: string;
+  createdAt: number;
+  expiresAt: number;
+}
+interface CacheStore {
+  get(key: string): Promise<CacheEntry | undefined>;
+  set(key: string, entry: Omit<CacheEntry, 'createdAt' | 'expiresAt'>, ttl: number): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  clear(): Promise<void>;
+  /**
+   * 返回 entry(无论是否过期),不进行过期清理(P9-03 ISR SWR 用)。
+   *
+   * 不实现此方法的存储后端将不支持 ISR SWR(自动降级为同步重新生成)。
+   */
+  peek?(key: string): Promise<CacheEntry | undefined>;
+  /**
+   * 内部 Map(仅内存存储实现暴露)。供 `invalidateCachePattern` /
+   * `isIsrEntryStale` 等函数通过 `memStore.store` 访问底层存储进行模式匹配。
+   *
+   * 其他后端(Redis 等)不实现此属性,模式匹配将返回 0/false。
+   */
+  store?: Map<string, CacheEntry>;
+}
+declare function createMemoryStore(maxEntries?: number): CacheStore;
+declare function useCacheStore(store?: CacheStore): CacheStore;
+declare function clearCacheStore(): void;
+interface CacheRule {
+  ttl: number;
+  swr?: boolean | number;
+  name?: string;
+}
+declare function createCacheMiddleware(options?: {
+  store?: CacheStore;
+  rules?: Record<string, CacheRule>;
+  defaultTtl?: number;
+}): (c: Context, next: Next) => Promise<Response | undefined>;
+declare function cachedEventHandler<T extends (c: Context) => Response | Promise<Response>>(handler: T, options?: CacheRule): T;
+declare function invalidateRouteCache(keyPattern?: string | RegExp): Promise<void>;
+declare function resolveRouteCacheRules(routeRules: Record<string, RouteRule>): Record<string, CacheRule>;
+//#endregion
+export { clearCacheStore as a, invalidateRouteCache as c, cachedEventHandler as i, resolveRouteCacheRules as l, CacheRule as n, createCacheMiddleware as o, CacheStore as r, createMemoryStore as s, CacheEntry as t, useCacheStore as u };

package/dist/cache-directive-C1Nekkza.js

@@ -0,0 +1,304 @@
+import { o as revalidateDataCachePath, s as revalidateDataCacheTag, t as clearFetchDataCache } from "./fetch-memo-rbkxxnW4.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/cache-directive.ts
+/**
+* 组件级缓存 —— 运行时原语
+*
+* 通过 `defineCachedFunction()` 显式包装异步函数,缓存其返回值。
+*
+* 设计要点:
+* - **值缓存**(非 HTTP 响应缓存):缓存异步函数的返回值(JSON 可序列化),
+*   与 `cache.ts`(HTTP 响应缓存)解耦。
+* - **AsyncLocalStorage 作用域**:`cacheLife()` / `cacheTag()` 通过 ALS 写入
+*   当前缓存的执行作用域,无需手动传递 scope 对象。
+* - **标签失效**:`revalidateTag(tag)` 失效所有带该标签的缓存条目;
+*   `revalidatePath(path)` 失效匹配路径的缓存条目。
+* - **零外部依赖**:使用内置 `AsyncLocalStorage` + `Map` 内存存储。
+*
+* 用户通过 `defineCachedFunction(fn, options)` 显式声明缓存函数,无需 Vite 插件
+* 参与,运行时通过此模块的 API 执行缓存逻辑。
+*/
+/**
+* 默认内存组件缓存存储。带标签反向索引以加速 `revalidateTag`。
+*/
+function createComponentMemoryStore(maxEntries = 500) {
+	const store = /* @__PURE__ */ new Map();
+	/** tag → 关联的缓存键集合 */
+	const tagIndex = /* @__PURE__ */ new Map();
+	function addToTagIndex(key, tags) {
+		for (const tag of tags) {
+			let set = tagIndex.get(tag);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				tagIndex.set(tag, set);
+			}
+			set.add(key);
+		}
+	}
+	function removeFromTagIndex(key, tags) {
+		for (const tag of tags) {
+			const set = tagIndex.get(tag);
+			if (set) {
+				set.delete(key);
+				if (set.size === 0) tagIndex.delete(tag);
+			}
+		}
+	}
+	function evict() {
+		if (store.size <= maxEntries) return;
+		const entries = Array.from(store.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];
+			removeFromTagIndex(key, entry.tags);
+			store.delete(key);
+		}
+	}
+	return {
+		async get(key) {
+			const entry = store.get(key);
+			if (!entry) return void 0;
+			if (Date.now() > entry.expiresAt) {
+				removeFromTagIndex(key, entry.tags);
+				store.delete(key);
+				return;
+			}
+			return entry;
+		},
+		async set(key, entry, ttl) {
+			const now = Date.now();
+			const existing = store.get(key);
+			if (existing) removeFromTagIndex(key, existing.tags);
+			const full = {
+				...entry,
+				createdAt: now,
+				expiresAt: now + ttl * 1e3
+			};
+			store.set(key, full);
+			addToTagIndex(key, full.tags);
+			evict();
+		},
+		async delete(key) {
+			const entry = store.get(key);
+			if (entry) removeFromTagIndex(key, entry.tags);
+			return store.delete(key);
+		},
+		async clear() {
+			store.clear();
+			tagIndex.clear();
+		},
+		async keys() {
+			return Array.from(store.keys());
+		}
+	};
+}
+let globalComponentStore = null;
+function useComponentCacheStore(store) {
+	if (store) {
+		globalComponentStore = store;
+		return store;
+	}
+	if (!globalComponentStore) globalComponentStore = createComponentMemoryStore();
+	return globalComponentStore;
+}
+function clearComponentCacheStore() {
+	globalComponentStore = null;
+}
+const cacheScopeStorage = new AsyncLocalStorage();
+/**
+* 设置当前缓存作用域的 TTL(秒)。
+*
+* 必须在 `defineCachedFunction()` 包装的函数体内调用,否则为空操作(允许在
+* 非缓存上下文中调用以简化条件逻辑)。
+*
+* @example
+* ```ts
+* const getUser = defineCachedFunction(
+*   async (id: string) => {
+*     cacheLife(3600); // 缓存 1 小时
+*     return await db.query.user.findById(id);
+*   },
+*   { name: 'getUser' }
+* );
+* ```
+*/
+function cacheLife(seconds) {
+	const scope = cacheScopeStorage.getStore();
+	if (scope) scope.ttl = Math.max(0, Math.floor(seconds));
+}
+/**
+* 为当前缓存作用域添加标签。
+*
+* 标签可用于通过 `revalidateTag(tag)` 精确失效缓存。
+*
+* @example
+* ```ts
+* const getUser = defineCachedFunction(
+*   async (id: string) => {
+*     cacheTag('users', `user:${id}`);
+*     return await db.query.user.findById(id);
+*   },
+*   { name: 'getUser' }
+* );
+*
+* // 失效所有带 'users' 标签的缓存
+* await revalidateTag('users');
+* ```
+*/
+function cacheTag(...tags) {
+	const scope = cacheScopeStorage.getStore();
+	if (scope) scope.tags.push(...tags);
+}
+/**
+* 默认缓存键生成器:`name + ":" + JSON.stringify(args)`。
+*/
+function defaultGetKey(name, args) {
+	if (args.length === 0) return name;
+	try {
+		return `${name}:${JSON.stringify(args)}`;
+	} catch {
+		return `${name}:__unserializable__`;
+	}
+}
+/**
+* 将异步函数包装为带缓存的函数。
+*
+* 用户在源码中显式调用此函数声明缓存函数(无需 Vite 插件参与)。
+*
+* 工作流程:
+* 1. 根据参数生成缓存键
+* 2. 查询缓存 → 命中则返回反序列化的值
+* 3. 未命中 → 在 `AsyncLocalStorage` 作用域中执行原函数
+*    - 函数体内的 `cacheLife()` / `cacheTag()` 写入作用域
+* 4. 将结果序列化存入缓存(带标签 + TTL)
+* 5. 返回结果
+*
+* @example
+* ```ts
+* import { defineCachedFunction, cacheLife, cacheTag } from '@ubean/server';
+*
+* const getUser = defineCachedFunction(
+*   async (id: string) => {
+*     cacheLife(3600);
+*     cacheTag('users', `user:${id}`);
+*     return await db.query.user.findById(id);
+*   },
+*   { name: 'getUser' }
+* );
+* ```
+*
+* @param fn 原始异步函数
+* @param options 缓存选项
+*/
+function defineCachedFunction(fn, options) {
+	const store = useComponentCacheStore();
+	const defaultTtl = options.defaultTtl ?? 60;
+	return async (...args) => {
+		const key = options.getKey ? options.getKey(...args) : defaultGetKey(options.name, args);
+		const cached = await store.get(key);
+		if (cached) try {
+			return JSON.parse(cached.value);
+		} catch {}
+		const scope = {
+			ttl: defaultTtl,
+			tags: []
+		};
+		const result = await cacheScopeStorage.run(scope, () => fn(...args));
+		try {
+			const value = JSON.stringify(result);
+			await store.set(key, {
+				value,
+				tags: scope.tags
+			}, scope.ttl);
+		} catch {}
+		return result;
+	};
+}
+/**
+* @deprecated 请使用 `defineCachedFunction()`。保留旧名称仅为向后兼容。
+*/
+const wrapWithCache = defineCachedFunction;
+/**
+* 失效所有带指定标签的缓存条目。
+*
+* @example
+* ```ts
+* // 用户数据更新后,失效所有 'users' 标签的缓存
+* await revalidateTag('users');
+* ```
+*/
+async function revalidateTag(tag) {
+	const store = useComponentCacheStore();
+	let deleted = 0;
+	if (store.keys) {
+		const allKeys = await store.keys();
+		for (const key of allKeys) {
+			const entry = await store.get(key);
+			if (entry && entry.tags.includes(tag)) {
+				await store.delete(key);
+				deleted++;
+			}
+		}
+	}
+	deleted += await revalidateDataCacheTag(tag);
+	return deleted;
+}
+/**
+* 失效多个标签的缓存条目。
+*/
+async function revalidateTags(...tags) {
+	let total = 0;
+	for (const tag of tags) total += await revalidateTag(tag);
+	return total;
+}
+/**
+* 失效缓存键匹配指定模式的条目。
+*
+* 支持 `*`(单段通配)和 `**`(多段通配)。
+*
+* @example
+* ```ts
+* // 失效所有 getUser 开头的缓存
+* await revalidatePath('getUser:*');
+* // 失效特定用户缓存
+* await revalidatePath('getUser:["user-123"]');
+* ```
+*/
+async function revalidatePath(pattern) {
+	const store = useComponentCacheStore();
+	let deleted = 0;
+	if (store.keys) {
+		const allKeys = await store.keys();
+		const regex = pattern instanceof RegExp ? pattern : globToRegex(pattern);
+		for (const key of allKeys) if (regex.test(key)) {
+			await store.delete(key);
+			deleted++;
+		}
+	}
+	deleted += await revalidateDataCachePath(pattern);
+	return deleted;
+}
+/**
+* 清空所有组件级缓存。
+*/
+async function clearComponentCache() {
+	await useComponentCacheStore().clear();
+	clearFetchDataCache();
+}
+/**
+* 将 glob 模式转换为正则表达式。
+* `*` → `[^/]*`,`**` → `.*`。
+*/
+function globToRegex(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 { createComponentMemoryStore as a, revalidateTag as c, wrapWithCache as d, clearComponentCacheStore as i, revalidateTags as l, cacheTag as n, defineCachedFunction as o, clearComponentCache as r, revalidatePath as s, cacheLife as t, useComponentCacheStore as u };