@harperfast/harper 5.2.0 → 5.2.2

package/dist/resources/Table.js

@@ -341,10 +341,20 @@ function makeTable(options) {
     if (!properties)
         properties = (0, jsonSchemaTypes_ts_1.projectAttributesToProperties)(attributes);
     const updateRecord = (0, RecordEncoder_ts_1.recordUpdater)(primaryStore, tableId, auditStore);
+    let warnedNullSourcePut = false; // latched: one warn per table per worker (see _writeUpdate)
     let sourceLoad; // if a source has a load function (replicator), record it here
     let hasSourceGet;
     let primaryKeyAttribute;
     let lastEvictionCompletion = Promise.resolve();
+    // getFromSource() intentionally resolves its caller before the resolved record's cache
+    // write has committed (see there) so GET latency doesn't pay for the write. dropTable()
+    // must not drop this table's column families while one of those writes is still landing —
+    // racing a drop against an in-flight write is what corrupts the column family handle and
+    // produces "Invalid column family specified in write batch" (harper#1381). Track the
+    // in-flight commit promises here so dropTable() can drain them first, and stop admitting
+    // new ones (droppingTable) once a drop has actually started.
+    const pendingSourceCommits = new Set();
+    let droppingTable = false;
     let createdTimeProperty, updatedTimeProperty, expiresAtProperty;
     for (const attribute of attributes) {
         if (attribute.assignCreatedTime || attribute.name === '__createdtime__')
@@ -1317,12 +1327,52 @@ function makeTable(options) {
                         await tombstoneWrite;
                 }
             }
+            // A get() against a sourcedFrom table resolves to its caller before the resolved
+            // record's cache write has committed (see getFromSource) - the write lands "in the
+            // background" for latency reasons. Flip this BEFORE removing the table from the
+            // schema below: getFromSource() checks it and skips caching (treats the load as
+            // noCacheStore) for any call it admits from here on, including one that slipped in
+            // through a stale reference to this Table between the two steps.
+            droppingTable = true;
             // Remove the table from the in-memory schema immediately so concurrent
             // requests get "table does not exist" instead of racing the column
             // family drops below. If a drop fails past this point the table stays
             // invisible, and the tombstone guarantees the drop completes on the
             // next startup (or on a same-name create).
             delete databases_ts_1.databases[databaseName][tableName];
+            // The above stops new source-fill writes from starting, but a write from a get()
+            // that already returned to its caller may still be in flight. Dropping the column
+            // families out from under that write is a genuine invariant violation, not just a
+            // benign race: RocksDB rejects the still-open write batch with "Invalid column
+            // family specified in write batch" (or "Could not access column family N"), which
+            // can also abort this drop before it removes the tombstoned catalog rows - leaving
+            // the table stuck "dropping" for completeInterruptedDrop to retry (and fail
+            // identically) on every subsequent load (harper#1381). Drain any in-flight commits
+            // before the blob sweep below (so it observes every row a drain-caught write just
+            // committed) and before touching a single column family.
+            //
+            // Bounded, and fails CLOSED: the tracked promise covers the whole source round-trip
+            // plus the local commit (see getFromSource), so a hung/slow source or a slow commit
+            // (e.g. a large blob write) could otherwise wedge this drop forever. Rather than
+            // give up and drop anyway - which would reopen exactly the race this drain exists to
+            // close, just less often - a timeout FAILS the drop. The tombstone written above is
+            // already durable, so completeInterruptedDrop picks the drop back up on the next
+            // load, once the stuck write has had time to finish.
+            if (pendingSourceCommits.size) {
+                const pending = [...pendingSourceCommits];
+                let timer;
+                const timedOut = Symbol('timedOut');
+                const result = await Promise.race([
+                    Promise.allSettled(pending),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve(timedOut), LOCK_TIMEOUT);
+                    }),
+                ]);
+                clearTimeout(timer);
+                if (result === timedOut) {
+                    throw new Error(`dropTable() timed out after ${LOCK_TIMEOUT}ms waiting for ${pending.length} in-flight source-populated cache write(s) on ${tableName} to settle; refusing to drop the column families out from under a write that may still be staged. The drop tombstone is durable, so this will be retried on the next load.`);
+                }
+            }
             for (const entry of primaryStore.getRange({ versions: true, snapshot: false, lazy: true })) {
                 if (entry.metadataFlags & auditStore_ts_1.HAS_BLOBS && entry.value) {
                     (0, blob_ts_1.deleteBlobsInObject)(entry.value);
@@ -2108,6 +2158,19 @@ function makeTable(options) {
             const context = this.getContext();
             const transaction = txnForContext(context);
             checkValidId(id);
+            if (fullUpdate && recordUpdate == null && options?.isNotification) {
+                // A source/replication-applied put must carry the record; these applies skip record
+                // validation, so this is the one path a nullish full update reaches (isNotification scopes
+                // this to the apply dispatcher, not instance flows that fill from #changes). Applying it
+                // stores nothing and mints an audit-only entry misrepresenting the write (#2153) — skip it;
+                // a redelivery re-skips and a later real write supersedes.
+                logger_ts_1.logger.trace?.('Skipped valueless source put', tableName, id, options?.nodeId);
+                if (!warnedNullSourcePut) {
+                    warnedNullSourcePut = true;
+                    logger_ts_1.logger.warn?.(`Skipping a source-applied put with no record content for ${tableName} id ${id} from node ${options?.nodeId}`, new Error('valueless source put'));
+                }
+                return;
+            }
             const entry = this.#entry ?? primaryStore.getEntry(id, { transaction: transaction.getReadTxn() });
             const writeToSource = () => {
                 if (!this.constructor.source || context?.source)
@@ -3137,6 +3200,13 @@ function makeTable(options) {
             if (conditions.length > 0 || operator)
                 conditions = prepareConditions(conditions, operator);
             const sort = typeof target.sort === 'object' && target.sort;
+            for (let order = sort; order; order = order.next) {
+                if (typeof order.attribute !== 'string')
+                    continue;
+                const customIndex = indices[order.attribute]?.customIndex;
+                if (customIndex?.exactDistance)
+                    customIndex.exactDistance(order, null);
+            }
             let postOrdering;
             if (sort) {
                 // TODO: Support index-assisted sorts of unions, which will require potentially recursively adding/modifying an order aligned condition and be able to recursively undo it if necessary
@@ -3174,9 +3244,12 @@ function makeTable(options) {
                     if (sort.next) {
                         postOrdering = {
                             dbOrderedAttribute: sort.attribute,
+                            dbOrderedSort: sort,
                             attribute: sort.next.attribute,
                             descending: sort.next.descending,
                             next: sort.next.next,
+                            target: sort.next.target,
+                            distance: sort.next.distance,
                         };
                     }
                 }
@@ -3241,7 +3314,7 @@ function makeTable(options) {
             // since those never run the ensureLoaded-gated freshness check this transform
             // otherwise applies unconditionally to every read.
             const includeExpired = target.includeExpired === true;
-            const transformToRecord = TableResource.transformEntryForSelect(select, context, readTxn, filtered, ensure_loaded, true, boundRowFilter, includeExpired);
+            const transformToRecord = TableResource.transformEntryForSelect(select, context, readTxn, filtered, ensure_loaded, true, boundRowFilter, includeExpired, postOrdering);
             let results = TableResource.transformToOrderedSelect(entries, select, postOrdering, context, readTxn, transformToRecord);
             // apply any offset/limit after all the sorting and filtering
             if (target.offset || target.limit !== undefined)
@@ -3283,10 +3356,9 @@ function makeTable(options) {
                     function createComparator(order) {
                         const nextComparator = order.next && createComparator(order.next);
                         const descending = order.descending;
-                        context.sort = order; // make sure this is set to the current sort order
                         return (entryA, entryB) => {
-                            const a = getAttributeValue(entryA, order.attribute, context);
-                            const b = getAttributeValue(entryB, order.attribute, context);
+                            const a = getAttributeValue(entryA, order.attribute, context, order);
+                            const b = getAttributeValue(entryB, order.attribute, context, order);
                             const diff = descending
                                 ? (0, ordered_binary_1.compareKeys)(convertToComparableKeys(b), convertToComparableKeys(a))
                                 : (0, ordered_binary_1.compareKeys)(convertToComparableKeys(a), convertToComparableKeys(b));
@@ -3336,7 +3408,7 @@ function makeTable(options) {
                                     // if the index has already provided the first order of sorting, we only need to sort
                                     // within each grouping
                                     if (dbOrderedAttribute) {
-                                        const groupingValue = getAttributeValue(entry, dbOrderedAttribute, context);
+                                        const groupingValue = getAttributeValue(entry, dbOrderedAttribute, context, sort.dbOrderedSort);
                                         if (firstEntry) {
                                             firstEntry = false;
                                             lastGroupingValue = groupingValue;
@@ -3446,9 +3518,10 @@ function makeTable(options) {
          * authorization verdict can't be made on bytes that differ from what the caller receives.
          * @param includeExpired when true, a row past its TTL but not yet swept is treated as a live
          * match rather than gone (used by the SQL engine's UPDATE/DELETE row-finder).
+         * @param sort post-ordering owned by this selection
          * @returns
          */
-        static transformEntryForSelect(select, context, readTxn, filtered, ensure_loaded, canSkip, rowFilter, includeExpired) {
+        static transformEntryForSelect(select, context, readTxn, filtered, ensure_loaded, canSkip, rowFilter, includeExpired, sort) {
             let checkLoaded;
             if (ensure_loaded &&
                 hasSourceGet &&
@@ -3517,7 +3590,7 @@ function makeTable(options) {
                         swrResource.setRecord(record);
                         const loadingFromSource = ensureLoadedFromSource(source, entry.key ?? entry, entry, context, swrResource);
                         if (loadingFromSource?.then) {
-                            return loadingFromSource.then(transform);
+                            return loadingFromSource.then(transform.bind(this));
                         }
                     }
                 }
@@ -3554,7 +3627,7 @@ function makeTable(options) {
                                 }
                             }
                             else {
-                                value = resolver(record, context, entry, true);
+                                value = resolver(record, context, entry, true, sort);
                             }
                             const handleResolvedValue = (value) => {
                                 if (resolver.directReturn)
@@ -3572,7 +3645,7 @@ function makeTable(options) {
                                         // otherwise pass along the nested selected
                                         attribute_name === attribute
                                             ? null
-                                            : attribute.select || (Array.isArray(attribute) ? attribute : null), context, targetReadTxn, filterMap, ensure_loaded));
+                                            : attribute.select || (Array.isArray(attribute) ? attribute : null), context, targetReadTxn, filterMap, ensure_loaded, undefined, undefined, undefined, typeof attribute.sort === 'object' && attribute.sort));
                                     if (Array.isArray(value)) {
                                         const results = [];
                                         const iterator = targetTable
@@ -4510,13 +4583,13 @@ function makeTable(options) {
                 (stats.totalSize ??
                     (stats.treeBranchPageCount + stats.treeLeafPageCount + stats.overflowPages) * stats.pageSize));
         }
-        static getStorageStats() {
-            const stats = node_fs_1.default.statfsSync(primaryStore.path);
-            return {
-                available: stats.bavail * stats.bsize,
-                free: stats.bfree * stats.bsize,
-                size: stats.blocks * stats.bsize,
-            };
+        /**
+         * Get available/free/size storage stats for the table's underlying volume. Async because
+         * this may need to read quota-status.json (#1976); getSize/getAuditSize stay sync because
+         * they only read in-memory store stats.
+         */
+        static async getStorageStats() {
+            return (0, storageReclamation_ts_1.getStorageSpaceStats)(primaryStore.path);
         }
         static async getRecordCount(options) {
             // iterate through the metadata entries to exclude their count and exclude the deletion counts
@@ -4630,8 +4703,26 @@ function makeTable(options) {
                 $updatedTime: (object, context, entry) => entry.version,
                 $expiresAt: (object, context, entry) => entry.expiresAt,
                 $record: (object, context, entry) => (entry ? { value: object } : object),
-                $distance: (object, context, entry) => {
-                    return entry && (entry.distance ?? context?.vectorDistances?.get(entry));
+                $distance: (object, context, entry, returnEntry, sort) => {
+                    if (!entry)
+                        return;
+                    if (entry.distance !== undefined)
+                        return entry.distance;
+                    let distanceSort = sort;
+                    while (distanceSort &&
+                        (typeof distanceSort.attribute !== 'string' ||
+                            !Array.isArray(distanceSort.target) ||
+                            !indices[distanceSort.attribute]?.customIndex?.propertyResolver))
+                        distanceSort = distanceSort.next;
+                    if (!distanceSort)
+                        return;
+                    const customIndex = indices[distanceSort.attribute].customIndex;
+                    const vector = object[distanceSort.attribute];
+                    const distanceCache = context?.vectorDistanceCaches?.get(distanceSort);
+                    const cachedDistance = distanceCache?.get(entry) ?? distanceCache?.get(vector);
+                    if (cachedDistance !== undefined)
+                        return cachedDistance;
+                    return customIndex.propertyResolver(vector, context, entry, distanceSort);
                 },
             };
             for (const attribute of this.attributes) {
@@ -4771,9 +4862,13 @@ function makeTable(options) {
                 }
                 else if (indices[attribute.name]?.customIndex?.propertyResolver) {
                     const customIndex = indices[attribute.name].customIndex;
-                    propertyResolvers[attribute.name] = (object, context, entry) => {
+                    propertyResolvers[attribute.name] = (object, context, entry, returnEntry, sort, comparing) => {
                         const value = object[attribute.name];
-                        return customIndex.propertyResolver(value, context, entry);
+                        const sortAttribute = sort?.attribute;
+                        const resolvesSort = comparing === true &&
+                            (sortAttribute === attribute.name ||
+                                (Array.isArray(sortAttribute) && sortAttribute[sortAttribute.length - 1] === attribute.name));
+                        return customIndex.propertyResolver(value, context, entry, resolvesSort ? sort : undefined);
                     };
                     propertyResolvers[attribute.name].directReturn = true;
                 }
@@ -5337,14 +5432,16 @@ function makeTable(options) {
                     // Inherit never-drop-on-conflict so a source-applied multi-store transaction doesn't
                     // drop the canonical write when a secondary store hits a transient conflict.
                     transaction.next.sourceApply = transaction.sourceApply;
+                    transaction.next.timeoutBudget = transaction.timeoutBudget;
                     // Inherit the replay marker so a multi-table replay transaction skips validation on
                     // every store, not just the first (harper#1316).
                     transaction.next.isReplay = transaction.isReplay;
                     // Inherit which resource/method started this logical operation, so a chained (second
                     // table) transaction's long-transaction-abort log (DatabaseTransaction.ts) can still
-                    // identify the request that caused it instead of leaving that field blank. (The
-                    // checkOverloaded() stuck-commit log reads this too, but a chained link's own commit
-                    // rarely arms outstandingCommit — see the note at DatabaseTransaction.ts's arming site.)
+                    // identify the request that caused it instead of leaving that field blank. The
+                    // checkOverloaded() stuck-commit log reads this too — every chained link's own native
+                    // commit is tracked with its own identity (DatabaseTransaction.ts's trackOutstandingCommit),
+                    // so a wedged second-store commit is named just as precisely as a wedged first one.
                     transaction.next.startedFrom = transaction.startedFrom;
                     if (transaction.open === DatabaseTransaction_ts_1.TRANSACTION_STATE.CLOSED) {
                         // if the current transaction is already closed, we need to retain that state on new databases we work with
@@ -5367,7 +5464,7 @@ function makeTable(options) {
             return transaction;
         }
     }
-    function getAttributeValue(entry, attribute_name, context) {
+    function getAttributeValue(entry, attribute_name, context, sort) {
         if (!entry) {
             return;
         }
@@ -5379,14 +5476,17 @@ function makeTable(options) {
             for (let i = 0, l = attribute_name.length; i < l; i++) {
                 const attribute = attribute_name[i];
                 const resolver = resolvers?.[attribute];
-                value = resolver && value ? resolver(value, context, entry) : value?.[attribute];
+                value =
+                    resolver && value
+                        ? resolver(value, context, entry, false, i === l - 1 ? sort : undefined, true)
+                        : value?.[attribute];
                 entry = null; // can't use this in the nested object
                 resolvers = resolver?.definition?.tableClass?.propertyResolvers;
             }
             return value;
         }
         const resolver = propertyResolvers[attribute_name];
-        return resolver ? resolver(record, context, entry) : record[attribute_name];
+        return resolver ? resolver(record, context, entry, false, sort, true) : record[attribute_name];
     }
     function transformToEntries(ids, select, context, readTxn, filters) {
         // TODO: Test and ensure that we break out of these loops when a connection is lost
@@ -5527,7 +5627,10 @@ function makeTable(options) {
             replacingRecord: existingRecord,
             replacingEntry: existingEntry,
             replacingVersion: existingVersion,
-            noCacheStore: false,
+            // Once dropTable() has started, no new source-fill write may begin (dropTable()
+            // only drains writes already in flight - see there); still resolve the caller's
+            // read with fresh source data, just don't cache it into a table that's going away.
+            noCacheStore: droppingTable,
             source: null,
             transaction: undefined,
             expiresAt: undefined,
@@ -5538,7 +5641,18 @@ function makeTable(options) {
             // we don't want to wait for the transaction because we want to return as fast as possible
             // and let the transaction commit in the background
             let resolved;
-            (0, when_ts_1.when)((0, transaction_ts_1.transaction)(sourceContext, async (_txn) => {
+            // Tracked in pendingSourceCommits (below) for the full lifetime of this transaction -
+            // including the source round-trip, not just from the point it's actually staged -
+            // so dropTable() can wait for it before dropping the table's column families (see the
+            // comment there). Registering only once a write reaches staging would track less (no
+            // Set churn for a plain cache miss, and a slow/hung source couldn't delay a drop) and
+            // is safe on its own given the live droppingTable re-checks in this function - but it
+            // would make dropTable()'s correctness depend on every future early-return path in
+            // this function remembering to check droppingTable, rather than on dropTable() simply
+            // waiting for whatever this function is doing. Tracking the whole lifetime is the
+            // belt to that suspenders, at the cost of a bounded wait on a merely slow source
+            // before the drain's fail-closed timeout below.
+            const commitPromise = (0, transaction_ts_1.transaction)(sourceContext, async (_txn) => {
                 const start = performance.now();
                 let updatedRecord;
                 let hasChanges, invalidated;
@@ -5663,8 +5777,11 @@ function makeTable(options) {
                     sourceContext.transaction.abort();
                     return;
                 }
-                if (context?.noCacheStore || sourceContext.noCacheStore) {
-                    // abort before we write any change
+                if (context?.noCacheStore || sourceContext.noCacheStore || droppingTable) {
+                    // abort before we write any change. droppingTable is re-checked live (not just
+                    // the noCacheStore snapshot taken at call start) because a call admitted before
+                    // dropTable() began can still be sitting here after it started - the await above
+                    // waited on the source, which may take arbitrarily long.
                     sourceContext.transaction.abort();
                     return;
                 }
@@ -5773,11 +5890,21 @@ function makeTable(options) {
                 const embedBefore = (0, embedHook_ts_1.buildEmbedBefore)(updatedRecord, sourceContext, undefined, TableResource.embedAttributes, TableResource.userEmbedders);
                 if (embedBefore)
                     await embedBefore();
+                if (droppingTable) {
+                    // Re-check right before staging the write: dropTable() may have started
+                    // while we were awaiting the embed step above (harper#1381).
+                    sourceContext.transaction.abort();
+                    return;
+                }
                 sourceWrite.before = preCommitBlobsForRecordBefore(sourceWrite, updatedRecord);
                 dbTxn.addWrite(sourceWrite);
-            }), () => {
+            });
+            pendingSourceCommits.add(commitPromise);
+            (0, when_ts_1.when)(commitPromise, () => {
+                pendingSourceCommits.delete(commitPromise);
                 primaryStore.unlock(id);
             }, (error) => {
+                pendingSourceCommits.delete(commitPromise);
                 primaryStore.unlock(id);
                 if (resolved)
                     logger_ts_1.logger.error?.('Error committing cache update', error);