@harperfast/harper 5.2.1 → 5.2.2

package/dist/resources/Table.js

@@ -341,6 +341,7 @@ 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;
@@ -2157,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)
@@ -3186,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
@@ -3223,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,
                         };
                     }
                 }
@@ -3290,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)
@@ -3332,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));
@@ -3385,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;
@@ -3495,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 &&
@@ -3566,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));
                         }
                     }
                 }
@@ -3603,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)
@@ -3621,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
@@ -4679,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) {
@@ -4820,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;
                 }
@@ -5386,6 +5432,7 @@ 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;
@@ -5417,7 +5464,7 @@ function makeTable(options) {
             return transaction;
         }
     }
-    function getAttributeValue(entry, attribute_name, context) {
+    function getAttributeValue(entry, attribute_name, context, sort) {
         if (!entry) {
             return;
         }
@@ -5429,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