@earendil-works/chord 1.5.0 → 1.5.1

package/dist/store/step.js

@@ -0,0 +1,52 @@
+// The commit step's working state (slice 6a §3, slice 6b §1.3) and the shape every write takes into it: a write staged
+// before the queue (serialized, rule 8), applied inside the step, returning the writes it recorded.
+/**
+ * One commit step: its backend transaction, its seq, the store's id allocator (D3: ids are taken from it as the
+ * writes apply, never copied), the ids of the documents it created, the table records it changed (the store's catalog
+ * takes them after `COMMIT`), the statements it ran (`chord.store.statements`) and the table rows its writes changed
+ * (`chord.commit`'s `rows`). Its reads are the step reader of adapters: they see the step's own writes.
+ */
+export class Step {
+    executor;
+    seq;
+    ids;
+    /** The ids of the commit's created documents, in the order of their writes. */
+    created = [];
+    /** The table records this step changed, by SQL name. */
+    tables = new Map();
+    #catalog;
+    statements = 0;
+    /** Table rows its writes changed: a `put` one, the others the count their statement returned. */
+    rows = 0;
+    constructor(executor, seq, ids, catalog) {
+        this.executor = executor;
+        this.seq = seq;
+        this.ids = ids;
+        this.#catalog = catalog;
+    }
+    /** The record of table `name` as this step leaves it so far. */
+    table(name) {
+        return this.tables.get(name) ?? this.#catalog.get(name);
+    }
+    /** Runs one statement. */
+    run(sql, ...params) {
+        this.statements++;
+        return this.executor.run(sql, ...params);
+    }
+    /** Runs one statement and resolves with the rows it changed. */
+    runCounted(sql, ...params) {
+        this.statements++;
+        return this.executor.runCounted(sql, ...params);
+    }
+    /** Runs one query for its first row. */
+    get(sql, ...params) {
+        this.statements++;
+        return this.executor.get(sql, ...params);
+    }
+    /** Runs one query. */
+    all(sql, ...params) {
+        this.statements++;
+        return this.executor.all(sql, ...params);
+    }
+}
+//# sourceMappingURL=step.js.map

package/dist/store/step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.js","sourceRoot":"","sources":["../../src/store/step.ts"],"names":[],"mappings":"AAAA,uHAAuH;AACvH,oGAAoG;AAwBpG;;;;;GAKG;AACH,MAAM,OAAO,IAAI;IACP,QAAQ,CAAiB;IACzB,GAAG,CAAS;IACZ,GAAG,CAAc;IAC1B,+EAA+E;IACtE,OAAO,GAAa,EAAE,CAAC;IAChC,wDAAwD;IAC/C,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAC;IACxC,QAAQ,CAAmC;IACpD,UAAU,GAAG,CAAC,CAAC;IACf,iGAAiG;IACjG,IAAI,GAAG,CAAC,CAAC;IAET,YAAY,QAAwB,EAAE,GAAW,EAAE,GAAgB,EAAE,OAAyC;QAC7G,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,gEAAgE;IAChE,KAAK,CAAC,IAAY;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,0BAA0B;IAC1B,GAAG,CAAC,GAAW,EAAE,GAAG,MAAqB;QACxC,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED,gEAAgE;IAChE,UAAU,CAAC,GAAW,EAAE,GAAG,MAAqB;QAC/C,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;IACjD,CAAC;IAED,wCAAwC;IACxC,GAAG,CAAmB,GAAW,EAAE,GAAG,MAAqB;QAC1D,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAI,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,sBAAsB;IACtB,GAAG,CAAmB,GAAW,EAAE,GAAG,MAAqB;QAC1D,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAI,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;IAC7C,CAAC;CACD","sourcesContent":["// The commit step's working state (slice 6a §3, slice 6b §1.3) and the shape every write takes into it: a write staged\n// before the queue (serialized, rule 8), applied inside the step, returning the writes it recorded.\n\nimport type { SqliteExecutor, SqliteValue } from \"../sqlite/index.ts\";\nimport type { IdAllocator } from \"./allocator.ts\";\nimport type { TableRecord } from \"./catalog.ts\";\nimport type { StoreWrite } from \"./writes.ts\";\n\n/**\n * Where a staged write goes in its commit: retirements, creations, then everything else, each phase in staging order.\n * A retirement frees a live address before a creation takes it (the partial unique index); an adapter's composite\n * write orders its own parts inside `write`.\n */\nexport type WriteOrder = \"retire\" | \"create\" | \"write\";\n\n/** A write staged for the commit step: its order and what it does there, returning the writes as recorded. */\nexport type StagedWrite = {\n\treadonly order: WriteOrder;\n\t/**\n\t * Applies the write inside the step's backend transaction; resolves with the writes as the outbox records them, in\n\t * the order applied, with what only the step knows resolved (its seq, a record's revision).\n\t */\n\tapply(step: Step): Promise<readonly StoreWrite[]>;\n};\n\n/**\n * One commit step: its backend transaction, its seq, the store's id allocator (D3: ids are taken from it as the\n * writes apply, never copied), the ids of the documents it created, the table records it changed (the store's catalog\n * takes them after `COMMIT`), the statements it ran (`chord.store.statements`) and the table rows its writes changed\n * (`chord.commit`'s `rows`). Its reads are the step reader of adapters: they see the step's own writes.\n */\nexport class Step {\n\treadonly executor: SqliteExecutor;\n\treadonly seq: number;\n\treadonly ids: IdAllocator;\n\t/** The ids of the commit's created documents, in the order of their writes. */\n\treadonly created: number[] = [];\n\t/** The table records this step changed, by SQL name. */\n\treadonly tables = new Map<string, TableRecord>();\n\treadonly #catalog: ReadonlyMap<string, TableRecord>;\n\tstatements = 0;\n\t/** Table rows its writes changed: a `put` one, the others the count their statement returned. */\n\trows = 0;\n\n\tconstructor(executor: SqliteExecutor, seq: number, ids: IdAllocator, catalog: ReadonlyMap<string, TableRecord>) {\n\t\tthis.executor = executor;\n\t\tthis.seq = seq;\n\t\tthis.ids = ids;\n\t\tthis.#catalog = catalog;\n\t}\n\n\t/** The record of table `name` as this step leaves it so far. */\n\ttable(name: string): TableRecord | undefined {\n\t\treturn this.tables.get(name) ?? this.#catalog.get(name);\n\t}\n\n\t/** Runs one statement. */\n\trun(sql: string, ...params: SqliteValue[]): Promise<void> {\n\t\tthis.statements++;\n\t\treturn this.executor.run(sql, ...params);\n\t}\n\n\t/** Runs one statement and resolves with the rows it changed. */\n\trunCounted(sql: string, ...params: SqliteValue[]): Promise<number> {\n\t\tthis.statements++;\n\t\treturn this.executor.runCounted(sql, ...params);\n\t}\n\n\t/** Runs one query for its first row. */\n\tget<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n\t\tthis.statements++;\n\t\treturn this.executor.get<T>(sql, ...params);\n\t}\n\n\t/** Runs one query. */\n\tall<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n\t\tthis.statements++;\n\t\treturn this.executor.all<T>(sql, ...params);\n\t}\n}\n"]}

package/dist/store/store.d.ts

@@ -0,0 +1,171 @@
+import { type Context } from "../context/index.ts";
+import type { SqliteDatabase, SqliteExecutor } from "../sqlite/index.ts";
+import type { Batch } from "../state/internal.ts";
+import { IdAllocator } from "./allocator.ts";
+import type { ArchivePart } from "./archive.ts";
+import type { Backend } from "./backend.ts";
+import { type TableRecord } from "./catalog.ts";
+import { Claims } from "./claims.ts";
+import { Outbox } from "./outbox.ts";
+import { type MetaRow } from "./schema.ts";
+import { type StagedWrite, Step } from "./step.ts";
+/** A store as apps hold it: opened by `openStore`, owned and closed by the app. */
+export interface Store {
+    /** The seq of the store's last commit (0 for a new store). */
+    readonly lastSeq: number;
+    /** The outbox the sync layer reads; `undefined` without one. */
+    readonly outbox: Outbox | undefined;
+    /**
+     * The store's state after its `lastSeq` as archive parts (slice 6a §13), holding the commit queue from the first
+     * `next()` until the iteration ends, throws, is closed or `context` aborts.
+     */
+    export(context: Context): AsyncIterableIterator<ArchivePart>;
+    /**
+     * Closes the store: waits for a running commit step (a group's, its commits' solo runs included), rejects queued
+     * commits and reads `released`, closes the backend. Idempotent, also after `storage_failed`; `context` ends only
+     * this caller's wait (the close goes on).
+     */
+    close(context: Context): Promise<void>;
+}
+/** What `openStore` takes besides the backend. */
+export type StoreOptions = {
+    /** Turns the outbox on (`true`) or off (`false`); omitted, the persisted setting stays (a new store: off). */
+    readonly outbox?: boolean;
+};
+/**
+ * Opens a store over `backend`: the store's schema migrations, the UTF-8 check, the metadata read once, the outbox
+ * switched when asked. A failure closes the backend and rejects (rule 12).
+ */
+export declare function openStore(backend: Backend, context: Context, options?: StoreOptions): Promise<Store>;
+/** The seal fence's two checks of a commit (§1.3), as the commit step calls them. */
+export type CommitFence = {
+    /** At the step's entry: `false` rejects the commit `released` and writes nothing. */
+    admit(): boolean;
+    /**
+     * After `COMMIT`: adopts the commit, `ids` being its created documents' ids in the order of their writes, `rows` the
+     * table rows its writes changed.
+     */
+    adopt(seq: number, ids: readonly number[], rows: number): void;
+};
+/**
+ * One commit of a series (`ChordStore.commitSeries`): its own checks, which write nothing, and its writes. The checks
+ * read through the commit's step, which sees what the series' earlier commits wrote.
+ */
+export type SeriesCommit = {
+    /** Throws to refuse the commit: the series stops before it, the commits before it stand. */
+    check(step: Step): Promise<void>;
+    readonly writes: readonly StagedWrite[];
+};
+/** What a series stored: how many of its commits, and why the next one was refused, if one was. */
+export type SeriesResult = {
+    readonly stored: number;
+    readonly refused?: unknown;
+};
+/** What the open host gives the store: its `storage_failed` listener and its batch, in which adapters publish (§1.3). */
+export type Attachment = {
+    readonly failed: (error: unknown) => void;
+    readonly batch: Batch;
+};
+/** Where a replayed batch leaves the store: its last commit's seq and allocator value, the tables it changed. */
+export type Replayed = {
+    readonly lastSeq: number;
+    readonly nextId: number;
+    readonly tables: ReadonlyMap<string, TableRecord>;
+};
+/** The store behind `Store`, with what Chord's layers use: commits, guarded reads, the host's failure listener. */
+export declare class ChordStore implements Store {
+    #private;
+    /** The claims of its tables and documents (slice 6b). */
+    readonly claims: Claims;
+    constructor(db: SqliteDatabase, meta: MetaRow, catalog: Map<string, TableRecord>);
+    get lastSeq(): number;
+    get outbox(): Outbox | undefined;
+    /** The allocator's value as the last commit persisted it. */
+    get nextId(): number;
+    /** The id allocator: `mint` takes the next id, `raise` makes room above an explicit one (D3). */
+    get ids(): IdAllocator;
+    /** Takes the next id from the allocator (Durable's `mintId`); refused once the store stopped or closed. */
+    mintId(): number;
+    /** The open host's batch, in which an adapter publishes its commits; `undefined` without a host. */
+    get batch(): Batch | undefined;
+    /** Every recorded table, by SQL name, as of the last commit. */
+    get tables(): ReadonlyMap<string, TableRecord>;
+    export(context: Context): AsyncIterableIterator<ArchivePart>;
+    /**
+     * Takes the commit queue (an export): resolves once every earlier commit settled, with the release that lets the
+     * later ones run (idempotent). Closing the store calls `end` (from the call on, also while waiting, and at once for a
+     * store closed before the call took the queue), which must release.
+     */
+    take(end: () => void): Promise<() => void>;
+    /** The recorded table `name` (its SQL name), as of the last commit. */
+    table(name: string): TableRecord | undefined;
+    /**
+     * The version table `name` is at or is being migrated to: the recorded one, or a higher one a migration announced
+     * before its first commit (`announceTable`), so an old handle is refused before its SQL could queue behind the
+     * migration's DDL (fix round 1, Sol 8).
+     */
+    tableVersion(name: string): number | undefined;
+    /** Announces a migration of table `name` to `version` until the returned withdrawal (after its last commit). */
+    announceTable(name: string, version: number): () => void;
+    /** Attaches the open host; a store attached to an open host is refused (rule 7). */
+    attach(attachment: Attachment): void;
+    /** The host closed: the store may serve another one. */
+    detach(): void;
+    /**
+     * Commits `writes` as one seq when the commit queue reaches it: `fence.admit()` at the entry of its step (its
+     * group's), the writes in their order (retirements, creations, the rest), the outbox commit, `lastSeq` and the
+     * allocator's value, `COMMIT`, then `fence.adopt` before the next step starts. Resolves with the seq. A refused
+     * admission rejects `released`. A step the backend rolled back after the step's own code threw (a refusal, D4)
+     * rejects with that error unchanged and the store goes on; any other failure (`BEGIN`, `COMMIT`, `ROLLBACK`, a
+     * throwing `adopt` or metrics adapter) is an unknown outcome that stops the store (`storage_failed`). `context`
+     * counts the step (no abort once queued).
+     *
+     * Group commit: the commits queued while a step runs form one group, which the next turn admits and writes in one
+     * backend transaction (each commit its own seq, outbox commit and adoption, in queue order; the metadata once), so a
+     * busy store costs a transaction per group, not per commit. If one of them refuses, the group rolls back and its
+     * commits run again one by one as above: the refusal stays its own commit's.
+     */
+    commit(writes: readonly StagedWrite[], fence: CommitFence, context: Context): Promise<number>;
+    /**
+     * Commits `commits` in one backend transaction when the commit queue reaches them, one seq each, in order: each
+     * commit's `check`, which writes nothing, then its writes as `commit` writes them, with its own outbox commit and the
+     * metadata (a commit without writes takes no seq: it stands at the one before). A `check` that throws refuses its
+     * commit: the series stops there and the transaction commits the ones before it. A check whose backend statement
+     * failed, and a throw of a commit's writes, roll the whole series back and reject with that error, the store going
+     * on (D4); any other failure is an unknown outcome that stops the store, as for `commit`. After `COMMIT`,
+     * `receive(index, seq, ids)` is called per stored commit, in order, before the next step starts (`ids`: its created
+     * documents). Resolves with what it stored.
+     */
+    commitSeries(commits: readonly SeriesCommit[], receive: (index: number, seq: number, ids: readonly number[]) => void, context: Context): Promise<SeriesResult>;
+    /**
+     * Runs `read` on the backend under the guard (rule 11, Durable's `GuardedStorage`): refused once the store stopped
+     * or closed; a backend error fails the store unless `context` was aborted (then `aborted`); a read settling after
+     * the store stopped rejects `unavailable/storage_failed`. `read` returns data and never throws for a request: an
+     * adapter checks a request from what it returned, after the guard (slice 6b §1.4).
+     */
+    read<T>(read: (executor: SqliteExecutor) => Promise<T>, context: Context): Promise<T>;
+    /**
+     * `read` for several queries that must see one state (S4, a document from its record and revisions): one backend
+     * transaction, guarded as `read`.
+     */
+    readTransaction<T>(read: (executor: SqliteExecutor) => Promise<T>, context: Context): Promise<T>;
+    /**
+     * Runs `write` on the backend outside the commit queue (the outbox's `trim`), in a backend transaction, guarded as
+     * a read without a context: any error stops the store.
+     */
+    maintain(write: (executor: SqliteExecutor) => Promise<void>): Promise<void>;
+    close(context: Context): Promise<void>;
+    /**
+     * Batch apply's turn (slice 6b §1.6, S5): refused (`invalid/args`) while an owner holds a claim (its memory would
+     * go stale) and once the store diverged; otherwise `apply` runs in the commit queue, in one backend transaction, and
+     * returns the position its last commit leaves (`lastSeq`, the allocator's value) and the tables it changed, which
+     * memory takes after `COMMIT`. `apply`'s own error rolls back and rejects as a refusal (a `Diverged` one marks the
+     * store diverged); any other failure stops the store.
+     */
+    replay(apply: (executor: SqliteExecutor, catalog: ReadonlyMap<string, TableRecord>) => Promise<Replayed>, isDivergence: (error: unknown) => boolean): Promise<void>;
+    /** Whether the store has an outbox, which a replayed batch writes too. */
+    get recordsOutbox(): boolean;
+    /** Throws `unavailable/storage_failed` once the store stopped, `released` once it closed. */
+    assertUsable(): void;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/store/store.ts"],"names":[],"mappings":"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"}