harper 5.3.3 → 5.3.4

package/dist/resources/DatabaseTransaction.d.ts

@@ -128,6 +128,7 @@ export type TransactionWrite = {
     appendedTo?: RocksTransaction;
     stagedIn?: DatabaseTransaction;
     priorWrite?: TransactionWrite;
+    keyId?: unknown;
     chainsStagedState?: boolean;
     pendingPriorWrite?: TransactionWrite | null;
     stagedEntry?: Partial<Entry>;
@@ -141,6 +142,8 @@ export type TransactionWrite = {
     innerCommit?: MaybePromise<CommitResolution>;
     reloadCommitBase?: boolean;
     stagedOn?: RocksTransaction;
+    committedOn?: RocksTransaction;
+    committedRound?: number;
     baseReadTxn?: any;
     writeGeneration?: WriteGeneration;
     instanceClosed?: boolean;
@@ -198,6 +201,7 @@ export declare class DatabaseTransaction implements Transaction {
     readTxn: ReadTransaction;
     readTxnRefCount: number;
     readTxnsUsed: number;
+    readTxnGeneration: number;
     timeout: number;
     writeTimeout: number;
     writeTick: number;
@@ -306,7 +310,7 @@ export declare class DatabaseTransaction implements Transaction {
      */
     closeOwnedReadIterators(): number;
     useReadTxn(disableSnapshot?: boolean): ReadTransaction;
-    doneReadTxn(): void;
+    doneReadTxn(generation?: number): void;
     private releaseRetainedWriteIntents;
     /**
      * Force-release the retained native read handle without touching staged writes. Used by the

package/dist/resources/DatabaseTransaction.js

@@ -620,6 +620,10 @@ class DatabaseTransaction {
     readTxn;
     readTxnRefCount;
     readTxnsUsed;
+    // Bumped each time this instance acquires a read handle, so a reference can be returned to the
+    // acquisition it came from (doneReadTxn()). Not the handle's identity: lmdb-js hands back the same
+    // read Txn object for a new snapshot.
+    readTxnGeneration = 0;
     timeout;
     writeTick = -1;
     timeoutBudget = 0;
@@ -742,6 +746,7 @@ class DatabaseTransaction {
         readTransactionOwners.set(transaction, this);
         this.rangeReadActive = false;
         this.readTxnsUsed = 1;
+        this.readTxnGeneration++;
         this.baseReadRefConsumed = false;
         this.handleOpenedAt = performance.now();
     }
@@ -843,11 +848,12 @@ class DatabaseTransaction {
         // is not worth doing either, so those reads stay untraced.
         if (DEBUG_LONG_TXNS && this.stackTraces)
             this.stackTraces.push(new StartedTransaction());
-        this.readTxnsUsed++;
+        if (readTxn)
+            this.readTxnsUsed++;
         return readTxn;
     }
-    doneReadTxn() {
-        if (!this.transaction)
+    doneReadTxn(generation = this.readTxnGeneration) {
+        if (!this.transaction || generation !== this.readTxnGeneration)
             return;
         if (--this.readTxnsUsed === 0) {
             // The native handle was only being held open for the read iterators: any writes staged
@@ -926,7 +932,7 @@ class DatabaseTransaction {
         let writesForStore = (this.writesByKey ??= new Map()).get(operation.store);
         if (!writesForStore)
             this.writesByKey.set(operation.store, (writesForStore = new Map()));
-        const keyId = writeKeyId(operation.key);
+        const keyId = (operation.keyId = writeKeyId(operation.key));
         const priorWrite = writesForStore.get(keyId);
         if (priorWrite)
             operation.priorWrite = priorWrite;
@@ -1806,6 +1812,8 @@ class DatabaseTransaction {
                 operation.trackRecordVersion = true;
             if (operation.trackRecordVersion)
                 operation.recordVersionApplied = false;
+            operation.committedOn = transaction;
+            operation.committedRound = txnRetries;
             try {
                 completion = operation.commit(writeVersion, operation.entry, (wasSaved || this.isReplay) && txnRetries > 0, transaction, this);
             }
@@ -2274,11 +2282,19 @@ class DatabaseTransaction {
                             this.trackActiveCommitHandle(replayTransaction);
                             if (prevStagedTxnTime)
                                 this.setHandleStagedTxnTime(replayTransaction, prevStagedTxnTime);
+                            const abandoned = transaction;
+                            const abandonedLogged = hasDurableLog(abandoned);
                             transaction = replayTransaction;
                             try {
                                 for (const operation of this.writes) {
                                     if (!operation?.saved)
                                         continue;
+                                    // A non-durable abandoned handle left no readable audit entry; a durable one may
+                                    // have published its log and must retain the retry shield.
+                                    if (operation.appendedTo === abandoned && !abandonedLogged) {
+                                        operation.appendedAuditEntry = false;
+                                        operation.appendedTo = undefined;
+                                    }
                                     this.save(operation, replayTransaction, true, options);
                                 }
                             }
@@ -2880,7 +2896,7 @@ class DatabaseTransaction {
                     }
                 }
                 else {
-                    while (this.readTxnsUsed > 0)
+                    while (this.transaction && this.readTxnsUsed > 0)
                         this.doneReadTxn(); // release the read snapshot when we abort, we assume we don't need it
                 }
                 // A write-only transaction never took a read reference (getReadTxn was never called), so the