@photon-grove/evt 0.1.1 → 0.2.0

package/dist/postgres/schema.d.ts

@@ -0,0 +1,81 @@
+/** The default events table. */
+export declare const DEFAULT_EVENTS_TABLE = "evt_events";
+/** The default snapshots table. */
+export declare const DEFAULT_SNAPSHOTS_TABLE = "evt_snapshots";
+/**
+ * The infix the engine relations derive from the events table name with, such as
+ * `evt_events__evt_features`. A configured table name may not contain it, in any case, so one
+ * log's tables can never equal another log's derived relation.
+ */
+export declare const RESERVED_INFIX = "__evt_";
+/**
+ * The longest events table name, in bytes. Its longest derived relation,
+ * `{events}__evt_rebuild_generation_pkey`, then fills PostgreSQL's 63-byte identifier limit.
+ */
+export declare const MAX_EVENTS_TABLE_NAME_BYTES: number;
+/** The longest snapshots table name, in bytes, which leaves room for its `_pkey` index. */
+export declare const MAX_SNAPSHOTS_TABLE_NAME_BYTES: number;
+declare const validated: unique symbol;
+/**
+ * An event log's two configured tables, validated and folded to lower case. Only
+ * {@link pgTables} makes one.
+ */
+export interface PgTables {
+    readonly events: string;
+    readonly snapshots: string;
+    readonly [validated]: true;
+}
+/**
+ * Validates an event log's table names and folds them to lower case, as PostgreSQL folds unquoted
+ * identifiers. Each must be a plain identifier that isn't a reserved keyword, within its length
+ * limit, without the {@link RESERVED_INFIX}, and no two relations the schema creates may share a
+ * name. A name that breaks a rule fails with `invalidArgument`, as Go and Rust refuse it at
+ * construction.
+ */
+export declare function pgTables(events?: string, snapshots?: string): PgTables;
+/** The command-outcomes table: `evt_events` yields `evt_events__evt_command_outcomes`. */
+export declare function outcomesTable(tables: PgTables): string;
+/** The feature-marker table: `evt_events` yields `evt_events__evt_features`. */
+export declare function featuresTable(tables: PgTables): string;
+/** The rebuild-lock table: `evt_events` yields `evt_events__evt_rebuild_lock`. */
+export declare function rebuildLockTable(tables: PgTables): string;
+/** The rebuild-generation table: `evt_events` yields `evt_events__evt_rebuild_generation`. */
+export declare function rebuildGenerationTable(tables: PgTables): string;
+/** The stream-heads table: `evt_events` yields `evt_events__evt_stream_heads`. */
+export declare function streamHeadsTable(tables: PgTables): string;
+/** The entity-type index of the events table: `evt_events__evt_entity_type_idx`. */
+export declare function entityTypeIndex(tables: PgTables): string;
+/**
+ * The idempotent DDL of an event log, byte for byte the DDL Go's `EnsureSchema` and Rust's
+ * `ensure_schema` run: the events and snapshots tables, the entity-type index (dropping its
+ * pre-v0.9 name), and the command-outcome, feature-marker, rebuild-fence and stream-heads tables.
+ * Run it inside one transaction, after {@link SCHEMA_LOCK} with the events table name, as Go and
+ * Rust do.
+ */
+export declare function schemaDdl(tables: PgTables): string;
+/**
+ * Serializes schema changes across processes, in every language: `IF NOT EXISTS` alone can still
+ * race in PostgreSQL's catalogs. `$1` is the events table name.
+ */
+export declare const SCHEMA_LOCK = "SELECT pg_advisory_xact_lock(1702261762, hashtext($1))";
+/**
+ * The per-entity transaction lock every commit and snapshot write takes, `$1` being the entity
+ * ID. Go and Rust run this exact statement, so writers in every language exclude each other.
+ */
+export declare const ENTITY_LOCK = "SELECT pg_advisory_xact_lock(1702261760, hashtext($1))";
+/**
+ * The shared engine-row lock a commit takes and holds to `COMMIT`, `$1` being a key from
+ * {@link featuresLockKey} or {@link rebuildLockKey}. Commits don't serialize against each other.
+ */
+export declare const ENGINE_LOCK_SHARED = "SELECT pg_advisory_xact_lock_shared(1702261761, hashtext($1))";
+/**
+ * The exclusive engine-row lock a declaration or a rebuild lifecycle step takes for its short
+ * transaction, so it never slips between a commit's check and its `COMMIT`.
+ */
+export declare const ENGINE_LOCK_EXCLUSIVE = "SELECT pg_advisory_xact_lock(1702261761, hashtext($1))";
+/** The feature marker's engine-row lock key: `{events}:features`. */
+export declare function featuresLockKey(tables: PgTables): string;
+/** The rebuild fence's engine-row lock key: `{events}:rebuild`. */
+export declare function rebuildLockKey(tables: PgTables): string;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/postgres/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/postgres/schema.ts"],"names":[],"mappings":"AAMA,gCAAgC;AAChC,eAAO,MAAM,oBAAoB,eAAe,CAAA;AAEhD,mCAAmC;AACnC,eAAO,MAAM,uBAAuB,kBAAkB,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,cAAc,WAAW,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,2BAA2B,QAA8C,CAAA;AAEtF,2FAA2F;AAC3F,eAAO,MAAM,8BAA8B,QAAsB,CAAA;AAGjE,OAAO,CAAC,MAAM,SAAS,EAAE,OAAO,MAAM,CAAA;AAEtC;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAC3B;AAkBD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,GAAE,MAA6B,EACrC,SAAS,GAAE,MAAgC,GAC1C,QAAQ,CA0BV;AAED,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEtD;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEtD;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEzD;AAED,8FAA8F;AAC9F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAE/D;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEzD;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CA6FlD;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,2DAA2D,CAAA;AAEnF;;;GAGG;AACH,eAAO,MAAM,WAAW,2DAA2D,CAAA;AAEnF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,kEAAkE,CAAA;AAEjG;;;GAGG;AACH,eAAO,MAAM,qBAAqB,2DAA2D,CAAA;AAE7F,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAExD;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEvD"}

package/dist/postgres/schema.js

@@ -0,0 +1,249 @@
+// The PostgreSQL layout of an event log, independent of any driver (storage format, "PostgreSQL"):
+// the table names a store is configured with, the engine relations derived from them, and the
+// idempotent DDL that Go's EnsureSchema and Rust's ensure_schema run.
+import { EvtError } from '../errors.js';
+/** The default events table. */
+export const DEFAULT_EVENTS_TABLE = 'evt_events';
+/** The default snapshots table. */
+export const DEFAULT_SNAPSHOTS_TABLE = 'evt_snapshots';
+/**
+ * The infix the engine relations derive from the events table name with, such as
+ * `evt_events__evt_features`. A configured table name may not contain it, in any case, so one
+ * log's tables can never equal another log's derived relation.
+ */
+export const RESERVED_INFIX = '__evt_';
+/**
+ * The longest events table name, in bytes. Its longest derived relation,
+ * `{events}__evt_rebuild_generation_pkey`, then fills PostgreSQL's 63-byte identifier limit.
+ */
+export const MAX_EVENTS_TABLE_NAME_BYTES = 63 - '__evt_rebuild_generation_pkey'.length;
+/** The longest snapshots table name, in bytes, which leaves room for its `_pkey` index. */
+export const MAX_SNAPSHOTS_TABLE_NAME_BYTES = 63 - '_pkey'.length;
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+// PostgreSQL's reserved keywords (pg_get_keywords() categories R and T), which can't be unquoted
+// table names. The same list as Go's and Rust's.
+const RESERVED_KEYWORDS = new Set(`all analyse analyze and any array as asc asymmetric authorization binary both case cast check
+  collate collation column concurrently constraint create cross current_catalog current_date
+  current_role current_schema current_time current_timestamp current_user default deferrable desc
+  distinct do else end except false fetch for foreign freeze from full grant group having ilike in
+  initially inner intersect into is isnull join lateral leading left like limit localtime
+  localtimestamp natural not notnull null offset on only or order outer overlaps placing primary
+  references returning right select session_user similar some symmetric system_user table
+  tablesample then to trailing true union unique user using variadic verbose when where window
+  with`.split(/\s+/));
+/**
+ * Validates an event log's table names and folds them to lower case, as PostgreSQL folds unquoted
+ * identifiers. Each must be a plain identifier that isn't a reserved keyword, within its length
+ * limit, without the {@link RESERVED_INFIX}, and no two relations the schema creates may share a
+ * name. A name that breaks a rule fails with `invalidArgument`, as Go and Rust refuse it at
+ * construction.
+ */
+export function pgTables(events = DEFAULT_EVENTS_TABLE, snapshots = DEFAULT_SNAPSHOTS_TABLE) {
+    for (const [name, limit] of [
+        [events, MAX_EVENTS_TABLE_NAME_BYTES],
+        [snapshots, MAX_SNAPSHOTS_TABLE_NAME_BYTES],
+    ]) {
+        if (!validIdentifier(name, limit)) {
+            throw invalidConfig(`invalid table name ${JSON.stringify(name)}`);
+        }
+        if (name.toLowerCase().includes(RESERVED_INFIX)) {
+            throw invalidConfig(`table name ${JSON.stringify(name)} must not contain the reserved infix ` +
+                JSON.stringify(RESERVED_INFIX));
+        }
+    }
+    const tables = { events: events.toLowerCase(), snapshots: snapshots.toLowerCase() };
+    const shared = sharedRelation(tables);
+    if (shared !== null) {
+        throw invalidConfig(`tables ${JSON.stringify(events)} and ${JSON.stringify(snapshots)} would both use the ` +
+            `name ${JSON.stringify(shared)}`);
+    }
+    return tables;
+}
+/** The command-outcomes table: `evt_events` yields `evt_events__evt_command_outcomes`. */
+export function outcomesTable(tables) {
+    return derived(tables.events, 'command_outcomes');
+}
+/** The feature-marker table: `evt_events` yields `evt_events__evt_features`. */
+export function featuresTable(tables) {
+    return derived(tables.events, 'features');
+}
+/** The rebuild-lock table: `evt_events` yields `evt_events__evt_rebuild_lock`. */
+export function rebuildLockTable(tables) {
+    return derived(tables.events, 'rebuild_lock');
+}
+/** The rebuild-generation table: `evt_events` yields `evt_events__evt_rebuild_generation`. */
+export function rebuildGenerationTable(tables) {
+    return derived(tables.events, 'rebuild_generation');
+}
+/** The stream-heads table: `evt_events` yields `evt_events__evt_stream_heads`. */
+export function streamHeadsTable(tables) {
+    return derived(tables.events, 'stream_heads');
+}
+/** The entity-type index of the events table: `evt_events__evt_entity_type_idx`. */
+export function entityTypeIndex(tables) {
+    return derived(tables.events, 'entity_type_idx');
+}
+/**
+ * The idempotent DDL of an event log, byte for byte the DDL Go's `EnsureSchema` and Rust's
+ * `ensure_schema` run: the events and snapshots tables, the entity-type index (dropping its
+ * pre-v0.9 name), and the command-outcome, feature-marker, rebuild-fence and stream-heads tables.
+ * Run it inside one transaction, after {@link SCHEMA_LOCK} with the events table name, as Go and
+ * Rust do.
+ */
+export function schemaDdl(tables) {
+    const { events, snapshots } = tables;
+    return `
+CREATE TABLE IF NOT EXISTS ${events} (
+    entity_id   text   NOT NULL,
+    sequence    bigint NOT NULL,
+    event_id    text   NOT NULL,
+    event_type  text   NOT NULL,
+    version     bigint NOT NULL,
+    entity_type text   NOT NULL,
+    payload     bytea  NOT NULL,
+    metadata    jsonb  NOT NULL DEFAULT '{}'::jsonb,
+    created_at  timestamptz NOT NULL DEFAULT now(),
+    PRIMARY KEY (entity_id, sequence)
+);
+CREATE INDEX IF NOT EXISTS ${entityTypeIndex(tables)} ON ${events} (entity_type);
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1 FROM pg_index
+        WHERE indexrelid = to_regclass('${events}_entity_type_idx')
+          AND indrelid = '${events}'::regclass
+    ) THEN
+        DROP INDEX ${events}_entity_type_idx;
+    END IF;
+END $$;
+
+CREATE TABLE IF NOT EXISTS ${snapshots} (
+    entity_id      text   PRIMARY KEY,
+    entity_type    text   NOT NULL,
+    sequence       bigint NOT NULL,
+    event_sequence bigint NOT NULL,
+    payload        bytea  NOT NULL,
+    updated_at     timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS ${outcomesTable(tables)} (
+    command_id text        PRIMARY KEY,
+    status     text        NOT NULL CHECK (status IN ('accepted', 'rejected')),
+    digest     text        NOT NULL,
+    response   bytea,
+    events     jsonb       NOT NULL DEFAULT '[]'::jsonb,
+    rejection  jsonb,
+    code       text,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    command_type text,
+    targets      jsonb,
+    principal    text,
+    CHECK ((status = 'rejected' AND rejection IS NOT NULL AND code IS NOT NULL)
+           OR (status = 'accepted' AND rejection IS NULL AND code IS NULL))
+);
+
+DO $$
+BEGIN
+    IF (SELECT count(*) FROM pg_attribute
+        WHERE attrelid = '${outcomesTable(tables)}'::regclass
+          AND attname IN ('command_type', 'targets', 'principal')
+          AND NOT attisdropped) < 3 THEN
+        ALTER TABLE ${outcomesTable(tables)}
+            ADD COLUMN IF NOT EXISTS command_type text,
+            ADD COLUMN IF NOT EXISTS targets      jsonb,
+            ADD COLUMN IF NOT EXISTS principal    text;
+    END IF;
+END $$;
+
+CREATE TABLE IF NOT EXISTS ${featuresTable(tables)} (
+    id                integer PRIMARY KEY,
+    version           bigint NOT NULL,
+    features          text   NOT NULL,
+    history_dependent text   NOT NULL DEFAULT '[]',
+    retention         text   NOT NULL DEFAULT '[]'
+);
+
+CREATE TABLE IF NOT EXISTS ${rebuildLockTable(tables)} (
+    id               integer PRIMARY KEY,
+    owner            text        NOT NULL,
+    generation       bigint      NOT NULL,
+    lease_expires_at timestamptz NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS ${rebuildGenerationTable(tables)} (
+    id             integer PRIMARY KEY,
+    value          bigint   NOT NULL,
+    force_released boolean  NOT NULL DEFAULT false
+);
+
+CREATE TABLE IF NOT EXISTS ${streamHeadsTable(tables)} (
+    entity_id   text   PRIMARY KEY,
+    entity_type text   NOT NULL,
+    head        bigint NOT NULL CHECK (head >= 1)
+);
+`;
+}
+/**
+ * Serializes schema changes across processes, in every language: `IF NOT EXISTS` alone can still
+ * race in PostgreSQL's catalogs. `$1` is the events table name.
+ */
+export const SCHEMA_LOCK = 'SELECT pg_advisory_xact_lock(1702261762, hashtext($1))';
+/**
+ * The per-entity transaction lock every commit and snapshot write takes, `$1` being the entity
+ * ID. Go and Rust run this exact statement, so writers in every language exclude each other.
+ */
+export const ENTITY_LOCK = 'SELECT pg_advisory_xact_lock(1702261760, hashtext($1))';
+/**
+ * The shared engine-row lock a commit takes and holds to `COMMIT`, `$1` being a key from
+ * {@link featuresLockKey} or {@link rebuildLockKey}. Commits don't serialize against each other.
+ */
+export const ENGINE_LOCK_SHARED = 'SELECT pg_advisory_xact_lock_shared(1702261761, hashtext($1))';
+/**
+ * The exclusive engine-row lock a declaration or a rebuild lifecycle step takes for its short
+ * transaction, so it never slips between a commit's check and its `COMMIT`.
+ */
+export const ENGINE_LOCK_EXCLUSIVE = 'SELECT pg_advisory_xact_lock(1702261761, hashtext($1))';
+/** The feature marker's engine-row lock key: `{events}:features`. */
+export function featuresLockKey(tables) {
+    return `${tables.events}:features`;
+}
+/** The rebuild fence's engine-row lock key: `{events}:rebuild`. */
+export function rebuildLockKey(tables) {
+    return `${tables.events}:rebuild`;
+}
+function derived(events, suffix) {
+    return `${events}${RESERVED_INFIX}${suffix}`;
+}
+// A valid identifier is ASCII, so its length is its byte count and folding it changes only A-Z.
+// The type check refuses a non-string passed from JavaScript, which the pattern would coerce.
+function validIdentifier(name, limit) {
+    return (typeof name === 'string' &&
+        name.length <= limit &&
+        IDENTIFIER.test(name) &&
+        !RESERVED_KEYWORDS.has(name.toLowerCase()));
+}
+// A name two relations of the schema would share, or null, with the names already folded to lower
+// case. CREATE TABLE IF NOT EXISTS would otherwise skip a table whose name an index already took.
+function sharedRelation(tables) {
+    const { events, snapshots } = tables;
+    const derivedTables = [
+        outcomesTable(tables),
+        featuresTable(tables),
+        rebuildLockTable(tables),
+        rebuildGenerationTable(tables),
+        streamHeadsTable(tables),
+    ];
+    const relations = [
+        events,
+        `${events}_pkey`,
+        entityTypeIndex(tables),
+        ...derivedTables.flatMap((table) => [table, `${table}_pkey`]),
+        snapshots,
+        `${snapshots}_pkey`,
+    ];
+    return relations.find((relation, index) => relations.indexOf(relation) !== index) ?? null;
+}
+function invalidConfig(message) {
+    return new EvtError('invalidArgument', `postgres: ${message}`);
+}
+//# sourceMappingURL=schema.js.map

package/dist/postgres/schema.js.map

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

package/dist/repository.d.ts

@@ -1,3 +1,4 @@
+import { EvtError, type FenceProvenance } from './errors.js';
 import { type SerializedEvent, type SerializedSnapshot } from './event.js';
 /** A snapshot to write with a commit. Its event sequence is the commit's last event. */
 export interface NewSnapshot {
@@ -7,9 +8,23 @@ export interface NewSnapshot {
     /** The aggregate state after the commit's events. */
     payload: Uint8Array;
 }
+/**
+ * Operations a projector adds to a commit, for the backend it names to write in the commit's own
+ * transaction (Go's transaction groups). The DynamoDB repository writes `dynamodb` groups, whose
+ * operations are `TransactWriteItems` actions. The in-memory repository budgets every group and
+ * writes none, as Go's does, so code with projectors runs on it unchanged.
+ */
+export interface ProjectorGroup {
+    /** The backend whose transaction carries the operations, such as `dynamodb`. */
+    readonly backend: string;
+    /** The operations, in the order they're written. */
+    readonly operations: readonly unknown[];
+    /** Each operation's size in the commit budget, as DynamoDB counts it. */
+    readonly sizes: readonly number[];
+}
 /**
  * Everything a repository writes atomically for one command. A commit with no events is a no-op,
- * and its snapshot is ignored.
+ * and its snapshot is ignored, unless it carries projector operations: then it's refused.
  */
 export interface Commit {
     /** The stream the events are appended to. */
@@ -18,6 +33,8 @@ export interface Commit {
     events: SerializedEvent[];
     /** The snapshot to write, when the commit reaches a snapshot boundary. */
     snapshot?: NewSnapshot | null | undefined;
+    /** The operations the aggregate's projectors add, written first, in order. */
+    projections?: readonly ProjectorGroup[] | null | undefined;
 }
 /** Options every repository call takes. */
 export interface CallOptions {
@@ -41,7 +58,9 @@ export interface CallOptions {
  *   {@link StreamHeadDriftError}, ranked above a gap and any other conflict;
  * - refuse a commit's snapshot whose sequence isn't the stored snapshot's plus one (1 with none
  *   stored) with a {@link ConflictError};
- * - write a commit's events, head and snapshot atomically, or nothing;
+ * - write a commit's events, head and snapshot atomically, or nothing, with the projector
+ *   operations it writes (a backend writes only its own groups), and refuse projector operations
+ *   without events with a {@link ProjectorOnlyCommitError};
  * - refuse an entity ID in a reserved namespace on every write path, before any request;
  * - refuse every write (a commit, a snapshot write, compaction) to a store whose feature manifest
  *   declares a pair this package doesn't model, with an {@link UnsupportedFeatureError}, and to
@@ -99,6 +118,74 @@ export interface StoreInitializer {
      */
     initialize(options?: CallOptions): Promise<boolean>;
 }
+/**
+ * A stream a transaction read but doesn't write, whose head must not move before it commits (ADR
+ * 0007): the fence passes while the stream's stored head still equals `head`.
+ */
+export interface ReadFence {
+    entityId: string;
+    /** The stream's entity type, which a fence on a retained type is refused for. */
+    entityType: string;
+    /** The head the transaction observed: 0 for a stream with no events. */
+    head: bigint;
+    /** Whether the engine read the head itself, or the caller stamped it. */
+    provenance: FenceProvenance;
+}
+/**
+ * Everything one transaction writes atomically: the streams it appends to, and fences on the
+ * streams it read. A fence on a stream the transaction also writes is dropped, since that stream's
+ * head update already conditions on the head it read. A transaction that writes nothing and fences
+ * nothing is a no-op.
+ */
+export interface TransactionCommit {
+    /** The streams written, each a {@link Commit}, at most one per stream. */
+    streams: readonly Commit[];
+    /** The streams read but not written, at most one fence per stream. */
+    fences?: readonly ReadFence[] | null | undefined;
+}
+/**
+ * A repository that commits several streams atomically, with read fences (ADR 0004). A
+ * transaction is refused as a commit is, and also:
+ *
+ * - with `invalidCommit` when it writes a stream twice, fences a stream twice, fences at a head
+ *   below 0 or at the largest int64, or carries a snapshot for a stream it writes no events to;
+ * - with a {@link RetentionConflictError} when it fences an entity type with retention: by the
+ *   repository's own configuration before any request, and by the store's manifest after the
+ *   manifest's other refusals, but always before the rebuild lock's;
+ * - with a {@link FenceConflictError} when a fenced stream's head moved, unless the stream
+ *   drifted, ranked after every drift and gap of the transaction, in transaction order.
+ */
+export interface TransactionalRepository extends Repository {
+    /** Appends to every stream and checks every fence atomically. */
+    commitTransaction(transaction: TransactionCommit, options?: CallOptions): Promise<void>;
+}
+/** A transaction as the backends write it. */
+export interface NormalizedTransaction {
+    /** The streams it writes events to, sorted by entity ID bytes, without their projections. */
+    readonly streams: readonly Commit[];
+    /** Its fences on the streams it doesn't write, sorted the same way. */
+    readonly fences: readonly ReadFence[];
+    /** The written streams' projector groups, in the order the streams were declared. */
+    readonly projections: readonly ProjectorGroup[];
+}
+/**
+ * Validates a transaction and puts it in the order every backend writes it: the written streams,
+ * then the fences, each sorted by entity ID bytes, the order that pins a DynamoDB transaction and
+ * PostgreSQL's locks. The projector groups keep the order the streams were declared in. Streams
+ * without events are dropped, and so are the fences on streams that write events, whose head
+ * updates condition on the head they read. A fence on a stream listed without events stays.
+ */
+export declare function normalizeTransaction(transaction: TransactionCommit): NormalizedTransaction;
+/**
+ * Refuses a transaction that fences a retained entity type, by the store's manifest or the
+ * repository's own configuration.
+ */
+export declare function checkFenceRetention(transaction: NormalizedTransaction, retained: (entityType: string) => boolean): void;
+/**
+ * The error a failed transaction reports from the failures of its streams and fences, given in
+ * transaction order: the first drift, else the first gap, else the first of the rest.
+ */
+export declare function rankFailures(failures: readonly EvtError[]): EvtError | undefined;
 /** The most actions one commit may carry, DynamoDB's transaction limit. */
 export declare const MAX_COMMIT_ACTIONS = 100;
 /** The most bytes one commit may carry, summed over its actions: 95% of DynamoDB's 4 MB. */
@@ -113,16 +200,24 @@ export declare function checkNotReserved(entityId: string): void;
  * Checks that a commit's events can be stored as written: each belongs to the commit's entity and
  * has the ID `{entityId}:{sequence}`, they share one entity type, the first sequence is at least
  * 1, and the sequences are contiguous. A snapshot must have the events' entity type and a
- * sequence of at least 1. A commit with no events is valid, and its snapshot isn't checked.
+ * sequence of at least 1, and each projector group a size per operation. A commit with no events
+ * is valid, and its snapshot isn't checked, but its projector operations are refused.
  */
 export declare function validateCommit(commit: Commit): void;
 /**
  * The size of each action a commit's transaction carries, in order: the feature-marker and
- * rebuild-lock checks, then the stream's head update, its event puts, and its snapshot put when
- * it writes one. `ttl` gives the expiry an entity type's items carry, if it's retained. Every
- * backend budgets a commit by these sizes, so an oversized commit fails the same way on each.
+ * rebuild-lock checks, the projector operations, then the stream's head update, its event puts,
+ * and its snapshot put when it writes one. `ttl` gives the expiry an entity type's items carry, if
+ * it's retained. Every backend budgets a commit by these sizes, so an oversized commit fails the
+ * same way on each.
  */
 export declare function commitSizes(commit: Commit, ttl: (entityType: string) => number | undefined): number[];
+/**
+ * The size of each action a transaction carries: the two control checks, every stream's projector
+ * operations, every written stream's head update, event puts and snapshot put, then a check on
+ * every fenced stream's head. Every backend budgets a transaction by these sizes.
+ */
+export declare function transactionSizes(transaction: NormalizedTransaction, ttl: (entityType: string) => number | undefined): number[];
 /**
  * Refuses a commit whose actions are over the budget: more than {@link MAX_COMMIT_ACTIONS}, more
  * than {@link MAX_COMMIT_BYTES} in all, or one over {@link MAX_COMMIT_ITEM_BYTES}.

package/dist/repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,eAAe,EAAE,KAAK,kBAAkB,EAAU,MAAM,YAAY,CAAA;AAGjF,wFAAwF;AACxF,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,qFAAqF;IACrF,QAAQ,EAAE,MAAM,CAAA;IAChB,qDAAqD;IACrD,OAAO,EAAE,UAAU,CAAA;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAA;IAChB,mDAAmD;IACnD,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAA;CAC1C;AAED,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5D,mDAAmD;IACnD,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAE3E,6DAA6D;IAC7D,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAE/F;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAEtF,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;IAErF;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAElF;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACxF;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACpD;AAED,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,UAAY,CAAA;AAEzC,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAG7C,CAAA;AAEF,uDAAuD;AACvD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIvD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAsDnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GAC9C,MAAM,EAAE,CA4BV;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAe1D"}
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"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"}