rescript-relay 3.0.1 → 3.2.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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"]]`.
+
 # 3.0.1
 
 - Add `Environment.findAllConnectionIds` for finding all IDs of all connection instances for a specific connection, regardless of what configs that connection has been fetched (and cached) with.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -49,14 +49,14 @@
     "node-fetch": "^2.6.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",
-    "react-relay": "17.0.0",
-    "relay-runtime": "17.0.0",
+    "react-relay": "18.2.0",
+    "relay-runtime": "18.2.0",
     "rescript": "11.1.1"
   },
   "peerDependencies": {
     "@rescript/react": ">=0.13.0",
-    "react-relay": "17.0.0",
-    "relay-runtime": "17.0.0",
+    "react-relay": "18.2.0",
+    "relay-runtime": "18.2.0",
     "rescript": "^11.0.0"
   },
   "dependencies": {

package/src/RescriptRelay.bs.js

@@ -10,8 +10,34 @@ var Caml_option = require("rescript/lib/js/caml_option.js");
 var ReactRelay = require("react-relay");
 var RelayRuntime = require("relay-runtime");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
-var LiveResolverStore = require("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore");
-var LiveResolverStore$1 = require("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore").default;
+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 = {};
 
@@ -209,14 +235,14 @@ function make(source, gcReleaseBufferSize, queryCacheExpirationTime) {
 }
 
 function makeLiveStore(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore$1(source, {
+  return new LiveResolverStore(source, {
               gcReleaseBufferSize: gcReleaseBufferSize,
               queryCacheExpirationTime: queryCacheExpirationTime
             });
 }
 
 function _makeLiveStoreCjs(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore(source, {
+  return new LiveResolverStore$1(source, {
               gcReleaseBufferSize: gcReleaseBufferSize,
               queryCacheExpirationTime: queryCacheExpirationTime
             });
@@ -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
 
@@ -643,9 +662,9 @@ module Store = {
 
   @module @new
   external makeLiveStoreCjs: (RecordSource.t, storeConfig) => t =
-    "relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore"
+    "relay-runtime/lib/store/live-resolvers/LiveResolverStore"
 
-  @module("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore") @new
+  @module("relay-runtime/lib/store/live-resolvers/LiveResolverStore") @new
   external makeLiveStore: (RecordSource.t, storeConfig) => t = "default"
 
   @module("relay-runtime") @new
@@ -686,8 +705,19 @@ module Store = {
 module RelayFieldLogger = {
   @tag("kind")
   type arg =
-    | @as("missing_field.log") MissingFieldLog({owner: string, fieldPath: string})
-    | @as("missing_field.throw") MissingFieldThrow({owner: string, fieldPath: string})
+    | @as("missing_required_field.log") MissingRequiredFieldLog({owner: string, fieldPath: string})
+    | @as("missing_required_field.throw")
+    MissingRequiredFieldThrow({
+        owner: string,
+        fieldPath: string,
+      })
+    | @as("missing_expected_data.log") MissingExpectedData({owner: string, fieldPath: string})
+    | @as("missing_expected_data.throw")
+    MissingExpectedDataThrow({
+        owner: string,
+        fieldPath: string,
+        handled: bool,
+      })
     | @as("relay_resolver.error")
     RelayResolverError({
         owner: string,

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
 
@@ -744,8 +762,19 @@ module Disposable: {
 module RelayFieldLogger: {
   @tag("kind")
   type arg =
-    | @as("missing_field.log") MissingFieldLog({owner: string, fieldPath: string})
-    | @as("missing_field.throw") MissingFieldThrow({owner: string, fieldPath: string})
+    | @as("missing_required_field.log") MissingRequiredFieldLog({owner: string, fieldPath: string})
+    | @as("missing_required_field.throw")
+    MissingRequiredFieldThrow({
+        owner: string,
+        fieldPath: string,
+      })
+    | @as("missing_expected_data.log") MissingExpectedData({owner: string, fieldPath: string})
+    | @as("missing_expected_data.throw")
+    MissingExpectedDataThrow({
+        owner: string,
+        fieldPath: string,
+        handled: bool,
+      })
     | @as("relay_resolver.error")
     RelayResolverError({
         owner: string,

package/src/RescriptRelay_Fragment.bs.js

@@ -5,8 +5,8 @@ var React = require("react");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 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);
@@ -69,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, {
@@ -81,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));
@@ -112,11 +107,17 @@ function useRefetchableFragment(node, convertFragment, convertRefetchVariables,
         ];
 }
 
+async function waitForFragmentData(environment, node, convertFragment, fRef) {
+  var fragmentData = await Experimental.waitForFragmentData(environment, node, fRef);
+  return convertFragment(fragmentData);
+}
+
 exports.useFragment = useFragment;
 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(
@@ -241,3 +258,20 @@ let useRefetchableFragment = (
     ),
   )
 }
+
+@module("relay-runtime/experimental")
+external waitForFragmentData_: (
+  Environment.t,
+  fragmentNode<'node>,
+  'fragmentRef,
+) => promise<'fragment> = "waitForFragmentData"
+
+let waitForFragmentData = async (
+  ~environment,
+  ~node,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef,
+) => {
+  let fragmentData = await waitForFragmentData_(environment, node, fRef)
+  convertFragment(fragmentData)
+}

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>,
@@ -83,3 +88,10 @@ let useRefetchableFragment: (
     ~onComplete: option<Js.Exn.t> => unit=?,
   ) => Disposable.t,
 )
+
+let waitForFragmentData: (
+  ~environment: Environment.t,
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef: 'b,
+) => promise<'fragment>