fix(storage): delete a partition's IndexedDB dataset when an authorized purge cannot open it (05-03)

LOGOUT and ACCOUNT_DELETION purged row by row and so needed an open that a
corrupt budget or binding row always rejected, leaving personal rows on the
device. After authority approval, a purge that finds the dataset rejected by
admission now deletes that partition's own database and reports it; healthy
datasets and other partitions are untouched.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
DongHyeonka
2026-09-25 22:24:55 +09:00
co-authored by Claude Opus 5.5
parent 9cae587aea
commit 3e37fbf0ed
7 changed files with 412 additions and 10 deletions
@@ -36,6 +36,9 @@ primitive를 coordinator 완료 증거로 사용하지 않는다.
incident 중에도 다음 작업은 금지한다.
- 자동 또는 일괄 `deleteDatabase()`
- 예외는 하나다. authority가 승인한 LOGOUT/ACCOUNT_DELETION이 손상된
governance 때문에 dataset을 열 수 없을 때, runtime이 그 partition의 DB
하나만 지운다(§5 "database 전체 삭제" 참고).
- origin의 모든 `caches.keys()` 삭제
- user-authored/unsynced IndexedDB 또는 OPFS data 자동 purge
- schema version downgrade
@@ -248,7 +251,21 @@ remote tab 강제 종료, database 삭제, 무한 reload는 금지한다.
proof를 운영자가 수동 생성·재사용하지 않음
database 전체 삭제는 data owner가 export/recovery와 영향 scope를 승인한 별도
action이다.
action이다. runtime이 스스로 DB를 지우는 경우는 하나뿐이다(05-03).
- 조건: `enforceLifecycleBatch`의 action이 `LOGOUT` 또는 `ACCOUNT_DELETION`이고,
`authorizeLifecycle`이 proof를 내준 뒤, open이 `POLICY_REJECTED` 또는
`CORRUPT_DATA`로 실패했을 때(budget/binding 행 손상, 바뀐 policy). 행 단위
purge는 open이 필요해서 이 상태에서는 영영 돌 수 없다
(`src/adapters/storage/indexeddb/indexeddb-runtime.ts` `deleteUnadmittedDataset`).
- 범위: 세 opaque token에서 만든 그 partition의 DB 이름 하나
(`indexeddb-governance.ts` `indexedDbPhysicalDatabaseName`). 다른 partition과
origin의 다른 DB는 건드리지 않는다.
- 결과: 지워지면 receipt `COMPLETE`와 `datasetDeleted: true`(행 수는 세지
않는다). 다른 context가 연결을 닫지 않아 blocked deadline이 지나면 `BLOCKED`
/ `RELOAD_OTHER_CONTEXTS`를 반환한다. 이때 삭제 요청은 브라우저에 살아 있어
나중에 적용될 수 있으므로 다른 tab을 닫고 같은 purge를 다시 호출한다.
- governance가 정상이면 지금처럼 행 단위 purge만 하고 DB는 지우지 않는다.
성공 판정:
@@ -605,9 +605,9 @@ export function createIndexedDbConnection<Failure>(
/**
* In this module because it is the same `IDBOpenDBRequest` state machine as
* `openIndexedDbDatabase`, not because three subsystems need it — only
* `indexeddb-checkpoint-store.ts` deletes a database, and nothing here asks the
* other three to start. Leaving it out would leave a third hand-written copy of
* `openIndexedDbDatabase`. Two callers delete a database:
* `indexeddb-checkpoint-store.ts`, and the IndexedDB runtime's authorized
* LOGOUT/ACCOUNT_DELETION purge when its dataset fails admission. Leaving it out would leave a third hand-written copy of
* the settle-once blocked-deadline latch eight lines away from the kernel's.
*
* There is deliberately no `signal`: the request cannot be cancelled after
@@ -24,6 +24,7 @@ import {
import { snapshotAbortTimers } from "../../platform/abortable-operation.ts";
import {
createIndexedDbConnection,
deleteIndexedDbDatabase,
openIndexedDbDatabase,
type IndexedDbTranslate,
} from "../../platform/indexeddb-connection.ts";
@@ -2500,7 +2501,9 @@ export function createIndexedDbRuntime<Value, WireValue, Query>(
cutoffEpochMs,
);
} else {
result = await purgePartitionRecords(input, deadline);
result =
(await deleteUnadmittedDataset(input.signal)) ??
(await purgePartitionRecords(input, deadline));
}
return observeResult(
operation,
@@ -2509,6 +2512,54 @@ export function createIndexedDbRuntime<Value, WireValue, Query>(
);
}
/**
* 05-03. A LOGOUT or ACCOUNT_DELETION purge must not depend on the dataset
* passing admission: a corrupt governance row rejects every open, so no row
* could ever be purged one by one. The authority has already approved this
* purge, and the database name comes from this partition's own tokens, so
* deleting the whole database touches no other partition. Returns `null`
* when a connection is ready for the row-by-row purge.
*/
async function deleteUnadmittedDataset(
signal: AbortSignal | undefined,
): Promise<BrowserDataResult<IndexedDbLifecycleBatchReceipt> | null> {
if (connection.current()) return null;
const opened = await open(signal);
if (opened.ok) return null;
if (
(opened.error.code !== "POLICY_REJECTED" &&
opened.error.code !== "CORRUPT_DATA") ||
disposed ||
typeof factory?.deleteDatabase !== "function"
) {
return opened;
}
const deleted = await deleteIndexedDbDatabase<BrowserDataFailure>({
factory,
databaseName,
translate: translateFor("INDEXEDDB_WRITE"),
blockedTimeoutMs,
timers,
});
if (!deleted.ok) return deleted;
if (deleted.value.kind === "BLOCKED_DEADLINE") {
// The request is still live and may yet land; the next call finds out.
return browserDataFailure("BLOCKED", "INDEXEDDB_WRITE", {
retryable: true,
recovery: "RELOAD_OTHER_CONTEXTS",
});
}
return browserDataSuccess(
Object.freeze({
state: "COMPLETE" as const,
scannedRows: 0,
deletedRows: 0,
budgetExhausted: false,
datasetDeleted: true as const,
}),
);
}
function close(): void {
if (disposed) return;
disposed = true;
@@ -144,6 +144,13 @@ export type IndexedDbLifecycleBatchReceipt = Readonly<{
scannedRows: number;
deletedRows: number;
budgetExhausted: boolean;
/**
* 05-03. Present when an authorized LOGOUT or ACCOUNT_DELETION found the
* dataset's governance rows unreadable, so no row could be purged one by
* one, and deleted the partition's whole database instead. Rows are then
* not counted.
*/
datasetDeleted?: true;
}>;
export type IndexedDbLifecycleAuthorityRequest = Readonly<{
@@ -23,12 +23,14 @@ async function startLifecycleRuntime(
name: string,
targetVersion: 1 | 2,
blockedTimeoutMs = 1_000,
partitioned = false,
): Promise<void> {
await page.evaluate(
async ({
currentDatabaseName,
currentTargetVersion,
currentBlockedTimeoutMs,
currentPartitioned,
}) => {
const modulePath =
"/src/adapters/storage/indexeddb/indexeddb-runtime.ts";
@@ -38,24 +40,31 @@ async function startLifecycleRuntime(
type LifecycleValue = Readonly<{ value: string }>;
const [authorityToken, namespaceToken, partitionToken] =
currentDatabaseName.slice("ca-idb-v1:".length).split(".");
const accountScope = currentPartitioned
? ("OPAQUE_PARTITION" as const)
: ("ORIGIN_SHARED" as const);
const scope = {
authorityToken,
namespaceToken,
partitionToken,
accountScope: "ORIGIN_SHARED" as const,
accountScope,
};
const storagePolicy = {
owner: "platform-storage",
namespace: "indexeddb-browser-lifecycle",
classification: "INTERNAL" as const,
authority: "SERVER" as const,
accountScope: "ORIGIN_SHARED" as const,
accountScope,
retention: { kind: "EXPLICIT_DELETE" as const },
softBudgetBytes: 1_000_000,
hardBudgetBytes: 2_000_000,
evictionPriority: "SYNCED_COPY" as const,
logoutAction: "KEEP_ORIGIN_SHARED" as const,
accountDeletionAction: "KEEP_ORIGIN_SHARED" as const,
logoutAction: currentPartitioned
? ("PURGE_PARTITION" as const)
: ("KEEP_ORIGIN_SHARED" as const),
accountDeletionAction: currentPartitioned
? ("PURGE_PARTITION" as const)
: ("KEEP_ORIGIN_SHARED" as const),
pressureAction: "RETAIN" as const,
unavailableFallback: "ONLINE_ONLY" as const,
};
@@ -184,6 +193,7 @@ async function startLifecycleRuntime(
currentDatabaseName: name,
currentTargetVersion: targetVersion,
currentBlockedTimeoutMs: blockedTimeoutMs,
currentPartitioned: partitioned,
},
);
}
@@ -1067,3 +1077,112 @@ test("fails a blocked v2 upgrade closed, then closes its late connection after t
await blockerPage.close();
}
});
test("05-03 deletes a partition's dataset for an authorized ACCOUNT_DELETION when its budget row is corrupt", async ({
page,
}) => {
const name = databaseName("corrupt-governance");
await page.goto("/");
await startLifecycleRuntime(page, name, 1, 1_000, true);
expect(await settleLifecycleRuntime(page)).toMatchObject({
opened: { ok: true },
});
expect(
await page.evaluate(async () => {
const runtime = (
globalThis as unknown as {
__indexedDbLifecycleRuntime: {
compareAndSwap(input: unknown): Promise<unknown>;
close(): void;
};
}
).__indexedDbLifecycleRuntime;
const written = await runtime.compareAndSwap({
key: "personal-1",
value: { value: "mine" },
expectedRevision: null,
idempotencyKey: "personal-create",
});
runtime.close();
return written;
}),
).toMatchObject({ ok: true });
expect(
await page.evaluate(
async (currentDatabaseName) =>
await new Promise<string>((resolve) => {
const request = indexedDB.open(currentDatabaseName, 1);
request.onerror = () =>
resolve(request.error?.name ?? "UNKNOWN_ERROR");
request.onsuccess = () => {
const database = request.result;
const transaction = database.transaction(
"governance",
"readwrite",
);
transaction.objectStore("governance").put({
bindingKey: "dataset-budget",
budgetVersion: 1,
usedBytes: -5,
receiptCount: 1,
});
transaction.oncomplete = () => {
database.close();
resolve("CORRUPTED");
};
transaction.onabort = () => {
database.close();
resolve("ABORTED");
};
};
}),
name,
),
).toBe("CORRUPTED");
await startLifecycleRuntime(page, name, 1, 1_000, true);
expect(await settleLifecycleRuntime(page)).toMatchObject({
opened: { ok: false, error: { code: "POLICY_REJECTED" } },
});
const purged = await page.evaluate(async () => {
const runtime = (
globalThis as unknown as {
__indexedDbLifecycleRuntime: {
enforceLifecycleBatch(input: unknown): Promise<unknown>;
};
}
).__indexedDbLifecycleRuntime;
return await runtime.enforceLifecycleBatch({
action: "ACCOUNT_DELETION",
maxRows: 100,
maxDurationMs: 5_000,
});
});
expect(purged).toMatchObject({
ok: true,
value: { state: "COMPLETE", datasetDeleted: true },
});
const remaining = await page.evaluate(async (currentDatabaseName) => {
(
globalThis as unknown as {
__indexedDbLifecycleRuntime?: { close(): void };
}
).__indexedDbLifecycleRuntime?.close();
// A fresh open of a deleted database runs its upgrade from version 0.
return await new Promise<number>((resolve, reject) => {
const request = indexedDB.open(currentDatabaseName);
let oldVersion = -1;
request.onupgradeneeded = (event) => {
oldVersion = event.oldVersion;
};
request.onsuccess = () => {
request.result.close();
const deletion = indexedDB.deleteDatabase(currentDatabaseName);
deletion.onsuccess = () => resolve(oldVersion);
deletion.onerror = () => reject(deletion.error);
};
request.onerror = () => reject(request.error);
});
}, name);
expect(remaining).toBe(0);
});
+56 -1
View File
@@ -29,8 +29,12 @@ type DatabaseState = {
stores: Map<string, StoreState>;
version: number;
latest: FakeDatabase | null;
/** Connections handed out by a successful open, closed or not. */
connections: FakeDatabase[];
/** Transactions that have not finished, in creation order. */
transactions: FakeTransaction[];
/** A `deleteDatabase` waiting for the open connections to close. */
pendingDelete: (() => void) | null;
};
function storeOf(state: DatabaseState, name: string): StoreState {
@@ -314,9 +318,10 @@ class FakeDatabase {
close(): void {
this.closed = true;
this.state.pendingDelete?.();
}
fireVersionChange(newVersion: number): void {
fireVersionChange(newVersion: number | null): void {
this.onversionchange?.({
oldVersion: this.version,
newVersion,
@@ -887,6 +892,8 @@ export class MemoryIndexedDbFactory {
readonly factory: IDBFactory = {
open: (name: string, version?: number) =>
this.open(name, version ?? 1) as unknown as IDBOpenDBRequest,
deleteDatabase: (name: string) =>
this.deleteDatabase(name) as unknown as IDBOpenDBRequest,
cmp: compareKeys,
} as IDBFactory;
@@ -958,6 +965,51 @@ export class MemoryIndexedDbFactory {
return request;
}
/**
* Like a browser: open connections get `versionchange` (new version
* `null`); if any stays open the request reports `blocked` and completes
* once the last one closes. The name then holds an empty version-0
* database, so `hasStore` answers false.
*/
deleteDatabase(name: string): MutableOpenRequest {
const request: MutableOpenRequest = {
...createRequest<IDBDatabase>(),
transaction: null,
onblocked: null,
onupgradeneeded: null,
};
queueMicrotask(() => {
const state = this.databaseNamed(name);
const oldVersion = state.version;
const finish = () => {
if (state.connections.some((connection) => !connection.closed)) {
return;
}
state.pendingDelete = null;
state.stores = new Map();
state.version = 0;
state.connections = [];
request.onsuccess?.({
oldVersion,
newVersion: null,
} as unknown as Event);
};
for (const connection of state.connections) {
if (!connection.closed) connection.fireVersionChange(null);
}
if (state.connections.some((connection) => !connection.closed)) {
state.pendingDelete = finish;
request.onblocked?.({
oldVersion,
newVersion: null,
} as IDBVersionChangeEvent);
return;
}
finish();
});
return request;
}
blockNextOpen(): void {
this.shouldBlockNextOpen = true;
}
@@ -1056,7 +1108,9 @@ export class MemoryIndexedDbFactory {
stores: new Map(),
version: 0,
latest: null,
connections: [],
transactions: [],
pendingDelete: null,
};
this.databases.set(name, state);
}
@@ -1101,6 +1155,7 @@ export class MemoryIndexedDbFactory {
state.version = targetVersion;
}
database.version = state.version;
state.connections.push(database);
request.result = database as unknown as IDBDatabase;
request.onsuccess?.(new Event("success"));
}
+153
View File
@@ -1453,3 +1453,156 @@ describe("IndexedDB runtime", () => {
expect(hardMemory.readRaw("records", "x")).toBeUndefined();
});
});
describe("05-03 a LOGOUT or ACCOUNT_DELETION purge survives corrupt governance", () => {
const partitionScope = {
...TEST_SCOPE,
accountScope: "OPAQUE_PARTITION" as const,
};
const otherScope = {
...partitionScope,
partitionToken: "partitiontoken_002",
};
const partitionPolicy = {
...TEST_STORAGE_POLICY,
accountScope: "OPAQUE_PARTITION" as const,
logoutAction: "PURGE_PARTITION" as const,
accountDeletionAction: "PURGE_PARTITION" as const,
};
const batch = { maxRows: 100, maxDurationMs: 1_000 } as const;
/**
* Another partition and this one each hold a record in one factory; this
* partition's budget row is then corrupted, so a fresh runtime cannot pass
* admission (E1).
*/
async function corruptedPartition(
authorizeLifecycle: IndexedDbRuntimeDependencies<
Item,
Item,
Query
>["authorizeLifecycle"] = () => ({
authorized: true,
proofToken: "authorityproof_001",
}),
) {
const memory = new MemoryIndexedDbFactory();
const other = createIndexedDbRuntime(
dependencies(memory, {
scope: otherScope,
storagePolicy: partitionPolicy,
}),
);
expect(await other.open()).toMatchObject({ ok: true });
await other.compareAndSwap({
key: "kept",
value: { label: "other", rank: 1 },
expectedRevision: null,
idempotencyKey: "kept-create",
});
const writer = createIndexedDbRuntime(
dependencies(memory, {
scope: partitionScope,
storagePolicy: partitionPolicy,
}),
);
expect(await writer.open()).toMatchObject({ ok: true });
await writer.compareAndSwap({
key: "personal-1",
value: { label: "mine", rank: 1 },
expectedRevision: null,
idempotencyKey: "personal-create",
});
writer.close();
memory.seed("governance", {
bindingKey: "dataset-budget",
budgetVersion: 1,
usedBytes: -5,
receiptCount: 1,
});
const deleteDatabase = vi.spyOn(memory.factory, "deleteDatabase");
const fresh = createIndexedDbRuntime(
dependencies(memory, {
scope: partitionScope,
storagePolicy: partitionPolicy,
authorizeLifecycle,
}),
);
expect(await fresh.open()).toMatchObject({
ok: false,
error: { code: "POLICY_REJECTED" },
});
return { memory, other, fresh, deleteDatabase };
}
it.each(["LOGOUT", "ACCOUNT_DELETION"] as const)(
"deletes the partition's whole dataset for an authorized %s and leaves other partitions alone",
async (action) => {
const { memory, other, fresh, deleteDatabase } =
await corruptedPartition();
expect(
await fresh.enforceLifecycleBatch({ action, ...batch }),
).toMatchObject({
ok: true,
value: { state: "COMPLETE", datasetDeleted: true },
});
expect(deleteDatabase).toHaveBeenCalledTimes(1);
expect(deleteDatabase).toHaveBeenCalledWith(
indexedDbPhysicalDatabaseName(partitionScope),
);
expect(memory.hasStore("records")).toBe(false);
expect(await other.read("kept")).toMatchObject({
ok: true,
value: { value: { label: "other", rank: 1 } },
});
},
);
it("keeps the dataset when the authority does not approve", async () => {
const { memory, fresh, deleteDatabase } = await corruptedPartition(
() => ({ authorized: false }),
);
expect(
await fresh.enforceLifecycleBatch({ action: "ACCOUNT_DELETION", ...batch }),
).toMatchObject({ ok: false, error: { code: "POLICY_REJECTED" } });
expect(deleteDatabase).not.toHaveBeenCalled();
expect(memory.readRaw("records", "personal-1")).toBeDefined();
});
it("purges row by row, never the database, when governance is healthy", async () => {
const memory = new MemoryIndexedDbFactory();
const deleteDatabase = vi.spyOn(memory.factory, "deleteDatabase");
const runtime = createIndexedDbRuntime(
dependencies(memory, {
scope: partitionScope,
storagePolicy: partitionPolicy,
}),
);
expect(await runtime.open()).toMatchObject({ ok: true });
await runtime.compareAndSwap({
key: "personal-1",
value: { label: "mine", rank: 1 },
expectedRevision: null,
idempotencyKey: "personal-create",
});
runtime.close();
const fresh = createIndexedDbRuntime(
dependencies(memory, {
scope: partitionScope,
storagePolicy: partitionPolicy,
}),
);
const purged = await fresh.enforceLifecycleBatch({
action: "LOGOUT",
...batch,
});
expect(purged).toMatchObject({ ok: true, value: { state: "COMPLETE" } });
expect(purged.ok && purged.value).not.toHaveProperty("datasetDeleted");
expect(deleteDatabase).not.toHaveBeenCalled();
expect(memory.hasStore("records")).toBe(true);
expect(memory.readRaw("records", "personal-1")).toBeUndefined();
});
});