Spaces:
Paused
Paused
File size: 4,558 Bytes
35743bd | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | /**
* DB Read Cache — In-memory TTL cache for hot read paths.
*
* SQLite reads are already fast since better-sqlite3 is synchronous and
* memory-mapped. However, some functions (getSettings, getPricing,
* getProviderConnections) are called on every request by multiple callers.
* A short TTL cache (5s) eliminates redundant I/O without staling data for
* long enough to matter (settings changes are applied within one cache cycle).
*
* Usage:
* import { dbCache } from '@/lib/db/readCache';
* const settings = await dbCache.getSettings();
*/
type CacheEntry<T> = {
value: T;
expiresAt: number;
};
class TTLCache<T> {
private cache = new Map<string, CacheEntry<T>>();
private readonly ttlMs: number;
constructor(ttlMs: number) {
this.ttlMs = ttlMs;
}
get(key: string): T | undefined {
const entry = this.cache.get(key);
if (!entry) return undefined;
if (Date.now() > entry.expiresAt) {
this.cache.delete(key);
return undefined;
}
return entry.value;
}
set(key: string, value: T): void {
this.cache.set(key, { value, expiresAt: Date.now() + this.ttlMs });
}
invalidate(key?: string): void {
if (key) {
this.cache.delete(key);
} else {
this.cache.clear();
}
}
}
// Cache with 5s TTL — short enough to pick up dashboard changes quickly,
// long enough to serve burst request bursts without hammering SQLite.
const SETTINGS_TTL_MS = 5_000;
const PRICING_TTL_MS = 30_000;
const CONNECTIONS_TTL_MS = 5_000;
const settingsCache = new TTLCache<Record<string, unknown>>(SETTINGS_TTL_MS);
const pricingCache = new TTLCache<Record<string, unknown>>(PRICING_TTL_MS);
const connectionsCache = new TTLCache<unknown[]>(CONNECTIONS_TTL_MS);
/**
* Cached wrapper for getSettings.
* Invalidated on every updateSettings() call.
*/
export async function getCachedSettings(): Promise<Record<string, unknown>> {
const cached = settingsCache.get("settings");
if (cached) return cached;
const { getSettings } = await import("@/lib/db/settings");
const value = await getSettings();
settingsCache.set("settings", value);
return value;
}
/**
* Cached wrapper for getPricing.
* Longer TTL since pricing rarely changes mid-session.
*/
export async function getCachedPricing(): Promise<Record<string, unknown>> {
const cached = pricingCache.get("pricing");
if (cached) return cached as Record<string, unknown>;
const { getPricing } = await import("@/lib/db/settings");
const value = await getPricing();
pricingCache.set("pricing", value);
return value;
}
/**
* Cached wrapper for getProviderConnections.
* Used in request hot-paths (usageStats, callLogs, usageHistory).
*/
export async function getCachedProviderConnections(
filter?: Record<string, unknown>
): Promise<unknown[]> {
// Only cache the unfiltered "all connections" query (most common)
if (filter && Object.keys(filter).length > 0) {
const { getProviderConnections } = await import("@/lib/db/providers");
return getProviderConnections(filter);
}
const cached = connectionsCache.get("all");
if (cached) return cached;
const { getProviderConnections } = await import("@/lib/db/providers");
const value = await getProviderConnections();
connectionsCache.set("all", value);
return value;
}
// ──────────────── LKGP Cache Wrappers ────────────────
const lkgpCache = new TTLCache<string | null>(SETTINGS_TTL_MS);
export async function getCachedLKGP(comboName: string, modelId: string): Promise<string | null> {
const cacheKey = `lkgp:${comboName}:${modelId}`;
const cached = lkgpCache.get(cacheKey);
if (cached !== undefined) return cached;
const { getLKGP } = await import("@/lib/db/settings");
const value = await getLKGP(comboName, modelId);
lkgpCache.set(cacheKey, value);
return value;
}
export async function setCachedLKGP(
comboName: string,
modelId: string,
providerId: string
): Promise<void> {
const { setLKGP } = await import("@/lib/db/settings");
await setLKGP(comboName, modelId, providerId);
lkgpCache.invalidate(`lkgp:${comboName}:${modelId}`);
}
/**
* Invalidate all caches (call after writes to any of: settings, pricing, connections).
*/
export function invalidateDbCache(scope?: "settings" | "pricing" | "connections"): void {
if (!scope || scope === "settings") settingsCache.invalidate();
if (!scope || scope === "pricing") pricingCache.invalidate();
if (!scope || scope === "connections") connectionsCache.invalidate();
}
|