@harperfast/harper 5.3.0 → 5.3.1

package/dist/resources/Table.js

@@ -561,6 +561,15 @@ function scopeViolation(handle, resolved, databaseName) {
         return undefined;
     return new hdbError_ts_1.ClientError('This transaction already holds a node-scoped lock on this record, so a cluster-scoped lock cannot be taken on top of it', 409);
 }
+function rescope(resolved, tableReplicates) {
+    if (resolved.scopeRequested)
+        return resolved;
+    const scope = tableReplicates ? 'cluster' : 'node';
+    return scope === resolved.scope ? resolved : { ...resolved, scope };
+}
+function transportUnavailable(databaseName) {
+    return new hdbError_ts_1.LockUnavailableError(`Cluster-scoped record locks are not available on ${databaseName}: no record lock transport is registered`);
+}
 /** Distinguishes bare lock options from a record target (id, URL, {id:...}). */
 function isPlainOptions(value) {
     return (typeof value === 'object' &&
@@ -577,6 +586,26 @@ function isPlainOptions(value) {
         return undefined;
     return (entry) => Table.writeLockControlEntry(entry);
 });
+// Valid for one synchronous notify pass, in which a key's subscribers on this thread all receive the same
+// freshly decoded audit record; cleared after it so it pins no store or record once delivery is done.
+let memoizedEntryAuditRecord;
+let memoizedEntryStore;
+let memoizedEntryId;
+let memoizedEntry;
+function clearEntryMemo() {
+    memoizedEntryAuditRecord = memoizedEntryStore = memoizedEntryId = memoizedEntry = undefined;
+}
+function currentEntryForAudit(store, id, auditRecord) {
+    if (auditRecord !== memoizedEntryAuditRecord || store !== memoizedEntryStore || id !== memoizedEntryId) {
+        if (memoizedEntryAuditRecord === undefined)
+            queueMicrotask(clearEntryMemo);
+        memoizedEntry = store.getEntry(id);
+        memoizedEntryAuditRecord = auditRecord;
+        memoizedEntryStore = store;
+        memoizedEntryId = id;
+    }
+    return memoizedEntry;
+}
 function makeTable(options) {
     var _a;
     const { primaryKey, indices, tableId, tableName, primaryStore, databasePath, databaseName, auditStore, schemaDefined, dbisDB: dbisDb, sealed, splitSegments, replicate, description, hidden, cacheControl, isBranch, fullTextIndexes = [], fullTextFields = [], fullTextIndexGenerations = Object.create(null), fullTextIndexRetirements = [], } = options;
@@ -865,12 +894,26 @@ function makeTable(options) {
             return;
         return { key, descriptor };
     }
+    const COMMIT_BASE_METHODS = new Set(['put', 'patch', 'delete']);
+    function entryBeforeWrite(loadedEntry, id, transaction, reloadsCommitBase) {
+        if (loadedEntry != null)
+            return loadedEntry;
+        if (isRocksDB && reloadsCommitBase) {
+            // save() reads this write's base from the staging snapshot (harper#2259); the read handle is still opened
+            // here because it is what gives the staged write coordinated conflict retries
+            transaction.getReadTxn();
+            return undefined;
+        }
+        return primaryStore.getEntry(id, { transaction: transaction.getReadTxn() });
+    }
     class TableResource extends Resource_ts_1.Resource {
         #record; // the stored/frozen record from the database and stored in the cache (should not be modified directly)
         #changes; // the changes to the record that have been made (should not be modified directly)
         #version; // version of the record
         #entry; // the entry from the database
         #savingOperation; // operation for the record is currently being saved
+        #baseReadTxn; // staging handle this instance's uncached pre-load read through
+        #baseReadEntry; // what that read returned, reusable as the commit base only while it is still #entry
         #lockHandle; // the record lock acquired by lock() — scoped or hold
         #lockWritable; // set by #reloadLocked to let save() stage lock-writable updates
         #writeGeneration;
@@ -1611,12 +1654,25 @@ function makeTable(options) {
                 if (readTxn?.isDone) {
                     throw new Error('You can not read from a transaction that has already been committed/aborted');
                 }
-                return loadLocalRecord(id, request, { transaction: readTxn, ensureLoaded: resourceOptions?.ensureLoaded }, sync, (entry) => {
+                const readsCommitBase = isRocksDB &&
+                    COMMIT_BASE_METHODS.has(resourceOptions?.method) &&
+                    !resourceOptions?.ensureLoaded &&
+                    readTxn &&
+                    !readTxn.snapshotDisabled;
+                return loadLocalRecord(id, request, {
+                    transaction: readTxn,
+                    ensureLoaded: resourceOptions?.ensureLoaded,
+                    uncachedRead: readsCommitBase || undefined,
+                }, sync, (entry) => {
                     if (entry) {
                         _a._updateResource(this, entry);
                     }
                     else
                         this.#record = null;
+                    if (readsCommitBase) {
+                        this.#baseReadTxn = readTxn;
+                        this.#baseReadEntry = entry;
+                    }
                     if (request.onlyIfCached) {
                         // don't go into the loading from source condition, but HTTP spec says to
                         // return 504 (rather than 404) if there is no content and the cache-control header
@@ -1647,6 +1703,16 @@ function makeTable(options) {
                 throw error;
             }
         }
+        // Reusable only for the key this instance read and while #entry is the entry that read returned: a source fill
+        // or retry replaces #entry, and ensureLoaded() can evict it in place, so ensureLoaded() drops the receipt.
+        #commitBaseTxn(id) {
+            const baseReadTxn = this.#baseReadTxn;
+            if (!baseReadTxn || this.#baseReadEntry !== this.#entry)
+                return;
+            const receiverId = this.getId();
+            if (Object.is(id, receiverId) || (0, DatabaseTransaction_ts_1.writeKeyId)(id) === (0, DatabaseTransaction_ts_1.writeKeyId)(receiverId))
+                return baseReadTxn;
+        }
         static _updateResource(resource, entry) {
             resource.#entry = entry;
             resource.#record = entry?.value ?? null;
@@ -1658,6 +1724,7 @@ function makeTable(options) {
          * @returns
          */
         ensureLoaded() {
+            this.#baseReadTxn = undefined;
             const loadedFromSource = ensureLoadedFromSource(this.constructor.source, this.getId(), this.#entry, this.getContext());
             if (loadedFromSource) {
                 return (0, when_ts_1.when)(loadedFromSource, (entry) => {
@@ -2848,6 +2915,7 @@ function makeTable(options) {
                         additionalAuditRefs: isRocksDB && audit && txnLogKey !== txnTime
                             ? [{ version: txnLogKey, nodeId: options?.nodeId }]
                             : undefined,
+                        localOnly: options?.localOnly,
                     }, 'invalidate');
                     if (write.trackRecordVersion)
                         write.recordVersionApplied = true;
@@ -2906,6 +2974,7 @@ function makeTable(options) {
                         additionalAuditRefs: isRocksDB && audit && txnLogKey !== txnTime
                             ? [{ version: txnLogKey, nodeId: options?.nodeId }]
                             : undefined,
+                        localOnly: options?.localOnly,
                     }, 'relocate', false, null);
                     if (write.trackRecordVersion)
                         write.recordVersionApplied = true;
@@ -3078,7 +3147,7 @@ function makeTable(options) {
             const id = target != null ? requestTargetToId(target) : this.getId();
             checkValidId(id);
             this.#assertLiveHandle(id);
-            const resolved = (0, recordLock_ts_1.resolveLockOptions)(options);
+            const resolved = (0, recordLock_ts_1.resolveLockOptions)(options, _a.replicate !== false);
             const context = this.getContext();
             const link = txnForContext(context);
             const keyId = (0, DatabaseTransaction_ts_1.writeKeyId)(id);
@@ -3088,7 +3157,7 @@ function makeTable(options) {
             if (resolved.scope === 'cluster' &&
                 (resolved.scopeRequested || (0, recordLockCoordinator_ts_1.isClusterLockRequired)(databaseName)) &&
                 !(0, recordLockCoordinator_ts_1.getClusterLockTransport)(databaseName))
-                return Promise.reject(new hdbError_ts_1.LockUnavailableError(`Cluster-scoped record locks are not available on ${databaseName}: no record lock transport is registered`));
+                return Promise.reject(transportUnavailable(databaseName));
             const held = this.#lockHandle;
             if (held && !held.isExpired() && held.keyId === keyId) {
                 // Re-entrant: upgrade to hold if requested, then preserve staged changes.
@@ -3181,7 +3250,7 @@ function makeTable(options) {
                     clearTimeout(followerTimer);
                     const acquired = link.recordLockFor(primaryStore, keyId);
                     if (acquired && !acquired.isExpired()) {
-                        const violation = scopeViolation(acquired, resolved, databaseName);
+                        const violation = scopeViolation(acquired, rescope(resolved, _a.replicate !== false), databaseName);
                         if (violation)
                             throw violation;
                         if (resolved.hold && !acquired.hold) {
@@ -3223,9 +3292,9 @@ function makeTable(options) {
                 // caller's whole timeout, long enough for harper-pro to register the transport on this
                 // worker. Using the snapshot would take the native key alone and hand back a node-scoped
                 // handle while a peer that already had the transport is granted the same key.
+                const current = rescope(resolved, _a.replicate !== false);
                 try {
-                    if (resolved.scope !== 'node')
-                        coordinator = _a.lockCoordinator ?? coordinator;
+                    coordinator = current.scope === 'cluster' ? (_a.lockCoordinator ?? coordinator) : undefined;
                 }
                 catch (error) {
                     // The getter fails closed on an unusable node identity, and that has to reach the caller
@@ -3235,6 +3304,13 @@ function makeTable(options) {
                     handle.release();
                     throw error;
                 }
+                // The entry check cannot cover this: the wait is where the call became cluster-scoped.
+                if (current.scope === 'cluster' &&
+                    !coordinator &&
+                    (current.scopeRequested || (0, recordLockCoordinator_ts_1.isClusterLockRequired)(databaseName))) {
+                    handle.release();
+                    throw transportUnavailable(databaseName);
+                }
                 if (coordinator) {
                     try {
                         // Not a 423 when the budget is gone, and not a skip either: the native wait can consume
@@ -3538,7 +3614,9 @@ function makeTable(options) {
                     }
                 };
             }
-            const entry = this.#entry ?? primaryStore.getEntry(id, { transaction: transaction.getReadTxn() });
+            const reloadsCommitBase = options?.isCopyApply !== true;
+            const entry = entryBeforeWrite(this.#entry, id, transaction, reloadsCommitBase);
+            const baseReadTxn = this.#commitBaseTxn(id);
             const writeToSource = () => {
                 if (!this.constructor.source || context?.source)
                     return;
@@ -3567,11 +3645,12 @@ function makeTable(options) {
                 key: id,
                 store: primaryStore,
                 entry,
+                baseReadTxn,
                 nodeName: context?.nodeName,
                 fullUpdate,
                 chainsStagedState: true,
                 // copy-apply rows keep their pre-read base: one read per row, healed by the post-copy replay
-                reloadCommitBase: options?.isCopyApply !== true,
+                reloadCommitBase: reloadsCommitBase,
                 deferSave: true,
                 // the origin's record version on an applied write; absent for a locally-originated one
                 recordVersion: options?.version,
@@ -4373,11 +4452,13 @@ function makeTable(options) {
             const transaction = txnForContext(context);
             assertDerivedIndexAdmission(options, transaction);
             checkValidId(id);
-            const entry = this.#entry ?? primaryStore.getEntry(id, { transaction: transaction.getReadTxn() });
+            const entry = entryBeforeWrite(this.#entry, id, transaction, true);
+            const baseReadTxn = this.#commitBaseTxn(id);
             const write = {
                 key: id,
                 store: primaryStore,
                 entry,
+                baseReadTxn,
                 chainsStagedState: true,
                 reloadCommitBase: true,
                 nodeName: context?.nodeName,
@@ -4428,6 +4509,7 @@ function makeTable(options) {
                             additionalAuditRefs: isRocksDB && audit && txnLogKey !== txnTime
                                 ? [{ version: txnLogKey, nodeId: options?.nodeId }]
                                 : undefined,
+                            localOnly: options?.localOnly,
                         }, 'delete');
                         if (!audit || isRocksDB)
                             scheduleCleanup();
@@ -5027,8 +5109,12 @@ function makeTable(options) {
                     results = results.slice(offset, end);
                 results.onDone = () => {
                     results.onDone = null; // ensure that it isn't called twice
+                    txn.unregisterReadIterator(results);
                     txn.doneReadTxn();
                 };
+                // Recorded ownership: if the request dies before anything consumes these results, the
+                // transaction closes them itself rather than leaving its read snapshot pinned.
+                txn.registerReadIterator(results);
                 results.selectApplied = true;
                 results.getColumns = getColumns;
                 return results;
@@ -5869,7 +5955,12 @@ function makeTable(options) {
                 if (subscription.closed)
                     return;
                 harper_logger_ts_1.default.error?.('Error in real-time subscription:', error);
-                subscription.close(error);
+                try {
+                    subscription.close(error);
+                }
+                catch (listenerError) {
+                    harper_logger_ts_1.default.error?.('Error in real-time subscription listener:', listenerError);
+                }
             }
             function eventFromAudit(id, auditRecord, localTime, beginTxn) {
                 let type = auditRecord.type;
@@ -5878,7 +5969,7 @@ function makeTable(options) {
                 if (isMutation && !includeSuperseded) {
                     if (id === undefined)
                         return;
-                    const entry = primaryStore.getEntry(id);
+                    const entry = currentEntryForAudit(primaryStore, id, auditRecord);
                     if (!entry || entry.version !== auditRecord.version)
                         return;
                     if (getFullRecord) {
@@ -6076,7 +6167,7 @@ function makeTable(options) {
                     logger_ts_1.logger.trace?.(`Publishing message to id: ${id}, timestamp: ${new Date(txnTime).toISOString()}`);
                     // always audit this, but don't change existing version
                     // TODO: Use direct writes in the future (copying binary data is hard because it invalidates the cache)
-                    return updateRecord(id, existingEntry?.value ?? null, existingEntry, txnTime, 0, true, {
+                    return updateRecord(id, existingEntry?.value ?? null, existingEntry, txnTime, (existingEntry?.metadataFlags ?? 0) & auditStore_ts_1.LOCAL_ONLY, true, {
                         user: context?.user,
                         residencyId: options?.residencyId,
                         expiresAt: context?.expiresAt,
@@ -6084,6 +6175,7 @@ function makeTable(options) {
                         viaNodeId: options?.viaNodeId,
                         transaction,
                         tableToTrack: tableName,
+                        auditLocalOnly: options?.localOnly,
                     }, 'message', false, message);
                 },
             };
@@ -7712,6 +7804,16 @@ function makeTable(options) {
                         // regardless of this state.
                         transaction.next.open = DatabaseTransaction_ts_1.TRANSACTION_STATE.CLOSED;
                     }
+                    // A poison flag must travel with `open`, or a link created after the poisoning (a
+                    // handler touching this database for the first time post-poison) sees CLOSED but not
+                    // the reason, takes save()'s immediateCommit path, and commits on behalf of a request
+                    // that was supposed to have been cut off.
+                    if (transaction.timedOut)
+                        transaction.next.timedOut = true;
+                    if (transaction.disconnected)
+                        transaction.next.disconnected = true;
+                    if (transaction.postSubmitPoisoned)
+                        transaction.next.postSubmitPoisoned = true;
                     transaction = transaction.next;
                     transaction.db = primaryStore;
                     return transaction;
@@ -7725,6 +7827,8 @@ function makeTable(options) {
                 context.transaction = transaction;
                 if (context.timestamp)
                     transaction.timestamp = context.timestamp;
+                if (!context.sourceApply)
+                    transaction.requestSignal = context.signal;
             }
             return transaction;
         }