dynamo-query-engine 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamo-query-engine",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Type-safe DynamoDB query builder for GraphQL with support for filtering, sorting, pagination, and relation expansion",
   "type": "module",
   "main": "index.js",

package/src/core/expandResolver.js

@@ -76,30 +76,78 @@ export async function resolveExpand({
   // Resolve relations for each parent item
   const expandPromises = parentItems.map(async (parent) => {
     try {
-      // For MANY relations, we need a partition key value
-      // This should be either parent.pk or a specific field based on the relation
+      // Get partition key value from parent
+      // This should be either parent.pk or the first field (usually tenantId)
       const partitionKeyValue = parent.pk || parent[Object.keys(parent)[0]];
 
       if (!partitionKeyValue) {
         console.warn(
           `Cannot expand '${field}' for parent: missing partition key value`
         );
-        parent[expandPropertyName] = [];
+        parent[expandPropertyName] = policy.relation === "ONE" ? null : [];
         return;
       }
 
-      // Build query for expanded items
-      const { query } = buildGridQuery({
-        model: targetModel,
-        partitionKeyValue,
-        filterModel: args.filter,
-        sortModel: args.sort,
-        paginationModel: { pageSize: limit },
-        // No cursor for nested expands
-      });
+      let results;
+
+      // For ONE relations with a foreignKey, we can optimize by directly querying for that specific item
+      if (policy.relation === "ONE" && policy.foreignKey) {
+        const foreignKeyValue = parent[policy.foreignKey];
+        
+        if (!foreignKeyValue) {
+          console.warn(
+            `Cannot expand '${field}' for parent: missing foreign key value '${policy.foreignKey}'`
+          );
+          parent[expandPropertyName] = null;
+          return;
+        }
+
+        // Build a query that filters for the specific range key value
+        const targetAttributes = targetModel.schema.getAttributes();
+        const rangeKeyName = Object.keys(targetAttributes).find(
+          (key) => targetAttributes[key].rangeKey === true
+        );
 
-      // Execute query
-      const results = await query.exec();
+        if (!rangeKeyName) {
+          console.warn(
+            `Cannot expand '${field}': target model '${policy.type}' has no range key defined`
+          );
+          parent[expandPropertyName] = null;
+          return;
+        }
+
+        // Build query with range key filter
+        const filterModel = JSON.stringify({
+          items: [
+            {
+              field: rangeKeyName,
+              operator: "equals",
+              value: foreignKeyValue,
+            },
+          ],
+        });
+
+        const { query } = buildGridQuery({
+          model: targetModel,
+          partitionKeyValue,
+          filterModel,
+          limit: 1,
+        });
+
+        results = await query.exec();
+      } else {
+        // For MANY relations or ONE without foreignKey, use standard query
+        const { query } = buildGridQuery({
+          model: targetModel,
+          partitionKeyValue,
+          filterModel: args.filter,
+          sortModel: args.sort,
+          paginationModel: { pageSize: limit },
+          // No cursor for nested expands
+        });
+
+        results = await query.exec();
+      }
 
       // Add __typename to each result
       const resultsWithTypename = results.map((item) => ({

package/tests/unit/expandResolver.test.js

@@ -33,6 +33,7 @@ describe("ExpandResolver", () => {
             expand: {
               type: "Unit",
               relation: "ONE",
+              foreignKey: "unitId", // Field in parent that references the child
               defaultLimit: 1,
               maxLimit: 1,
             },
@@ -177,6 +178,22 @@ describe("ExpandResolver", () => {
       expect(parentItems[0].Units[1].__typename).toBe("Units");
     });
 
+    it("should use foreignKey to filter for specific item in ONE relation", async () => {
+      await resolveExpand({
+        parentItems,
+        parentModel,
+        field: "unitId",
+      });
+
+      // Should have expanded exactly one unit
+      expect(parentItems[0].Unit).toBeDefined();
+      expect(parentItems[0].Unit.unitId).toBe("unit-1");
+      expect(parentItems[0].Unit.name).toBe("Unit A");
+      
+      // Verify that buildGridQuery was called with a filterModel
+      // (This would require spy/mock inspection in a more detailed test)
+    });
+
     it("should fallback to field name when graphql.type is not defined", async () => {
       // Clear and re-register with different config
       modelRegistry.clear();