Files
otunes/apps/web/lib/persistent-cache.ts

269 lines
6.5 KiB
TypeScript

const DB_NAME = "otunes-cache"
const DB_VERSION = 1
const STORE_NAME = "entries"
const WRITE_DELAY_MS = 250
/** Keys are `<prefix>:<rest>`; prefixes without a limit are never evicted. */
const MAX_ENTRIES_BY_PREFIX: Record<string, number> = {
q: 400,
song: 5000,
}
type Entry = { value: unknown; touchedAt: number }
const memory = new Map<string, Entry>()
const prefixCounts = new Map<string, number>()
const listeners = new Map<string, Set<() => void>>()
const loadListeners = new Set<() => void>()
const pendingWrites = new Map<string, Entry | null>()
let flushTimer: ReturnType<typeof setTimeout> | null = null
let dbPromise: Promise<IDBDatabase | null> | null = null
let loadPromise: Promise<void> | null = null
let loaded = false
function requestToPromise<T>(request: IDBRequest<T>) {
return new Promise<T>((resolve, reject) => {
request.onsuccess = () => resolve(request.result)
request.onerror = () => reject(request.error)
})
}
function transactionDone(transaction: IDBTransaction) {
return new Promise<void>((resolve, reject) => {
transaction.oncomplete = () => resolve()
transaction.onabort = () => reject(transaction.error)
transaction.onerror = () => reject(transaction.error)
})
}
function openDb() {
if (dbPromise) {
return dbPromise
}
dbPromise = new Promise<IDBDatabase | null>((resolve) => {
if (typeof indexedDB === "undefined") {
resolve(null)
return
}
try {
const request = indexedDB.open(DB_NAME, DB_VERSION)
request.onupgradeneeded = () => {
if (!request.result.objectStoreNames.contains(STORE_NAME)) {
request.result.createObjectStore(STORE_NAME)
}
}
request.onsuccess = () => resolve(request.result)
request.onerror = () => resolve(null)
request.onblocked = () => resolve(null)
} catch {
resolve(null)
}
})
return dbPromise
}
function notify(key: string) {
for (const listener of listeners.get(key) ?? []) {
listener()
}
}
function notifyAll() {
for (const key of listeners.keys()) {
notify(key)
}
for (const listener of loadListeners) {
listener()
}
}
async function flushWrites() {
flushTimer = null
if (pendingWrites.size === 0) {
return
}
const writes = [...pendingWrites]
pendingWrites.clear()
const db = await openDb()
if (!db) {
return
}
try {
const transaction = db.transaction(STORE_NAME, "readwrite")
const store = transaction.objectStore(STORE_NAME)
for (const [key, entry] of writes) {
if (entry === null) {
store.delete(key)
} else {
store.put(entry, key)
}
}
await transactionDone(transaction)
} catch {
// Persisting is best-effort; the in-memory copy stays authoritative.
}
}
function scheduleWrite(key: string, entry: Entry | null) {
pendingWrites.set(key, entry)
if (flushTimer === null) {
flushTimer = setTimeout(() => void flushWrites(), WRITE_DELAY_MS)
}
}
function entryPrefix(key: string) {
const index = key.indexOf(":")
return index === -1 ? key : key.slice(0, index)
}
function evictOldEntries(prefix: string, force = false) {
const limit = MAX_ENTRIES_BY_PREFIX[prefix]
const count = prefixCounts.get(prefix) ?? 0
if (limit === undefined || count <= (force ? limit : limit * 1.25)) {
return
}
const oldest = [...memory.entries()]
.filter(([key]) => entryPrefix(key) === prefix)
.sort(([, a], [, b]) => a.touchedAt - b.touchedAt)
.slice(0, count - limit)
for (const [key] of oldest) {
removeFromMemory(key)
scheduleWrite(key, null)
}
}
function setInMemory(key: string, entry: Entry) {
if (!memory.has(key)) {
const prefix = entryPrefix(key)
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 0) + 1)
}
memory.set(key, entry)
}
function removeFromMemory(key: string) {
if (memory.delete(key)) {
const prefix = entryPrefix(key)
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 1) - 1)
}
}
/** Writes pending entries now instead of after the batching delay. */
export function flushPersistentCache() {
if (flushTimer !== null) {
clearTimeout(flushTimer)
}
void flushWrites()
}
export function loadPersistentCache() {
if (loadPromise) {
return loadPromise
}
loadPromise = (async () => {
const db = await openDb()
if (db) {
try {
const transaction = db.transaction(STORE_NAME, "readonly")
const store = transaction.objectStore(STORE_NAME)
const [keys, values] = await Promise.all([
requestToPromise(store.getAllKeys()),
requestToPromise(store.getAll() as IDBRequest<Entry[]>),
])
keys.forEach((key, index) => {
const entry = values[index]
if (typeof key === "string" && entry && !memory.has(key)) {
setInMemory(key, entry)
}
})
for (const prefix of Object.keys(MAX_ENTRIES_BY_PREFIX)) {
evictOldEntries(prefix, true)
}
} catch {
// Treat an unreadable cache as empty.
}
}
loaded = true
notifyAll()
})()
return loadPromise
}
export function isPersistentCacheLoaded() {
return loaded
}
export function readCache<T>(key: string): T | undefined {
return memory.get(key)?.value as T | undefined
}
export function writeCache(
key: string,
value: unknown,
options: { notify?: boolean } = {}
) {
const entry = { value, touchedAt: Date.now() }
setInMemory(key, entry)
scheduleWrite(key, entry)
evictOldEntries(entryPrefix(key))
if (options.notify) {
notify(key)
}
}
export async function clearPersistentCache() {
memory.clear()
prefixCounts.clear()
pendingWrites.clear()
if (flushTimer !== null) {
clearTimeout(flushTimer)
flushTimer = null
}
notifyAll()
const db = await openDb()
if (!db) {
return
}
try {
const transaction = db.transaction(STORE_NAME, "readwrite")
transaction.objectStore(STORE_NAME).clear()
await transactionDone(transaction)
} catch {
// Ignore; stale entries are scoped per user and evicted over time.
}
}
export function subscribeCache(key: string, listener: () => void) {
let keyListeners = listeners.get(key)
if (!keyListeners) {
keyListeners = new Set()
listeners.set(key, keyListeners)
}
keyListeners.add(listener)
return () => {
keyListeners.delete(listener)
if (keyListeners.size === 0) {
listeners.delete(key)
}
}
}
export function subscribeCacheLoaded(listener: () => void) {
loadListeners.add(listener)
return () => {
loadListeners.delete(listener)
}
}