rescript-relay 1.1.1 → 2.0.0-alpha.0

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?: 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=?,
+  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")
+external useBlockingPaginationFragment_: (
+  fragmentNode<'node>,
+  'fragmentRef,
+) => paginationFragmentReturnRaw<'fragment, 'refetchVariables> = "useBlockingPaginationFragment"
+
+/** 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,86 @@
+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
+
+type paginationLoadMoreOptions = {onComplete?: Js.Nullable.t<Js.Exn.t> => unit}
+
+type paginationLoadMoreFn = (
+  ~count: int,
+  ~onComplete: option<Js.Exn.t> => unit=?,
+  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=?,
+    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,
+}
+
+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=?,
+    unit,
+  ) => Disposable.t,
+)

package/src/RescriptRelay_Internal.bs.js

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
-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");
@@ -56,14 +55,14 @@ function internal_removeUndefinedAndConvertNullsRaw(record) {
 
 function internal_useConvertedValue(convert, v) {
   return React.useMemo((function () {
-                return Curry._1(convert, v);
+                return convert(v);
               }), [v]);
 }
 
 function internal_nullableToOptionalExnHandler(x) {
   if (x !== undefined) {
     return (function (maybeExn) {
-              return Curry._1(x, (maybeExn == null) ? undefined : Caml_option.some(maybeExn));
+              return x((maybeExn == null) ? undefined : Caml_option.some(maybeExn));
             });
   }
   

package/src/RescriptRelay_Mutation.bs.js

@@ -0,0 +1,57 @@
+// 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 RelayRuntime = require("relay-runtime");
+
+function commitMutation(convertVariables, node, convertResponse, convertWrapRawResponse) {
+  return function (environment, variables, optimisticUpdater, optimisticResponse, updater, onCompleted, onError, uploadables, param) {
+    return RelayRuntime.commitMutation(environment, {
+                mutation: node,
+                variables: convertVariables(variables),
+                onCompleted: onCompleted !== undefined ? (function (res, err) {
+                      onCompleted(convertResponse(res), (err == null) ? undefined : Caml_option.some(err));
+                    }) : undefined,
+                onError: onError,
+                optimisticResponse: optimisticResponse !== undefined ? Caml_option.some(convertWrapRawResponse(Caml_option.valFromOption(optimisticResponse))) : undefined,
+                optimisticUpdater: optimisticUpdater,
+                updater: updater !== undefined ? (function (store, response) {
+                      updater(store, convertResponse(response));
+                    }) : undefined,
+                uploadables: uploadables
+              });
+  };
+}
+
+function useMutation(convertVariables, node, convertResponse, convertWrapRawResponse) {
+  return function () {
+    var match = ReactRelay.useMutation(node);
+    var mutate = match[0];
+    return [
+            React.useMemo((function () {
+                    return function (variables, optimisticUpdater, optimisticResponse, updater, onCompleted, onError, uploadables, param) {
+                      return mutate({
+                                  onError: onError,
+                                  onCompleted: onCompleted !== undefined ? (function (res, err) {
+                                        onCompleted(convertResponse(res), (err == null) ? undefined : Caml_option.some(err));
+                                      }) : undefined,
+                                  optimisticResponse: optimisticResponse !== undefined ? Caml_option.some(convertWrapRawResponse(Caml_option.valFromOption(optimisticResponse))) : undefined,
+                                  optimisticUpdater: optimisticUpdater,
+                                  updater: updater !== undefined ? (function (store, response) {
+                                        updater(store, convertResponse(response));
+                                      }) : undefined,
+                                  variables: convertVariables(variables),
+                                  uploadables: uploadables
+                                });
+                    };
+                  }), [mutate]),
+            match[1]
+          ];
+  };
+}
+
+exports.commitMutation = commitMutation;
+exports.useMutation = useMutation;
+/* react Not a pure module */

package/src/RescriptRelay_Mutation.res

@@ -0,0 +1,146 @@
+open RescriptRelay
+
+type updaterFn<'response> = (RecordSourceSelectorProxy.t, 'response) => unit
+type optimisticUpdaterFn = RecordSourceSelectorProxy.t => unit
+type useMutationConfig<'response, 'rawResponse, 'variables> = {
+  onError?: mutationError => unit,
+  onCompleted?: ('response, option<array<mutationError>>) => unit,
+  onUnsubscribe?: unit => unit,
+  optimisticResponse?: 'rawResponse,
+  optimisticUpdater?: optimisticUpdaterFn,
+  updater?: updaterFn<'response>,
+  variables: 'variables,
+  uploadables?: uploadables,
+}
+
+type commitMutationConfigRaw<'m, 'variables, 'response, 'rawResponse> = {
+  mutation: mutationNode<'m>,
+  variables: 'variables,
+  onCompleted?: ('response, Js.Nullable.t<array<mutationError>>) => unit,
+  onError?: mutationError => unit,
+  optimisticResponse?: 'rawResponse,
+  optimisticUpdater?: optimisticUpdaterFn,
+  updater?: updaterFn<'response>,
+  uploadables?: uploadables,
+}
+
+type useMutationConfigRaw<'m, 'variables, 'response, 'rawResponse> = {
+  onError?: mutationError => unit,
+  onCompleted?: ('response, Js.Nullable.t<array<mutationError>>) => unit,
+  onUnsubscribe?: unit => unit,
+  optimisticResponse?: 'rawResponse,
+  optimisticUpdater?: optimisticUpdaterFn,
+  updater?: updaterFn<'response>,
+  variables: 'variables,
+  uploadables?: uploadables,
+}
+
+@module("relay-runtime")
+external commitMutation_: (
+  Environment.t,
+  commitMutationConfigRaw<'m, 'variables, 'response, 'rawResponse>,
+) => Disposable.t = "commitMutation"
+
+@module("react-relay")
+external useMutation_: 'm => (
+  useMutationConfigRaw<'m, 'variables, 'response, 'rawResponse> => Disposable.t,
+  bool,
+) = "useMutation"
+
+let commitMutation = (
+  ~convertVariables: 'variables => 'variables,
+  ~node: 'm,
+  ~convertResponse: 'response => 'response,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => {
+  /**Commits the current mutation. Use this outside of React's \
+               render. If you're inside render, you should use `Mutation.use` \
+               instead, which is more convenient.\n\n\
+               ### Optimistic updates\n\
+               Remember to annotate your mutation with `@raw_response_type` if \
+               you want to do optimistic updates. That'll make Relay emit the \
+               required type information for covering everything needed when \
+               doing optimistic updates.*/
+  (
+    ~environment: Environment.t,
+    ~variables: 'variables,
+    ~optimisticUpdater=?,
+    ~optimisticResponse: option<'rawResponse>=?,
+    ~updater=?,
+    ~onCompleted=?,
+    ~onError=?,
+    ~uploadables=?,
+    (),
+  ) => {
+    commitMutation_(
+      environment,
+      {
+        mutation: node,
+        onCompleted: ?switch onCompleted {
+        | Some(cb) => Some((res, err) => cb(res->convertResponse, err->Js.Nullable.toOption))
+        | None => None
+        },
+        ?onError,
+        optimisticResponse: ?switch optimisticResponse {
+        | Some(optimisticResponse) => Some(optimisticResponse->convertWrapRawResponse)
+        | None => None
+        },
+        ?optimisticUpdater,
+        updater: ?switch updater {
+        | Some(updater) => Some((store, response) => updater(store, response->convertResponse))
+        | None => None
+        },
+        ?uploadables,
+        variables: variables->convertVariables,
+      },
+    )
+  }
+}
+
+let useMutation = (
+  ~convertVariables: 'variables => 'variables,
+  ~node: 'm,
+  ~convertResponse: 'response => 'response,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => {
+  /**React hook for commiting this mutation.\n\n\
+               ### Optimistic updates\n\
+               Remember to annotate your mutation with `@raw_response_type` if \
+               you want to do optimistic updates. That'll make Relay emit the \
+               required type information for covering everything needed when \
+               doing optimistic updates.*/
+  () => {
+    let (mutate, mutating) = useMutation_(node)
+    (React.useMemo1(() => {
+        (
+          ~variables: 'variables,
+          ~optimisticUpdater=?,
+          ~optimisticResponse: option<'rawResponse>=?,
+          ~updater=?,
+          ~onCompleted=?,
+          ~onError=?,
+          ~uploadables=?,
+          (),
+        ) => {
+          mutate({
+            onCompleted: ?switch onCompleted {
+            | Some(cb) => Some((res, err) => cb(res->convertResponse, err->Js.Nullable.toOption))
+            | None => None
+            },
+            ?onError,
+            optimisticResponse: ?switch optimisticResponse {
+            | Some(optimisticResponse) => Some(optimisticResponse->convertWrapRawResponse)
+            | None => None
+            },
+            ?optimisticUpdater,
+            updater: ?switch updater {
+            | Some(updater) => Some((store, response) => updater(store, response->convertResponse))
+            | None => None
+            },
+            ?uploadables,
+            variables: variables->convertVariables,
+          })
+        }
+      }, [mutate]), mutating)
+  }
+}

package/src/RescriptRelay_Mutation.resi

@@ -0,0 +1,54 @@
+/*** Internal file, do not use directly.*/
+
+open RescriptRelay
+
+type updaterFn<'response> = (RecordSourceSelectorProxy.t, 'response) => unit
+type optimisticUpdaterFn = RecordSourceSelectorProxy.t => unit
+
+@live
+type useMutationConfig<'response, 'rawResponse, 'variables> = {
+  onError?: mutationError => unit,
+  onCompleted?: ('response, option<array<mutationError>>) => unit,
+  onUnsubscribe?: unit => unit,
+  optimisticResponse?: 'rawResponse,
+  optimisticUpdater?: optimisticUpdaterFn,
+  updater?: updaterFn<'response>,
+  variables: 'variables,
+  uploadables?: uploadables,
+}
+
+let commitMutation: (
+  ~convertVariables: 'variables => 'variables,
+  ~node: mutationNode<'a>,
+  ~convertResponse: 'response => 'response,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => (
+  ~environment: Environment.t,
+  ~variables: 'variables,
+  ~optimisticUpdater: optimisticUpdaterFn=?,
+  ~optimisticResponse: 'rawResponse=?,
+  ~updater: (RecordSourceSelectorProxy.t, 'response) => unit=?,
+  ~onCompleted: ('response, option<array<mutationError>>) => unit=?,
+  ~onError: mutationError => unit=?,
+  ~uploadables: uploadables=?,
+  unit,
+) => Disposable.t
+
+let useMutation: (
+  ~convertVariables: 'variables => 'variables,
+  ~node: mutationNode<'node>,
+  ~convertResponse: 'response => 'response,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => unit => (
+  (
+    ~variables: 'variables,
+    ~optimisticUpdater: optimisticUpdaterFn=?,
+    ~optimisticResponse: 'rawResponse=?,
+    ~updater: (RecordSourceSelectorProxy.t, 'response) => unit=?,
+    ~onCompleted: ('response, option<array<mutationError>>) => unit=?,
+    ~onError: mutationError => unit=?,
+    ~uploadables: uploadables=?,
+    unit,
+  ) => Disposable.t,
+  bool,
+)