rescript-relay 0.0.0-autocodesplit-09ee6f6c

package/src/RescriptRelayUtils.bs.js

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var List = require("rescript/lib/js/list.js");
+var Belt_List = require("rescript/lib/js/belt_List.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var RelayRuntime = require("relay-runtime");
+
+function resolveNestedRecord(rootRecord, path) {
+  var currentRecord = rootRecord;
+  var pathLength = List.length(path);
+  if (pathLength !== 0) {
+    for(var i = 0; i < pathLength; ++i){
+      var currentPath = Belt_List.get(path, i);
+      var match = currentRecord;
+      currentRecord = match !== undefined && currentPath !== undefined ? Caml_option.nullable_to_opt(Caml_option.valFromOption(match).getLinkedRecord(currentPath)) : undefined;
+    }
+  }
+  return currentRecord;
+}
+
+function resolveNestedRecordFromRoot(store, path) {
+  if (!path) {
+    return ;
+  }
+  var restPath = path.tl;
+  var rootRecordPath = path.hd;
+  if (restPath) {
+    return resolveNestedRecord(Caml_option.nullable_to_opt(store.getRootField(rootRecordPath)), restPath);
+  }
+  var rootRecord = store.getRootField(rootRecordPath);
+  if (!(rootRecord == null)) {
+    return Caml_option.some(rootRecord);
+  }
+  
+}
+
+function removeNodeFromConnections(store, node, connections) {
+  Belt_List.forEach(connections, (function (connectionConfig) {
+          var owner = store.get(connectionConfig.parentID);
+          if (owner == null) {
+            return ;
+          }
+          var connection = RelayRuntime.ConnectionHandler.getConnection(owner, connectionConfig.key, connectionConfig.filters !== undefined ? Caml_option.valFromOption(connectionConfig.filters) : undefined);
+          if (!(connection == null)) {
+            RelayRuntime.ConnectionHandler.deleteNode(connection, node.getDataID());
+            return ;
+          }
+          
+        }));
+}
+
+function createAndAddEdgeToConnections(store, node, connections, edgeName, insertAt) {
+  Belt_List.forEach(connections, (function (connectionConfig) {
+          var connectionOwner = store.get(connectionConfig.parentID);
+          if (connectionOwner == null) {
+            return ;
+          }
+          var connection = RelayRuntime.ConnectionHandler.getConnection(connectionOwner, connectionConfig.key, connectionConfig.filters !== undefined ? Caml_option.valFromOption(connectionConfig.filters) : undefined);
+          if (connection == null) {
+            return ;
+          }
+          var edge = RelayRuntime.ConnectionHandler.createEdge(store, connection, node, edgeName);
+          if (insertAt === "Start") {
+            RelayRuntime.ConnectionHandler.insertEdgeAfter(connection, edge);
+            return ;
+          }
+          RelayRuntime.ConnectionHandler.insertEdgeBefore(connection, edge);
+        }));
+}
+
+exports.resolveNestedRecord = resolveNestedRecord;
+exports.resolveNestedRecordFromRoot = resolveNestedRecordFromRoot;
+exports.removeNodeFromConnections = removeNodeFromConnections;
+exports.createAndAddEdgeToConnections = createAndAddEdgeToConnections;
+/* relay-runtime Not a pure module */

package/src/RescriptRelayUtils.res

@@ -0,0 +1,89 @@
+open RescriptRelay
+
+let resolveNestedRecord = (
+  ~rootRecord: option<RescriptRelay.RecordProxy.t>,
+  ~path: list<string>,
+) => {
+  let currentRecord = ref(rootRecord)
+  let pathLength = List.length(path)
+
+  switch pathLength {
+  | 0 => ()
+  | _ =>
+    for i in 0 to pathLength - 1 {
+      let currentPath = path->Belt.List.get(i)
+      switch (currentRecord.contents, currentPath) {
+      | (Some(record), Some(currentPath)) =>
+        currentRecord := record->RescriptRelay.RecordProxy.getLinkedRecord(~name=currentPath)
+      | _ => currentRecord := None
+      }
+    }
+  }
+
+  currentRecord.contents
+}
+
+let resolveNestedRecordFromRoot = (~store, ~path: list<string>) =>
+  switch path {
+  | list{} => None
+  | list{rootRecordPath} =>
+    switch store->RescriptRelay.RecordSourceSelectorProxy.getRootField(~fieldName=rootRecordPath) {
+    | Some(rootRecord) => Some(rootRecord)
+    | None => None
+    }
+  | list{rootRecordPath, ...restPath} =>
+    resolveNestedRecord(
+      ~rootRecord=store->RescriptRelay.RecordSourceSelectorProxy.getRootField(
+        ~fieldName=rootRecordPath,
+      ),
+      ~path=restPath,
+    )
+  }
+
+type insertAt =
+  | Start
+  | End
+
+type connectionConfig = {
+  parentID: dataId,
+  key: string,
+  filters: option<RescriptRelay.arguments>,
+}
+
+let removeNodeFromConnections = (~store, ~node, ~connections) =>
+  connections->Belt.List.forEach(connectionConfig =>
+    switch store->RecordSourceSelectorProxy.get(~dataId=connectionConfig.parentID) {
+    | Some(owner) =>
+      switch ConnectionHandler.getConnection(
+        ~record=owner,
+        ~key=connectionConfig.key,
+        ~filters=?connectionConfig.filters,
+      ) {
+      | Some(connection) =>
+        ConnectionHandler.deleteNode(~connection, ~nodeId=node->RecordProxy.getDataId)
+      | None => ()
+      }
+    | None => ()
+    }
+  )
+
+let createAndAddEdgeToConnections = (~store, ~node, ~connections, ~edgeName, ~insertAt) =>
+  connections->Belt.List.forEach(connectionConfig =>
+    switch store->RecordSourceSelectorProxy.get(~dataId=connectionConfig.parentID) {
+    | Some(connectionOwner) =>
+      switch ConnectionHandler.getConnection(
+        ~record=connectionOwner,
+        ~key=connectionConfig.key,
+        ~filters=?connectionConfig.filters,
+      ) {
+      | Some(connection) =>
+        let edge = ConnectionHandler.createEdge(~store, ~connection, ~node, ~edgeType=edgeName)
+        switch insertAt {
+        | Start => ConnectionHandler.insertEdgeAfter(~connection, ~newEdge=edge)
+        | End => ConnectionHandler.insertEdgeBefore(~connection, ~newEdge=edge)
+        }
+      | None => ()
+      }
+    | None => ()
+    }
+  )

package/src/RescriptRelayUtils.resi

@@ -0,0 +1,36 @@
+/**Tries to return a record from a nested path of linked records.*/
+let resolveNestedRecord: (
+  ~rootRecord: option<RescriptRelay.RecordProxy.t>,
+  ~path: list<string>,
+) => option<RescriptRelay.RecordProxy.t>
+
+/**Tries to return a record from a nested path of linked records, starting from the root.*/
+let resolveNestedRecordFromRoot: (
+  ~store: RescriptRelay.RecordSourceSelectorProxy.t,
+  ~path: list<string>,
+) => option<RescriptRelay.RecordProxy.t>
+
+/**Helpers for handling connections.*/
+type insertAt =
+  | Start
+  | End
+
+type connectionConfig = {
+  parentID: RescriptRelay.dataId,
+  key: string,
+  filters: option<RescriptRelay.arguments>,
+}
+
+let removeNodeFromConnections: (
+  ~store: RescriptRelay.RecordSourceSelectorProxy.t,
+  ~node: RescriptRelay.RecordProxy.t,
+  ~connections: list<connectionConfig>,
+) => unit
+
+let createAndAddEdgeToConnections: (
+  ~store: RescriptRelay.RecordSourceSelectorProxy.t,
+  ~node: RescriptRelay.RecordProxy.t,
+  ~connections: list<connectionConfig>,
+  ~edgeName: string,
+  ~insertAt: insertAt,
+) => unit

package/src/RescriptRelay_Fragment.bs.js

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+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 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);
+  return RescriptRelay_Internal.internal_useConvertedValue(convertFragment, __x);
+}
+
+function useFragmentOpt(fRef, node, convertFragment) {
+  var data = ReactRelay.useFragment(node, fRef);
+  return React.useMemo((function () {
+                if (!(data == null)) {
+                  return Caml_option.some(convertFragment(data));
+                }
+                
+              }), [(data == null) ? undefined : Caml_option.some(data)]);
+}
+
+function readInlineData(node, convertFragment, fRef) {
+  return convertFragment(ReactRelay.readInlineData(node, fRef));
+}
+
+function read(node, convertFragment, fRef) {
+  return convertFragment(ResolverFragments.readFragment(node, fRef));
+}
+
+function internal_makeRefetchableFnOpts(fetchPolicy, onComplete, param) {
+  return {
+          fetchPolicy: 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 () {
+                  return function (count, onComplete) {
+                    return p.loadNext(count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [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,
+          isLoadingPrevious: p.isLoadingPrevious,
+          refetch: React.useMemo((function () {
+                  return function (variables, fetchPolicy, onComplete) {
+                    return p.refetch(RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(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 () {
+                  return function (count, onComplete) {
+                    return p.loadNext(count, {
+                                onComplete: RescriptRelay_Internal.internal_nullableToOptionalExnHandler(onComplete)
+                              });
+                  };
+                }), [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,
+          refetch: React.useMemo((function () {
+                  return function (variables, fetchPolicy, onComplete) {
+                    return p.refetch(RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(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 () {
+                  return function (variables, fetchPolicy, onComplete) {
+                    return refetchFn(RescriptRelay_Internal.internal_removeUndefinedAndConvertNullsRaw(convertRefetchVariables(variables)), internal_makeRefetchableFnOpts(fetchPolicy, onComplete, undefined));
+                  };
+                }), [refetchFn])
+        ];
+}
+
+exports.useFragment = useFragment;
+exports.useFragmentOpt = useFragmentOpt;
+exports.readInlineData = readInlineData;
+exports.read = read;
+exports.usePaginationFragment = usePaginationFragment;
+exports.useBlockingPaginationFragment = useBlockingPaginationFragment;
+exports.useRefetchableFragment = useRefetchableFragment;
+/* react Not a pure module */

package/src/RescriptRelay_Fragment.res

@@ -0,0 +1,243 @@
+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)
+}
+
+@module("relay-runtime/lib/store/ResolverFragments")
+external read_: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "readFragment"
+
+let read = (~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.*/
+  (read_(node, fRef)->convertFragment)
+}
+
+type refetchableFnOpts = {
+  fetchPolicy?: fetchPolicy,
+  onComplete?: Js.Nullable.t<Js.Exn.t> => unit,
+}
+
+let internal_makeRefetchableFnOpts = (~fetchPolicy=?, ~onComplete=?, ()) => {
+  ?fetchPolicy,
+  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=?) => 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=?,
+  ) => 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=?,
+  ) => 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/legacy/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],
+    ),
+  )
+}

package/src/RescriptRelay_Fragment.resi

@@ -0,0 +1,85 @@
+open RescriptRelay
+
+let useFragment: (
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef: 'b,
+) => 'fragment
+
+let useFragmentOpt: (
+  ~fRef: option<'a>,
+  ~node: fragmentNode<'b>,
+  ~convertFragment: 'fragment => 'fragment,
+) => option<'fragment>
+
+let readInlineData: (
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef: 'b,
+) => 'fragment
+
+let read: (
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef: 'b,
+) => 'fragment
+
+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> = {
+  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,
+  loadPrevious: paginationLoadMoreFn,
+  hasNext: bool,
+  hasPrevious: bool,
+  isLoadingNext: bool,
+  isLoadingPrevious: bool,
+  refetch: (
+    ~variables: 'refetchVariables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~onComplete: option<Js.Exn.t> => unit=?,
+  ) => Disposable.t,
+}
+
+let usePaginationFragment: (
+  ~node: fragmentNode<'a>,
+  ~fRef: 'b,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+) => paginationFragmentReturn<'fragment, 'refetchVariables>
+
+let useBlockingPaginationFragment: (
+  ~node: fragmentNode<'a>,
+  ~fRef: 'b,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+) => paginationBlockingFragmentReturn<'fragment, 'refetchVariables>
+
+let useRefetchableFragment: (
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~convertRefetchVariables: 'refetchVariables => 'refetchVariables,
+  ~fRef: 'b,
+) => (
+  'fragment,
+  (
+    ~variables: 'refetchVariables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~onComplete: option<Js.Exn.t> => unit=?,
+  ) => Disposable.t,
+)