diff --git a/src/adapters/storage/indexeddb/indexeddb-governance.ts b/src/adapters/storage/indexeddb/indexeddb-governance.ts index 1fc0c6c5..296f7c37 100644 --- a/src/adapters/storage/indexeddb/indexeddb-governance.ts +++ b/src/adapters/storage/indexeddb/indexeddb-governance.ts @@ -3,6 +3,10 @@ import { assertValidStoragePolicy, type BrowserStoragePolicy, } from "../../../application/ports/browser-file-storage/shared.ts"; +import { + onIndexedDbRequest, + runIndexedDbTransaction, +} from "../../platform/indexeddb-transaction.ts"; import { INDEXEDDB_DATASET_BUDGET_KEY, isStoredDatasetBudget, @@ -219,105 +223,72 @@ export function queueIndexedDbUpgradeBinding( /** * Post-open verification protects non-upgrade opens and maintenance callers. + * 05-12. It runs on the kernel transaction, so settle-once, caller abort and + * the abort-after-commit rule (CP-4) are the kernel's, not a local copy's. */ -export function verifyIndexedDbDatasetBinding( +export async function verifyIndexedDbDatasetBinding( database: IDBDatabase, governanceStore: string, expected: StoredDatasetBinding, signal?: AbortSignal, ): Promise { - if (signal?.aborted) { - return Promise.resolve({ ok: false, reason: "ABORTED" }); - } - let transaction: IDBTransaction; - try { - transaction = database.transaction(governanceStore, "readonly"); - } catch (error) { - return Promise.resolve({ - ok: false, - reason: "NATIVE_ERROR", - error, - }); - } - - return new Promise((resolve) => { - let settled = false; - let observed: unknown; - let observedBudget: unknown; - let requestError: unknown; - let callerAborted = false; - const finish = (result: IndexedDbBindingVerification) => { - if (settled) return; - settled = true; - signal?.removeEventListener("abort", onAbort); - resolve(result); - }; - function onAbort(): void { - callerAborted = true; - try { - transaction.abort(); - } catch { - // Completion determines the race. - } - } - signal?.addEventListener("abort", onAbort, { once: true }); - - transaction.onerror = () => { - requestError ??= transaction.error; - }; - transaction.onabort = () => - finish( - callerAborted - ? { ok: false, reason: "ABORTED" } - : { - ok: false, - reason: "NATIVE_ERROR", - error: requestError ?? transaction.error, - }, + const outcome = await runIndexedDbTransaction< + IndexedDbBindingVerification, + BindingFailure + >({ + database, + stores: [governanceStore], + mode: "readonly", + signal, + translate: (cause) => + cause.kind === "CALLER_ABORT" + ? { ok: false, reason: "ABORTED" } + : { + ok: false, + reason: "NATIVE_ERROR", + error: cause.kind === "NATIVE_EXCEPTION" ? cause.error : undefined, + }, + queue: (transaction, context) => { + const store = transaction.objectStore(governanceStore); + let observed: unknown; + onIndexedDbRequest( + store.get(INDEXEDDB_DATASET_BINDING_KEY), + context, + (value) => { + observed = value; + }, ); - transaction.oncomplete = () => { - if (observed === undefined) { - finish({ ok: false, reason: "MISSING" }); - } else if (!isStoredDatasetBinding(observed)) { - finish({ ok: false, reason: "CORRUPT" }); - } else if (!sameIndexedDbDatasetBinding(observed, expected)) { - finish({ ok: false, reason: "MISMATCH" }); - } else if ( - !isStoredDatasetBudget(observedBudget) || - observedBudget.usedBytes > expected.storagePolicy.hardBudgetBytes - ) { - finish({ ok: false, reason: "CORRUPT" }); - } else { - finish({ ok: true }); - } - }; - - try { - const request = transaction - .objectStore(governanceStore) - .get(INDEXEDDB_DATASET_BINDING_KEY); - request.onerror = () => { - requestError ??= request.error; - }; - request.onsuccess = () => { - observed = request.result; - }; - const budgetRequest = transaction - .objectStore(governanceStore) - .get(INDEXEDDB_DATASET_BUDGET_KEY); - budgetRequest.onerror = () => { - requestError ??= budgetRequest.error; - }; - budgetRequest.onsuccess = () => { - observedBudget = budgetRequest.result; - }; - } catch (error) { - requestError = error; - try { - transaction.abort(); - } catch { - finish({ ok: false, reason: "NATIVE_ERROR", error }); - } - } + onIndexedDbRequest( + store.get(INDEXEDDB_DATASET_BUDGET_KEY), + context, + (budget) => { + context.succeed(bindingVerdict(observed, budget, expected)); + }, + ); + }, }); + return outcome.ok ? outcome.value : outcome.error; +} + +type BindingFailure = Extract; + +function bindingVerdict( + observed: unknown, + budget: unknown, + expected: StoredDatasetBinding, +): IndexedDbBindingVerification { + if (observed === undefined) return { ok: false, reason: "MISSING" }; + if (!isStoredDatasetBinding(observed)) { + return { ok: false, reason: "CORRUPT" }; + } + if (!sameIndexedDbDatasetBinding(observed, expected)) { + return { ok: false, reason: "MISMATCH" }; + } + if ( + !isStoredDatasetBudget(budget) || + budget.usedBytes > expected.storagePolicy.hardBudgetBytes + ) { + return { ok: false, reason: "CORRUPT" }; + } + return { ok: true }; }