dynamo-query-engine 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamo-query-engine",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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

@@ -35,7 +35,11 @@ export async function resolveExpand({
   field,
   args = {},
 }) {
+  console.log(`[expandResolver] resolveExpand called for field: ${field}`);
+  console.log(`[expandResolver] parentItems count: ${parentItems?.length || 0}`);
+  
   if (!parentItems || parentItems.length === 0) {
+    console.log(`[expandResolver] No parent items, skipping expand for field: ${field}`);
     return;
   }
 
@@ -52,11 +56,13 @@ export async function resolveExpand({
   const policy = expandPolicy[field];
 
   if (!policy) {
+    console.error(`[expandResolver] Field '${field}' does not have expand configuration`);
     throw new Error(
       `Field '${field}' does not have expand configuration in parent model`
     );
   }
 
+  
   // Get target model from registry
   const targetModel = modelRegistry.get(policy.type);
 
@@ -76,30 +82,87 @@ 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
-      const partitionKeyValue = parent.pk || parent[Object.keys(parent)[0]];
+      // Get partition key value from parent
+      // First, determine the target model's hash key name
+      const targetAttributes = targetModel.schema.getAttributes();
+      const targetHashKeyName = Object.keys(targetAttributes).find(
+        (key) => targetAttributes[key].hashKey === true
+      );
+      
+      
+      // Get the partition key value from the parent using the target's hash key name
+      const partitionKeyValue = parent[targetHashKeyName];
 
+      
       if (!partitionKeyValue) {
         console.warn(
-          `Cannot expand '${field}' for parent: missing partition key value`
+          `[expandResolver] 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(
+            `[expandResolver] 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
+        );
+
+        if (!rangeKeyName) {
+          console.warn(
+            `[expandResolver] Cannot expand '${field}': target model '${policy.type}' has no range key defined`
+          );
+          parent[expandPropertyName] = null;
+          return;
+        }
 
-      // Execute query
-      const results = await query.exec();
+        // Build query with range key filter
+        const filterModel = JSON.stringify({
+          items: [
+            {
+              field: rangeKeyName,
+              operator: "eq",
+              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) => ({
@@ -107,6 +170,7 @@ export async function resolveExpand({
         __typename: graphqlTypeName,
       }));
 
+ 
       // Assign results to parent
       if (policy.relation === "ONE") {
         parent[expandPropertyName] = resultsWithTypename.length > 0 ? resultsWithTypename[0] : null;
@@ -114,7 +178,8 @@ export async function resolveExpand({
         parent[expandPropertyName] = resultsWithTypename;
       }
     } catch (error) {
-      console.error(`Error expanding '${field}' for parent:`, error);
+      console.error(`[expandResolver] Error expanding '${field}' for parent:`, error);
+      console.error(`[expandResolver] Error stack:`, error.stack);
       // Gracefully handle errors - set empty result
       parent[expandPropertyName] = policy.relation === "ONE" ? null : [];
     }
@@ -145,19 +210,102 @@ function createGraphQLToSchemaFieldMap(schema) {
   return map;
 }
 
+/**
+ * Parse AppSync selectionSetList to extract requested expand fields
+ * @param {string[]} selectionSetList - AppSync selectionSetList array
+ * @param {string} parentPath - Parent path prefix (e.g., "rows")
+ * @returns {Set<string>} Set of field names that were requested
+ */
+function parseAppSyncSelectionSet(selectionSetList, parentPath = "rows") {
+  const requestedFields = new Set();
+  const prefix = parentPath + "/";
+  
+  for (const path of selectionSetList) {
+    if (path.startsWith(prefix)) {
+      const afterPrefix = path.substring(prefix.length);
+      const firstSlash = afterPrefix.indexOf("/");
+      
+      if (firstSlash === -1) {
+        // This is a direct child field (e.g., "rows/unitId")
+        requestedFields.add(afterPrefix);
+      } else {
+        // This is a nested field (e.g., "rows/Unit/name")
+        const fieldName = afterPrefix.substring(0, firstSlash);
+        requestedFields.add(fieldName);
+      }
+    }
+  }
+  
+  return requestedFields;
+}
+
 /**
  * Resolve multiple expands from GraphQL resolve info
  * @param {Array} parentItems - Parent items to expand
  * @param {*} parentModel - Parent Dynamoose model
- * @param {Object} fieldsByTypeName - Fields by type name from graphql-parse-resolve-info
+ * @param {Object|string[]} fieldsByTypeName - Fields by type name from graphql-parse-resolve-info OR AppSync selectionSetList
+ * @param {Object} [options] - Additional options
+ * @param {boolean} [options.isAppSync] - Whether to parse AppSync selectionSetList format
+ * @param {string} [options.parentPath] - Parent path for AppSync (default: "rows")
  * @returns {Promise<void>}
  */
 export async function resolveExpands(
   parentItems,
   parentModel,
-  fieldsByTypeName
+  fieldsByTypeName,
+  options = {}
 ) {
+  const { isAppSync = false, parentPath = "rows" } = options;
+
+  // Handle AppSync format
+  if (isAppSync) {
+    const selectionSetList = fieldsByTypeName;
+    
+    if (!selectionSetList || selectionSetList.length === 0) {
+      console.log(`[expandResolver] No selectionSetList, skipping`);
+      return;
+    }
+
+    // Parse AppSync selection set to find requested fields
+    const requestedFields = parseAppSyncSelectionSet(selectionSetList, parentPath);
+
+    // Get expand policy to filter only expandable fields
+    const expandPolicy = extractExpandPolicy(parentModel.schema);
+
+    // Create mapping from GraphQL field names to schema field names
+    const graphqlToSchemaMap = createGraphQLToSchemaFieldMap(parentModel.schema);
+
+    // Resolve all expands in parallel
+    const expandPromises = Array.from(requestedFields)
+      .map((graphqlFieldName) => {
+        // Map GraphQL field name to schema field name
+        const schemaFieldName = graphqlToSchemaMap[graphqlFieldName];
+        
+        // Check if this field is expandable
+        if (!schemaFieldName || !expandPolicy[schemaFieldName]) {
+          console.log(`[expandResolver] Field '${graphqlFieldName}' is not expandable (schemaFieldName: ${schemaFieldName}, has policy: ${!!expandPolicy[schemaFieldName]})`);
+          return null;
+        }
+
+        console.log(`[expandResolver] Expanding field '${graphqlFieldName}' (schema: ${schemaFieldName})`);
+        return resolveExpand({
+          parentItems,
+          parentModel,
+          field: schemaFieldName,
+          args: {},
+        });
+      })
+      .filter(Boolean); // Remove null entries
+
+    console.log(`[expandResolver] Executing ${expandPromises.length} expand promises`);
+    await Promise.all(expandPromises);
+    console.log(`[expandResolver] All expands completed`);
+    return;
+  }
+
+  // Handle standard graphql-parse-resolve-info format
   if (!fieldsByTypeName || Object.keys(fieldsByTypeName).length === 0) {
+    console.log(`[expandResolver] No fieldsByTypeName, skipping`);
     return;
   }
 
@@ -166,12 +314,13 @@ export async function resolveExpands(
   const fields = fieldsByTypeName[typeName];
 
   if (!fields) {
+    console.log(`[expandResolver] No fields found for type ${typeName}`);
     return;
   }
 
   // Get expand policy to filter only expandable fields
   const expandPolicy = extractExpandPolicy(parentModel.schema);
-  
+
   // Create mapping from GraphQL field names to schema field names
   const graphqlToSchemaMap = createGraphQLToSchemaFieldMap(parentModel.schema);
 
@@ -183,6 +332,7 @@ export async function resolveExpands(
       
       // Check if this field is expandable
       if (!schemaFieldName || !expandPolicy[schemaFieldName]) {
+        console.log(`[expandResolver] Field '${graphqlFieldName}' is not expandable (schemaFieldName: ${schemaFieldName}, has policy: ${!!expandPolicy[schemaFieldName]})`);
         return null;
       }
 

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();