rescript-relay 0.0.0-test-rust-compiler-a2f32b9e → 0.0.0-windows-96019f80

package/src/RescriptRelay_Internal.bs.js

@@ -3,23 +3,51 @@
 
 var Curry = require("rescript/lib/js/curry.js");
 var React = require("react");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 
-var internal_cleanObjectFromUndefinedRaw = (function (obj) {
-    if (!obj) {
-      return obj;
-    }
-
-    var newObj = {};
+function internal_keepMapFieldsRaw(record, f) {
+  return Belt_Option.map(record, (function (obj) {
+                return Js_dict.fromArray(Belt_Array.keepMap(Js_dict.entries(obj), f));
+              }));
+}
 
-    Object.keys(obj).forEach(function(key) {
-      if (typeof obj[key] !== 'undefined') {
-        newObj[key] = obj[key];
-      }
-    });
+function internal_cleanObjectFromUndefinedRaw(record) {
+  return internal_keepMapFieldsRaw(record, (function (param) {
+                var value = param[1];
+                if (value !== undefined) {
+                  return [
+                          param[0],
+                          Caml_option.valFromOption(value)
+                        ];
+                }
+                
+              }));
+}
 
-    return newObj;
-  });
+function internal_removeUndefinedAndConvertNullsRaw(record) {
+  return internal_keepMapFieldsRaw(record, (function (param) {
+                var value = param[1];
+                var key = param[0];
+                var match = Caml_obj.caml_equal(value, Caml_option.some(undefined));
+                if (value !== undefined) {
+                  return [
+                          key,
+                          Caml_option.valFromOption(value)
+                        ];
+                } else if (match) {
+                  return [
+                          key,
+                          null
+                        ];
+                } else {
+                  return ;
+                }
+              }));
+}
 
 function internal_useConvertedValue(convert, v) {
   return React.useMemo((function () {
@@ -38,5 +66,6 @@ function internal_nullableToOptionalExnHandler(x) {
 
 exports.internal_useConvertedValue = internal_useConvertedValue;
 exports.internal_cleanObjectFromUndefinedRaw = internal_cleanObjectFromUndefinedRaw;
+exports.internal_removeUndefinedAndConvertNullsRaw = internal_removeUndefinedAndConvertNullsRaw;
 exports.internal_nullableToOptionalExnHandler = internal_nullableToOptionalExnHandler;
 /* react Not a pure module */

package/src/RescriptRelay_Internal.res

@@ -1,23 +1,27 @@
-// We occasionally have to remove undefined keys from objects, something I haven't figured out how to do with pure BuckleScript
-let internal_cleanObjectFromUndefinedRaw = %raw(
-  `
-  function (obj) {
-    if (!obj) {
-      return obj;
-    }
-
-    var newObj = {};
+let internal_keepMapFieldsRaw = (record, f) =>
+  record
+  ->Obj.magic
+  ->Belt.Option.map(obj => obj->Js.Dict.entries->Belt.Array.keepMap(f)->Js.Dict.fromArray)
+  ->Obj.magic
 
-    Object.keys(obj).forEach(function(key) {
-      if (typeof obj[key] !== 'undefined') {
-        newObj[key] = obj[key];
-      }
-    });
+// we need to do this until we can use @obj on record types
+// see https://github.com/rescript-lang/rescript-compiler/pull/5253
+let internal_cleanObjectFromUndefinedRaw = record =>
+  internal_keepMapFieldsRaw(record, ((key, value)) => {
+    switch value {
+    | Some(value) => Some((key, value))
+    | None => None
+    }
+  })
 
-    return newObj;
-  }
-`
-)
+let internal_removeUndefinedAndConvertNullsRaw = record =>
+  internal_keepMapFieldsRaw(record, ((key, value)) => {
+    switch (value, value == Some(None)) {
+    | (Some(value), _) => Some((key, Js.Nullable.return(value)))
+    | (_, true) => Some((key, Js.Nullable.null))
+    | (None, _) => None
+    }
+  })
 
 let internal_useConvertedValue = (convert, v) => React.useMemo1(() => convert(v), [v])
 

package/src/RescriptRelay_Internal.resi

@@ -1,5 +1,6 @@
 let internal_useConvertedValue: ('a => 'a, 'a) => 'a
 let internal_cleanObjectFromUndefinedRaw: 't => 't
+let internal_removeUndefinedAndConvertNullsRaw: 't => 't
 let internal_nullableToOptionalExnHandler: option<option<'b> => 'a> => option<
   Js.Nullable.t<'b> => 'a,
 >

package/src/experimental-router/RescriptRelayRouter.bs.js

@@ -9,6 +9,7 @@ var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var ReactExperimental = require("../ReactExperimental.bs.js");
 var RescriptReactRouter = require("@rescript/react/src/RescriptReactRouter.bs.js");
 
 function matchesUrl(t, url) {
@@ -242,7 +243,7 @@ function RescriptRelayRouter$RouteRenderer(Props) {
       });
   var initialized = match[0];
   var router = React.useContext(context);
-  var match$1 = React.useTransition();
+  var match$1 = ReactExperimental.useTransition(undefined);
   var startTransition = match$1[1];
   var match$2 = React.useState(function () {
         return Curry._1(router.get, undefined);

package/src/utils.js

@@ -10,6 +10,19 @@ function makeNewPath(currentPath, newKeys) {
   return [].concat(currentPath, newKeys);
 }
 
+function getTypename(v) {
+  if (v != null && typeof v === "object") {
+    if (v.__typename) {
+      return v.__typename;
+    }
+
+    // `v.VAL` relies on internal implementation details in ReScript.
+    if (v.VAL != null && typeof v.VAL === "object") {
+      return v.VAL.__typename;
+    }
+  }
+}
+
 /**
  * Runs on each object in the tree and follows the provided instructions
  * to apply transforms etc.
@@ -24,6 +37,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) {
@@ -32,6 +49,8 @@ function traverse(
   }
 
   for (var key in currentObj) {
+    if (key === "VAL" || key === "NAME") continue;
+
     var isUnion = false;
     var originalValue = currentObj[key];
 
@@ -39,151 +58,73 @@ function traverse(
     var thisPath = makeNewPath(currentPath, [key]);
     var path = getPathName(thisPath);
 
-    var instructions = instructionMap[path];
-
-    var hasDeeperInstructions =
-      instructionPaths.filter(function (p) {
-        return p.indexOf(path) === 0 && p.length > path.length;
-      }).length > 0;
+    var instructions = instructionMap[path] || {};
 
-    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"]];
+    if (currentObj[key] == null) {
+      newObj = getNewObj(newObj, currentObj);
+      newObj[key] = nullableValue;
+      continue;
+    }
 
-        var shouldAddFragmentFn = instructions["f"] === "";
+    var shouldConvertRootObj =
+      typeof instructions["r"] === "string" &&
+      fullInstructionMap[instructions["r"]];
 
-        var shouldConvertEnum =
-          typeof instructions["e"] === "string" &&
-          !!converters[instructions["e"]];
+    var shouldAddFragmentFn = instructions["f"] === "";
 
-        var shouldConvertCustomField =
-          typeof instructions["c"] === "string" &&
-          !!converters[instructions["c"]];
+    var shouldConvertEnum =
+      typeof instructions["e"] === "string" && !!converters[instructions["e"]];
 
-        var shouldConvertUnion =
-          typeof instructions["u"] === "string" &&
-          !!converters[instructions["u"]];
+    var shouldConvertCustomField =
+      typeof instructions["c"] === "string" && !!converters[instructions["c"]];
 
-        var isTopLevelNodeField = typeof instructions["tnf"] === "string";
+    var shouldConvertUnion =
+      typeof instructions["u"] === "string" && !!converters[instructions["u"]];
 
-        /**
-         * Handle arrays
-         */
-        if (Array.isArray(currentObj[key])) {
-          newObj = getNewObj(newObj, currentObj);
-          newObj[key] = currentObj[key].map(function (v) {
-            if (v == null) {
-              return nullableValue;
-            }
+    var isTopLevelNodeField = typeof instructions["tnf"] === "string";
 
-            if (shouldConvertRootObj) {
-              return 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 (shouldConvertEnum) {
-              return converters[instructions["e"]](v);
-            }
+        if (shouldConvertRootObj) {
+          return traverser(
+            v,
+            fullInstructionMap,
+            converters,
+            nullableValue,
+            instructions["r"]
+          );
+        }
 
-            if (shouldConvertCustomField) {
-              return converters[instructions["c"]](v);
-            }
+        if (shouldConvertEnum) {
+          return converters[instructions["e"]](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 (shouldConvertCustomField) {
+          return converters[instructions["c"]](v);
+        }
 
-            if (shouldAddFragmentFn && typeof v === "object") {
-              var objWithFragmentFn = Object.assign({}, v);
-              objWithFragmentFn.fragmentRefs = Object.assign(
-                {},
-                objWithFragmentFn
-              );
-              return objWithFragmentFn;
-            }
+        if (shouldConvertUnion && v != null && typeof v === "object") {
+          var typename = getTypename(v);
 
-            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 (typename != null) {
+            isUnion = true;
+            var unionObj = v;
 
-          if (isTopLevelNodeField) {
-            if (
-              !v ||
-              !v.hasOwnProperty("__typename") ||
-              v.__typename !== instructions["tnf"]
-            ) {
-              newObj = getNewObj(newObj, currentObj);
-              newObj[key] = nullableValue;
+            // Means we're wrapping, and this will be a ReScript value.
+            if (nullableValue === null) {
+              // Convert it back to a flat JS value
+              unionObj = converters[instructions["u"]](v);
             }
-          }
 
-          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 &&
-            typeof v === "object" &&
-            typeof v.__typename === "string"
-          ) {
-            isUnion = true;
-
-            var newPath = makeNewPath(currentPath, [key, v.__typename]);
+            var newPath = makeNewPath(currentPath, [key, typename]);
 
             var unionRootHasFragment =
               (instructionMap[getPathName(newPath)] || {}).f === "";
@@ -191,7 +132,7 @@ function traverse(
             var traversedValue = traverse(
               fullInstructionMap,
               newPath,
-              v,
+              unionObj,
               instructionMap,
               converters,
               nullableValue,
@@ -199,27 +140,113 @@ function traverse(
               unionRootHasFragment
             );
 
-            newObj = getNewObj(newObj, currentObj);
-            newObj[key] = converters[instructions["u"]](traversedValue);
+            // Undefined means we're going from JS to ReScript, in which case we
+            // need to run the conversion here rather than earlier.
+            return nullableValue === undefined
+              ? converters[instructions["u"]](traversedValue)
+              : traversedValue;
           }
+        }
 
-          if (shouldAddFragmentFn && typeof v === "object") {
-            newObj = getNewObj(newObj, currentObj);
+        if (shouldAddFragmentFn && typeof v === "object") {
+          var objWithFragmentFn = Object.assign({}, v);
+          objWithFragmentFn.fragmentRefs = Object.assign({}, objWithFragmentFn);
+          return objWithFragmentFn;
+        }
 
-            var objWithFragmentFn = Object.assign({}, v);
+        return v;
+      });
+    } else {
+      /**
+       * Handle normal values.
+       */
+      var v = currentObj[key];
 
-            objWithFragmentFn.fragmentRefs = Object.assign(
-              {},
-              objWithFragmentFn
-            );
+      if (shouldConvertRootObj) {
+        newObj = getNewObj(newObj, currentObj);
+        newObj[key] = traverser(
+          v,
+          fullInstructionMap,
+          converters,
+          nullableValue,
+          instructions["r"]
+        );
+      }
+
+      if (isTopLevelNodeField) {
+        // If this is a top level node field we should try and convert, ensure
+        // it conforms to the desired shape (has the correct typename). If not,
+        // null it and return right away.
+        if (
+          v == null ||
+          !v.hasOwnProperty("__typename") ||
+          v.__typename !== instructions["tnf"]
+        ) {
+          newObj = getNewObj(newObj, currentObj);
+          newObj[key] = nullableValue;
+          return newObj;
+        }
+      }
+
+      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") {
+        var typename = getTypename(v);
+
+        if (typename != null) {
+          isUnion = true;
+          var unionObj = v;
 
-            newObj[key] = objWithFragmentFn;
+          // Means we're wrapping, and this will be a ReScript value.
+          if (nullableValue === null) {
+            // Convert it back to a flat JS value
+            unionObj = converters[instructions["u"]](v);
           }
+
+          var newPath = makeNewPath(currentPath, [key, typename]);
+
+          var unionRootHasFragment =
+            (instructionMap[getPathName(newPath)] || {}).f === "";
+
+          var traversedValue = traverse(
+            fullInstructionMap,
+            newPath,
+            unionObj,
+            instructionMap,
+            converters,
+            nullableValue,
+            instructionPaths,
+            unionRootHasFragment
+          );
+
+          newObj = getNewObj(newObj, currentObj);
+
+          newObj[key] =
+            // Undefined means we're going from JS to ReScript, in which case we
+            // need to run the conversion here rather than earlier.
+            nullableValue === undefined
+              ? converters[instructions["u"]](traversedValue)
+              : 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)) {
@@ -240,17 +267,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;
+          }
         });
       }
     }
@@ -280,21 +311,11 @@ function traverser(
   }
 
   var instructionMaps = instructionMaps_ || {};
-  var instructionMap = instructionMaps[rootObjectKey || "__root"];
-
-  // No instructions
-  if (!instructionMap) {
-    return root;
-  }
+  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];