rescript-relay 0.0.0-cli-687699fd → 0.0.0-linux-musl-d5435e23

package/src/utils.js

@@ -24,6 +24,10 @@ function traverse(
   instructionPaths,
   addFragmentOnRoot
 ) {
+  // We lazily set up a new object for each "level", as we don't want to mutate
+  // what comes back from the Relay store, and nor do we want to create new
+  // objects unless we need to. And we only need to when we need to change
+  // something.
   var newObj;
 
   if (addFragmentOnRoot) {
@@ -39,193 +43,168 @@ function traverse(
     var thisPath = makeNewPath(currentPath, [key]);
     var path = getPathName(thisPath);
 
-    var instructions = instructionMap[path];
+    var instructions = instructionMap[path] || {};
 
-    var hasDeeperInstructions =
-      instructionPaths.filter(function (p) {
-        return p.indexOf(path) === 0 && p.length > path.length;
-      }).length > 0;
+    if (currentObj[key] == null) {
+      newObj = getNewObj(newObj, currentObj);
+      newObj[key] = nullableValue;
+      continue;
+    }
 
-    if (instructions) {
-      if (currentObj[key] == null) {
-        if (instructions["n"] === "") {
-          newObj = getNewObj(newObj, currentObj);
-          newObj[key] = nullableValue;
-        }
-      } else {
-        var shouldConvertRootObj =
-          typeof instructions["r"] === "string" &&
-          fullInstructionMap[instructions["r"]];
+    var shouldConvertRootObj =
+      typeof instructions["r"] === "string" &&
+      fullInstructionMap[instructions["r"]];
 
-        var shouldAddFragmentFn = instructions["f"] === "";
+    var shouldAddFragmentFn = instructions["f"] === "";
 
-        var shouldConvertEnum =
-          typeof instructions["e"] === "string" &&
-          !!converters[instructions["e"]];
+    var shouldConvertEnum =
+      typeof instructions["e"] === "string" && !!converters[instructions["e"]];
 
-        var shouldConvertCustomField =
-          typeof instructions["c"] === "string" &&
-          !!converters[instructions["c"]];
+    var shouldConvertCustomField =
+      typeof instructions["c"] === "string" && !!converters[instructions["c"]];
 
-        var shouldConvertUnion =
-          typeof instructions["u"] === "string" &&
-          !!converters[instructions["u"]];
+    var shouldConvertUnion =
+      typeof instructions["u"] === "string" && !!converters[instructions["u"]];
 
-        var isTopLevelNodeField = typeof instructions["tnf"] === "string";
+    var isTopLevelNodeField = typeof instructions["tnf"] === "string";
 
-        /**
-         * Handle arrays
-         */
-        if (Array.isArray(currentObj[key])) {
-          newObj = getNewObj(newObj, currentObj);
-          newObj[key] = currentObj[key].map(function (v) {
-            if (v == null) {
-              return nullableValue;
-            }
-
-            if (shouldConvertRootObj) {
-              return traverser(
-                v,
-                fullInstructionMap,
-                converters,
-                nullableValue,
-                instructions["r"]
-              );
-            }
-
-            if (shouldConvertEnum) {
-              return converters[instructions["e"]](v);
-            }
-
-            if (shouldConvertCustomField) {
-              return converters[instructions["c"]](v);
-            }
-
-            if (
-              shouldConvertUnion &&
-              typeof v === "object" &&
-              typeof v.__typename === "string"
-            ) {
-              isUnion = true;
-
-              var newPath = makeNewPath(currentPath, [
-                key,
-                v.__typename.toLowerCase(),
-              ]);
-
-              var unionRootHasFragment =
-                (instructionMap[getPathName(newPath)] || {}).f === "";
-
-              var traversedValue = traverse(
-                fullInstructionMap,
-                newPath,
-                v,
-                instructionMap,
-                converters,
-                nullableValue,
-                instructionPaths,
-                unionRootHasFragment
-              );
-
-              return converters[instructions["u"]](traversedValue);
-            }
-
-            if (shouldAddFragmentFn && typeof v === "object") {
-              var objWithFragmentFn = Object.assign({}, v);
-              objWithFragmentFn.fragmentRefs = Object.assign(
-                {},
-                objWithFragmentFn
-              );
-              return objWithFragmentFn;
-            }
-
-            return v;
-          });
-        } else {
-          /**
-           * Handle normal values.
-           */
-          var v = currentObj[key];
-
-          if (shouldConvertRootObj) {
-            newObj = getNewObj(newObj, currentObj);
-            newObj[key] = traverser(
-              v,
-              fullInstructionMap,
-              converters,
-              nullableValue,
-              instructions["r"]
-            );
-          }
+    /**
+     * Handle arrays
+     */
+    if (Array.isArray(currentObj[key])) {
+      newObj = getNewObj(newObj, currentObj);
+      newObj[key] = currentObj[key].map(function (v) {
+        if (v == null) {
+          return nullableValue;
+        }
 
-          if (isTopLevelNodeField) {
-            if (
-              !v ||
-              !v.hasOwnProperty("__typename") ||
-              v.__typename !== instructions["tnf"]
-            ) {
-              newObj = getNewObj(newObj, currentObj);
-              newObj[key] = nullableValue;
-            }
-          }
+        if (shouldConvertRootObj) {
+          return traverser(
+            v,
+            fullInstructionMap,
+            converters,
+            nullableValue,
+            instructions["r"]
+          );
+        }
 
-          if (shouldConvertEnum) {
-            newObj = getNewObj(newObj, currentObj);
-            newObj[key] = converters[instructions["e"]](v);
-          }
+        if (shouldConvertEnum) {
+          return converters[instructions["e"]](v);
+        }
 
-          if (shouldConvertCustomField) {
-            newObj = getNewObj(newObj, currentObj);
-            newObj[key] = converters[instructions["c"]](v);
-          }
+        if (shouldConvertCustomField) {
+          return converters[instructions["c"]](v);
+        }
 
-          if (
-            shouldConvertUnion &&
-            typeof v === "object" &&
-            typeof v.__typename === "string"
-          ) {
-            isUnion = true;
+        if (
+          shouldConvertUnion &&
+          typeof v === "object" &&
+          typeof v.__typename === "string"
+        ) {
+          isUnion = true;
+
+          var newPath = makeNewPath(currentPath, [key, v.__typename]);
+
+          var unionRootHasFragment =
+            (instructionMap[getPathName(newPath)] || {}).f === "";
+
+          var traversedValue = traverse(
+            fullInstructionMap,
+            newPath,
+            v,
+            instructionMap,
+            converters,
+            nullableValue,
+            instructionPaths,
+            unionRootHasFragment
+          );
+
+          return converters[instructions["u"]](traversedValue);
+        }
 
-            var newPath = makeNewPath(currentPath, [
-              key,
-              v.__typename.toLowerCase(),
-            ]);
+        if (shouldAddFragmentFn && typeof v === "object") {
+          var objWithFragmentFn = Object.assign({}, v);
+          objWithFragmentFn.fragmentRefs = Object.assign({}, objWithFragmentFn);
+          return objWithFragmentFn;
+        }
 
-            var unionRootHasFragment =
-              (instructionMap[getPathName(newPath)] || {}).f === "";
+        return v;
+      });
+    } else {
+      /**
+       * Handle normal values.
+       */
+      var v = currentObj[key];
 
-            var traversedValue = traverse(
-              fullInstructionMap,
-              newPath,
-              v,
-              instructionMap,
-              converters,
-              nullableValue,
-              instructionPaths,
-              unionRootHasFragment
-            );
+      if (shouldConvertRootObj) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = traverser(
+          v,
+          fullInstructionMap,
+          converters,
+          nullableValue,
+          instructions["r"]
+        );
+      }
 
-            newObj = getNewObj(newObj, currentObj);
-            newObj[key] = converters[instructions["u"]](traversedValue);
-          }
+      if (isTopLevelNodeField) {
+        if (
+          v == null ||
+          !v.hasOwnProperty("__typename") ||
+          v.__typename !== instructions["tnf"]
+        ) {
+          newObj = getNewObj(newObj, currentObj);
+          newObj[key] = nullableValue;
+        }
+      }
 
-          if (shouldAddFragmentFn && typeof v === "object") {
-            newObj = getNewObj(newObj, currentObj);
+      if (shouldConvertEnum) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = converters[instructions["e"]](v);
+      }
 
-            var objWithFragmentFn = Object.assign({}, v);
+      if (shouldConvertCustomField) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = converters[instructions["c"]](v);
+      }
 
-            objWithFragmentFn.fragmentRefs = Object.assign(
-              {},
-              objWithFragmentFn
-            );
+      if (
+        shouldConvertUnion &&
+        v != null &&
+        typeof v === "object" &&
+        typeof v.__typename === "string"
+      ) {
+        isUnion = true;
 
-            newObj[key] = objWithFragmentFn;
-          }
-        }
+        var newPath = makeNewPath(currentPath, [key, v.__typename]);
+
+        var unionRootHasFragment =
+          (instructionMap[getPathName(newPath)] || {}).f === "";
+
+        var traversedValue = traverse(
+          fullInstructionMap,
+          newPath,
+          v,
+          instructionMap,
+          converters,
+          nullableValue,
+          instructionPaths,
+          unionRootHasFragment
+        );
+
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = converters[instructions["u"]](traversedValue);
+      }
+
+      if (shouldAddFragmentFn && typeof v === "object") {
+        newObj = getNewObj(newObj, currentObj);
+        var objWithFragmentFn = Object.assign({}, v);
+        objWithFragmentFn.fragmentRefs = Object.assign({}, objWithFragmentFn);
+        newObj[key] = objWithFragmentFn;
       }
     }
 
-    if (hasDeeperInstructions && originalValue != null && !isUnion) {
+    if (originalValue != null && !isUnion) {
       var nextObj = (newObj && newObj[key]) || currentObj[key];
 
       if (typeof nextObj === "object" && !Array.isArray(originalValue)) {
@@ -246,17 +225,21 @@ function traverse(
       } else if (Array.isArray(originalValue)) {
         newObj = getNewObj(newObj, currentObj);
         newObj[key] = nextObj.map(function (o) {
-          return typeof o === "object" && o != null
-            ? traverse(
-                fullInstructionMap,
-                thisPath,
-                o,
-                instructionMap,
-                converters,
-                nullableValue,
-                instructionPaths
-              )
-            : o;
+          if (typeof o === "object" && o != null) {
+            return traverse(
+              fullInstructionMap,
+              thisPath,
+              o,
+              instructionMap,
+              converters,
+              nullableValue,
+              instructionPaths
+            );
+          } else if (o == null) {
+            return nullableValue;
+          } else {
+            return o;
+          }
         });
       }
     }
@@ -276,7 +259,7 @@ function traverse(
  */
 function traverser(
   root,
-  _instructionMaps,
+  instructionMaps_,
   theConverters,
   nullableValue,
   rootObjectKey
@@ -285,22 +268,12 @@ function traverser(
     return nullableValue;
   }
 
-  var instructionMaps = _instructionMaps || {};
-  var instructionMap = instructionMaps[rootObjectKey || "__root"];
-
-  // No instructions
-  if (!instructionMap) {
-    return root;
-  }
+  var instructionMaps = instructionMaps_ || {};
+  var instructionMap = instructionMaps[rootObjectKey || "__root"] || {};
 
   var converters = theConverters == null ? {} : theConverters;
   var instructionPaths = Object.keys(instructionMap);
 
-  // Nothing to convert, bail early
-  if (instructionPaths.length === 0) {
-    return root;
-  }
-
   // We'll add the fragmentRefs reference to the root if needed here.
   var fragmentsOnRoot = (instructionMap[""] || {}).f === "";
   var unionRootConverter = converters[(instructionMap[""] || {}).u];
@@ -311,9 +284,19 @@ function traverser(
         return nullableValue;
       }
 
+      var n = [];
+
+      // Since a root level union is treated as a "new root level", we'll need
+      // to do a separate check here of whether there's a fragment on the root
+      // we need to account for, or not.
+      if (unionRootConverter != null) {
+        n = [v.__typename];
+        fragmentsOnRoot = (instructionMap[v.__typename] || {}).f === "";
+      }
+
       var traversedObj = traverse(
         instructionMaps,
-        [],
+        n,
         v,
         instructionMap,
         converters,
@@ -330,9 +313,18 @@ function traverser(
 
   var newObj = Object.assign({}, root);
 
+  var n = [];
+
+  // Same as in the union array check above - if there's a fragment in the new
+  // root created by the union, we need to account for that separately here.
+  if (unionRootConverter != null) {
+    n = [newObj.__typename];
+    fragmentsOnRoot = (instructionMap[newObj.__typename] || {}).f === "";
+  }
+
   var v = traverse(
     instructionMaps,
-    [],
+    n,
     newObj,
     instructionMap,
     converters,