@harperfast/harper 5.2.5 → 5.2.7

package/dist/resources/Table.js

@@ -403,6 +403,18 @@ function makeTable(options) {
     // it, so such a table takes the guarded serialization path rather than the raw fast path.
     let hasSurfacedComputed = false;
     let runningRecordExpiration;
+    const reportedResolverCollisions = new Set();
+    // Reached from record materialization, so it can never be the reason a record fails to load: the
+    // name is marked before the log call, and a throwing log sink is swallowed.
+    function reportResolverCollision(name) {
+        if (reportedResolverCollisions.has(name))
+            return;
+        reportedResolverCollisions.add(name);
+        try {
+            logger_ts_1.logger.warn?.(`Table "${tableName}" has a stored value under "${name}", which is a computed attribute; the stored value is being discarded and the computed value used instead`);
+        }
+        catch { }
+    }
     const isRocksDB = primaryStore instanceof rocksdb_js_1.RocksDatabase;
     let idIncrementer;
     let replicateToCount;
@@ -1818,8 +1830,27 @@ function makeTable(options) {
         }
         #saveOperation(operation) {
             const transaction = txnForContext(this.getContext());
-            if (transaction.save)
-                return transaction.save(operation) || operation.promise || operation.result;
+            const holder = operation.stagedIn;
+            // never-drop-on-conflict lives on the transaction and would not travel with the write, so an
+            // apply or a replay keeps it (harper-pro#348)
+            const holderOwnsPolicy = holder?.sourceApply || holder?.isReplay;
+            // stagesWriteOnSave: LMDBTransaction's addWrite never runs the write (its commit applies
+            // `writes`), so handing it one is a dead end
+            if (holder &&
+                holder !== transaction &&
+                !holderOwnsPolicy &&
+                transaction.stagesWriteOnSave &&
+                (0, DatabaseTransaction_ts_1.isJoinableScope)(transaction)) {
+                holder.detachWrite(operation);
+                // The basis chain belongs to the holder: derived from a write this scope cannot commit, the
+                // merge and index diff would be relative to a record that may never land.
+                operation.priorWrite = undefined;
+                operation.deferSave = false;
+                return (0, when_ts_1.when)(transaction.addWrite(operation), () => operation.promise ?? operation.result);
+            }
+            const owner = holder ?? transaction;
+            if (owner.save)
+                return owner.save(operation) || operation.promise || operation.result;
         }
         addTo(property, value) {
             if (typeof value === 'number' || typeof value === 'bigint') {
@@ -2234,12 +2265,12 @@ function makeTable(options) {
                 nodeName: context?.nodeName,
                 fullUpdate,
                 deferSave: true,
-                validate: (txnTime) => {
+                validate: (txnTime, committedBy = transaction) => {
                     if (!recordUpdate)
                         recordUpdate = this.#changes;
                     if (fullUpdate || (recordUpdate && (0, tracked_ts_1.hasChanges)(this.#changes === recordUpdate ? this : recordUpdate))) {
                         if (!context?.source) {
-                            transaction.checkOverloaded();
+                            committedBy.checkOverloaded();
                             // A record must be a plain object. Reject primitive, string/number, bare-binary,
                             // and bare-array roots — e.g. a raw Buffer from an application/octet-stream PUT, a
                             // JSON string/number body, or a top-level JSON array. Such roots carry no primary
@@ -2275,7 +2306,7 @@ function makeTable(options) {
                             // by replayLogs). Records were valid when originally written; post-crash schema
                             // evolution (e.g. newly required fields) must not prevent replaying them
                             // (harper#1316, facet b).
-                            if (!transaction.isReplay)
+                            if (!committedBy.isReplay)
                                 this.validate(recordUpdate, !fullUpdate);
                             if (updatedTimeProperty) {
                                 recordUpdate[updatedTimeProperty.name] =
@@ -2313,7 +2344,7 @@ function makeTable(options) {
                         }
                     }
                     else {
-                        transaction.removeWrite?.(write);
+                        committedBy.removeWrite?.(write);
                         return false;
                     }
                 },
@@ -2356,6 +2387,7 @@ function makeTable(options) {
                     this.#version = txnTime;
                     let incrementalUpdateToApply;
                     this.#savingOperation = null;
+                    write.stagedIn = undefined; // nothing may pin this write's transaction past its commit
                     let omitLocalRecord = false;
                     // we use optimistic locking to only commit if the existing record state still holds true.
                     // this is superior to using an async transaction since it doesn't require JS execution
@@ -4766,6 +4798,9 @@ function makeTable(options) {
                 if (attribute.isPrimaryKey)
                     primaryKeyAttribute = attribute;
                 attribute.resolve = null; // reset this
+                // Also the setter, or a reload that turns a @relationship into a @computed keeps the
+                // relationship's setter and writes a foreign key from a computed assignment.
+                attribute.set = null;
                 const relationship = attribute.relationship;
                 const computed = attribute.computed;
                 // Register the default embedder unless an author override is set. Sits outside
@@ -4917,14 +4952,20 @@ function makeTable(options) {
             enumerableAttributeNames = [];
             enumerableRelationDefs.clear();
             hasSurfacedComputed = false;
+            const resolvedAttributeNames = [];
             for (const attribute of attributes) {
                 const name = attribute.name;
                 if (attribute.resolve) {
+                    resolvedAttributeNames.push(name);
                     Object.defineProperty(primaryStore.encoder.structPrototype, name, {
                         get() {
                             return attribute.resolve(this, transaction_ts_1.contextStorage.getStore()); // it is only possible to get the context from ALS, we don't have a direct reference to the current context
                         },
                         set(related) {
+                            // A read-only resolver must never be the reason a record fails to materialize — the
+                            // same reason the one-to-many branch above installs a no-op.
+                            if (!attribute.set)
+                                return reportResolverCollision(name);
                             return attribute.set(this, related);
                         },
                         configurable: true,
@@ -4954,6 +4995,12 @@ function makeTable(options) {
                 installEnumerableToJSON(primaryStore.encoder.structPrototype, this, hasSurfacedComputed);
             else if (primaryStore.encoder.structPrototype.toJSON)
                 delete primaryStore.encoder.structPrototype.toJSON;
+            // Undefined rather than an empty set for a table with no resolved attributes: that is the
+            // check which keeps the projection off an unaffected store's write path.
+            primaryStore.encoder.resolvedAttributeNames =
+                resolvedAttributeNames.length > 0 ? new Set(resolvedAttributeNames) : undefined;
+            primaryStore.encoder.resolvedAttributeNamesList = resolvedAttributeNames;
+            primaryStore.encoder.surfacedToJSON = primaryStore.encoder.structPrototype.toJSON;
         }
         // #section: computed-history
         static setComputedAttribute(attribute_name, resolver) {
@@ -5464,10 +5511,31 @@ function makeTable(options) {
                 if (transaction.db?.path === primaryStore.path)
                     return transaction;
                 // try the next one:
-                const nextTxn = transaction.next;
+                let nextTxn = transaction.next;
+                // A self-committing link is CLOSED once it has committed, and a further write through it
+                // commits on a native handle nothing awaits (#2323). Spent — closed, handle detached, none of
+                // its OWN writes left (hasPendingWrites walks successors, which is not this question) — it
+                // holds nothing, so drop it. A run of them can be spent, hence the loop. A timeout-poisoned
+                // link is kept: reusing it is what makes the rest of the operation fail atomically (#1411).
+                while (nextTxn?.saveCommits &&
+                    nextTxn.open !== DatabaseTransaction_ts_1.TRANSACTION_STATE.OPEN &&
+                    !nextTxn.timedOut &&
+                    !nextTxn.transaction &&
+                    !nextTxn.writes.some((write) => write)) {
+                    transaction.next = nextTxn.next;
+                    nextTxn = transaction.next;
+                }
                 if (!nextTxn) {
                     // no next one, then add our database
-                    transaction.next = isRocksDB ? new DatabaseTransaction_ts_1.DatabaseTransaction() : new LMDBTransaction_1.LMDBTransaction();
+                    // A staging link under a self-committing head is committed only if the head's own database
+                    // is written again and cascades the chain, so a handler writing this one last loses it (#2292).
+                    transaction.next = transaction.saveCommits
+                        ? (isRocksDB
+                            ? new DatabaseTransaction_ts_1.ImmediateTransaction(primaryStore)
+                            : new LMDBTransaction_1.ImmediateTransaction(primaryStore))
+                        : isRocksDB
+                            ? new DatabaseTransaction_ts_1.DatabaseTransaction()
+                            : new LMDBTransaction_1.LMDBTransaction();
                     // The chain root, so a link that only ever receives a blind write is supervised by the
                     // long-transaction monitor as part of its logical transaction rather than as its own
                     // timeout root (issue #2231).
@@ -5489,8 +5557,11 @@ function makeTable(options) {
                     // A second database joined after a mid-scope commit belongs to the same snapshot-free
                     // generation as the head, or its reads would re-pin what the commit just unpinned.
                     transaction.next.snapshotFree = transaction.snapshotFree;
-                    if (transaction.open === DatabaseTransaction_ts_1.TRANSACTION_STATE.CLOSED) {
+                    if (transaction.open === DatabaseTransaction_ts_1.TRANSACTION_STATE.CLOSED && !transaction.next.saveCommits) {
                         // if the current transaction is already closed, we need to retain that state on new databases we work with
+                        // Never onto a self-committing link: CLOSED is what routes its first write through the
+                        // commit re-entry that drops the native commit promise (#2323), and it commits per write
+                        // regardless of this state.
                         transaction.next.open = DatabaseTransaction_ts_1.TRANSACTION_STATE.CLOSED;
                     }
                     transaction = transaction.next;
@@ -5771,6 +5842,32 @@ function makeTable(options) {
                         // 5.2 record caching relies on it — so we must not write through the frozen object).
                         if (isFrozenRecordObject(updatedRecord))
                             updatedRecord = { ...updatedRecord };
+                        // A writable resolver (a relationship) keeps its meaning for source payloads: a source
+                        // returning the related object instead of the foreign key gets the key derived, the way
+                        // the promotion setter used to. Derivation runs against a probe first — a malformed
+                        // value (a scalar, an object without the related primary key) derives undefined, and
+                        // applying that would durably wipe the foreign key. The projection then drops the
+                        // resolver-owned key itself, so the cache-fill response cannot be the one read
+                        // reporting the source's value.
+                        const resolvedNames = primaryStore.encoder.resolvedAttributeNamesList;
+                        if (resolvedNames) {
+                            for (const name of resolvedNames) {
+                                if (Object.hasOwn(updatedRecord, name)) {
+                                    const resolvedAttribute = (0, search_ts_1.findAttribute)(attributes, name);
+                                    if (resolvedAttribute?.set && updatedRecord[name] != null) {
+                                        const probe = {};
+                                        resolvedAttribute.set(probe, updatedRecord[name]);
+                                        for (const key in probe) {
+                                            const derived = probe[key];
+                                            const usable = Array.isArray(derived) ? derived.every((one) => one != null) : derived != null;
+                                            if (usable)
+                                                updatedRecord[key] = derived;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        updatedRecord = (0, RecordEncoder_ts_1.storedFieldsOnly)(primaryStore.encoder, updatedRecord);
                         if (primaryKey && updatedRecord[primaryKey] !== id)
                             updatedRecord[primaryKey] = id;
                     }