rescript-relay 1.0.0-beta.7 → 1.0.0-beta.8

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # master
 
-# 1.0.0-beta.7
+# 1.0.0-beta.8
 
 _[Here's a commit showing a project being upgraded to this version](https://github.com/zth/rescript-relay/commit/5831c2f1f0f13eedc1cb60468c32fd32b2dc01d3)_
 
@@ -24,11 +24,19 @@ You can go ahead and remove these packages, that are no longer needed, as the co
 - There's no longer any need to manually select `__typename` on interfaces and unions for RescriptRelay's sake, unless you actually want to use it yourself.
 - We now support the `@required` directive from Relay, which is a new directive that lets you force non-nullability for nullable fields on the client side. You can then choose to throw an error if null values are encountered, or let the null value bubble up. Docs are coming soon.
 - The errors reported by the compiler is now quite a lot better.
+- Full support for `reanalyze` as all false positive dead code results from generated code are now suppressed.
+- Bindings for `requiredFieldLogger` for logging when missing fields are encountered (kudos [Emilios1995](https://github.com/Emilios1995)).
+- Improved utils for [dealing with enums](https://rescript-relay-documentation.vercel.app/docs/enums).
 
 ## Beta fix changelog
 
 ### unreleased
 
+### beta.8
+
+- More fixes for conversion instructions in variables and input objects.
+- Project now works in `"type": "module"` mode in `package.json` (kudos [cometkim](https://github.com/cometkim))
+
 ### beta.7
 
 - Full support for `reanalyze` as all false positive dead code results from generated code are now suppressed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.8",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -19,6 +19,14 @@
     "reasonml",
     "rescript"
   ],
+  "exports": {
+    "./src/utils": {
+      "require": "./src/utils.js",
+      "import": "./src/utils.mjs"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "rescript-relay-compiler": "compiler.js",
     "rescript-relay-cli": "cli/cli.js"

package/src/utils.mjs

@@ -0,0 +1,339 @@
+function getNewObj(maybeNewObj, currentObj) {
+  return maybeNewObj || Object.assign({}, currentObj);
+}
+
+function getPathName(path) {
+  return path.join("_");
+}
+
+function makeNewPath(currentPath, newKeys) {
+  return [].concat(currentPath, newKeys);
+}
+
+/**
+ * Runs on each object in the tree and follows the provided instructions
+ * to apply transforms etc.
+ */
+function traverse(
+  fullInstructionMap,
+  currentPath,
+  currentObj,
+  instructionMap,
+  converters,
+  nullableValue,
+  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) {
+    newObj = getNewObj(newObj, currentObj);
+    newObj.fragmentRefs = Object.assign({}, newObj);
+  }
+
+  for (var key in currentObj) {
+    var isUnion = false;
+    var originalValue = currentObj[key];
+
+    // Instructions are stored by the path in the object where they apply
+    var thisPath = makeNewPath(currentPath, [key]);
+    var path = getPathName(thisPath);
+
+    var instructions = instructionMap[path] || {};
+
+    if (currentObj[key] == null) {
+      newObj = getNewObj(newObj, currentObj);
+      newObj[key] = nullableValue;
+      continue;
+    }
+
+    var shouldConvertRootObj =
+      typeof instructions["r"] === "string" &&
+      fullInstructionMap[instructions["r"]];
+
+    var shouldAddFragmentFn = instructions["f"] === "";
+
+    var shouldConvertEnum =
+      typeof instructions["e"] === "string" && !!converters[instructions["e"]];
+
+    var shouldConvertCustomField =
+      typeof instructions["c"] === "string" && !!converters[instructions["c"]];
+
+    var shouldConvertUnion =
+      typeof instructions["u"] === "string" && !!converters[instructions["u"]];
+
+    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]);
+
+          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"]
+        );
+      }
+
+      if (isTopLevelNodeField) {
+        if (
+          v == null ||
+          !v.hasOwnProperty("__typename") ||
+          v.__typename !== instructions["tnf"]
+        ) {
+          newObj = getNewObj(newObj, currentObj);
+          newObj[key] = nullableValue;
+        }
+      }
+
+      if (shouldConvertEnum) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = converters[instructions["e"]](v);
+      }
+
+      if (shouldConvertCustomField) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = converters[instructions["c"]](v);
+      }
+
+      if (
+        shouldConvertUnion &&
+        v != null &&
+        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
+        );
+
+        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 (originalValue != null && !isUnion) {
+      var nextObj = (newObj && newObj[key]) || currentObj[key];
+
+      if (typeof nextObj === "object" && !Array.isArray(originalValue)) {
+        var traversedObj = traverse(
+          fullInstructionMap,
+          thisPath,
+          nextObj,
+          instructionMap,
+          converters,
+          nullableValue,
+          instructionPaths
+        );
+
+        if (traversedObj !== nextObj) {
+          newObj = getNewObj(newObj, currentObj);
+          newObj[key] = traversedObj;
+        }
+      } else if (Array.isArray(originalValue)) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = nextObj.map(function (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;
+          }
+        });
+      }
+    }
+  }
+
+  return newObj || currentObj;
+}
+
+/**
+ * This function takes an object (snapshot from the Relay store) and applies a
+ * set of conversions deeply on the object (instructions coming from "converters"-prop).
+ * It converts nullable values either to null or undefined, and it wraps/unwraps enums
+ * and unions.
+ *
+ * It preserves structural integrity where possible, and return new objects where properties
+ * have been modified.
+ */
+function traverser(
+  root,
+  instructionMaps_,
+  theConverters,
+  nullableValue,
+  rootObjectKey
+) {
+  if (!root) {
+    return nullableValue;
+  }
+
+  var instructionMaps = instructionMaps_ || {};
+  var instructionMap = instructionMaps[rootObjectKey || "__root"] || {};
+
+  var converters = theConverters == null ? {} : theConverters;
+  var instructionPaths = Object.keys(instructionMap);
+
+  // We'll add the fragmentRefs reference to the root if needed here.
+  var fragmentsOnRoot = (instructionMap[""] || {}).f === "";
+  var unionRootConverter = converters[(instructionMap[""] || {}).u];
+
+  if (Array.isArray(root)) {
+    return root.map(function (v) {
+      if (v == null) {
+        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,
+        nullableValue,
+        instructionPaths,
+        fragmentsOnRoot
+      );
+
+      return unionRootConverter != null
+        ? unionRootConverter(traversedObj)
+        : traversedObj;
+    });
+  }
+
+  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,
+    nullableValue,
+    instructionPaths,
+    fragmentsOnRoot
+  );
+
+  return unionRootConverter != null ? unionRootConverter(v) : v;
+}
+
+export { traverser };