rescript-relay 3.1.0 → 3.2.0

package/CHANGELOG.md

@@ -1,7 +1,17 @@
 # master
 
+# 3.2.0
+
+- Add support for the new Relay `@catch` directive. https://github.com/zth/rescript-relay/pull/549
+- Add support for `usePrefetchableForwardPagination`. https://github.com/zth/rescript-relay/pull/551
+- Remove `useBlockingPagination` since it's being removed from Relay.
+
 # 3.1.0
 
+This brings the Relay version to `18.2.0`.
+
+If you have enabled the feature flags in `relay.config.js` for aliased fragments or Relay resolvers you'll need to remove them from the config file as they are now on by default, and not removing them will cause the compiler to fail with a non super helpful error message.
+
 - **Upgrade versions**: `react-relay` and `relay-runtime` to `18.2.0`.
 - Add support for `Fragment.waitForFragmentData`, a new API in Relay 18.2 that lets you wait for fragment data outside of React.
 - Experimental: Add a "non React" mode to the PPX, which makes sure only APIs that don't rely on React directly are exposed. This is intended to be a way to simplify using RescriptRelay without React. Activate by passing `-non-react` to the PPX, like `"ppx-flags": [["rescript-relay/ppx", "-non-react"]]`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",

package/src/RescriptRelay.bs.js

@@ -13,6 +13,32 @@ var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
 var LiveResolverStore = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore").default;
 var LiveResolverStore$1 = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore");
 
+function toOption(t) {
+  if (t.ok === true) {
+    return Caml_option.some(t.value);
+  }
+  
+}
+
+function toResult(t) {
+  if (t.ok === true) {
+    return {
+            TAG: "Ok",
+            _0: t.value
+          };
+  } else {
+    return {
+            TAG: "Error",
+            _0: t.errors
+          };
+  }
+}
+
+var CatchResult = {
+  toOption: toOption,
+  toResult: toResult
+};
+
 var SuspenseSentinel = {};
 
 function convertObj(prim0, prim1, prim2, prim3) {
@@ -345,6 +371,7 @@ function MakeLoadQuery(C) {
 
 var Mutation_failed = /* @__PURE__ */Caml_exceptions.create("RescriptRelay.Mutation_failed");
 
+exports.CatchResult = CatchResult;
 exports.SuspenseSentinel = SuspenseSentinel;
 exports.convertObj = convertObj;
 exports.RecordProxy = RecordProxy;

package/src/RescriptRelay.res

@@ -17,6 +17,25 @@ type dataIdObject = {id: dataId}
 type recordSourceRecords = Js.Json.t
 type uploadables
 
+module CatchResult = {
+  type catchError = Js.Json.t
+
+  @tag("ok")
+  type t<'value> = | @as(true) Ok({value: 'value}) | @as(false) Error({errors: array<catchError>})
+
+  let toOption = (t: t<'value>) =>
+    switch t {
+    | Ok({value}) => Some(value)
+    | Error(_) => None
+    }
+
+  let toResult = (t: t<'value>): result<'value, array<catchError>> =>
+    switch t {
+    | Ok({value}) => Ok(value)
+    | Error({errors}) => Error(errors)
+    }
+}
+
 module SuspenseSentinel = {
   type t
 

package/src/RescriptRelay.resi

@@ -41,6 +41,24 @@ type dataId
 
 type dataIdObject = {id: dataId}
 
+/** A module for results originating from the @catch directive. */
+module CatchResult: {
+  /** The shape of an error caught via @catch. */
+  type catchError = Js.Json.t
+
+  /** The result type for @catch. */
+  @tag("ok")
+  type t<'value> =
+    | @as(true) Ok({value: 'value})
+    | @as(false) Error({errors: array<catchError>})
+
+  /** Convert a @catch result to option. */
+  let toOption: t<'value> => option<'value>
+
+  /** Convert a @catch result to result. */
+  let toResult: t<'value> => result<'value, array<catchError>>
+}
+
 module SuspenseSentinel: {
   type t
 

package/src/RescriptRelay_Fragment.bs.js

@@ -7,7 +7,6 @@ var ReactRelay = require("react-relay");
 var RescriptRelay_Internal = require("./RescriptRelay_Internal.bs.js");
 var Experimental = require("relay-runtime/experimental");
 var ResolverFragments = require("relay-runtime/lib/store/ResolverFragments");
-var UseBlockingPaginationFragment = require("react-relay/lib/relay-hooks/legacy/useBlockingPaginationFragment").default;
 
 function useFragment(node, convertFragment, fRef) {
   var __x = ReactRelay.useFragment(node, fRef);
@@ -70,11 +69,13 @@ function usePaginationFragment(node, fRef, convertFragment, convertRefetchVariab
         };
 }
 
-function useBlockingPaginationFragment(node, fRef, convertFragment, convertRefetchVariables) {
-  var p = UseBlockingPaginationFragment(node, fRef);
+function usePrefetchableForwardPagination(node, fRef, convertEdges, convertFragment, convertRefetchVariables, bufferSize, initialSize, prefetchingLoadMoreOptions, minimumFetchSize) {
+  var p = ReactRelay.usePrefetchableForwardPaginationFragment_EXPERIMENTAL(node, fRef, bufferSize, initialSize !== undefined ? Caml_option.valFromOption(initialSize) : undefined, prefetchingLoadMoreOptions !== undefined ? Caml_option.valFromOption(prefetchingLoadMoreOptions) : undefined, minimumFetchSize !== undefined ? Caml_option.valFromOption(minimumFetchSize) : undefined);
   var data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data);
+  var edges = RescriptRelay_Internal.internal_useConvertedValue(convertEdges, p.edges);
   return {
           data: data,
+          edges: edges,
           loadNext: React.useMemo((function () {
                   return function (count, onComplete) {
                     return p.loadNext(count, {
@@ -82,15 +83,8 @@ function useBlockingPaginationFragment(node, fRef, convertFragment, convertRefet
                               });
                   };
                 }), [p.loadNext]),
-          loadPrevious: React.useMemo((function () {
-                  return function (count, onComplete) {
-                    return p.loadPrevious(count, {
-                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
-                              });
-                  };
-                }), [p.loadPrevious]),
           hasNext: p.hasNext,
-          hasPrevious: p.hasPrevious,
+          isLoadingNext: p.isLoadingNext,
           refetch: React.useMemo((function () {
                   return function (variables, fetchPolicy, onComplete) {
                     return p.refetch(RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(convertRefetchVariables(variables)), internal_makeRefetchableFnOpts(fetchPolicy, onComplete, undefined));
@@ -123,7 +117,7 @@ exports.useFragmentOpt = useFragmentOpt;
 exports.readInlineData = readInlineData;
 exports.read = read;
 exports.usePaginationFragment = usePaginationFragment;
-exports.useBlockingPaginationFragment = useBlockingPaginationFragment;
+exports.usePrefetchableForwardPagination = usePrefetchableForwardPagination;
 exports.useRefetchableFragment = useRefetchableFragment;
 exports.waitForFragmentData = waitForFragmentData;
 /* react Not a pure module */

package/src/RescriptRelay_Fragment.res

@@ -84,18 +84,6 @@ type paginationFragmentReturnRaw<'fragment, 'refetchVariables> = {
   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=?,
-  ) => Disposable.t,
-}
 type paginationFragmentReturn<'fragment, 'refetchVariables> = {
   data: 'fragment,
   loadNext: paginationLoadMoreFn,
@@ -117,10 +105,7 @@ external usePaginationFragment_: (
   '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`.*/
+/** React hook for paginating a fragment. Paginating with this hook will _not_ cause your component to suspend. */
 let usePaginationFragment = (
   ~node,
   ~fRef,
@@ -158,39 +143,71 @@ let usePaginationFragment = (
   }
 }
 
-@module("react-relay/lib/relay-hooks/legacy/useBlockingPaginationFragment")
-external useBlockingPaginationFragment_: (
+type prefetchableForwardPaginationFragmentReturnRaw<'fragment, 'edges, 'refetchVariables> = {
+  data: 'fragment,
+  edges: 'edges,
+  loadNext: (int, paginationLoadMoreOptions) => Disposable.t,
+  hasNext: bool,
+  isLoadingNext: bool,
+  refetch: ('refetchVariables, refetchableFnOpts) => Disposable.t,
+}
+type prefetchableForwardPaginationFragmentReturn<'fragment, 'edges, 'refetchVariables> = {
+  data: 'fragment,
+  edges: 'edges,
+  loadNext: paginationLoadMoreFn,
+  hasNext: bool,
+  isLoadingNext: bool,
+  refetch: (
+    ~variables: 'refetchVariables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~onComplete: option<Js.Exn.t> => unit=?,
+  ) => Disposable.t,
+}
+
+@module("react-relay")
+external usePrefetchableForwardPaginationFragment_: (
   fragmentNode<'node>,
   'fragmentRef,
-) => paginationFragmentReturnRaw<'fragment, 'refetchVariables> = "default"
+  ~bufferSize: int,
+  ~initialSize: int=?,
+  ~prefetchingLoadMoreOptions: paginationLoadMoreOptions=?,
+  ~minimumFetchSize: int=?,
+) => prefetchableForwardPaginationFragmentReturnRaw<'fragment, 'edges, 'refetchVariables> =
+  "usePrefetchableForwardPaginationFragment_EXPERIMENTAL"
 
-/** Like `Fragment.usePagination`, but calling the \
-                       pagination function will trigger suspense. Useful for \
-                       all-at-once pagination.*/
-let useBlockingPaginationFragment = (
+/** React hook for paginating a fragment. Paginating with this hook will _not_ cause your component to suspend. */
+let usePrefetchableForwardPagination = (
   ~node,
   ~fRef,
+  ~convertEdges: 'edges => 'edges,
   ~convertFragment: 'fragment => 'fragment,
   ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+  ~bufferSize: int,
+  ~initialSize: option<int>=?,
+  ~prefetchingLoadMoreOptions: option<paginationLoadMoreOptions>=?,
+  ~minimumFetchSize: option<int>=?,
 ) => {
-  let p = useBlockingPaginationFragment_(node, fRef)
+  let p = usePrefetchableForwardPaginationFragment_(
+    node,
+    fRef,
+    ~bufferSize,
+    ~initialSize?,
+    ~prefetchingLoadMoreOptions?,
+    ~minimumFetchSize?,
+  )
   let data = RescriptRelay_Internal.internal_useConvertedValue(convertFragment, p.data)
+  let edges = RescriptRelay_Internal.internal_useConvertedValue(convertEdges, p.edges)
   {
     data,
+    edges,
     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,
     refetch: React.useMemo1(() => (~variables, ~fetchPolicy=?, ~onComplete=?) => {
       p.refetch(
         RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(

package/src/RescriptRelay_Fragment.resi

@@ -28,12 +28,14 @@ type paginationLoadMoreOptions = {onComplete?: Js.Nullable.t<Js.Exn.t> => unit}
 
 type paginationLoadMoreFn = (~count: int, ~onComplete: option<Js.Exn.t> => unit=?) => Disposable.t
 
-type paginationBlockingFragmentReturn<'fragment, 'refetchVariables> = {
+type paginationFragmentReturn<'fragment, 'refetchVariables> = {
   data: 'fragment,
   loadNext: paginationLoadMoreFn,
   loadPrevious: paginationLoadMoreFn,
   hasNext: bool,
   hasPrevious: bool,
+  isLoadingNext: bool,
+  isLoadingPrevious: bool,
   refetch: (
     ~variables: 'refetchVariables,
     ~fetchPolicy: fetchPolicy=?,
@@ -41,14 +43,19 @@ type paginationBlockingFragmentReturn<'fragment, 'refetchVariables> = {
   ) => Disposable.t,
 }
 
-type paginationFragmentReturn<'fragment, 'refetchVariables> = {
+let usePaginationFragment: (
+  ~node: fragmentNode<'a>,
+  ~fRef: 'b,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+) => paginationFragmentReturn<'fragment, 'refetchVariables>
+
+type prefetchableForwardPaginationFragmentReturn<'fragment, 'edges, 'refetchVariables> = {
   data: 'fragment,
+  edges: 'edges,
   loadNext: paginationLoadMoreFn,
-  loadPrevious: paginationLoadMoreFn,
   hasNext: bool,
-  hasPrevious: bool,
   isLoadingNext: bool,
-  isLoadingPrevious: bool,
   refetch: (
     ~variables: 'refetchVariables,
     ~fetchPolicy: fetchPolicy=?,
@@ -56,19 +63,17 @@ type paginationFragmentReturn<'fragment, 'refetchVariables> = {
   ) => Disposable.t,
 }
 
-let usePaginationFragment: (
-  ~node: fragmentNode<'a>,
-  ~fRef: 'b,
-  ~convertFragment: 'fragment => 'fragment,
-  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
-) => paginationFragmentReturn<'fragment, 'refetchVariables>
-
-let useBlockingPaginationFragment: (
+let usePrefetchableForwardPagination: (
   ~node: fragmentNode<'a>,
   ~fRef: 'b,
+  ~convertEdges: 'edges => 'edges,
   ~convertFragment: 'fragment => 'fragment,
   ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
-) => paginationBlockingFragmentReturn<'fragment, 'refetchVariables>
+  ~bufferSize: int,
+  ~initialSize: int=?,
+  ~prefetchingLoadMoreOptions: paginationLoadMoreOptions=?,
+  ~minimumFetchSize: int=?,
+) => prefetchableForwardPaginationFragmentReturn<'fragment, 'edges, 'refetchVariables>
 
 let useRefetchableFragment: (
   ~node: fragmentNode<'a>,