feat: add the shared IndexedDB connection and transaction kernel
네 어댑터가 각자 구현한 open/blocked/upgrade/트랜잭션 메커니즘을 커널로 모은다. 사본은 아직 이행하지 않았으므로 런타임 동작은 그대로다. 실패 분류는 커널에 넣지 않고 translate 콜백으로 주입한다. RT/MT/OP의 mapIndexedDbException과 CP의 mapBrowserDataException이 같은 에러에 다른 답을 내며, 그 차이를 통일하는 것은 별건이기 때문이다. IndexedDbFailureCause는 translate의 입력과 호출자가 주는 admit FAIL에만 나오고 공개 반환 타입에는 나오지 않는다. 기존 커널 abortable-operation.ts는 AbortTerminalReason 3멤버를 반환 타입에 박아서 5종이 필요한 http v3가 아예 쓰지 못했는데, 그 함정을 피하기 위한 설계다. 사양 3.4의 네 호출부를 실제 코드로 써서 tsc --strict로 컴파일해 수용을 확인했다. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
DongHyeonka
co-authored by
Claude Opus 5
Claude Opus 5
parent
0f157494cd
commit
cb62bfb9a9
@@ -0,0 +1,699 @@
|
||||
/**
|
||||
* IDB-X-01. Shared IndexedDB connection mechanics.
|
||||
*
|
||||
* Four adapters independently reimplemented "turn an open request into a
|
||||
* promise, hold a blocked deadline, route upgrade/error/success, close a
|
||||
* connection that arrives after the caller gave up, and drop the cached handle
|
||||
* when the browser takes it away". Only the mechanics are shared here. Database
|
||||
* naming, schema, migrations, governance binding and the failure taxonomy stay
|
||||
* with each subsystem, so this module imports none of them and is not a
|
||||
* generic storage layer.
|
||||
*
|
||||
* The `IDBFactory` is a required parameter rather than a read of
|
||||
* `globalThis.indexedDB`. `eslint.config.ts:40-63` bans that property on every
|
||||
* browser root and `eslint.config.ts:519-530` grants the owned-adapter escape
|
||||
* hatch to `src/adapters/platform/browser-lifecycle.ts` as a single file, not
|
||||
* to this folder. Requiring the factory is also what all four callers already
|
||||
* do, so nothing in eslint.config.ts has to change.
|
||||
*
|
||||
* What this module owns: event wiring, the settle-once latch, the blocked
|
||||
* deadline and the cached-handle lifecycle. What it must never own: database
|
||||
* names, schemas, migrations, governance bindings, codecs, byte budgets,
|
||||
* retention, idempotency receipts, failure code tables, operation labels,
|
||||
* observation event shapes, durability defaults and budget criteria. Wanting to
|
||||
* move one of those in here is the signal to stop.
|
||||
*/
|
||||
|
||||
import type { Result } from "../../contracts/result.ts";
|
||||
import type { AbortTimerSnapshot } from "./abortable-operation.ts";
|
||||
|
||||
/**
|
||||
* Everything that can end an IndexedDB operation without the caller getting a
|
||||
* value. The kernel reports the cause; the caller's `translate` turns it into
|
||||
* that subsystem's failure code.
|
||||
*
|
||||
* This union is the extension point. `abortable-operation.ts:11` baked a closed
|
||||
* three-member `AbortTerminalReason` into its return type, so http v3 needed
|
||||
* five owners and could not use the kernel at all. Here the owner vocabulary is
|
||||
* never in a return type: adding a member is a compile error in every
|
||||
* `translate` (they are total functions over the union) rather than a silent
|
||||
* behavior change, and no consumer has to fork.
|
||||
*/
|
||||
export type IndexedDbFailureCause =
|
||||
/** A native throw or a `request.error` / `transaction.error`. */
|
||||
| Readonly<{ kind: "NATIVE_EXCEPTION"; error: unknown }>
|
||||
/** `onblocked` fired and no deadline was configured. */
|
||||
| Readonly<{ kind: "BLOCKED"; oldVersion: number; newVersion: number | null }>
|
||||
/** `onblocked` fired and the configured deadline then elapsed. */
|
||||
| Readonly<{ kind: "BLOCKED_DEADLINE" }>
|
||||
/** The caller's own `AbortSignal` fired. */
|
||||
| Readonly<{ kind: "CALLER_ABORT" }>
|
||||
/** The connection handle was closed, which is not the caller aborting. */
|
||||
| Readonly<{ kind: "CLOSED" }>
|
||||
/** `upgrade` returned `REJECTED`, or a version change happened unexpectedly. */
|
||||
| Readonly<{
|
||||
kind: "UPGRADE_REJECTED";
|
||||
oldVersion: number;
|
||||
newVersion: number | null;
|
||||
detail?: unknown;
|
||||
}>
|
||||
/** `admit` returned `REJECT`. `detail` is opaque to the kernel. */
|
||||
| Readonly<{ kind: "ADMISSION_REJECTED"; detail?: unknown }>
|
||||
/** A transaction completed without `succeed()` ever being called. */
|
||||
| Readonly<{ kind: "NO_VALUE_PRODUCED" }>
|
||||
/**
|
||||
* No `IDBFactory`, or a required `IDBKeyRange` the caller did not supply.
|
||||
* The kernel never raises this itself — the factory is a required parameter,
|
||||
* so the condition can only exist before the kernel is called. It is part of
|
||||
* the vocabulary so a caller that resolves those globals has one place to
|
||||
* name the failure instead of a second taxonomy beside `translate`.
|
||||
*/
|
||||
| Readonly<{ kind: "UNSUPPORTED" }>;
|
||||
|
||||
/**
|
||||
* Turns a cause into this subsystem's failure value. Built per call site so the
|
||||
* kernel never learns an operation label or a failure code; a caller that needs
|
||||
* `INDEXEDDB_READ` and one that needs `UPLOAD_RECONCILE` differ only here.
|
||||
*/
|
||||
export type IndexedDbTranslate<Failure> = (
|
||||
cause: IndexedDbFailureCause,
|
||||
) => Failure;
|
||||
|
||||
export type IndexedDbUpgradeContext = Readonly<{
|
||||
database: IDBDatabase;
|
||||
transaction: IDBTransaction;
|
||||
oldVersion: number;
|
||||
/** Never `null`: a null `newVersion` is reported as `UPGRADE_REJECTED` before `upgrade` runs. */
|
||||
newVersion: number;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* `REJECTED` aborts the versionchange transaction, so a schema change can never
|
||||
* commit under a rejected policy. A throw from `upgrade` is equivalent to
|
||||
* `REJECTED` with the thrown value as `detail`.
|
||||
*/
|
||||
export type IndexedDbUpgradeOutcome =
|
||||
| Readonly<{ kind: "APPLIED" }>
|
||||
| Readonly<{ kind: "REJECTED"; detail?: unknown }>;
|
||||
|
||||
/**
|
||||
* Post-open validation. It runs after `onsuccess` and may be asynchronous, so
|
||||
* store/index assertions and governance reads both fit. A rejected or failed
|
||||
* admission closes the connection before the caller ever sees it.
|
||||
*/
|
||||
export type IndexedDbAdmission =
|
||||
| Readonly<{ kind: "ADMIT" }>
|
||||
| Readonly<{ kind: "REJECT"; detail?: unknown }>
|
||||
| Readonly<{ kind: "FAIL"; cause: IndexedDbFailureCause }>;
|
||||
|
||||
export type IndexedDbOpenInput<Failure> = Readonly<{
|
||||
/** Required. See the module comment for why this is not read from a global. */
|
||||
factory: IDBFactory;
|
||||
databaseName: string;
|
||||
/** Omit to open whatever version exists. */
|
||||
version?: number;
|
||||
translate: IndexedDbTranslate<Failure>;
|
||||
/**
|
||||
* Called inside the versionchange transaction. Omitting it means any upgrade
|
||||
* is unexpected and the open fails with `UPGRADE_REJECTED` — which is what
|
||||
* `indexeddb-maintenance.ts:477-484` does by hand today.
|
||||
*/
|
||||
upgrade?: (context: IndexedDbUpgradeContext) => IndexedDbUpgradeOutcome;
|
||||
/** Post-open validation. Omitting it admits every successful open. */
|
||||
admit?: (
|
||||
database: IDBDatabase,
|
||||
) => IndexedDbAdmission | Promise<IndexedDbAdmission>;
|
||||
/** Aborts a pending upgrade transaction and settles with `CALLER_ABORT`. */
|
||||
signal?: AbortSignal;
|
||||
/**
|
||||
* `undefined` or `0`: the `onblocked` event itself is terminal and settles
|
||||
* with `BLOCKED` (maintenance's behavior). A positive value waits that long
|
||||
* before settling with `BLOCKED_DEADLINE` (runtime/opfs/checkpoint).
|
||||
*/
|
||||
blockedTimeoutMs?: number;
|
||||
/**
|
||||
* Required when `blockedTimeoutMs` is positive. Build it with
|
||||
* `snapshotAbortTimers` from `./abortable-operation.ts`, which binds the
|
||||
* callables once so replacing a method after composition cannot change how an
|
||||
* open already in flight is bounded.
|
||||
*/
|
||||
timers?: AbortTimerSnapshot;
|
||||
/** Observation only; it cannot change the outcome and its throw is swallowed. */
|
||||
onBlocked?: (
|
||||
event: Readonly<{ oldVersion: number; newVersion: number | null }>,
|
||||
) => void;
|
||||
}>;
|
||||
|
||||
export type IndexedDbConnection<Failure> = Readonly<{
|
||||
/**
|
||||
* Single-flight: concurrent callers share one in-flight open, and a cached
|
||||
* live connection is returned without touching the factory.
|
||||
*/
|
||||
acquire(signal?: AbortSignal): Promise<Result<IDBDatabase, Failure>>;
|
||||
/** The cached connection, or `null` while none is live. Live accessor, not a snapshot. */
|
||||
current(): IDBDatabase | null;
|
||||
/**
|
||||
* Idempotent. Closes the cached connection and settles any in-flight open
|
||||
* with `CLOSED` — not `CALLER_ABORT`, because the two have different codes in
|
||||
* `indexeddb-runtime.ts` (`L743` resolves UNAVAILABLE while `L676` resolves
|
||||
* ABORTED), and collapsing them would change one of them.
|
||||
*/
|
||||
close(): void;
|
||||
isClosed(): boolean;
|
||||
}>;
|
||||
|
||||
export type IndexedDbConnectionInput<Failure> = Readonly<{
|
||||
/**
|
||||
* How to produce a connection. Normally a closure over
|
||||
* `openIndexedDbDatabase`. It is a seam rather than a fixed body so a caller
|
||||
* can retry, decorate or fake the open without faking an `IDBFactory`.
|
||||
*/
|
||||
open: (
|
||||
signal: AbortSignal | undefined,
|
||||
) => Promise<Result<IDBDatabase, Failure>>;
|
||||
translate: IndexedDbTranslate<Failure>;
|
||||
/**
|
||||
* Fired after the handle has already dropped its cached connection, so a
|
||||
* listener cannot keep a connection the browser is taking back. The next
|
||||
* `acquire()` opens again.
|
||||
*/
|
||||
onVersionChange?: (event: IDBVersionChangeEvent) => void;
|
||||
/** `onclose`: the browser closed the connection without a version change. */
|
||||
onForcedClose?: () => void;
|
||||
}>;
|
||||
|
||||
export type IndexedDbDeleteOutcome =
|
||||
| Readonly<{ kind: "DELETED" }>
|
||||
/**
|
||||
* The request is still live in the browser. It is not a failure and it is not
|
||||
* "not applied": `deleteDatabase` cannot be cancelled after dispatch, so the
|
||||
* effect is unknown. `indexeddb-checkpoint-store.ts:449-462` makes the same
|
||||
* distinction and its comment explains why.
|
||||
*/
|
||||
| Readonly<{ kind: "BLOCKED_DEADLINE" }>;
|
||||
|
||||
export type IndexedDbDeleteInput<Failure> = Readonly<{
|
||||
factory: IDBFactory;
|
||||
databaseName: string;
|
||||
translate: IndexedDbTranslate<Failure>;
|
||||
blockedTimeoutMs?: number;
|
||||
timers?: AbortTimerSnapshot;
|
||||
/**
|
||||
* Called exactly once when the native request truly settles, success or
|
||||
* error — never on a blocked deadline. The caller uses it to release a
|
||||
* pending-deletion registration; the kernel does not own such a registry
|
||||
* because whether a realm may recreate the database is the caller's policy.
|
||||
*/
|
||||
onSettled?: () => void;
|
||||
}>;
|
||||
|
||||
function succeeded<Value, Failure>(value: Value): Result<Value, Failure> {
|
||||
return Object.freeze({ ok: true as const, value });
|
||||
}
|
||||
|
||||
function failed<Value, Failure>(error: Failure): Result<Value, Failure> {
|
||||
return Object.freeze({ ok: false as const, error });
|
||||
}
|
||||
|
||||
/**
|
||||
* A connection that lost a race is closed, never leaked. The close itself is
|
||||
* best effort: a handle the browser already tore down cannot be closed again,
|
||||
* and that must not replace the outcome the caller was given.
|
||||
*/
|
||||
function closeQuietly(database: IDBDatabase): void {
|
||||
try {
|
||||
database.close();
|
||||
} catch {
|
||||
// A connection that cannot be closed is already gone.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A positive deadline with no scheduler leaves the open unbounded, which is the
|
||||
* same class of configuration defect `assertBoundedCapacity` and
|
||||
* `snapshotAbortTimers` reject at construction rather than at runtime. It is a
|
||||
* throw instead of a `Failure` because no `translate` could describe it without
|
||||
* the caller first deciding it is acceptable to run unbounded.
|
||||
*/
|
||||
function assertBlockedDeadline(
|
||||
blockedTimeoutMs: number | undefined,
|
||||
timers: AbortTimerSnapshot | undefined,
|
||||
): boolean {
|
||||
const bounded =
|
||||
blockedTimeoutMs !== undefined &&
|
||||
Number.isFinite(blockedTimeoutMs) &&
|
||||
blockedTimeoutMs > 0;
|
||||
if (bounded && !timers) {
|
||||
throw new TypeError(
|
||||
"A positive blockedTimeoutMs requires a timer snapshot.",
|
||||
);
|
||||
}
|
||||
return bounded;
|
||||
}
|
||||
|
||||
/**
|
||||
* Settles exactly once. A connection that arrives after the settle — a late
|
||||
* `onsuccess`, a rejected admission, an abort — is closed rather than leaked.
|
||||
*/
|
||||
export function openIndexedDbDatabase<Failure>(
|
||||
input: IndexedDbOpenInput<Failure>,
|
||||
): Promise<Result<IDBDatabase, Failure>> {
|
||||
const { factory, databaseName, translate } = input;
|
||||
const bounded = assertBlockedDeadline(input.blockedTimeoutMs, input.timers);
|
||||
if (input.signal?.aborted) {
|
||||
return Promise.resolve(failed(translate({ kind: "CALLER_ABORT" })));
|
||||
}
|
||||
|
||||
return new Promise<Result<IDBDatabase, Failure>>((resolve) => {
|
||||
let settled = false;
|
||||
let blockedTimer: unknown;
|
||||
let blockedTimerSet = false;
|
||||
let upgradeRejection: IndexedDbFailureCause | null = null;
|
||||
|
||||
const settle = (result: Result<IDBDatabase, Failure>) => {
|
||||
if (settled) {
|
||||
if (result.ok) closeQuietly(result.value);
|
||||
return;
|
||||
}
|
||||
settled = true;
|
||||
if (blockedTimerSet) {
|
||||
blockedTimerSet = false;
|
||||
try {
|
||||
input.timers?.clearTimer(blockedTimer);
|
||||
} catch {
|
||||
// A throwing scheduler cannot keep the open unresolved.
|
||||
}
|
||||
}
|
||||
try {
|
||||
input.signal?.removeEventListener("abort", onCallerAbort);
|
||||
} catch {
|
||||
// A hostile signal facade cannot block cleanup.
|
||||
}
|
||||
resolve(result);
|
||||
};
|
||||
const settleFailure = (cause: IndexedDbFailureCause) => {
|
||||
settle(failed(translate(cause)));
|
||||
};
|
||||
|
||||
let request: IDBOpenDBRequest;
|
||||
try {
|
||||
request =
|
||||
input.version === undefined
|
||||
? factory.open(databaseName)
|
||||
: factory.open(databaseName, input.version);
|
||||
} catch (error) {
|
||||
settleFailure({ kind: "NATIVE_EXCEPTION", error });
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* An upgrade transaction is the only cancellable part of an open request:
|
||||
* aborting it makes the request fail through `onerror`, and there is no
|
||||
* other way to stop a dispatched open.
|
||||
*/
|
||||
const abortUpgrade = () => {
|
||||
try {
|
||||
request.transaction?.abort();
|
||||
} catch {
|
||||
// The request's own error path owns whatever happens next.
|
||||
}
|
||||
};
|
||||
|
||||
function onCallerAbort(): void {
|
||||
abortUpgrade();
|
||||
settleFailure({ kind: "CALLER_ABORT" });
|
||||
}
|
||||
input.signal?.addEventListener("abort", onCallerAbort, { once: true });
|
||||
|
||||
request.onupgradeneeded = (event) => {
|
||||
const transaction = request.transaction;
|
||||
const oldVersion = event.oldVersion;
|
||||
const newVersion = event.newVersion;
|
||||
// A null `newVersion` means a delete is in progress, and no `upgrade`
|
||||
// policy can be applied to a schema that is going away. It is reported
|
||||
// before the callback runs so a caller never sees a half-open upgrade.
|
||||
if (!transaction || newVersion === null || !input.upgrade) {
|
||||
upgradeRejection = { kind: "UPGRADE_REJECTED", oldVersion, newVersion };
|
||||
abortUpgrade();
|
||||
return;
|
||||
}
|
||||
let outcome: IndexedDbUpgradeOutcome;
|
||||
try {
|
||||
outcome = input.upgrade({
|
||||
database: request.result,
|
||||
transaction,
|
||||
oldVersion,
|
||||
newVersion,
|
||||
});
|
||||
} catch (error) {
|
||||
outcome = { kind: "REJECTED", detail: error };
|
||||
}
|
||||
if (outcome.kind === "APPLIED") return;
|
||||
upgradeRejection = {
|
||||
kind: "UPGRADE_REJECTED",
|
||||
oldVersion,
|
||||
newVersion,
|
||||
detail: outcome.detail,
|
||||
};
|
||||
abortUpgrade();
|
||||
};
|
||||
|
||||
request.onblocked = (event) => {
|
||||
const blocked = Object.freeze({
|
||||
oldVersion: event.oldVersion,
|
||||
newVersion: event.newVersion,
|
||||
});
|
||||
if (input.onBlocked) {
|
||||
try {
|
||||
input.onBlocked(blocked);
|
||||
} catch {
|
||||
// Observation cannot change the outcome.
|
||||
}
|
||||
}
|
||||
if (!bounded) {
|
||||
settleFailure({ kind: "BLOCKED", ...blocked });
|
||||
return;
|
||||
}
|
||||
if (blockedTimerSet || settled) return;
|
||||
try {
|
||||
blockedTimer = input.timers?.setTimer(() => {
|
||||
settleFailure({ kind: "BLOCKED_DEADLINE" });
|
||||
}, input.blockedTimeoutMs as number);
|
||||
blockedTimerSet = true;
|
||||
} catch {
|
||||
// A scheduler that cannot install the deadline leaves the open
|
||||
// unbounded, so the deadline is treated as already elapsed.
|
||||
settleFailure({ kind: "BLOCKED_DEADLINE" });
|
||||
}
|
||||
};
|
||||
|
||||
request.onerror = () => {
|
||||
settleFailure(
|
||||
upgradeRejection ?? { kind: "NATIVE_EXCEPTION", error: request.error },
|
||||
);
|
||||
};
|
||||
|
||||
const routeAdmission = (
|
||||
database: IDBDatabase,
|
||||
admission: IndexedDbAdmission,
|
||||
) => {
|
||||
if (settled) {
|
||||
closeQuietly(database);
|
||||
return;
|
||||
}
|
||||
if (admission.kind === "ADMIT") {
|
||||
settle(succeeded(database));
|
||||
return;
|
||||
}
|
||||
// A connection the caller will never see is closed before the failure is
|
||||
// reported, so a rejected admission cannot leak a live handle.
|
||||
closeQuietly(database);
|
||||
settleFailure(
|
||||
admission.kind === "REJECT"
|
||||
? { kind: "ADMISSION_REJECTED", detail: admission.detail }
|
||||
: admission.cause,
|
||||
);
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
const database = request.result;
|
||||
if (settled) {
|
||||
closeQuietly(database);
|
||||
return;
|
||||
}
|
||||
if (!input.admit) {
|
||||
settle(succeeded(database));
|
||||
return;
|
||||
}
|
||||
let admission: IndexedDbAdmission | Promise<IndexedDbAdmission>;
|
||||
try {
|
||||
admission = input.admit(database);
|
||||
} catch (error) {
|
||||
closeQuietly(database);
|
||||
settleFailure({ kind: "NATIVE_EXCEPTION", error });
|
||||
return;
|
||||
}
|
||||
void Promise.resolve(admission).then(
|
||||
(resolved) => routeAdmission(database, resolved),
|
||||
(error: unknown) => {
|
||||
closeQuietly(database);
|
||||
settleFailure({ kind: "NATIVE_EXCEPTION", error });
|
||||
},
|
||||
);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export function createIndexedDbConnection<Failure>(
|
||||
input: IndexedDbConnectionInput<Failure>,
|
||||
): IndexedDbConnection<Failure> {
|
||||
let connection: IDBDatabase | null = null;
|
||||
let attempt: Promise<Result<IDBDatabase, Failure>> | null = null;
|
||||
let controller: AbortController | null = null;
|
||||
let closed = false;
|
||||
const closeWaiters = new Set<() => void>();
|
||||
|
||||
/**
|
||||
* The browser is taking the connection back. The cached handle is dropped
|
||||
* before the subsystem is told, so a notification callback cannot hand out a
|
||||
* connection that is already gone. The next `acquire()` opens again.
|
||||
*/
|
||||
const invalidate = (database: IDBDatabase, notify: () => void) => {
|
||||
if (connection !== database) return;
|
||||
connection = null;
|
||||
try {
|
||||
notify();
|
||||
} catch {
|
||||
// Losing the connection is independent from announcing it.
|
||||
}
|
||||
};
|
||||
|
||||
const adopt = (database: IDBDatabase): IDBDatabase => {
|
||||
database.onversionchange = (event) => {
|
||||
// The connection has to go for the other context's upgrade to proceed,
|
||||
// so it is closed here rather than left to a listener's discretion.
|
||||
closeQuietly(database);
|
||||
invalidate(database, () => input.onVersionChange?.(event));
|
||||
};
|
||||
database.onclose = () => {
|
||||
// `onclose` means the browser already tore the connection down, so there
|
||||
// is nothing left to close — only a cached handle to drop.
|
||||
invalidate(database, () => input.onForcedClose?.());
|
||||
};
|
||||
return database;
|
||||
};
|
||||
|
||||
const start = (): Promise<Result<IDBDatabase, Failure>> => {
|
||||
const openController = new AbortController();
|
||||
controller = openController;
|
||||
const started = input.open(openController.signal).then(
|
||||
(result) => {
|
||||
if (attempt === started) {
|
||||
attempt = null;
|
||||
controller = null;
|
||||
}
|
||||
if (!result.ok) return result;
|
||||
if (closed) {
|
||||
// The handle was closed while the open was in flight; the connection
|
||||
// that arrived belongs to nobody.
|
||||
closeQuietly(result.value);
|
||||
return result;
|
||||
}
|
||||
connection = adopt(result.value);
|
||||
return result;
|
||||
},
|
||||
(error: unknown) => {
|
||||
if (attempt === started) {
|
||||
attempt = null;
|
||||
controller = null;
|
||||
}
|
||||
return failed<IDBDatabase, Failure>(
|
||||
input.translate({ kind: "NATIVE_EXCEPTION", error }),
|
||||
);
|
||||
},
|
||||
);
|
||||
attempt = started;
|
||||
return started;
|
||||
};
|
||||
|
||||
return Object.freeze({
|
||||
acquire(signal) {
|
||||
if (closed) {
|
||||
return Promise.resolve(
|
||||
failed<IDBDatabase, Failure>(input.translate({ kind: "CLOSED" })),
|
||||
);
|
||||
}
|
||||
if (signal?.aborted) {
|
||||
return Promise.resolve(
|
||||
failed<IDBDatabase, Failure>(
|
||||
input.translate({ kind: "CALLER_ABORT" }),
|
||||
),
|
||||
);
|
||||
}
|
||||
const live = connection;
|
||||
if (live) return Promise.resolve(succeeded<IDBDatabase, Failure>(live));
|
||||
|
||||
const shared = attempt ?? start();
|
||||
// The shared open is not cancelled by one caller giving up: another
|
||||
// caller may still want the connection, and the request cannot be
|
||||
// un-dispatched anyway.
|
||||
return new Promise<Result<IDBDatabase, Failure>>((resolve) => {
|
||||
let callerSettled = false;
|
||||
const finishCaller = (result: Result<IDBDatabase, Failure>) => {
|
||||
if (callerSettled) return;
|
||||
callerSettled = true;
|
||||
try {
|
||||
signal?.removeEventListener("abort", onAbort);
|
||||
} catch {
|
||||
// A hostile signal facade cannot block cleanup.
|
||||
}
|
||||
resolve(result);
|
||||
};
|
||||
function onAbort(): void {
|
||||
finishCaller(
|
||||
failed(input.translate({ kind: "CALLER_ABORT" })),
|
||||
);
|
||||
}
|
||||
function onClose(): void {
|
||||
finishCaller(failed(input.translate({ kind: "CLOSED" })));
|
||||
}
|
||||
signal?.addEventListener("abort", onAbort, { once: true });
|
||||
closeWaiters.add(onClose);
|
||||
void shared.then(
|
||||
(result) => {
|
||||
closeWaiters.delete(onClose);
|
||||
// A handle closed mid-open reports CLOSED even if the open itself
|
||||
// succeeded: the connection is already gone.
|
||||
finishCaller(
|
||||
closed
|
||||
? failed(input.translate({ kind: "CLOSED" }))
|
||||
: result,
|
||||
);
|
||||
},
|
||||
() => {
|
||||
closeWaiters.delete(onClose);
|
||||
finishCaller(failed(input.translate({ kind: "CLOSED" })));
|
||||
},
|
||||
);
|
||||
});
|
||||
},
|
||||
current: () => connection,
|
||||
close() {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
const live = connection;
|
||||
connection = null;
|
||||
if (live) closeQuietly(live);
|
||||
// Cancelling the in-flight open aborts a pending upgrade transaction, so
|
||||
// a closed handle does not leave a versionchange transaction running.
|
||||
try {
|
||||
controller?.abort();
|
||||
} catch {
|
||||
// A cancelled open still reports CLOSED to its waiters below.
|
||||
}
|
||||
controller = null;
|
||||
for (const waiter of [...closeWaiters]) {
|
||||
closeWaiters.delete(waiter);
|
||||
waiter();
|
||||
}
|
||||
},
|
||||
isClosed: () => closed,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
* the settle-once blocked-deadline latch eight lines away from the kernel's.
|
||||
*
|
||||
* There is deliberately no `signal`: the request cannot be cancelled after
|
||||
* dispatch, so reporting ABORTED while the deletion may still commit would be a
|
||||
* lie. Callers check their signal before calling.
|
||||
*/
|
||||
export function deleteIndexedDbDatabase<Failure>(
|
||||
input: IndexedDbDeleteInput<Failure>,
|
||||
): Promise<Result<IndexedDbDeleteOutcome, Failure>> {
|
||||
const { factory, databaseName, translate } = input;
|
||||
const bounded = assertBlockedDeadline(input.blockedTimeoutMs, input.timers);
|
||||
|
||||
return new Promise<Result<IndexedDbDeleteOutcome, Failure>>((resolve) => {
|
||||
let settled = false;
|
||||
let notified = false;
|
||||
let blockedTimer: unknown;
|
||||
let blockedTimerSet = false;
|
||||
|
||||
/**
|
||||
* Independent of `settle`: a blocked deadline resolves the caller while the
|
||||
* request is still live, and the registration must be released when the
|
||||
* request actually lands, not when the caller stopped waiting.
|
||||
*/
|
||||
const notifySettled = () => {
|
||||
if (notified) return;
|
||||
notified = true;
|
||||
try {
|
||||
input.onSettled?.();
|
||||
} catch {
|
||||
// Releasing a registration cannot change the deletion outcome.
|
||||
}
|
||||
};
|
||||
|
||||
const settle = (result: Result<IndexedDbDeleteOutcome, Failure>) => {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
if (blockedTimerSet) {
|
||||
blockedTimerSet = false;
|
||||
try {
|
||||
input.timers?.clearTimer(blockedTimer);
|
||||
} catch {
|
||||
// A throwing scheduler cannot keep the deletion unresolved.
|
||||
}
|
||||
}
|
||||
resolve(result);
|
||||
};
|
||||
|
||||
let request: IDBOpenDBRequest;
|
||||
try {
|
||||
request = factory.deleteDatabase(databaseName);
|
||||
} catch (error) {
|
||||
notifySettled();
|
||||
settle(failed(translate({ kind: "NATIVE_EXCEPTION", error })));
|
||||
return;
|
||||
}
|
||||
|
||||
request.onsuccess = () => {
|
||||
notifySettled();
|
||||
settle(succeeded({ kind: "DELETED" as const }));
|
||||
};
|
||||
request.onerror = () => {
|
||||
notifySettled();
|
||||
settle(
|
||||
failed(translate({ kind: "NATIVE_EXCEPTION", error: request.error })),
|
||||
);
|
||||
};
|
||||
request.onblocked = (event) => {
|
||||
if (!bounded) {
|
||||
settle(
|
||||
failed(
|
||||
translate({
|
||||
kind: "BLOCKED",
|
||||
oldVersion: event.oldVersion,
|
||||
newVersion: event.newVersion,
|
||||
}),
|
||||
),
|
||||
);
|
||||
return;
|
||||
}
|
||||
if (blockedTimerSet || settled) return;
|
||||
try {
|
||||
blockedTimer = input.timers?.setTimer(() => {
|
||||
settle(succeeded({ kind: "BLOCKED_DEADLINE" as const }));
|
||||
}, input.blockedTimeoutMs as number);
|
||||
blockedTimerSet = true;
|
||||
} catch {
|
||||
settle(succeeded({ kind: "BLOCKED_DEADLINE" as const }));
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,433 @@
|
||||
/**
|
||||
* IDB-X-02. Shared IndexedDB transaction and cursor mechanics.
|
||||
*
|
||||
* The same settle-once transaction state machine exists four times
|
||||
* (`indexeddb-runtime.ts:976-1074`, `indexeddb-maintenance.ts:606-705`,
|
||||
* `indexeddb-opfs-journal.ts:1098-1174`,
|
||||
* `indexeddb-checkpoint-store.ts:497-596`) and the four already disagree: one
|
||||
* of them never routes a request error at all, one aborts on a request error
|
||||
* while two only record it, and one reports a value-less completion as
|
||||
* CORRUPT_DATA while three report UNAVAILABLE. This module owns the mechanics
|
||||
* and keeps every one of those choices at the call site.
|
||||
*
|
||||
* Like `indexeddb-connection.ts`, it owns no policy: not a store name, not a
|
||||
* durability default, not a budget criterion, not a failure code.
|
||||
*/
|
||||
|
||||
import type { Result } from "../../contracts/result.ts";
|
||||
import type { IndexedDbTranslate } from "./indexeddb-connection.ts";
|
||||
|
||||
export type IndexedDbDurability = "default" | "strict" | "relaxed";
|
||||
|
||||
/**
|
||||
* The failure half of a transaction context. Split out so helpers that only
|
||||
* need to report failure (`onIndexedDbRequest`, `walkIndexedDbCursor`) do not
|
||||
* have to be generic over the transaction's success type.
|
||||
*/
|
||||
export type IndexedDbRequestSink<Failure> = Readonly<{
|
||||
/**
|
||||
* Records the failure and aborts the transaction. The first failure wins.
|
||||
* This is `indexeddb-runtime.ts:1047-1054`'s `fail`.
|
||||
*/
|
||||
fail(failure: Failure): void;
|
||||
/**
|
||||
* Records a request-level error **without aborting**: the transaction is left
|
||||
* to complete or abort on its own, and the recorded error becomes the reported
|
||||
* failure if it aborts. This is `indexeddb-runtime.ts:1055-1060`'s
|
||||
* `requestFailed`.
|
||||
*
|
||||
* `indexeddb-checkpoint-store.ts:577-588` deliberately aborts instead. It
|
||||
* keeps doing so by calling `fail(translate({kind:"NATIVE_EXCEPTION", error}))`.
|
||||
* The kernel does not pick.
|
||||
*/
|
||||
requestFailed(error: unknown): void;
|
||||
}>;
|
||||
|
||||
export type IndexedDbTransactionContext<Value, Failure> =
|
||||
IndexedDbRequestSink<Failure> &
|
||||
Readonly<{
|
||||
/** The first `succeed` wins; later ones are ignored. */
|
||||
succeed(value: Value): void;
|
||||
/** For callers that need `objectStore()`/`index()` directly. */
|
||||
readonly transaction: IDBTransaction;
|
||||
}>;
|
||||
|
||||
export type IndexedDbTransactionInput<Value, Failure> = Readonly<{
|
||||
database: IDBDatabase;
|
||||
stores: readonly string[];
|
||||
mode: "readonly" | "readwrite";
|
||||
translate: IndexedDbTranslate<Failure>;
|
||||
/** Aborts the transaction; the outcome is `CALLER_ABORT` unless completion won. */
|
||||
signal?: AbortSignal;
|
||||
/**
|
||||
* `undefined` opens with **no options bag at all**, which is
|
||||
* `indexeddb-checkpoint-store.ts:512`'s current behavior — not the same as
|
||||
* `"default"`, which passes `{durability:"default"}`. A named value falls back
|
||||
* to the no-options form when the engine rejects the bag with a `TypeError`.
|
||||
*/
|
||||
durability?: IndexedDbDurability;
|
||||
queue: (
|
||||
transaction: IDBTransaction,
|
||||
context: IndexedDbTransactionContext<Value, Failure>,
|
||||
) => void;
|
||||
}>;
|
||||
|
||||
/** How the visitor wants the cursor advanced. */
|
||||
export type IndexedDbCursorStep =
|
||||
| Readonly<{ kind: "CONTINUE" }>
|
||||
| Readonly<{ kind: "CONTINUE_FROM"; key: IDBValidKey }>
|
||||
| Readonly<{
|
||||
kind: "CONTINUE_PRIMARY";
|
||||
key: IDBValidKey;
|
||||
primaryKey: IDBValidKey;
|
||||
}>
|
||||
/** End the walk here; `done` gets `reason: "STOPPED"`. */
|
||||
| Readonly<{ kind: "STOP" }>
|
||||
/**
|
||||
* The visitor started its own request chain and will call `resume(step)` when
|
||||
* that chain finishes. Without this the pump is unusable by three of the four
|
||||
* callers: every walk in `indexeddb-runtime.ts` and `indexeddb-maintenance.ts`
|
||||
* issues nested requests before advancing (e.g. `L1487-1526`, `L2406-2471`,
|
||||
* `L1490-1541`). A pump that only understood `CONTINUE` would be the
|
||||
* too-narrow-to-adopt failure again.
|
||||
*/
|
||||
| Readonly<{ kind: "SUSPEND" }>;
|
||||
|
||||
export type IndexedDbBudgetVerdict = "CONTINUE" | "ROW_BUDGET" | "TIME_BUDGET";
|
||||
|
||||
export type IndexedDbBudget<Failure> = Readonly<{
|
||||
/**
|
||||
* Checked before each row, with the number of rows already handed to `visit`.
|
||||
* The kernel counts nothing itself: runtime bounds on rows it deleted
|
||||
* (`indexeddb-runtime.ts:2384`) while maintenance bounds on rows it scanned
|
||||
* (`indexeddb-maintenance.ts:823`), so the counter, the clock and the deadline
|
||||
* all belong to the caller. A clock that cannot be read is a failure rather
|
||||
* than a `false`, which is what `monotonicClock()`
|
||||
* (`indexeddb-runtime.ts:2260-2269`) already does.
|
||||
*/
|
||||
admit(scannedRows: number): Result<IndexedDbBudgetVerdict, Failure>;
|
||||
}>;
|
||||
|
||||
export type IndexedDbCursorVisit = Readonly<{
|
||||
cursor: IDBCursorWithValue;
|
||||
/** Rows handed to `visit` so far, this row included. */
|
||||
scannedRows: number;
|
||||
/** Only meaningful after the visitor returned `SUSPEND`. Idempotent. */
|
||||
resume(step: IndexedDbCursorStep): void;
|
||||
}>;
|
||||
|
||||
export type IndexedDbWalkSummary = Readonly<{
|
||||
reason: "EXHAUSTED" | "STOPPED" | "ROW_BUDGET" | "TIME_BUDGET" | "ABORTED";
|
||||
scannedRows: number;
|
||||
}>;
|
||||
|
||||
export type IndexedDbWalkInput<Failure> = Readonly<{
|
||||
request: IDBRequest<IDBCursorWithValue | null>;
|
||||
sink: IndexedDbRequestSink<Failure>;
|
||||
translate: IndexedDbTranslate<Failure>;
|
||||
budget?: IndexedDbBudget<Failure>;
|
||||
/**
|
||||
* Checked at each row. An aborted signal aborts the transaction and ends the
|
||||
* walk with `reason: "ABORTED"`, which is what `indexeddb-runtime.ts:1375-1382`
|
||||
* does inline today.
|
||||
*/
|
||||
signal?: AbortSignal;
|
||||
visit: (visit: IndexedDbCursorVisit) => IndexedDbCursorStep;
|
||||
/** The only success exit. The caller routes it into its own `succeed`. */
|
||||
done: (summary: IndexedDbWalkSummary) => void;
|
||||
}>;
|
||||
|
||||
function succeeded<Value, Failure>(value: Value): Result<Value, Failure> {
|
||||
return Object.freeze({ ok: true as const, value });
|
||||
}
|
||||
|
||||
function failed<Value, Failure>(error: Failure): Result<Value, Failure> {
|
||||
return Object.freeze({ ok: false as const, error });
|
||||
}
|
||||
|
||||
/**
|
||||
* The durability fallback on its own, for a caller that manages its own
|
||||
* transaction. `undefined` omits the options bag entirely.
|
||||
*/
|
||||
export function openIndexedDbTransaction(
|
||||
database: IDBDatabase,
|
||||
stores: readonly string[],
|
||||
mode: "readonly" | "readwrite",
|
||||
durability?: IndexedDbDurability,
|
||||
): IDBTransaction {
|
||||
const names = [...stores];
|
||||
// Not the same as `{durability:"default"}`: an engine that has never seen the
|
||||
// options bag treats the two differently, and one caller relies on that.
|
||||
if (durability === undefined) return database.transaction(names, mode);
|
||||
try {
|
||||
return database.transaction(names, mode, { durability });
|
||||
} catch (error) {
|
||||
// Only an engine that does not know the option answers with a TypeError.
|
||||
// Anything else — a closed connection, an unknown store — is a real error
|
||||
// and must not be retried into a second, differently shaped failure.
|
||||
if (error instanceof TypeError) return database.transaction(names, mode);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A transaction that completes without `succeed()` is reported through
|
||||
* `translate({kind:"NO_VALUE_PRODUCED"})`. Three callers map that to
|
||||
* UNAVAILABLE and `indexeddb-checkpoint-store.ts:541-547` maps it to
|
||||
* CORRUPT_DATA; the kernel never picks.
|
||||
*/
|
||||
export function runIndexedDbTransaction<Value, Failure>(
|
||||
input: IndexedDbTransactionInput<Value, Failure>,
|
||||
): Promise<Result<Value, Failure>> {
|
||||
const { translate } = input;
|
||||
if (input.signal?.aborted) {
|
||||
return Promise.resolve(failed(translate({ kind: "CALLER_ABORT" })));
|
||||
}
|
||||
|
||||
let transaction: IDBTransaction;
|
||||
try {
|
||||
transaction = openIndexedDbTransaction(
|
||||
input.database,
|
||||
input.stores,
|
||||
input.mode,
|
||||
input.durability,
|
||||
);
|
||||
} catch (error) {
|
||||
return Promise.resolve(failed(translate({ kind: "NATIVE_EXCEPTION", error })));
|
||||
}
|
||||
|
||||
return new Promise<Result<Value, Failure>>((resolve) => {
|
||||
let candidate: Result<Value, Failure> | undefined;
|
||||
let requestError: unknown;
|
||||
let hasRequestError = false;
|
||||
let callerAborted = false;
|
||||
let settled = false;
|
||||
|
||||
const finish = (result: Result<Value, Failure>) => {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
try {
|
||||
input.signal?.removeEventListener("abort", onCallerAbort);
|
||||
} catch {
|
||||
// A hostile signal facade cannot block cleanup.
|
||||
}
|
||||
resolve(result);
|
||||
};
|
||||
|
||||
function onCallerAbort(): void {
|
||||
const previous = callerAborted;
|
||||
callerAborted = true;
|
||||
try {
|
||||
transaction.abort();
|
||||
} catch {
|
||||
// CP-4. The transaction may already be durably committed while its
|
||||
// completion event is still queued. Claiming the abort would report a
|
||||
// committed mutation as ABORTED, so the claim is withdrawn and the
|
||||
// transaction's own events decide.
|
||||
callerAborted = previous;
|
||||
}
|
||||
}
|
||||
|
||||
transaction.oncomplete = () => {
|
||||
finish(candidate ?? failed(translate({ kind: "NO_VALUE_PRODUCED" })));
|
||||
};
|
||||
transaction.onerror = () => {
|
||||
// `onabort` is the terminal signal; this only captures the error that a
|
||||
// request left behind before the transaction unwinds.
|
||||
if (hasRequestError) return;
|
||||
requestError = transaction.error;
|
||||
hasRequestError = true;
|
||||
};
|
||||
transaction.onabort = () => {
|
||||
if (callerAborted) {
|
||||
finish(failed(translate({ kind: "CALLER_ABORT" })));
|
||||
return;
|
||||
}
|
||||
if (candidate && !candidate.ok) {
|
||||
finish(candidate);
|
||||
return;
|
||||
}
|
||||
// An abort never yields the value a `succeed` recorded: the transaction
|
||||
// did not commit, so the native error is what happened.
|
||||
finish(
|
||||
failed(
|
||||
translate({
|
||||
kind: "NATIVE_EXCEPTION",
|
||||
error: hasRequestError ? requestError : transaction.error,
|
||||
}),
|
||||
),
|
||||
);
|
||||
};
|
||||
input.signal?.addEventListener("abort", onCallerAbort, { once: true });
|
||||
|
||||
const context: IndexedDbTransactionContext<Value, Failure> = Object.freeze({
|
||||
transaction,
|
||||
succeed(value) {
|
||||
candidate ??= succeeded(value);
|
||||
},
|
||||
fail(failure) {
|
||||
candidate ??= failed(failure);
|
||||
try {
|
||||
transaction.abort();
|
||||
} catch {
|
||||
// The transaction is already finished, so no abort event is coming.
|
||||
// The recorded failure is the outcome rather than a hang.
|
||||
finish(candidate);
|
||||
}
|
||||
},
|
||||
requestFailed(error) {
|
||||
if (!hasRequestError) {
|
||||
requestError = error;
|
||||
hasRequestError = true;
|
||||
}
|
||||
candidate ??= failed(translate({ kind: "NATIVE_EXCEPTION", error }));
|
||||
},
|
||||
});
|
||||
|
||||
try {
|
||||
input.queue(transaction, context);
|
||||
} catch (error) {
|
||||
context.fail(translate({ kind: "NATIVE_EXCEPTION", error }));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Wires `onsuccess`/`onerror` in one place. The four copies write this pair by
|
||||
* hand at roughly 70 sites and `indexeddb-opfs-journal.ts` omits `onerror`
|
||||
* everywhere, which is how a request-level error there becomes whatever
|
||||
* `transaction.error` happens to hold.
|
||||
*/
|
||||
export function onIndexedDbRequest<Value, Failure>(
|
||||
request: IDBRequest<Value>,
|
||||
sink: IndexedDbRequestSink<Failure>,
|
||||
onSuccess: (value: Value) => void,
|
||||
): void {
|
||||
request.onsuccess = () => {
|
||||
onSuccess(request.result);
|
||||
};
|
||||
request.onerror = () => {
|
||||
sink.requestFailed(request.error);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Drives an open cursor. It reports a native advance failure through `sink` and
|
||||
* never decides what a finished walk means — `reason` distinguishes a row budget
|
||||
* from a time budget so a caller can keep reporting `budgetExhausted` exactly as
|
||||
* it does now (`indexeddb-runtime.ts:2387`).
|
||||
*/
|
||||
export function walkIndexedDbCursor<Failure>(
|
||||
input: IndexedDbWalkInput<Failure>,
|
||||
): void {
|
||||
const { request, sink, translate } = input;
|
||||
let scannedRows = 0;
|
||||
let finished = false;
|
||||
|
||||
const end = (reason: IndexedDbWalkSummary["reason"]) => {
|
||||
if (finished) return;
|
||||
finished = true;
|
||||
input.done(Object.freeze({ reason, scannedRows }));
|
||||
};
|
||||
const abandon = (failure: Failure) => {
|
||||
if (finished) return;
|
||||
finished = true;
|
||||
sink.fail(failure);
|
||||
};
|
||||
|
||||
const advance = (action: () => void) => {
|
||||
try {
|
||||
action();
|
||||
} catch (error) {
|
||||
abandon(translate({ kind: "NATIVE_EXCEPTION", error }));
|
||||
}
|
||||
};
|
||||
|
||||
const applyStep = (
|
||||
cursor: IDBCursorWithValue,
|
||||
step: IndexedDbCursorStep,
|
||||
): void => {
|
||||
switch (step.kind) {
|
||||
case "CONTINUE":
|
||||
advance(() => cursor.continue());
|
||||
return;
|
||||
case "CONTINUE_FROM":
|
||||
advance(() => cursor.continue(step.key));
|
||||
return;
|
||||
case "CONTINUE_PRIMARY":
|
||||
advance(() => cursor.continuePrimaryKey(step.key, step.primaryKey));
|
||||
return;
|
||||
case "STOP":
|
||||
end("STOPPED");
|
||||
return;
|
||||
case "SUSPEND":
|
||||
// The visitor owns the cursor until it calls `resume`.
|
||||
return;
|
||||
default: {
|
||||
const exhaustive: never = step;
|
||||
return exhaustive;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
request.onerror = () => {
|
||||
if (finished) return;
|
||||
finished = true;
|
||||
// No `done`: the walk produced no summary, and the transaction's own
|
||||
// outcome decides what a failed advance means for this call site.
|
||||
sink.requestFailed(request.error);
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
if (finished) return;
|
||||
const cursor = request.result;
|
||||
if (!cursor) {
|
||||
end("EXHAUSTED");
|
||||
return;
|
||||
}
|
||||
if (input.signal?.aborted) {
|
||||
// Aborting through the sink keeps one abort path instead of reaching for
|
||||
// a transaction the pump was never handed. `done` still runs so the
|
||||
// caller sees why the walk stopped; the recorded failure outranks any
|
||||
// value it produces there.
|
||||
finished = true;
|
||||
sink.fail(translate({ kind: "CALLER_ABORT" }));
|
||||
input.done(Object.freeze({ reason: "ABORTED" as const, scannedRows }));
|
||||
return;
|
||||
}
|
||||
if (input.budget) {
|
||||
const verdict = input.budget.admit(scannedRows);
|
||||
if (!verdict.ok) {
|
||||
abandon(verdict.error);
|
||||
return;
|
||||
}
|
||||
if (verdict.value === "ROW_BUDGET" || verdict.value === "TIME_BUDGET") {
|
||||
end(verdict.value);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
scannedRows += 1;
|
||||
let suspended = false;
|
||||
let resumed = false;
|
||||
const resume = (step: IndexedDbCursorStep) => {
|
||||
if (!suspended || resumed || finished) return;
|
||||
resumed = true;
|
||||
applyStep(cursor, step);
|
||||
};
|
||||
|
||||
let step: IndexedDbCursorStep;
|
||||
try {
|
||||
step = input.visit(
|
||||
Object.freeze({ cursor, scannedRows, resume }),
|
||||
);
|
||||
} catch (error) {
|
||||
// A visitor defect must not let a partially applied write commit, so it
|
||||
// aborts rather than merely being recorded.
|
||||
abandon(translate({ kind: "NATIVE_EXCEPTION", error }));
|
||||
return;
|
||||
}
|
||||
if (step.kind === "SUSPEND") suspended = true;
|
||||
applyStep(cursor, step);
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user