Carries 359 template commits, tag v0.2.0 plus one documentation commit: the generator-built feature index with its app, bounded-context and feature declarations, the src/platform kernel and scale tooling, the 2026-09-24 src review fixes, and the 2026-09-25 maturity review round with its CHANGELOG [보안]/[계약] rows. 691 of the 824 template paths are applied, 85 of them merged with product changes; 127 are not carried. Product identity is unchanged: name, version 0.1.0, routes, design and the TechLog domain. Three decisions worth naming. TechLog stays composed directly, as the last two syncs recorded; its directory carries a NOT_INSTALLED marker that says so, and every installed-* composer takes the template's projection with TechLog added on top. The reference sample is no longer installed: the template now installs a feature only through feature-module.ts and context-routes.ts, which load the screens this product deleted, so its three operations, six schemas and one topic leave the registries, recorded as registry change evidence. And AppRouter mounts the platform and TechLog routes only; the template's bounded-context route gateway waits for a generator-installed feature. Required fixes: readSubject on the BFF session owner (without it every HTTP Studio session would close as integration-failed), zod through the facade in nine TechLog files, noUnusedLocals, and public/config.json written out to match the local profile. Derived baselines were recomputed after reproducing both sides' values: CI contract 101 commands / 106 references / 141 artifacts, gate shape c9adcf85; registry approval 2dc6c3a3; the runtime config schema baseline equals the schema at8210d48. Verified here: types, lint, architecture, adapter inventory, CI contract, i18n, design system, diagnostics, browser security, dev release manifest, TechLog contract and build pass; 220 component, 155 integration, 15 contract, 418 TechLog, 43 reference-feature, 18 recipe and 46 release-coherence tests pass, and 2381 of 2383 unit tests. Reproduced at8210d48first and unchanged: check:registries (byte-identical), test:runtime-schema, verify:documentation. Brought by the template and escalated rather than suppressed: check:request-fanout on TechLog's cursor pagination, check:remediation-ledger (fails upstream too), the shared-chunk hash test, and the registry-dependent sample removal and second-feature tests. Playwright suites were not run. Full record, the five open questions and the follow-ups in docs/operations/template-sync-2026-09-29.md. (cherry picked from commit b2170cf265dea45dc9cc05d3c61e627e97f31cdb)
823 lines
26 KiB
TypeScript
823 lines
26 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import type {
|
|
BeginOpfsJournalTransaction,
|
|
OpfsPreparedObject,
|
|
OpfsStorageScope,
|
|
} from "../../src/application/ports/browser-file-storage/opfs-ports.ts";
|
|
import type {
|
|
BrowserStoragePolicy,
|
|
} from "../../src/application/ports/browser-file-storage/shared.ts";
|
|
import {
|
|
createIndexedDbOpfsJournal,
|
|
opfsJournalDatabaseName,
|
|
} from "../../src/adapters/storage/opfs/indexeddb-opfs-journal.ts";
|
|
import { MemoryIndexedDbFactory } from "../helpers/memory-indexeddb.ts";
|
|
|
|
const authorityToken = "authority_12345678";
|
|
const scope: OpfsStorageScope = Object.freeze({
|
|
namespace: "durable-objects",
|
|
authorityToken,
|
|
namespaceToken: "namespace_12345678",
|
|
partitionToken: "partition_12345678",
|
|
});
|
|
const otherPartition: OpfsStorageScope = Object.freeze({
|
|
...scope,
|
|
partitionToken: "partition_87654321",
|
|
});
|
|
const policy: BrowserStoragePolicy = Object.freeze({
|
|
owner: "test-owner",
|
|
namespace: scope.namespace,
|
|
classification: "PERSONAL",
|
|
authority: "LOCAL_FIRST",
|
|
accountScope: "OPAQUE_PARTITION",
|
|
retention: Object.freeze({ kind: "EXPLICIT_DELETE" }),
|
|
softBudgetBytes: 8,
|
|
hardBudgetBytes: 10,
|
|
evictionPriority: "USER_AUTHORED",
|
|
logoutAction: "EXPORT_THEN_PURGE",
|
|
accountDeletionAction: "PURGE_PARTITION",
|
|
pressureAction: "RETAIN",
|
|
unavailableFallback: "EXPORT_REQUIRED",
|
|
});
|
|
|
|
function beginInput(
|
|
transactionId: string,
|
|
objectId: string,
|
|
byteLength: number,
|
|
targetScope = scope,
|
|
): BeginOpfsJournalTransaction {
|
|
return {
|
|
transactionId,
|
|
mutation: "PUT",
|
|
scope: targetScope,
|
|
objectId,
|
|
expectedGeneration: null,
|
|
targetGeneration: 1,
|
|
targetByteLength: byteLength,
|
|
targetStoragePolicy: {
|
|
...policy,
|
|
namespace: targetScope.namespace,
|
|
},
|
|
startedAtEpochMs: 100,
|
|
};
|
|
}
|
|
|
|
function prepared(
|
|
input: BeginOpfsJournalTransaction,
|
|
): OpfsPreparedObject {
|
|
return {
|
|
physicalSchemaVersion: 1,
|
|
descriptor: {
|
|
objectId: input.objectId,
|
|
scope: input.scope,
|
|
generation: input.targetGeneration,
|
|
byteLength: input.targetByteLength,
|
|
mediaType: "application/octet-stream",
|
|
createdAtEpochMs: input.startedAtEpochMs,
|
|
integrity: {
|
|
algorithm: "SHA-256-TREE-V1",
|
|
rootDigestHex: "a".repeat(64),
|
|
chunkSizeBytes: 64 * 1024,
|
|
},
|
|
storagePolicy: input.targetStoragePolicy,
|
|
},
|
|
chunks:
|
|
input.targetByteLength === 0
|
|
? []
|
|
: [
|
|
{
|
|
sequence: 0,
|
|
byteLength: input.targetByteLength,
|
|
digestHex: "b".repeat(64),
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Records every `transaction.abort()` the journal itself calls, with the mode
|
|
* of the transaction it aborted.
|
|
*
|
|
* A failure code alone cannot tell `fail` (record and abort) from
|
|
* `requestFailed` (record only): the fake aborts a transaction on a request
|
|
* error by itself, so both land on the same code while only one of them stops
|
|
* the writes queued behind it.
|
|
*/
|
|
function trackAborts(memory: MemoryIndexedDbFactory): Readonly<{
|
|
factory: IDBFactory;
|
|
aborts: readonly string[];
|
|
}> {
|
|
const aborts: string[] = [];
|
|
const wrapped = new WeakSet<object>();
|
|
const wrapDatabase = (database: IDBDatabase): IDBDatabase => {
|
|
if (wrapped.has(database)) return database;
|
|
wrapped.add(database);
|
|
const openTransaction = database.transaction.bind(database);
|
|
Object.defineProperty(database, "transaction", {
|
|
configurable: true,
|
|
value: (...args: Parameters<IDBDatabase["transaction"]>) => {
|
|
const transaction = openTransaction(...args);
|
|
const abort = transaction.abort.bind(transaction);
|
|
Object.defineProperty(transaction, "abort", {
|
|
configurable: true,
|
|
value: () => {
|
|
aborts.push(transaction.mode);
|
|
abort();
|
|
},
|
|
});
|
|
return transaction;
|
|
},
|
|
});
|
|
return database;
|
|
};
|
|
const factory = {
|
|
cmp: (first: IDBValidKey, second: IDBValidKey) =>
|
|
memory.factory.cmp(first, second),
|
|
open: (name: string, version?: number) => {
|
|
const request = memory.factory.open(name, version);
|
|
let stored: IDBDatabase | undefined = request.result;
|
|
if (stored) wrapDatabase(stored);
|
|
Object.defineProperty(request, "result", {
|
|
configurable: true,
|
|
get: () => stored,
|
|
set: (value: IDBDatabase | undefined) => {
|
|
stored = value ? wrapDatabase(value) : value;
|
|
},
|
|
});
|
|
return request;
|
|
},
|
|
} as unknown as IDBFactory;
|
|
return Object.freeze({ factory, aborts });
|
|
}
|
|
|
|
function createHarness(factory = new MemoryIndexedDbFactory()) {
|
|
let tokenSequence = 0;
|
|
const journal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: factory.factory,
|
|
// `listCommittedObjects` is the only caller that needs a key range, and
|
|
// this environment has no global one.
|
|
keyRange: factory.keyRange,
|
|
createFencingToken: () =>
|
|
`fencing_${String(++tokenSequence).padStart(8, "0")}`,
|
|
});
|
|
return { factory, journal };
|
|
}
|
|
|
|
async function commitObject(
|
|
journal: ReturnType<typeof createHarness>["journal"],
|
|
transactionId: string,
|
|
objectId: string,
|
|
byteLength: number,
|
|
): Promise<void> {
|
|
const input = beginInput(transactionId, objectId, byteLength);
|
|
const begun = await journal.begin(input);
|
|
if (!begun.ok) throw new Error(`begin failed for ${objectId}`);
|
|
const token = begun.value.fencingToken;
|
|
const ready = await journal.markFilesReady(
|
|
transactionId,
|
|
token,
|
|
prepared(input),
|
|
);
|
|
if (!ready.ok) throw new Error(`markFilesReady failed for ${objectId}`);
|
|
const committed = await journal.commitPut(transactionId, token);
|
|
if (!committed.ok) throw new Error(`commitPut failed for ${objectId}`);
|
|
const completed = await journal.complete(transactionId, token);
|
|
if (!completed.ok) throw new Error(`complete failed for ${objectId}`);
|
|
}
|
|
|
|
describe("IndexedDB OPFS journal", () => {
|
|
it("fences stale writers and atomically publishes object, budget and chunk refs", async () => {
|
|
const { factory, journal } = createHarness();
|
|
const input = beginInput(
|
|
"transaction_12345678",
|
|
"object_12345678",
|
|
3,
|
|
);
|
|
const begun = await journal.begin(input);
|
|
expect(begun).toMatchObject({ ok: true });
|
|
if (!begun.ok) throw new Error("begin failed");
|
|
|
|
expect(
|
|
await journal.markFilesReady(
|
|
input.transactionId,
|
|
"fencing_stale_1234",
|
|
prepared(input),
|
|
),
|
|
).toMatchObject({ ok: false, error: { code: "CONFLICT" } });
|
|
expect(
|
|
await journal.markFilesReady(
|
|
input.transactionId,
|
|
begun.value.fencingToken,
|
|
prepared(input),
|
|
),
|
|
).toMatchObject({ ok: true, value: { phase: "FILES_READY" } });
|
|
|
|
factory.failNextWriteCommit(
|
|
new DOMException("quota", "QuotaExceededError"),
|
|
);
|
|
expect(
|
|
await journal.commitPut(
|
|
input.transactionId,
|
|
begun.value.fencingToken,
|
|
),
|
|
).toMatchObject({ ok: false, error: { code: "QUOTA_EXCEEDED" } });
|
|
expect(
|
|
await journal.getCommittedObject(scope, input.objectId),
|
|
).toEqual({ ok: true, value: null });
|
|
expect(
|
|
await journal.isChunkReferenced(scope, "b".repeat(64)),
|
|
).toEqual({ ok: true, value: false });
|
|
|
|
expect(
|
|
await journal.commitPut(
|
|
input.transactionId,
|
|
begun.value.fencingToken,
|
|
),
|
|
).toMatchObject({ ok: true, value: { phase: "COMMITTED" } });
|
|
expect(
|
|
await journal.getCommittedObject(scope, input.objectId),
|
|
).toMatchObject({
|
|
ok: true,
|
|
value: { descriptor: { byteLength: 3, generation: 1 } },
|
|
});
|
|
expect(
|
|
await journal.isChunkReferenced(scope, "b".repeat(64)),
|
|
).toEqual({ ok: true, value: true });
|
|
expect(
|
|
await journal.isChunkReferenced(otherPartition, "b".repeat(64)),
|
|
).toEqual({ ok: true, value: false });
|
|
});
|
|
|
|
it("reserves the hard budget in the same transaction and releases it on rollback", async () => {
|
|
const { journal } = createHarness();
|
|
const first = await journal.begin(
|
|
beginInput("transaction_11111111", "object_11111111", 6),
|
|
);
|
|
expect(first).toMatchObject({ ok: true });
|
|
if (!first.ok) throw new Error("begin failed");
|
|
|
|
expect(
|
|
await journal.begin(
|
|
beginInput("transaction_22222222", "object_22222222", 5),
|
|
),
|
|
).toMatchObject({
|
|
ok: false,
|
|
error: { code: "LIMIT_EXCEEDED" },
|
|
});
|
|
expect(
|
|
await journal.begin(
|
|
beginInput(
|
|
"transaction_33333333",
|
|
"object_33333333",
|
|
10,
|
|
otherPartition,
|
|
),
|
|
),
|
|
).toMatchObject({ ok: true });
|
|
|
|
expect(
|
|
await journal.rollback(
|
|
"transaction_11111111",
|
|
first.value.fencingToken,
|
|
),
|
|
).toEqual({ ok: true, value: undefined });
|
|
expect(
|
|
await journal.begin(
|
|
beginInput("transaction_44444444", "object_44444444", 5),
|
|
),
|
|
).toMatchObject({ ok: true });
|
|
});
|
|
|
|
it("commits and completes a DELETE row without requiring a prepared object", async () => {
|
|
const { journal } = createHarness();
|
|
const putInput = beginInput(
|
|
"transaction_55555555",
|
|
"object_55555555",
|
|
2,
|
|
);
|
|
const put = await journal.begin(putInput);
|
|
if (!put.ok) throw new Error("put begin failed");
|
|
await journal.markFilesReady(
|
|
putInput.transactionId,
|
|
put.value.fencingToken,
|
|
prepared(putInput),
|
|
);
|
|
await journal.commitPut(
|
|
putInput.transactionId,
|
|
put.value.fencingToken,
|
|
);
|
|
await journal.complete(
|
|
putInput.transactionId,
|
|
put.value.fencingToken,
|
|
);
|
|
|
|
const deletion = await journal.begin({
|
|
transactionId: "transaction_66666666",
|
|
mutation: "DELETE",
|
|
scope,
|
|
objectId: putInput.objectId,
|
|
expectedGeneration: 1,
|
|
targetGeneration: 2,
|
|
targetByteLength: 0,
|
|
targetStoragePolicy: policy,
|
|
startedAtEpochMs: 200,
|
|
});
|
|
if (!deletion.ok) throw new Error("delete begin failed");
|
|
expect(
|
|
await journal.commitDelete(
|
|
"transaction_66666666",
|
|
deletion.value.fencingToken,
|
|
),
|
|
).toMatchObject({
|
|
ok: true,
|
|
value: { mutation: "DELETE", phase: "COMMITTED" },
|
|
});
|
|
expect(
|
|
await journal.complete(
|
|
"transaction_66666666",
|
|
deletion.value.fencingToken,
|
|
),
|
|
).toEqual({ ok: true, value: undefined });
|
|
expect(
|
|
await journal.getCommittedObject(scope, putInput.objectId),
|
|
).toEqual({ ok: true, value: null });
|
|
});
|
|
|
|
it("binds one opaque physical authority to one deterministic database", async () => {
|
|
expect(opfsJournalDatabaseName(authorityToken)).toBe(
|
|
`ca-frontend-opfs-metadata-v1:${authorityToken}`,
|
|
);
|
|
expect(() =>
|
|
createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
databaseName: "unrelated-database",
|
|
factory: new MemoryIndexedDbFactory().factory,
|
|
}),
|
|
).toThrow();
|
|
|
|
const { journal } = createHarness();
|
|
const binding = await journal.begin(
|
|
beginInput(
|
|
"transaction_binding_1234",
|
|
"object_binding_12345678",
|
|
1,
|
|
),
|
|
);
|
|
if (!binding.ok) throw new Error("scope binding failed");
|
|
await journal.rollback(
|
|
"transaction_binding_1234",
|
|
binding.value.fencingToken,
|
|
);
|
|
|
|
const remappedScope: OpfsStorageScope = {
|
|
...scope,
|
|
namespace: "different-namespace",
|
|
};
|
|
expect(
|
|
await journal.begin(
|
|
beginInput(
|
|
"transaction_remap_1234",
|
|
"object_remap_12345678",
|
|
1,
|
|
remappedScope,
|
|
),
|
|
),
|
|
).toMatchObject({
|
|
ok: false,
|
|
error: { code: "POLICY_REJECTED" },
|
|
});
|
|
const retokenedScope: OpfsStorageScope = {
|
|
...scope,
|
|
namespaceToken: "namespace_87654321",
|
|
};
|
|
expect(
|
|
await journal.begin(
|
|
beginInput(
|
|
"transaction_retoken_1234",
|
|
"object_retoken_12345678",
|
|
1,
|
|
retokenedScope,
|
|
),
|
|
),
|
|
).toMatchObject({
|
|
ok: false,
|
|
error: { code: "POLICY_REJECTED" },
|
|
});
|
|
expect(
|
|
await journal.begin({
|
|
...beginInput(
|
|
"transaction_policy_1234",
|
|
"object_policy_12345678",
|
|
1,
|
|
),
|
|
targetStoragePolicy: {
|
|
...policy,
|
|
owner: "different-owner",
|
|
},
|
|
}),
|
|
).toMatchObject({
|
|
ok: false,
|
|
error: { code: "POLICY_REJECTED" },
|
|
});
|
|
|
|
const foreignScope: OpfsStorageScope = {
|
|
...scope,
|
|
authorityToken: "authority_87654321",
|
|
};
|
|
expect(
|
|
await journal.getCommittedObject(
|
|
foreignScope,
|
|
"object_12345678",
|
|
),
|
|
).toMatchObject({ ok: false, error: { code: "INVALID_INPUT" } });
|
|
expect(
|
|
await journal.begin(
|
|
beginInput(
|
|
"transaction_77777777",
|
|
"object_77777777",
|
|
1,
|
|
foreignScope,
|
|
),
|
|
),
|
|
).toMatchObject({ ok: false, error: { code: "INVALID_INPUT" } });
|
|
});
|
|
|
|
it("maps synchronous open failures and blocked upgrades to Result failures", async () => {
|
|
const throwingFactory = {
|
|
open() {
|
|
throw new DOMException("denied", "SecurityError");
|
|
},
|
|
} as unknown as IDBFactory;
|
|
const throwingJournal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: throwingFactory,
|
|
});
|
|
await expect(
|
|
throwingJournal.getCommittedObject(scope, "object_12345678"),
|
|
).resolves.toMatchObject({
|
|
ok: false,
|
|
error: { code: "PERMISSION_DENIED" },
|
|
});
|
|
|
|
const factory = new MemoryIndexedDbFactory();
|
|
factory.blockNextOpen();
|
|
const callbacks: Array<() => void> = [];
|
|
const blockedJournal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: factory.factory,
|
|
blockedTimeoutMs: 1,
|
|
scheduler: {
|
|
setTimeout(callback) {
|
|
callbacks.push(callback);
|
|
return callback;
|
|
},
|
|
clearTimeout() {},
|
|
},
|
|
});
|
|
const opening = blockedJournal.getCommittedObject(
|
|
scope,
|
|
"object_12345678",
|
|
);
|
|
await Promise.resolve();
|
|
callbacks.forEach((callback) => callback());
|
|
await expect(opening).resolves.toMatchObject({
|
|
ok: false,
|
|
error: { code: "BLOCKED" },
|
|
});
|
|
});
|
|
|
|
it("reopens after versionchange and rejects corrupt persisted journal rows", async () => {
|
|
const { factory, journal } = createHarness();
|
|
expect(
|
|
await journal.getCommittedObject(scope, "object_12345678"),
|
|
).toEqual({ ok: true, value: null });
|
|
factory.triggerVersionChange(2);
|
|
expect(factory.isConnectionClosed()).toBe(true);
|
|
expect(
|
|
await journal.getCommittedObject(scope, "object_12345678"),
|
|
).toEqual({ ok: true, value: null });
|
|
|
|
factory.seed("opfs-journal", {
|
|
transactionId: "transaction_88888888",
|
|
startedAtEpochMs: 1,
|
|
corrupt: true,
|
|
});
|
|
expect(await journal.listIncomplete(10)).toMatchObject({
|
|
ok: false,
|
|
error: { code: "CORRUPT_DATA" },
|
|
});
|
|
});
|
|
|
|
it("reports a unique logical-key violation as the request's own ConstraintError", async () => {
|
|
// OP-1. Two open journal rows for one object collide on the `by-logical-key`
|
|
// index, which is the only `unique: true` index in `src/adapters`. The
|
|
// violation belongs to the `add` request, not to the transaction: the
|
|
// journal never asks for the row's uniqueness, it asks the index to enforce
|
|
// it, so the answer has to be the request's `ConstraintError` rather than
|
|
// whatever the transaction happened to abort with.
|
|
const memory = new MemoryIndexedDbFactory();
|
|
const tracker = trackAborts(memory);
|
|
let tokenSequence = 0;
|
|
const journal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: tracker.factory,
|
|
createFencingToken: () =>
|
|
`fencing_${String(++tokenSequence).padStart(8, "0")}`,
|
|
});
|
|
|
|
const first = await journal.begin(
|
|
beginInput("transaction_dupe0001", "object_dupe_1234", 1),
|
|
);
|
|
expect(first).toMatchObject({ ok: true });
|
|
|
|
expect(
|
|
await journal.begin(
|
|
beginInput("transaction_dupe0002", "object_dupe_1234", 1),
|
|
),
|
|
).toEqual({
|
|
ok: false,
|
|
error: {
|
|
code: "CONFLICT",
|
|
operation: "INDEXEDDB_WRITE",
|
|
retryable: false,
|
|
recovery: "NONE",
|
|
},
|
|
});
|
|
// `mapIndexedDbException`'s ConstraintError arm carries no recovery, while
|
|
// the journal's own `conflict()` helper carries REOPEN. The NONE above is
|
|
// what proves the answer came from the native error rather than from a
|
|
// predicate the journal evaluated itself.
|
|
expect(tracker.aborts).toEqual([]);
|
|
// The losing transaction rolled back whole: no budget reservation from the
|
|
// second `begin` survives, so the partition still admits its full budget.
|
|
expect(memory.readRaw("opfs-budgets", `${scope.authorityToken}|${scope.namespaceToken}|${scope.partitionToken}`)).toMatchObject({
|
|
reservedBytes: 1,
|
|
});
|
|
expect(
|
|
(await journal.listIncomplete(10)) as unknown,
|
|
).toMatchObject({
|
|
ok: true,
|
|
value: { transactions: [{ transactionId: "transaction_dupe0001" }] },
|
|
});
|
|
});
|
|
|
|
it("lets the first explicit failure win over a later success in the same transaction", async () => {
|
|
// OP-2. `begin` runs two independent request chains: the scope-binding
|
|
// chain can fail while the object/budget chain is still queued to succeed.
|
|
// The binding chain's `get` is issued first, so its verdict always lands
|
|
// first and the later `succeed` never reaches the caller. The abort count
|
|
// is what separates "the journal rejected this" from "the store did".
|
|
const memory = new MemoryIndexedDbFactory();
|
|
const tracker = trackAborts(memory);
|
|
let tokenSequence = 0;
|
|
const journal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: tracker.factory,
|
|
createFencingToken: () =>
|
|
`fencing_${String(++tokenSequence).padStart(8, "0")}`,
|
|
});
|
|
|
|
const bound = await journal.begin(
|
|
beginInput("transaction_order001", "object_order_1234", 1),
|
|
);
|
|
if (!bound.ok) throw new Error("binding begin failed");
|
|
await journal.rollback(
|
|
"transaction_order001",
|
|
bound.value.fencingToken,
|
|
);
|
|
const abortsBefore = tracker.aborts.length;
|
|
|
|
expect(
|
|
await journal.begin({
|
|
...beginInput("transaction_order002", "object_order_5678", 1),
|
|
targetStoragePolicy: { ...policy, owner: "rebound-owner" },
|
|
}),
|
|
).toEqual({
|
|
ok: false,
|
|
error: {
|
|
code: "POLICY_REJECTED",
|
|
operation: "INDEXEDDB_WRITE",
|
|
retryable: false,
|
|
recovery: "READ_ONLY",
|
|
},
|
|
});
|
|
// Exactly one abort, from the binding chain's `fail`. A second would mean
|
|
// the budget chain also reached a verdict.
|
|
expect(tracker.aborts.length - abortsBefore).toBe(1);
|
|
expect(memory.readRaw("opfs-journal", "transaction_order002")).toBeUndefined();
|
|
});
|
|
|
|
it("keeps a commit failure attributable to the transaction rather than a request", async () => {
|
|
// The commit itself fails, so no request ever errors. The journal must not
|
|
// claim an abort it did not perform, and the quota code has to come from
|
|
// the transaction's own error.
|
|
const memory = new MemoryIndexedDbFactory();
|
|
const tracker = trackAborts(memory);
|
|
let tokenSequence = 0;
|
|
const journal = createIndexedDbOpfsJournal({
|
|
authorityToken,
|
|
factory: tracker.factory,
|
|
createFencingToken: () =>
|
|
`fencing_${String(++tokenSequence).padStart(8, "0")}`,
|
|
});
|
|
|
|
memory.failNextWriteCommit(
|
|
new DOMException("quota", "QuotaExceededError"),
|
|
);
|
|
expect(
|
|
await journal.begin(
|
|
beginInput("transaction_quota001", "object_quota_1234", 1),
|
|
),
|
|
).toEqual({
|
|
ok: false,
|
|
error: {
|
|
code: "QUOTA_EXCEEDED",
|
|
operation: "INDEXEDDB_WRITE",
|
|
retryable: false,
|
|
recovery: "READ_ONLY",
|
|
},
|
|
});
|
|
expect(tracker.aborts).toEqual([]);
|
|
});
|
|
|
|
it("pages incomplete transactions and validates a row before the page limit", async () => {
|
|
const { factory, journal } = createHarness();
|
|
for (const index of [1, 2, 3]) {
|
|
const id = `transaction_page000${index}`;
|
|
expect(
|
|
await journal.begin(
|
|
beginInput(id, `object_page_000${index}`, 1),
|
|
),
|
|
).toMatchObject({ ok: true });
|
|
}
|
|
|
|
expect(await journal.listIncomplete(2)).toMatchObject({
|
|
ok: true,
|
|
value: { moreAvailable: true },
|
|
});
|
|
const page = await journal.listIncomplete(2);
|
|
if (!page.ok) throw new Error("listIncomplete failed");
|
|
expect(page.value.transactions).toHaveLength(2);
|
|
|
|
const whole = await journal.listIncomplete(10);
|
|
if (!whole.ok) throw new Error("listIncomplete failed");
|
|
expect(whole.value.transactions).toHaveLength(3);
|
|
expect(whole.value.moreAvailable).toBe(false);
|
|
|
|
// A corrupt row one past the requested page still fails the read. The
|
|
// journal validates a row before it checks the limit, so a page that is
|
|
// already full does not hide the next row's damage behind `moreAvailable`.
|
|
factory.seed("opfs-journal", {
|
|
transactionId: "transaction_page9999",
|
|
startedAtEpochMs: 9_000,
|
|
corrupt: true,
|
|
});
|
|
expect(await journal.listIncomplete(3)).toMatchObject({
|
|
ok: false,
|
|
error: { code: "CORRUPT_DATA", recovery: "READ_ONLY" },
|
|
});
|
|
});
|
|
|
|
it("pages committed objects and reports where the next page resumes", async () => {
|
|
const { journal } = createHarness();
|
|
await commitObject(journal, "transaction_obj00001", "object_aaaa0001", 1);
|
|
await commitObject(journal, "transaction_obj00002", "object_bbbb0002", 1);
|
|
await commitObject(journal, "transaction_obj00003", "object_cccc0003", 1);
|
|
|
|
const first = await journal.listCommittedObjects({ scope, limit: 2 });
|
|
if (!first.ok) throw new Error("listCommittedObjects failed");
|
|
expect(first.value.objects.map((o) => o.descriptor.objectId)).toEqual([
|
|
"object_aaaa0001",
|
|
"object_bbbb0002",
|
|
]);
|
|
// A page cut short by the limit names the cursor the caller resumes from.
|
|
expect(first.value.moreAvailable).toBe(true);
|
|
expect(first.value.nextObjectId).toBe("object_bbbb0002");
|
|
|
|
const second = await journal.listCommittedObjects({
|
|
scope,
|
|
limit: 2,
|
|
afterObjectId: first.value.nextObjectId ?? undefined,
|
|
});
|
|
if (!second.ok) throw new Error("listCommittedObjects failed");
|
|
expect(second.value.objects.map((o) => o.descriptor.objectId)).toEqual([
|
|
"object_cccc0003",
|
|
]);
|
|
// An exhausted scan has nothing to resume from, so it reports neither.
|
|
expect(second.value.moreAvailable).toBe(false);
|
|
expect(second.value.nextObjectId).toBeNull();
|
|
});
|
|
|
|
it("R-5.5 keeps an object readable by its own chunk size and still rejects an inconsistent one", async () => {
|
|
const { journal } = createHarness();
|
|
const chunkSizeBytes = 4 * 1024 * 1024;
|
|
const byteLength = chunkSizeBytes + 1;
|
|
const input: BeginOpfsJournalTransaction = {
|
|
...beginInput("transaction_chunk001", "object_chunk_001", byteLength),
|
|
targetStoragePolicy: {
|
|
...policy,
|
|
softBudgetBytes: 2 * byteLength,
|
|
hardBudgetBytes: 2 * byteLength,
|
|
},
|
|
};
|
|
const base = prepared(input);
|
|
const stored: OpfsPreparedObject = {
|
|
...base,
|
|
descriptor: {
|
|
...base.descriptor,
|
|
integrity: { ...base.descriptor.integrity, chunkSizeBytes },
|
|
},
|
|
chunks: [
|
|
{ sequence: 0, byteLength: chunkSizeBytes, digestHex: "c".repeat(64) },
|
|
{ sequence: 1, byteLength: 1, digestHex: "d".repeat(64) },
|
|
],
|
|
};
|
|
const begun = await journal.begin(input);
|
|
if (!begun.ok) throw new Error("begin failed");
|
|
const token = begun.value.fencingToken;
|
|
|
|
// A first chunk shorter than the object's own chunk size is not a
|
|
// well-formed object under any policy.
|
|
expect(
|
|
await journal.markFilesReady(input.transactionId, token, {
|
|
...stored,
|
|
chunks: [
|
|
{ sequence: 0, byteLength: 1, digestHex: "c".repeat(64) },
|
|
{ sequence: 1, byteLength: chunkSizeBytes, digestHex: "d".repeat(64) },
|
|
],
|
|
}),
|
|
).toMatchObject({ ok: false, error: { code: "INVALID_INPUT" } });
|
|
|
|
expect(
|
|
await journal.markFilesReady(input.transactionId, token, stored),
|
|
).toMatchObject({ ok: true, value: { phase: "FILES_READY" } });
|
|
expect(await journal.listIncomplete(10)).toMatchObject({
|
|
ok: true,
|
|
value: { transactions: [{ preparedObject: stored }] },
|
|
});
|
|
expect(
|
|
await journal.commitPut(input.transactionId, token),
|
|
).toMatchObject({ ok: true });
|
|
expect(
|
|
await journal.getCommittedObject(scope, input.objectId),
|
|
).toEqual({ ok: true, value: stored });
|
|
});
|
|
|
|
it("answers UNSUPPORTED once the journal is closed", async () => {
|
|
const { factory, journal } = createHarness();
|
|
expect(
|
|
await journal.getCommittedObject(scope, "object_12345678"),
|
|
).toEqual({ ok: true, value: null });
|
|
|
|
journal.close();
|
|
expect(factory.isConnectionClosed()).toBe(true);
|
|
// A closed journal is not a retryable outage and not an abort: the store
|
|
// is gone for this realm, so the caller is told to work online. The
|
|
// failure names INDEXEDDB_OPEN rather than the operation that asked,
|
|
// because it belongs to the open that never happened.
|
|
expect(
|
|
await journal.getCommittedObject(scope, "object_12345678"),
|
|
).toEqual({
|
|
ok: false,
|
|
error: {
|
|
code: "UNSUPPORTED",
|
|
operation: "INDEXEDDB_OPEN",
|
|
retryable: false,
|
|
recovery: "ONLINE_ONLY",
|
|
},
|
|
});
|
|
expect(
|
|
await journal.begin(
|
|
beginInput("transaction_closed001", "object_closed_001", 1),
|
|
),
|
|
).toMatchObject({ ok: false, error: { code: "UNSUPPORTED" } });
|
|
});
|
|
});
|
|
|
|
describe("05-06 a journal from a newer release", () => {
|
|
it("answers online-only instead of a migration failure", async () => {
|
|
const memory = new MemoryIndexedDbFactory();
|
|
const name = opfsJournalDatabaseName("authority_12345678");
|
|
await new Promise<void>((resolve, reject) => {
|
|
const request = memory.factory.open(name, 2);
|
|
request.onsuccess = () => {
|
|
request.result.close();
|
|
resolve();
|
|
};
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
const journal = createIndexedDbOpfsJournal({
|
|
authorityToken: "authority_12345678",
|
|
factory: memory.factory,
|
|
keyRange: memory.keyRange,
|
|
});
|
|
|
|
expect(await journal.listIncomplete(10)).toMatchObject({
|
|
ok: false,
|
|
error: { code: "UNSUPPORTED", recovery: "ONLINE_ONLY" },
|
|
});
|
|
});
|
|
});
|