rescript-relay 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # master
 
+# 1.2.1
+
+## Bug fix
+
+- Proper import for `useBlockingPagination`. https://github.com/zth/rescript-relay/pull/459
+
+# 1.2.0
+
+This release mainly makes preparations under the hood for the upcoming `2.0` (ReScript v11 + uncurried mode support) and `3.0` (lots of changes, full uncurried mode only).
+
+## Breaking changes
+
+- A trailing unit `()` arg is no longer needed in `Query.usePreloaded()`. What was previously `Query.usePreloaded(~queryRef, ())` is now just `Query.usePreloaded(~queryRef)`.
+
+## Improvements
+
+- Add `@live` annotations to generated JSXv4 dynamic import compat modules, so they don't show up in dead code analysis (which they shouldn't).
+- Preparations under the hood for ReScript v11 + uncurried mode.
+
+# 1.1.1
+
+- Fix M1 binary to include new JSXv4 dynamic import compat changes.
+
 # 1.1.0
 
 Notable changes:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -39,11 +39,10 @@
     "test:ci": "jest --ci --runInBand"
   },
   "devDependencies": {
-    "rescript": "^10.1.3",
-    "@rescript/react": "0.11.0",
+    "@glennsl/rescript-fetch": "^0.2.0",
+    "@rescript/react": "0.12.0-alpha.2",
     "@testing-library/jest-dom": "^5.16.3",
     "@testing-library/react": "^13.0.0-alpha.6",
-    "bs-fetch": "^0.5.0",
     "graphql-query-test-mock": "^0.12.1",
     "jest": "^27.2.4",
     "nock": "^11.7.0",
@@ -51,7 +50,8 @@
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "react-relay": "15.0.0",
-    "relay-runtime": "15.0.0"
+    "relay-runtime": "15.0.0",
+    "rescript": "^11.0.0-beta.1"
   },
   "peerDependencies": {
     "@rescript/react": "*",

package/postinstall.js

@@ -152,6 +152,10 @@ function removeInitialBinaries() {
     recursive: true,
     force: true,
   });
+  fs.rmSync(path.join(__dirname, "relay-compiler-win-x64"), {
+    recursive: true,
+    force: true,
+  });
 }
 
 switch (platform) {

package/src/ReactExperimental.bs.js

@@ -8,8 +8,10 @@ function useTransition(param) {
   var startTransition = match[1];
   return [
           match[0],
-          React.useCallback((function (cb) {
-                  startTransition(cb, undefined);
+          React.useMemo((function (param) {
+                  return function (cb) {
+                    return startTransition(cb, undefined);
+                  };
                 }), [startTransition])
         ];
 }

package/src/ReactExperimental.res

@@ -9,7 +9,7 @@ external useTransitionWithOptions: unit => (
 
 let useTransition = () => {
   let (isPending, startTransition) = useTransitionWithOptions()
-  (isPending, React.useCallback1(cb => startTransition(. cb, None), [startTransition]))
+  (isPending, React.useMemo1(() => cb => startTransition(. cb, None), [startTransition]))
 }
 
 module SuspenseList = {

package/src/ReactExperimental.resi

@@ -7,7 +7,7 @@ external useTransitionWithOptions: unit => (
   (. unit => unit, option<{"name": option<string>}>) => unit,
 ) = "useTransition"
 
-let useTransition: unit => (bool, React.callback<unit => unit, unit>)
+let useTransition: unit => (bool, (unit => unit) => unit)
 
 module SuspenseList: {
   @module("react") @react.component

package/src/RescriptRelay.bs.js

@@ -50,22 +50,22 @@ function unwrapNormalizationArgument(wrapped) {
   var match = wrapped.kind;
   if (match === "Literal") {
     return {
-            TAG: /* Literal */1,
+            TAG: "Literal",
             _0: wrapped
           };
   } else if (match === "ListValue") {
     return {
-            TAG: /* ListValue */0,
+            TAG: "ListValue",
             _0: wrapped
           };
   } else if (match === "ObjectValue") {
     return {
-            TAG: /* ObjectValue */2,
+            TAG: "ObjectValue",
             _0: wrapped
           };
   } else {
     return {
-            TAG: /* Variable */3,
+            TAG: "Variable",
             _0: wrapped
           };
   }
@@ -196,13 +196,13 @@ function mapFetchPolicy(x) {
     return ;
   }
   switch (x) {
-    case /* StoreOnly */0 :
+    case "StoreOnly" :
         return "store-only";
-    case /* StoreOrNetwork */1 :
+    case "StoreOrNetwork" :
         return "store-or-network";
-    case /* StoreAndNetwork */2 :
+    case "StoreAndNetwork" :
         return "store-and-network";
-    case /* NetworkOnly */3 :
+    case "NetworkOnly" :
         return "network-only";
     
   }
@@ -210,10 +210,10 @@ function mapFetchPolicy(x) {
 
 function mapFetchQueryFetchPolicy(x) {
   if (x !== undefined) {
-    if (x) {
-      return "store-or-network";
-    } else {
+    if (x === "NetworkOnly") {
       return "network-only";
+    } else {
+      return "store-or-network";
     }
   }
   
@@ -237,7 +237,7 @@ function MakeLoadQuery(C) {
                     Caml_option.valFromOption(o).subscribe({
                           complete: (function (param) {
                               resolve({
-                                    TAG: /* Ok */0,
+                                    TAG: "Ok",
                                     _0: undefined
                                   });
                             })
@@ -245,7 +245,7 @@ function MakeLoadQuery(C) {
                     return ;
                   } else {
                     return resolve({
-                                TAG: /* Error */1,
+                                TAG: "Error",
                                 _0: undefined
                               });
                   }

package/src/RescriptRelay.res

@@ -507,6 +507,8 @@ module Observable = {
   external subscribe: (t<'response>, observer<'response>) => subscription = "subscribe"
 
   @send external toPromise: t<'t> => Js.Promise.t<'t> = "toPromise"
+
+  external ignoreSubscription: subscription => unit = "%ignore"
 }
 
 module Network = {
@@ -593,7 +595,7 @@ module RequiredFieldLogger = {
 
   type t = (~kind: kind, ~owner: string, ~fieldPath: string) => unit
 
-  let toJs: t => js = (f, arg) =>
+  let toJs: t => js = f => arg =>
     f(~kind=arg["kind"], ~owner=arg["owner"], ~fieldPath=arg["fieldPath"])
 }
 

package/src/RescriptRelay.resi

@@ -615,6 +615,8 @@ module Observable: {
   /**Turns an `Observable` into a promise. _Beware_ that reading the response in the resulting promise is currently _not safe_ due to some internals of how ReScript Relay works. This will be resolved in the future.*/
   @send
   external toPromise: t<'t> => Js.Promise.t<'t> = "toPromise"
+
+  /**Ignore this subscription.*/ external ignoreSubscription: subscription => unit = "%ignore"
 }
 
 /**Represents the network layer.*/
@@ -803,8 +805,11 @@ module Context: {
   /**The context provider you wrap your app in and pass your `Environment` for Relay to work.*/
   module Provider: {
     /**The React component you wrap your app in and pass your `Environment` for Relay to work.*/
-    @react.component
-    let make: (~environment: Environment.t, ~children: React.element) => React.element
+    type props<'environment, 'children> = {
+      environment: 'environment,
+      children: 'children,
+    }
+    let make: props<Environment.t, React.element> => React.element
   }
 }
 

package/src/RescriptRelayUtils.bs.js

@@ -61,11 +61,11 @@ function createAndAddEdgeToConnections(store, node, connections, edgeName, inser
             return ;
           }
           var edge = RelayRuntime.ConnectionHandler.createEdge(store, connection, node, edgeName);
-          if (insertAt) {
-            RelayRuntime.ConnectionHandler.insertEdgeBefore(connection, edge, undefined);
-          } else {
+          if (insertAt === "Start") {
             RelayRuntime.ConnectionHandler.insertEdgeAfter(connection, edge, undefined);
+            return ;
           }
+          RelayRuntime.ConnectionHandler.insertEdgeBefore(connection, edge, undefined);
         }));
 }
 

package/src/RescriptRelay_Fragment.bs.js

@@ -0,0 +1,117 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Curry = require("rescript/lib/js/curry.js");
+var React = require("react");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var ReactRelay = require("react-relay");
+var RescriptRelay = require("./RescriptRelay.bs.js");
+var RescriptRelay_Internal = require("./RescriptRelay_Internal.bs.js");
+var UseBlockingPaginationFragment = require("react-relay/lib/relay-hooks/useBlockingPaginationFragment").default;
+
+function useFragment(node, convertFragment, fRef) {
+  return RescriptRelay_Internal.internal_useConvertedValue(convertFragment, ReactRelay.useFragment(node, fRef));
+}
+
+function useFragmentOpt(fRef, node, convertFragment) {
+  var data = ReactRelay.useFragment(node, fRef);
+  return React.useMemo((function (param) {
+                if (!(data == null)) {
+                  return Caml_option.some(Curry._1(convertFragment, data));
+                }
+                
+              }), [(data == null) ? undefined : Caml_option.some(data)]);
+}
+
+function readInlineData(node, convertFragment, fRef) {
+  return Curry._1(convertFragment, ReactRelay.readInlineData(node, fRef));
+}
+
+function internal_makeRefetchableFnOpts(fetchPolicy, onComplete, param) {
+  return {
+          fetchPolicy: RescriptRelay.mapFetchPolicy(fetchPolicy),
+          onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+        };
+}
+
+function usePaginationFragment(node, fRef, convertFragment, convertRefetchVariables) {
+  var p = ReactRelay.usePaginationFragment(node, fRef);
+  var data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data);
+  return {
+          data: data,
+          loadNext: React.useMemo((function (param) {
+                  return function (count, onComplete, param) {
+                    return Curry._2(p.loadNext, count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [p.loadNext]),
+          loadPrevious: React.useMemo((function (param) {
+                  return function (count, onComplete, param) {
+                    return Curry._2(p.loadPrevious, count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [p.loadPrevious]),
+          hasNext: p.hasNext,
+          hasPrevious: p.hasPrevious,
+          isLoadingNext: p.isLoadingNext,
+          isLoadingPrevious: p.isLoadingPrevious,
+          refetch: React.useMemo((function (param) {
+                  return function (variables, fetchPolicy, onComplete, param) {
+                    return Curry._2(p.refetch, RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(Curry._1(convertRefetchVariables, variables)), internal_makeRefetchableFnOpts(fetchPolicy, onComplete, undefined));
+                  };
+                }), [p.refetch])
+        };
+}
+
+function useBlockingPaginationFragment(node, fRef, convertFragment, convertRefetchVariables) {
+  var p = UseBlockingPaginationFragment(node, fRef);
+  var data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data);
+  return {
+          data: data,
+          loadNext: React.useMemo((function (param) {
+                  return function (count, onComplete, param) {
+                    return Curry._2(p.loadNext, count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [p.loadNext]),
+          loadPrevious: React.useMemo((function (param) {
+                  return function (count, onComplete, param) {
+                    return Curry._2(p.loadPrevious, count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [p.loadPrevious]),
+          hasNext: p.hasNext,
+          hasPrevious: p.hasPrevious,
+          refetch: React.useMemo((function (param) {
+                  return function (variables, fetchPolicy, onComplete, param) {
+                    return Curry._2(p.refetch, RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(Curry._1(convertRefetchVariables, variables)), internal_makeRefetchableFnOpts(fetchPolicy, onComplete, undefined));
+                  };
+                }), [p.refetch])
+        };
+}
+
+function useRefetchableFragment(node, convertFragment, convertRefetchVariables, fRef) {
+  var match = ReactRelay.useRefetchableFragment(node, fRef);
+  var refetchFn = match[1];
+  var data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, match[0]);
+  return [
+          data,
+          React.useMemo((function (param) {
+                  return function (variables, fetchPolicy, onComplete, param) {
+                    return Curry._2(refetchFn, RescriptRelay_Internal.internal_removeUndefinedAndConvertNullsRaw(Curry._1(convertRefetchVariables, variables)), internal_makeRefetchableFnOpts(fetchPolicy, onComplete, undefined));
+                  };
+                }), [refetchFn])
+        ];
+}
+
+exports.useFragment = useFragment;
+exports.useFragmentOpt = useFragmentOpt;
+exports.readInlineData = readInlineData;
+exports.usePaginationFragment = usePaginationFragment;
+exports.useBlockingPaginationFragment = useBlockingPaginationFragment;
+exports.useRefetchableFragment = useRefetchableFragment;
+/* react Not a pure module */

package/src/RescriptRelay_Fragment.res

@@ -0,0 +1,239 @@
+open RescriptRelay
+
+@module("react-relay")
+external useFragment_: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "useFragment"
+
+let useFragment = (~node, ~convertFragment: 'fragment => 'fragment, ~fRef) => {
+  /** React hook for getting the data of this fragment. Pass \
+                     the `fragmentRefs` of any object where you've spread your \
+                     fragment into this and get the fragment data back.\n\n\
+                     ### Fragment data outside of React's render\n\
+                     If you're looking for a way to use fragments _outside_ of \
+                     render (for regular function calls for instance, like for \
+                     logging etc), look in to adding `@inline` to your \
+                     fragment definition (like `fragment SomeFragment_user on \
+                     User @inline {...}`) and then use `Fragment.readInline`. \
+                     This will allow you to get the fragment data, but outside \
+                     of React's render.*/
+  (
+    useFragment_(node, fRef)
+    ->(RescriptRelay_Internal.internal_useConvertedValue(convertFragment, _))
+  )
+}
+
+@module("react-relay")
+external useFragmentOpt_: (fragmentNode<'node>, option<'fragmentRef>) => Js.Nullable.t<'fragment> =
+  "useFragment"
+
+let useFragmentOpt = (~fRef, ~node, ~convertFragment: 'fragment => 'fragment) => {
+  // TODO(v11) can convert to Nullable pattern match.
+
+  /** A version of `Fragment.use` that'll allow you to pass \
+                     `option<fragmentRefs>` and get `option<'fragmentData>` \
+                     back. Useful for scenarios where you don't have the \
+                     fragmentRefs yet.*/
+  let data =
+    useFragmentOpt_(node, fRef)->Js.Nullable.toOption
+  React.useMemo1(() => {
+    switch data {
+    | Some(data) => Some(convertFragment(data))
+    | None => None
+    }
+  }, [data])
+}
+
+@module("react-relay")
+external readInlineData_: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "readInlineData"
+
+let readInlineData = (~node, ~convertFragment: 'fragment => 'fragment, ~fRef) => {
+  /** This lets you get the data for this fragment _outside \
+                       of React's render_. Useful for letting functions with \
+                       with fragments too, for things like logging etc.*/
+  (readInlineData_(node, fRef)->convertFragment)
+}
+
+type refetchableFnOpts = {
+  fetchPolicy?: string,
+  onComplete?: Js.Nullable.t<Js.Exn.t> => unit,
+}
+
+let internal_makeRefetchableFnOpts = (~fetchPolicy=?, ~onComplete=?, ()) => {
+  fetchPolicy: ?fetchPolicy->mapFetchPolicy,
+  onComplete: ?onComplete->RescriptRelay_Internal.internal_nullableToOptionalExnHandler,
+}
+
+type paginationLoadMoreOptions = {onComplete?: Js.Nullable.t<Js.Exn.t> => unit}
+type paginationLoadMoreFn = (
+  ~count: int,
+  ~onComplete: option<Js.Exn.t> => unit=?,
+  unit,
+) => Disposable.t
+type paginationFragmentReturnRaw<'fragment, 'refetchVariables> = {
+  data: 'fragment,
+  loadNext: (int, paginationLoadMoreOptions) => Disposable.t,
+  loadPrevious: (int, paginationLoadMoreOptions) => Disposable.t,
+  hasNext: bool,
+  hasPrevious: bool,
+  isLoadingNext: bool,
+  isLoadingPrevious: bool,
+  refetch: ('refetchVariables, refetchableFnOpts) => Disposable.t,
+}
+type paginationBlockingFragmentReturn<'fragment, 'refetchVariables> = {
+  data: 'fragment,
+  loadNext: paginationLoadMoreFn,
+  loadPrevious: paginationLoadMoreFn,
+  hasNext: bool,
+  hasPrevious: bool,
+  refetch: (
+    ~variables: 'refetchVariables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~onComplete: option<Js.Exn.t> => unit=?,
+    unit,
+  ) => Disposable.t,
+}
+type paginationFragmentReturn<'fragment, 'refetchVariables> = {
+  data: 'fragment,
+  loadNext: paginationLoadMoreFn,
+  loadPrevious: paginationLoadMoreFn,
+  hasNext: bool,
+  hasPrevious: bool,
+  isLoadingNext: bool,
+  isLoadingPrevious: bool,
+  refetch: (
+    ~variables: 'refetchVariables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~onComplete: option<Js.Exn.t> => unit=?,
+    unit,
+  ) => Disposable.t,
+}
+
+@module("react-relay")
+external usePaginationFragment_: (
+  fragmentNode<'node>,
+  'fragmentRef,
+) => paginationFragmentReturnRaw<'fragment, 'refetchVariables> = "usePaginationFragment"
+
+/** React hook for paginating a fragment. Paginating with \
+                       this hook will _not_ cause your component to suspend. \
+                       If you want pagination to trigger suspense, look into \
+                       using `Fragment.useBlockingPagination`.*/
+let usePaginationFragment = (
+  ~node,
+  ~fRef,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+) => {
+  let p = usePaginationFragment_(node, fRef)
+  let data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data)
+  {
+    data,
+    loadNext: React.useMemo1(() => (~count, ~onComplete=?, ()) => {
+      p.loadNext(
+        count,
+        {onComplete: ?onComplete->RescriptRelay_Internal.internal_nullableToOptionalExnHandler},
+      )
+    }, [p.loadNext]),
+    loadPrevious: React.useMemo1(() => (~count, ~onComplete=?, ()) => {
+      p.loadPrevious(
+        count,
+        {onComplete: ?onComplete->RescriptRelay_Internal.internal_nullableToOptionalExnHandler},
+      )
+    }, [p.loadPrevious]),
+    hasNext: p.hasNext,
+    hasPrevious: p.hasPrevious,
+    isLoadingNext: p.isLoadingNext,
+    isLoadingPrevious: p.isLoadingPrevious,
+    refetch: React.useMemo1(() => (~variables, ~fetchPolicy=?, ~onComplete=?, ()) => {
+      p.refetch(
+        RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(
+          variables->convertRefetchVariables,
+        ),
+        internal_makeRefetchableFnOpts(~onComplete?, ~fetchPolicy?, ()),
+      )
+    }, [p.refetch]),
+  }
+}
+
+@module("react-relay/lib/relay-hooks/useBlockingPaginationFragment")
+external useBlockingPaginationFragment_: (
+  fragmentNode<'node>,
+  'fragmentRef,
+) => paginationFragmentReturnRaw<'fragment, 'refetchVariables> = "default"
+
+/** Like `Fragment.usePagination`, but calling the \
+                       pagination function will trigger suspense. Useful for \
+                       all-at-once pagination.*/
+let useBlockingPaginationFragment = (
+  ~node,
+  ~fRef,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+) => {
+  let p = useBlockingPaginationFragment_(node, fRef)
+  let data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data)
+  {
+    data,
+    loadNext: React.useMemo1(() => (~count, ~onComplete=?, ()) => {
+      p.loadNext(
+        count,
+        {onComplete: ?onComplete->RescriptRelay_Internal.internal_nullableToOptionalExnHandler},
+      )
+    }, [p.loadNext]),
+    loadPrevious: React.useMemo1(() => (~count, ~onComplete=?, ()) => {
+      p.loadPrevious(
+        count,
+        {onComplete: ?onComplete->RescriptRelay_Internal.internal_nullableToOptionalExnHandler},
+      )
+    }, [p.loadPrevious]),
+    hasNext: p.hasNext,
+    hasPrevious: p.hasPrevious,
+    refetch: React.useMemo1(() => (~variables, ~fetchPolicy=?, ~onComplete=?, ()) => {
+      p.refetch(
+        RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(
+          variables->convertRefetchVariables,
+        ),
+        internal_makeRefetchableFnOpts(~onComplete?, ~fetchPolicy?, ()),
+      )
+    }, [p.refetch]),
+  }
+}
+
+@module("react-relay")
+external useRefetchableFragment_: (
+  fragmentNode<'node>,
+  'fragmentRef,
+) => ('fragment, ('refetchVariables, refetchableFnOpts) => Disposable.t) = "useRefetchableFragment"
+
+/**React hook for using a fragment that you want to refetch. Returns \
+             a tuple of `(fragmentData, refetchFn)`.\n\n\
+             ### Refetching and variables\n\
+             You supply a _diff_ of your variables to Relay when refetching. \
+             Diffed variables here means that any new value you supply when \
+             refetching will be merged with the variables you last used when \
+             fetching data for this fragment.\n\n\
+             ### `Fragment.makeRefetchVariables` - helper for making the \
+             refetch variables\n\
+             There's a helper generated for you to create those diffed \
+             variables more easily at `Fragment.makeRefetchVariables`.*/
+let useRefetchableFragment = (
+  ~node,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+  ~fRef,
+) => {
+  let (fragmentData, refetchFn) = useRefetchableFragment_(node, fRef)
+  let data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, fragmentData)
+  (
+    data,
+    React.useMemo1(
+      () => (~variables: 'refetchVariables, ~fetchPolicy=?, ~onComplete=?, ()) =>
+        refetchFn(
+          RescriptRelay_Internal.internal_removeUndefinedAndConvertNullsRaw(
+            variables->convertRefetchVariables,
+          ),
+          internal_makeRefetchableFnOpts(~fetchPolicy?, ~onComplete?, ()),
+        ),
+      [refetchFn],
+    ),
+  )
+}