@spine-event-engine/storage-postgres 2.0.0-snapshot.23 → 2.0.0-snapshot.25

package/dist/postgres/entity-history.js

@@ -11,10 +11,11 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { fromBinary } from "@bufbuild/protobuf";
+import {} from "@bufbuild/protobuf";
+import { AnyPacker } from "@spine-event-engine/core";
 import { disabledEventHistoryPort, disabledStateHistoryPort, eventHistorySpec, stateHistorySpec, } from "@spine-event-engine/storage/provider";
-import { PostgresClientDisposal, PostgresStorageDataError, PostgresStorageErrors, PostgresStorageOperationError, } from "./errors.js";
-import { PostgresRecordStorage } from "./record-storage.js";
+import { PostgresStorageDataError, PostgresStorageErrors } from "./errors.js";
+import { PostgresRecordStorage, } from "./record-storage.js";
 /**
  * Provides PostgreSQL-backed current Entity storage and optional disabled history ports.
  *
@@ -24,6 +25,7 @@ import { PostgresRecordStorage } from "./record-storage.js";
 export class PostgresEntityStorage {
     records;
     onClose;
+    onAdmit;
     /**
      * Exposes current Entity records.
      */
@@ -44,21 +46,23 @@ export class PostgresEntityStorage {
      * @param records Stores current Entity record envelopes.
      * @param open Opens grouped PostgreSQL record families.
      * @param onClose Unregisters this Entity handle from its factory.
+     * @param onAdmit Admits complete public Entity operations before callbacks.
      */
-    constructor(input, records, open, onClose) {
+    constructor(input, records, open, onClose, onAdmit) {
         this.records = records;
         this.onClose = onClose;
-        this.current = new PostgresCurrentStorage(input, records);
+        this.onAdmit = onAdmit;
+        this.current = new PostgresCurrentStorage(input, records, onAdmit);
         const states = input.stateHistory ? stateHistorySpec(input.stateSchema) : undefined;
         this.states =
             states === undefined
                 ? disabledStateHistoryPort()
-                : new PostgresStates(input, open(states.spec, states.group));
+                : new PostgresStates(input, open(states.spec, states.group), onAdmit);
         const events = input.eventHistory ? eventHistorySpec(input.stateSchema) : undefined;
         this.events =
             events === undefined
                 ? disabledEventHistoryPort()
-                : new PostgresEvents(input, open(events.spec, events.group));
+                : new PostgresEvents(input, open(events.spec, events.group), onAdmit);
     }
     /**
      * Returns whether this Entity handle accepts operations.
@@ -90,6 +94,7 @@ export class PostgresEntityStorage {
 class PostgresStates {
     input;
     records;
+    onAdmit;
     #executor;
     #open = true;
     /**
@@ -97,10 +102,12 @@ class PostgresStates {
      *
      * @param input Supplies Entity identity and state-schema definitions.
      * @param records Stores immutable Entity state records.
+     * @param onAdmit Admits complete public history operations.
      */
-    constructor(input, records) {
+    constructor(input, records, onAdmit) {
         this.input = input;
         this.records = records;
+        this.onAdmit = onAdmit;
         this.#executor = records.historyExecutor();
     }
     /**
@@ -110,16 +117,12 @@ class PostgresStates {
      * @returns Completion after PostgreSQL stores the record.
      */
     append(record) {
-        if (!this.#open)
-            return Promise.reject(new Error("Entity state history is closed."));
-        return this.#executor
-            .transaction(async (client) => {
-            await client.query("SELECT pg_advisory_xact_lock_shared($1)", [this.familyKey()]);
-            await client.query("SELECT pg_advisory_xact_lock($1)", [this.entityKey(record.entityId)]);
-            await this.#executor.appendImmutable(client, record);
-        })
-            .catch((error) => {
-            throw PostgresStorageErrors.operation(error);
+        return this.onAdmit(() => {
+            if (!this.#open)
+                return Promise.reject(new Error("Entity state history is closed."));
+            return this.records.writeImmutable(record).catch((error) => {
+                throw PostgresStorageErrors.operation(error);
+            });
         });
     }
     /**
@@ -130,12 +133,22 @@ class PostgresStates {
      * @param startingFromVersion Optional inclusive starting version.
      * @returns Entity state records in descending version order.
      */
-    async backward(entityId, depth, startingFromVersion) {
+    backward(entityId, depth, startingFromVersion) {
+        return this.onAdmit(() => this.backwardAdmitted(entityId, depth, startingFromVersion));
+    }
+    /**
+     * Reads an admitted state-history page.
+     * @param entityId Entity whose history is read.
+     * @param depth Maximum number of states to return.
+     * @param startingFromVersion Optional inclusive version.
+     * @returns Entity state records in descending version order.
+     */
+    async backwardAdmitted(entityId, depth, startingFromVersion) {
         this.assertOpen();
         HistoryValues.assertDepth(depth);
         await this.#executor.prepare();
         return this.#executor
-            .transaction((client) => this.#executor.query(client, this.backwardSql(startingFromVersion), this.backwardValues(entityId, depth, startingFromVersion)))
+            .using((client) => this.#executor.query(client, this.backwardSql(startingFromVersion), this.backwardValues(entityId, depth, startingFromVersion)))
             .catch((error) => {
             throw PostgresStorageErrors.operation(error);
         });
@@ -147,11 +160,20 @@ class PostgresStates {
      * @param time Inclusive state timestamp.
      * @returns Decoded state, or `undefined` when no state existed.
      */
-    async stateAt(entityId, time) {
+    stateAt(entityId, time) {
+        return this.onAdmit(() => this.stateAtAdmitted(entityId, time));
+    }
+    /**
+     * Reads an admitted Entity state at a timestamp.
+     * @param entityId Entity whose state is read.
+     * @param time Inclusive state timestamp.
+     * @returns Decoded state, or absence.
+     */
+    async stateAtAdmitted(entityId, time) {
         this.assertOpen();
         await this.#executor.prepare();
         const records = await this.#executor
-            .transaction((client) => this.#executor.query(client, this.stateAtSql(), [
+            .using((client) => this.#executor.query(client, this.stateAtSql(), [
             this.entityValue(entityId),
             HistoryValues.nanos(time),
             1,
@@ -163,7 +185,7 @@ class PostgresStates {
         if (record?.state === undefined)
             return undefined;
         try {
-            return fromBinary(this.input.stateSchema, record.state.value);
+            return AnyPacker.unpack(record.state, this.input.stateSchema);
         }
         catch (error) {
             throw new PostgresStorageDataError("Stored PostgreSQL state data is invalid.", {
@@ -178,33 +200,25 @@ class PostgresStates {
      * @param keepMostRecent Number of newest states to retain.
      * @returns Completion after all older pages are deleted.
      */
-    async trim(entityId, keepMostRecent) {
+    trim(entityId, keepMostRecent) {
+        return this.onAdmit(() => this.trimAdmitted(entityId, keepMostRecent));
+    }
+    /**
+     * Removes older admitted Entity state history.
+     * @param entityId Entity whose history is trimmed.
+     * @param keepMostRecent Number of newest states to retain.
+     * @returns Completion after all older pages are deleted.
+     */
+    async trimAdmitted(entityId, keepMostRecent) {
         this.assertOpen();
         HistoryValues.assertKeep(keepMostRecent);
         await this.#executor
             .using(async (client) => {
-            const [family, entity] = this.trimLocks(entityId);
-            const acquired = [];
-            let operationFailure;
-            try {
-                await client.query("SELECT pg_advisory_lock_shared($1)", [family]);
-                acquired.push([family, true]);
-                await client.query("SELECT pg_advisory_lock($1)", [entity]);
-                acquired.push([entity, false]);
-                let cursor = await this.trimBoundary(client, entityId, keepMostRecent);
-                let includeCursor = true;
-                while (cursor !== undefined && this.#open) {
-                    cursor = await this.trimPage(client, entityId, cursor, includeCursor);
-                    includeCursor = false;
-                    // The next page starts only while this history remains open.
-                }
-            }
-            catch (error) {
-                operationFailure = error;
-                throw error;
-            }
-            finally {
-                await PostgresSessionLocks.cleanup(client, acquired.reverse(), operationFailure);
+            let cursor = await this.trimBoundary(client, entityId, keepMostRecent);
+            let includeCursor = true;
+            while (cursor !== undefined && this.#open) {
+                cursor = await this.trimPage(client, entityId, cursor, includeCursor);
+                includeCursor = false;
             }
         })
             .catch((error) => {
@@ -217,32 +231,27 @@ class PostgresStates {
      * @param olderThan Exclusive history cutoff.
      * @returns Completion after all matching pages are deleted.
      */
-    async truncate(olderThan) {
+    truncate(olderThan) {
+        return this.onAdmit(() => this.truncateAdmitted(olderThan));
+    }
+    /**
+     * Deletes admitted Entity state history.
+     * @param olderThan Exclusive history cutoff.
+     * @returns Completion after all matching pages are deleted.
+     */
+    async truncateAdmitted(olderThan) {
         this.assertOpen();
-        await this.#executor.using(async (client) => {
-            const key = this.#executor.lock("history-family", this.#executor.table());
-            await client.query("SELECT pg_advisory_lock($1)", [key]);
-            let operationFailure;
-            try {
-                const cutoff = HistoryValues.nanos(olderThan);
-                const highWater = await this.highWater(client, cutoff);
-                if (highWater !== undefined)
-                    while (this.#open && (await this.truncatePage(client, cutoff, highWater))) {
-                        // The next page starts only while this history remains open.
-                    }
-            }
-            catch (error) {
-                operationFailure = error;
-            }
-            const cleanup = await PostgresSessionLocks.unlock(client, key, false).catch((error) => error);
-            if (cleanup instanceof Error)
-                PostgresClientDisposal.mark(operationFailure ?? cleanup);
-            if (operationFailure instanceof Error)
-                throw operationFailure;
-            if (operationFailure !== undefined)
-                throw new PostgresStorageOperationError("PostgreSQL state history operation failed.");
-            if (cleanup instanceof Error)
-                throw cleanup;
+        await this.#executor
+            .using(async (client) => {
+            const cutoff = HistoryValues.nanos(olderThan);
+            const highWater = await this.highWater(client, cutoff);
+            if (highWater !== undefined)
+                while (this.#open && (await this.truncatePage(client, cutoff, highWater))) {
+                    // Each completed page remains deleted if a later page fails.
+                }
+        })
+            .catch((error) => {
+            throw PostgresStorageErrors.operation(error);
         });
     }
     /**
@@ -302,49 +311,6 @@ class PostgresStates {
     entityValue(id) {
         return this.#executor.column("entity_id", this.input.id.pack(id));
     }
-    /**
-     * Calculates the lock key shared by this history family.
-     *
-     * @returns PostgreSQL advisory-lock key.
-     */
-    familyKey() {
-        return this.#executor.lock("history-family", this.#executor.table());
-    }
-    /**
-     * Calculates the family and Entity lock keys used while trimming.
-     *
-     * @param id Entity identifier.
-     * @returns Family lock followed by Entity lock.
-     */
-    trimLocks(id) {
-        return [
-            this.familyKey(),
-            this.#executor.lock("entity-mutation", this.input.sourceType.typeName, this.entityIdentity(id)),
-        ];
-    }
-    /**
-     * Calculates the mutation lock for a stored Entity record.
-     *
-     * @param entityId Packed Entity identifier from the record.
-     * @returns PostgreSQL advisory-lock key.
-     */
-    entityKey(entityId) {
-        if (entityId === undefined)
-            throw new Error("State history requires EntityRecord.entityId.");
-        const id = this.input.id.unpack(entityId);
-        if (id === undefined)
-            throw new Error("State history EntityRecord ID does not match storage.");
-        return this.#executor.lock("entity-mutation", this.input.sourceType.typeName, this.entityIdentity(id));
-    }
-    /**
-     * Returns the stable string identity used in Entity mutation locks.
-     *
-     * @param id Entity identifier.
-     * @returns Stable Entity identity string.
-     */
-    entityIdentity(id) {
-        return this.input.id.key(id);
-    }
     /**
      * Rejects state-history work after this port has closed.
      */
@@ -355,58 +321,42 @@ class PostgresStates {
     /**
      * Deletes one bounded page of old states for an Entity.
      *
-     * @param client PostgreSQL client holding the session locks.
+     * @param client Acquired PostgreSQL client.
      * @param id Entity identifier.
      * @param cursor Last retained or deleted history key.
      * @param includeCursor Whether the page includes the supplied cursor.
      * @returns The next page cursor, or `undefined` after the final page.
      */
     async trimPage(client, id, cursor, includeCursor) {
-        await client.query("BEGIN");
-        try {
-            const rows = await client.query(this.trimSql(includeCursor), [
-                this.entityValue(id),
-                ...cursor,
-                128,
-            ]);
-            const keys = rows.rows.map(({ ID }) => ID);
-            await this.deleteKeys(client, keys);
-            await client.query("COMMIT");
-            const last = rows.rows.at(-1);
-            return keys.length === 128 && last !== undefined
-                ? [last.version, last.created, last.ID]
-                : undefined;
-        }
-        catch (error) {
-            await client.query("ROLLBACK").catch(() => undefined);
-            throw error;
-        }
+        const rows = await client.query(this.trimSql(includeCursor), [
+            this.entityValue(id),
+            ...cursor,
+            128,
+        ]);
+        const keys = rows.rows.map(({ ID }) => ID);
+        await this.deleteKeys(client, keys);
+        const last = rows.rows.at(-1);
+        return keys.length === 128 && last !== undefined
+            ? [last.version, last.created, last.ID]
+            : undefined;
     }
     /**
      * Deletes one bounded page below a timestamp and stable high-water key.
      *
-     * @param client PostgreSQL client holding the family lock.
+     * @param client Acquired PostgreSQL client.
      * @param olderThan Exclusive timestamp cutoff in nanoseconds.
      * @param highWater Last key admitted when truncation began.
      * @returns Whether another full page may remain.
      */
     async truncatePage(client, olderThan, highWater) {
-        await client.query("BEGIN");
-        try {
-            const keys = await this.keys(client, this.truncateSql(), [olderThan, ...highWater, 128]);
-            await this.deleteKeys(client, keys);
-            await client.query("COMMIT");
-            return keys.length === 128;
-        }
-        catch (error) {
-            await client.query("ROLLBACK").catch(() => undefined);
-            throw error;
-        }
+        const keys = await this.keys(client, this.truncateSql(), [olderThan, ...highWater, 128]);
+        await this.deleteKeys(client, keys);
+        return keys.length === 128;
     }
     /**
      * Reads record identifiers for one bounded deletion page.
      *
-     * @param client PostgreSQL transaction client.
+     * @param client Acquired PostgreSQL client.
      * @param sql Parameterized key query.
      * @param values PostgreSQL bind values.
      * @returns Stored record identifiers.
@@ -417,7 +367,7 @@ class PostgresStates {
     /**
      * Deletes records identified by one bounded key page.
      *
-     * @param client PostgreSQL transaction client.
+     * @param client Acquired PostgreSQL client.
      * @param keys Stored record identifiers.
      * @returns Completion after the deletion query.
      */
@@ -445,7 +395,7 @@ class PostgresStates {
     /**
      * Finds the first state-history key that trimming may delete.
      *
-     * @param client PostgreSQL client holding the session locks.
+     * @param client Acquired PostgreSQL client.
      * @param id Entity identifier.
      * @param keep Number of newest states to retain.
      * @returns First deletable key, or `undefined` when nothing must be removed.
@@ -473,7 +423,7 @@ class PostgresStates {
     /**
      * Captures the last state key eligible when truncation begins.
      *
-     * @param client PostgreSQL client holding the family lock.
+     * @param client Acquired PostgreSQL client.
      * @param olderThan Exclusive timestamp cutoff in nanoseconds.
      * @returns Stable high-water key, or `undefined` when nothing is eligible.
      */
@@ -495,6 +445,7 @@ class PostgresStates {
 class PostgresEvents {
     input;
     records;
+    onAdmit;
     #executor;
     #open = true;
     /**
@@ -502,10 +453,12 @@ class PostgresEvents {
      *
      * @param input Supplies Entity identity and state-schema definitions.
      * @param records Stores immutable Entity events.
+     * @param onAdmit Admits complete public event-history operations.
      */
-    constructor(input, records) {
+    constructor(input, records, onAdmit) {
         this.input = input;
         this.records = records;
+        this.onAdmit = onAdmit;
         this.#executor = records.historyExecutor();
     }
     /**
@@ -515,15 +468,12 @@ class PostgresEvents {
      * @returns Completion after PostgreSQL stores the event.
      */
     append(record) {
-        if (!this.#open)
-            return Promise.reject(new Error("Entity event history is closed."));
-        return this.#executor
-            .transaction(async (client) => {
-            await client.query("SELECT pg_advisory_xact_lock_shared($1)", [this.familyKey()]);
-            await this.#executor.appendImmutable(client, record);
-        })
-            .catch((error) => {
-            throw PostgresStorageErrors.operation(error);
+        return this.onAdmit(() => {
+            if (!this.#open)
+                return Promise.reject(new Error("Entity event history is closed."));
+            return this.records.writeImmutable(record).catch((error) => {
+                throw PostgresStorageErrors.operation(error);
+            });
         });
     }
     /**
@@ -534,12 +484,22 @@ class PostgresEvents {
      * @param version Optional inclusive starting version.
      * @returns Events in descending version order.
      */
-    async backward(id, depth, version) {
+    backward(id, depth, version) {
+        return this.onAdmit(() => this.backwardAdmitted(id, depth, version));
+    }
+    /**
+     * Reads an admitted Entity event-history page.
+     * @param id Entity identifier.
+     * @param depth Maximum number of events to return.
+     * @param version Optional inclusive starting version.
+     * @returns Events in descending version order.
+     */
+    async backwardAdmitted(id, depth, version) {
         this.assertOpen();
         HistoryValues.assertDepth(depth);
         await this.#executor.prepare();
         return this.#executor
-            .transaction((client) => this.#executor.query(client, this.backwardSql(version), this.backwardValues(id, depth, version)))
+            .using((client) => this.#executor.query(client, this.backwardSql(version), this.backwardValues(id, depth, version)))
             .catch((error) => {
             throw PostgresStorageErrors.operation(error);
         });
@@ -550,32 +510,27 @@ class PostgresEvents {
      * @param olderThan Exclusive history cutoff.
      * @returns Completion after all matching pages are deleted.
      */
-    async truncate(olderThan) {
+    truncate(olderThan) {
+        return this.onAdmit(() => this.truncateAdmitted(olderThan));
+    }
+    /**
+     * Deletes admitted Entity event history.
+     * @param olderThan Exclusive history cutoff.
+     * @returns Completion after all matching pages are deleted.
+     */
+    async truncateAdmitted(olderThan) {
         this.assertOpen();
-        await this.#executor.using(async (client) => {
-            const key = this.familyKey();
-            await client.query("SELECT pg_advisory_lock($1)", [key]);
-            let operationFailure;
-            try {
-                const cutoff = HistoryValues.nanos(olderThan);
-                const highWater = await this.highWater(client, cutoff);
-                if (highWater !== undefined)
-                    while (this.#open && (await this.deletePage(client, cutoff, highWater))) {
-                        // The next page starts only while this history remains open.
-                    }
-            }
-            catch (error) {
-                operationFailure = error;
-            }
-            const cleanup = await PostgresSessionLocks.unlock(client, key, false).catch((error) => error);
-            if (cleanup instanceof Error)
-                PostgresClientDisposal.mark(operationFailure ?? cleanup);
-            if (operationFailure instanceof Error)
-                throw operationFailure;
-            if (operationFailure !== undefined)
-                throw new PostgresStorageOperationError("PostgreSQL event history operation failed.");
-            if (cleanup instanceof Error)
-                throw cleanup;
+        await this.#executor
+            .using(async (client) => {
+            const cutoff = HistoryValues.nanos(olderThan);
+            const highWater = await this.highWater(client, cutoff);
+            if (highWater !== undefined)
+                while (this.#open && (await this.deletePage(client, cutoff, highWater))) {
+                    // Each completed page remains deleted if a later page fails.
+                }
+        })
+            .catch((error) => {
+            throw PostgresStorageErrors.operation(error);
         });
     }
     /**
@@ -614,14 +569,6 @@ class PostgresEvents {
         const entity = this.#executor.column("entity_id", this.input.id.pack(id));
         return version === undefined ? [entity, depth] : [entity, version, depth];
     }
-    /**
-     * Calculates the lock key shared by this history family.
-     *
-     * @returns PostgreSQL advisory-lock key.
-     */
-    familyKey() {
-        return this.#executor.lock("history-family", this.#executor.table());
-    }
     /**
      * Rejects event-history work after this port has closed.
      */
@@ -632,7 +579,7 @@ class PostgresEvents {
     /**
      * Captures the last event key eligible when truncation begins.
      *
-     * @param client PostgreSQL client holding the family lock.
+     * @param client Acquired PostgreSQL client.
      * @param olderThan Exclusive timestamp cutoff in nanoseconds.
      * @returns Stable high-water key, or `undefined` when nothing is eligible.
      */
@@ -644,28 +591,20 @@ class PostgresEvents {
     /**
      * Deletes one bounded page below a timestamp and stable high-water key.
      *
-     * @param client PostgreSQL client holding the family lock.
+     * @param client Acquired PostgreSQL client.
      * @param olderThan Exclusive timestamp cutoff in nanoseconds.
      * @param highWater Last key admitted when truncation began.
      * @returns Whether another full page may remain.
      */
     async deletePage(client, olderThan, highWater) {
-        await client.query("BEGIN");
-        try {
-            const keys = await this.keys(client, [olderThan, ...highWater, 128]);
-            await this.deleteKeys(client, keys);
-            await client.query("COMMIT");
-            return keys.length === 128;
-        }
-        catch (error) {
-            await client.query("ROLLBACK").catch(() => undefined);
-            throw error;
-        }
+        const keys = await this.keys(client, [olderThan, ...highWater, 128]);
+        await this.deleteKeys(client, keys);
+        return keys.length === 128;
     }
     /**
      * Reads event identifiers for one bounded deletion page.
      *
-     * @param client PostgreSQL transaction client.
+     * @param client Acquired PostgreSQL client.
      * @param values PostgreSQL bind values.
      * @returns Stored event identifiers.
      */
@@ -677,7 +616,7 @@ class PostgresEvents {
     /**
      * Deletes events identified by one bounded key page.
      *
-     * @param client PostgreSQL transaction client.
+     * @param client Acquired PostgreSQL client.
      * @param keys Stored event identifiers.
      * @returns Completion after the deletion query.
      */
@@ -742,49 +681,6 @@ const HistoryValues = Object.freeze({
         return value.seconds * 1000000000n + BigInt(value.nanos || 0);
     },
 });
-const PostgresSessionLocks = Object.freeze({
-    /**
-     * Clears all session locks and marks the client after a release failure.
-     *
-     * @param client PostgreSQL client holding the locks.
-     * @param locks Lock keys paired with their shared/exclusive mode.
-     * @param operationFailure Earlier operation failure, when present.
-     * @returns Completion after all releases are attempted.
-     */
-    async cleanup(client, locks, operationFailure) {
-        for (const [key, shared] of locks) {
-            const cleanup = await this.unlock(client, key, shared).catch((error) => error);
-            if (cleanup instanceof Error) {
-                PostgresClientDisposal.mark(operationFailure ?? cleanup);
-                if (operationFailure === undefined)
-                    throw cleanup;
-            }
-        }
-    },
-    /**
-     * Clears one PostgreSQL advisory session lock.
-     *
-     * @param client PostgreSQL client holding the lock.
-     * @param key Advisory-lock key.
-     * @param shared Whether the held lock is shared.
-     * @returns Completion after PostgreSQL confirms the release.
-     */
-    async unlock(client, key, shared) {
-        try {
-            const result = await client.query(shared ? "SELECT pg_advisory_unlock_shared($1)" : "SELECT pg_advisory_unlock($1)", [key]);
-            const unlocked = shared
-                ? result.rows[0]?.pg_advisory_unlock_shared
-                : result.rows[0]?.pg_advisory_unlock;
-            if (unlocked !== true)
-                throw new PostgresStorageOperationError("PostgreSQL history cleanup failed.");
-        }
-        catch (error) {
-            if (error instanceof PostgresStorageOperationError)
-                throw error;
-            throw new PostgresStorageOperationError("PostgreSQL history cleanup failed.");
-        }
-    },
-});
 /**
  * Adapts current Entity records to the provider Entity-storage contract.
  *
@@ -794,15 +690,18 @@ const PostgresSessionLocks = Object.freeze({
 class PostgresCurrentStorage {
     input;
     records;
+    onAdmit;
     /**
      * Creates current Entity storage around one record family.
      *
      * @param input Supplies materialized Entity columns.
      * @param records Stores current Entity records.
+     * @param onAdmit Admits complete public current-record operations.
      */
-    constructor(input, records) {
+    constructor(input, records, onAdmit) {
         this.input = input;
         this.records = records;
+        this.onAdmit = onAdmit;
     }
     /**
      * Reads one current Entity record.
@@ -811,7 +710,7 @@ class PostgresCurrentStorage {
      * @returns The current record, or `undefined` when absent.
      */
     read(id) {
-        return this.records.read(id);
+        return this.onAdmit(() => this.records.read(id));
     }
     /**
      * Writes one current Entity record.
@@ -820,7 +719,7 @@ class PostgresCurrentStorage {
      * @returns Completion after PostgreSQL stores the record.
      */
     write(record) {
-        return this.records.write(record);
+        return this.onAdmit(() => this.records.write(record));
     }
     /**
      * Executes one normalized current-Entity query.
@@ -829,12 +728,14 @@ class PostgresCurrentStorage {
      * @returns Matching records with materialized column values.
      */
     async query(plan) {
-        const entries = await this.records.queryPlanEntries(plan);
-        return entries.map((entry) => ({
-            id: entry.id,
-            record: entry.record,
-            columns: new Map(this.input.columns.map((column) => [column.name, column.valueIn(entry.record)])),
-        }));
+        return this.onAdmit(async () => {
+            const entries = await this.records.queryPlanEntries(plan);
+            return entries.map((entry) => ({
+                id: entry.id,
+                record: entry.record,
+                columns: new Map(this.input.columns.map((column) => [column.name, column.valueIn(entry.record)])),
+            }));
+        });
     }
 }
 //# sourceMappingURL=entity-history.js.map