ds-harness-remote-fast/apps/android/src/services/compaction-store.ts

95 lines
3.2 KiB
TypeScript

import type { StoredCompactionRecord } from './storage'
type CompactionState =
| 'accepted'
| 'running'
| 'cancelling'
| 'succeeded'
| 'failed'
| 'cancelled'
| 'interrupted'
| 'unconfirmed'
interface CompactionRecord {
sessionId: string
requestId: string
operationId?: string
state: CompactionState
updatedAt: number
}
type Scopes = Record<string, Record<string, CompactionRecord>>
const MAX_RECORDS = 32
const MAX_RECORDS_PER_SCOPE = 8
let writeQueue: Promise<void> = Promise.resolve()
/**
* Load the SecureStore-backed module lazily. `storage.ts` pulls Expo native
* modules that unit tests do not compose; persistence failures must only make
* tracking unavailable, never break the connection or a compaction.
*/
async function persistence() {
return await import('./storage')
}
function serialize<T>(work: (scopes: Scopes) => T): Promise<T> {
const run = writeQueue.then(async () => {
const { loadCompactionRecords, saveCompactionRecords } = await persistence()
const scopes = await loadCompactionRecords() as unknown as Scopes
const result = work(scopes)
await saveCompactionRecords(scopes as unknown as Record<string, Record<string, StoredCompactionRecord>>)
return result
})
writeQueue = run.then(() => undefined, () => undefined)
return run
}
function prune(scopes: Scopes): void {
for (const [scope, records] of Object.entries(scopes)) {
const entries = Object.entries(records).sort((left, right) => right[1].updatedAt - left[1].updatedAt)
for (const [sessionId] of entries.slice(MAX_RECORDS_PER_SCOPE)) delete records[sessionId]
if (Object.keys(records).length === 0) delete scopes[scope]
}
const all = Object.values(scopes).flatMap(records => Object.values(records))
if (all.length <= MAX_RECORDS) return
const keep = new Set(all.sort((left, right) => right.updatedAt - left.updatedAt).slice(0, MAX_RECORDS))
for (const [scope, records] of Object.entries(scopes)) {
for (const [sessionId, record] of Object.entries(records)) {
if (!keep.has(record)) delete records[sessionId]
}
if (Object.keys(records).length === 0) delete scopes[scope]
}
}
/** Product-side store for Host-owned compaction attempts (scoped per Host). */
export const compactionStore = {
async load(scope: string, sessionId: string): Promise<CompactionRecord | undefined> {
const { loadCompactionRecords } = await persistence()
const scopes = await loadCompactionRecords() as unknown as Scopes
return scopes[scope]?.[sessionId]
},
async list(scope: string): Promise<CompactionRecord[]> {
const { loadCompactionRecords } = await persistence()
const scopes = await loadCompactionRecords() as unknown as Scopes
return Object.values(scopes[scope] ?? {})
},
async save(scope: string, record: CompactionRecord): Promise<void> {
await serialize(scopes => {
const records = scopes[scope] ?? {}
records[record.sessionId] = record
scopes[scope] = records
prune(scopes)
})
},
async remove(scope: string, sessionId: string): Promise<void> {
await serialize(scopes => {
const records = scopes[scope]
if (records === undefined) return
delete records[sessionId]
if (Object.keys(records).length === 0) delete scopes[scope]
})
},
}