@jackchuka/gql-ingest 4.1.0 → 4.2.0

package/dist/index.js

@@ -14550,6 +14550,11 @@ var DataMapper = class {
         variables[graphqlVar] = this.mapNestedObject(row, mappingValue, variableTypes, outputStore);
       }
     }
+    if (outputStore) {
+      for (const [key, value] of Object.entries(variables)) {
+        variables[key] = this.resolveRefsInData(value, row, outputStore);
+      }
+    }
     return variables;
   }
   getValueByPath(obj, dataPath) {
@@ -14595,12 +14600,44 @@ var DataMapper = class {
     }
     return mappingObj;
   }
+  /**
+   * Recursively walk a resolved value and resolve any $ref objects found in data.
+   * Unlike mapping-level $ref (where key is a JSONPath into the row), data-level
+   * $ref uses key as a literal lookup value unless it starts with "$.".
+   */
+  resolveRefsInData(value, row, outputStore) {
+    if (Array.isArray(value)) {
+      let changed = false;
+      const mapped = value.map((item) => {
+        const resolved = this.resolveRefsInData(item, row, outputStore);
+        if (resolved !== item) changed = true;
+        return resolved;
+      });
+      return changed ? mapped : value;
+    }
+    if (typeof value === "object" && value !== null) {
+      if (this.isRefMapping(value)) {
+        const keyStr = value.key.startsWith("$.") ? String(this.getValueByPath(row, this.stripJsonPathPrefix(value.key)) ?? value.key) : value.key;
+        return this.lookupRef(outputStore, value.$ref, keyStr, value.field);
+      }
+      let changed = false;
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        const resolved = this.resolveRefsInData(v, row, outputStore);
+        if (resolved !== v) changed = true;
+        result[k] = resolved;
+      }
+      return changed ? result : value;
+    }
+    return value;
+  }
   stripJsonPathPrefix(jsonPath) {
     return jsonPath.startsWith("$.") ? jsonPath.substring(2) : jsonPath;
   }
   isRefMapping(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) && "$ref" in value && "key" in value && "field" in value;
   }
+  /** Resolve a mapping-level $ref — throws on any failure so the row is skipped. */
   resolveRef(row, ref, outputStore) {
     if (!outputStore) {
       throw new RefResolutionError(`$ref to "${ref.$ref}" found but no output store is available`);
@@ -14611,20 +14648,33 @@ var DataMapper = class {
       throw new RefResolutionError(`$ref lookup key "${ref.key}" not found in current row`);
     }
     const keyStr = String(lookupKeyValue);
-    const entityStore = outputStore.get(ref.$ref);
+    const value = this.lookupRef(outputStore, ref.$ref, keyStr, ref.field);
+    if (value === void 0) {
+      throw new RefResolutionError(
+        `$ref resolution failed for "${ref.$ref}[${keyStr}].${ref.field}"`
+      );
+    }
+    return value;
+  }
+  /**
+   * Core ref lookup: entityName -> key -> field.
+   * Returns undefined with a warning on miss (caller decides whether to throw).
+   */
+  lookupRef(outputStore, entityName, keyStr, field) {
+    const entityStore = outputStore.get(entityName);
     if (!entityStore) {
-      throw new RefResolutionError(`$ref entity "${ref.$ref}" not found in output store`);
+      this.logger.warn(`$ref entity "${entityName}" not found in output store`);
+      return void 0;
     }
     const captured = entityStore.get(keyStr);
     if (!captured) {
-      throw new RefResolutionError(
-        `$ref key "${keyStr}" not found in entity "${ref.$ref}" output store`
-      );
+      this.logger.warn(`$ref key "${keyStr}" not found in entity "${entityName}" output store`);
+      return void 0;
     }
-    const value = captured[ref.field];
+    const value = captured[field];
     if (value === void 0) {
-      throw new RefResolutionError(
-        `$ref field "${ref.field}" not found in captured output for "${ref.$ref}[${keyStr}]"`
+      this.logger.warn(
+        `$ref field "${field}" not found in captured output for "${entityName}[${keyStr}]"`
       );
     }
     return value;