@remix-run/data-table 0.5.0 → 0.5.1

package/dist/lib/database/relations.js

@@ -62,10 +62,11 @@ async function loadHasManyThroughValues(database, sourceRows, relation) {
     if (!relation.through) {
         throw new DataTableQueryError('hasManyThrough relation is missing through metadata');
     }
+    let through = relation.through;
     if (sourceRows.length === 0) {
         return [];
     }
-    let throughRelation = relation.through.relation;
+    let throughRelation = through.relation;
     let sourceTuples = uniqueTuples(sourceRows, throughRelation.sourceKey);
     if (sourceTuples.length === 0) {
         return sourceRows.map(() => []);
@@ -92,12 +93,12 @@ async function loadHasManyThroughValues(database, sourceRows, relation) {
         pagedThroughRowsBySource.set(sourceKey, pagedMatchedRows);
         pagedThroughRows.push(...pagedMatchedRows);
     }
-    let throughTuples = uniqueTuples(pagedThroughRows, relation.through.throughSourceKey);
+    let throughTuples = uniqueTuples(pagedThroughRows, through.throughSourceKey);
     if (throughTuples.length === 0) {
         return sourceRows.map(() => []);
     }
     let targetQuery = createQuery(relation.targetTable);
-    let targetPredicate = buildLinkPredicate(relation.through.throughTargetKey, throughTuples);
+    let targetPredicate = buildLinkPredicate(through.throughTargetKey, throughTuples);
     if (targetPredicate) {
         targetQuery = targetQuery.where(targetPredicate);
     }
@@ -105,23 +106,41 @@ async function loadHasManyThroughValues(database, sourceRows, relation) {
         includePagination: false,
     });
     let relatedRows = await loadRowsWithRelationsForQuery(database, targetQuery);
-    let targetRowsByThrough = groupRowsByTuple(relatedRows, relation.through.throughTargetKey);
-    return sourceRows.map((sourceRow) => {
+    let sourceKeysByThroughKey = new Map();
+    let outputRowsBySourceKey = new Map();
+    for (let sourceRow of sourceRows) {
         let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey);
         let matchedThroughRows = pagedThroughRowsBySource.get(sourceKey) ?? [];
-        let outputRows = [];
-        let seen = new Set();
+        outputRowsBySourceKey.set(sourceKey, new Map());
         for (let throughRow of matchedThroughRows) {
-            let throughKey = getCompositeKey(throughRow, relation.through.throughSourceKey);
-            let rowsForThrough = targetRowsByThrough.get(throughKey) ?? [];
-            for (let row of rowsForThrough) {
-                let rowIdentity = getCompositeKey(row, getTablePrimaryKey(relation.targetTable));
-                if (!seen.has(rowIdentity)) {
-                    seen.add(rowIdentity);
-                    outputRows.push(row);
-                }
+            let throughKey = getCompositeKey(throughRow, through.throughSourceKey);
+            let sourceKeys = sourceKeysByThroughKey.get(throughKey);
+            if (!sourceKeys) {
+                sourceKeys = new Set();
+                sourceKeysByThroughKey.set(throughKey, sourceKeys);
+            }
+            sourceKeys.add(sourceKey);
+        }
+    }
+    let targetPrimaryKey = getTablePrimaryKey(relation.targetTable);
+    for (let row of relatedRows) {
+        let throughKey = getCompositeKey(row, through.throughTargetKey);
+        let sourceKeys = sourceKeysByThroughKey.get(throughKey);
+        if (!sourceKeys) {
+            continue;
+        }
+        let rowIdentity = getCompositeKey(row, targetPrimaryKey);
+        for (let sourceKey of sourceKeys) {
+            let outputRows = outputRowsBySourceKey.get(sourceKey);
+            if (!outputRows || outputRows.has(rowIdentity)) {
+                continue;
             }
+            outputRows.set(rowIdentity, row);
         }
+    }
+    return sourceRows.map((sourceRow) => {
+        let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey);
+        let outputRows = Array.from(outputRowsBySourceKey.get(sourceKey)?.values() ?? []);
         return applyPagination(outputRows, relation.modifiers.limit, relation.modifiers.offset);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/data-table",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A typed, relational query toolkit for JavaScript",
   "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
@@ -49,8 +49,8 @@
   "devDependencies": {
     "@types/node": "^24.6.0",
     "typescript": "^7.0.2",
-    "@remix-run/test": "0.6.0",
-    "@remix-run/assert": "0.3.0"
+    "@remix-run/assert": "0.3.0",
+    "@remix-run/test": "0.6.0"
   },
   "dependencies": {},
   "keywords": [

package/src/lib/database/relations.ts

@@ -116,11 +116,13 @@ async function loadHasManyThroughValues(
     throw new DataTableQueryError('hasManyThrough relation is missing through metadata')
   }
 
+  let through = relation.through
+
   if (sourceRows.length === 0) {
     return []
   }
 
-  let throughRelation = relation.through.relation
+  let throughRelation = through.relation
   let sourceTuples = uniqueTuples(sourceRows, throughRelation.sourceKey)
 
   if (sourceTuples.length === 0) {
@@ -163,14 +165,14 @@ async function loadHasManyThroughValues(
     pagedThroughRows.push(...pagedMatchedRows)
   }
 
-  let throughTuples = uniqueTuples(pagedThroughRows, relation.through.throughSourceKey)
+  let throughTuples = uniqueTuples(pagedThroughRows, through.throughSourceKey)
 
   if (throughTuples.length === 0) {
     return sourceRows.map(() => [])
   }
 
   let targetQuery = createQuery(relation.targetTable)
-  let targetPredicate = buildLinkPredicate(relation.through.throughTargetKey, throughTuples)
+  let targetPredicate = buildLinkPredicate(through.throughTargetKey, throughTuples)
 
   if (targetPredicate) {
     targetQuery = targetQuery.where(
@@ -183,27 +185,54 @@ async function loadHasManyThroughValues(
   })
 
   let relatedRows = await loadRowsWithRelationsForQuery(database, targetQuery)
-  let targetRowsByThrough = groupRowsByTuple(relatedRows, relation.through.throughTargetKey)
+  let sourceKeysByThroughKey = new Map<string, Set<string>>()
+  let outputRowsBySourceKey = new Map<string, Map<string, Record<string, unknown>>>()
 
-  return sourceRows.map((sourceRow) => {
+  for (let sourceRow of sourceRows) {
     let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey)
     let matchedThroughRows = pagedThroughRowsBySource.get(sourceKey) ?? []
-    let outputRows: Record<string, unknown>[] = []
-    let seen = new Set<string>()
+
+    outputRowsBySourceKey.set(sourceKey, new Map())
 
     for (let throughRow of matchedThroughRows) {
-      let throughKey = getCompositeKey(throughRow, relation.through!.throughSourceKey)
-      let rowsForThrough = targetRowsByThrough.get(throughKey) ?? []
+      let throughKey = getCompositeKey(throughRow, through.throughSourceKey)
+      let sourceKeys = sourceKeysByThroughKey.get(throughKey)
+
+      if (!sourceKeys) {
+        sourceKeys = new Set()
+        sourceKeysByThroughKey.set(throughKey, sourceKeys)
+      }
+
+      sourceKeys.add(sourceKey)
+    }
+  }
+
+  let targetPrimaryKey = getTablePrimaryKey(relation.targetTable)
 
-      for (let row of rowsForThrough) {
-        let rowIdentity = getCompositeKey(row, getTablePrimaryKey(relation.targetTable))
+  for (let row of relatedRows) {
+    let throughKey = getCompositeKey(row, through.throughTargetKey)
+    let sourceKeys = sourceKeysByThroughKey.get(throughKey)
 
-        if (!seen.has(rowIdentity)) {
-          seen.add(rowIdentity)
-          outputRows.push(row)
-        }
+    if (!sourceKeys) {
+      continue
+    }
+
+    let rowIdentity = getCompositeKey(row, targetPrimaryKey)
+
+    for (let sourceKey of sourceKeys) {
+      let outputRows = outputRowsBySourceKey.get(sourceKey)
+
+      if (!outputRows || outputRows.has(rowIdentity)) {
+        continue
       }
+
+      outputRows.set(rowIdentity, row)
     }
+  }
+
+  return sourceRows.map((sourceRow) => {
+    let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey)
+    let outputRows = Array.from(outputRowsBySourceKey.get(sourceKey)?.values() ?? [])
 
     return applyPagination(outputRows, relation.modifiers.limit, relation.modifiers.offset)
   })