rescript-relay 0.0.0-autocodesplit-09ee6f6c

package/src/RescriptRelay_Internal.bs.js

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var React = require("react");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+
+function internal_keepMapFieldsRaw(record, f) {
+  return Belt_Option.map(record, (function (obj) {
+                return Js_dict.fromArray(Belt_Array.keepMap(Js_dict.entries(obj), f));
+              }));
+}
+
+function internal_cleanObjectFromUndefinedRaw(record) {
+  var v = internal_keepMapFieldsRaw(record, (function (param) {
+          var value = param[1];
+          if (value !== undefined) {
+            return [
+                    param[0],
+                    Caml_option.valFromOption(value)
+                  ];
+          }
+          
+        }));
+  if (v !== undefined) {
+    return Caml_option.valFromOption(v);
+  } else {
+    return {};
+  }
+}
+
+function internal_removeUndefinedAndConvertNullsRaw(record) {
+  return internal_keepMapFieldsRaw(record, (function (param) {
+                var value = param[1];
+                var key = param[0];
+                var match = Caml_obj.equal(value, Caml_option.some(undefined));
+                if (value !== undefined) {
+                  return [
+                          key,
+                          Caml_option.valFromOption(value)
+                        ];
+                } else if (match) {
+                  return [
+                          key,
+                          null
+                        ];
+                } else {
+                  return ;
+                }
+              }));
+}
+
+function internal_useConvertedValue(convert, v) {
+  return React.useMemo((function () {
+                return convert(v);
+              }), [v]);
+}
+
+function internal_nullableToOptionalExnHandler(x) {
+  if (x !== undefined) {
+    return (function (maybeExn) {
+              return x((maybeExn == null) ? undefined : Caml_option.some(maybeExn));
+            });
+  }
+  
+}
+
+var unwrapUnion = (function unwrapUnion(union, members) {
+    if (union != null && members.indexOf(union.__typename) === -1) { 
+      return Object.assign({}, union, {__typename: "__unselected"});
+    }
+
+    return union;
+  });
+
+function wrapUnion(union) {
+  return union;
+}
+
+var applyCodesplitMetadata = (function applyCodesplitMetadata(node, meta) {
+    if (node != null && node.params != null) {
+      let metadata = node.params.metadata;
+      if (metadata == null) {
+        node.params.metadata = {codesplits: meta}
+      } else if (typeof metadata === "object") {
+        node.params.metadata.codesplits = meta
+      }
+    }
+    return node;
+  });
+
+exports.internal_useConvertedValue = internal_useConvertedValue;
+exports.internal_cleanObjectFromUndefinedRaw = internal_cleanObjectFromUndefinedRaw;
+exports.internal_removeUndefinedAndConvertNullsRaw = internal_removeUndefinedAndConvertNullsRaw;
+exports.internal_nullableToOptionalExnHandler = internal_nullableToOptionalExnHandler;
+exports.unwrapUnion = unwrapUnion;
+exports.wrapUnion = wrapUnion;
+exports.applyCodesplitMetadata = applyCodesplitMetadata;
+/* react Not a pure module */

package/src/RescriptRelay_Internal.res

@@ -0,0 +1,71 @@
+let internal_keepMapFieldsRaw = (record, f) =>
+  record
+  ->Obj.magic
+  ->Belt.Option.map(obj => obj->Js.Dict.entries->Belt.Array.keepMap(f)->Js.Dict.fromArray)
+  ->Obj.magic
+
+// we need to do this until we can use @obj on record types
+// see https://github.com/rescript-lang/rescript-compiler/pull/5253
+let internal_cleanObjectFromUndefinedRaw = record =>
+  switch internal_keepMapFieldsRaw(record, ((key, value)) => {
+    switch value {
+    | Some(value) => Some((key, value))
+    | None => None
+    }
+  }) {
+  | None => /* Relay expects an empty object, not undefined */ %raw(json`{}`)
+  | Some(v) => v
+  }
+
+let internal_removeUndefinedAndConvertNullsRaw = record =>
+  internal_keepMapFieldsRaw(record, ((key, value)) => {
+    switch (value, value == Some(None)) {
+    | (Some(value), _) => Some((key, Js.Nullable.return(value)))
+    | (_, true) => Some((key, Js.Nullable.null))
+    | (None, _) => None
+    }
+  })
+
+let internal_useConvertedValue = (convert, v) => React.useMemo1(() => convert(v), [v])
+
+let internal_nullableToOptionalExnHandler = x =>
+  switch x {
+  | None => None
+  | Some(handler) => Some(maybeExn => maybeExn->Js.Nullable.toOption->handler)
+  }
+
+@live @unboxed type rec arg = Arg(_): arg
+
+let unwrapUnion: ('a, array<string>) => 'a = %raw(`
+  function unwrapUnion(union, members) {
+    if (union != null && members.indexOf(union.__typename) === -1) { 
+      return Object.assign({}, union, {__typename: "__unselected"});
+    }
+
+    return union;
+  }
+`)
+
+let wrapUnion = union => union
+
+external internal_resolverFragmentRefsToFragmentRefs: RescriptRelay.resolverFragmentRefs<
+  'a,
+> => RescriptRelay.fragmentRefs<'a> = "%identity"
+
+external internal_resolverFragmentRefsToFragmentRefsPlural: RescriptRelay.resolverFragmentRefs<
+  'a,
+> => array<RescriptRelay.fragmentRefs<'a>> = "%identity"
+
+let applyCodesplitMetadata: ('node, array<(string, dict<Js.Json.t> => unit)>) => 'node = %raw(`
+  function applyCodesplitMetadata(node, meta) {
+    if (node != null && node.params != null) {
+      let metadata = node.params.metadata;
+      if (metadata == null) {
+        node.params.metadata = {codesplits: meta}
+      } else if (typeof metadata === "object") {
+        node.params.metadata.codesplits = meta
+      }
+    }
+    return node;
+  }
+`)

package/src/RescriptRelay_Internal.resi

@@ -0,0 +1,20 @@
+let internal_useConvertedValue: ('a => 'a, 'a) => 'a
+let internal_cleanObjectFromUndefinedRaw: 't => 't
+let internal_removeUndefinedAndConvertNullsRaw: 't => 't
+let internal_nullableToOptionalExnHandler: option<option<'b> => 'a> => option<
+  Js.Nullable.t<'b> => 'a,
+>
+@live @unboxed type rec arg = Arg(_): arg
+
+let unwrapUnion: ('a, array<string>) => 'a
+let wrapUnion: 'a => 'a
+
+external internal_resolverFragmentRefsToFragmentRefs: RescriptRelay.resolverFragmentRefs<
+  'a,
+> => RescriptRelay.fragmentRefs<'a> = "%identity"
+
+external internal_resolverFragmentRefsToFragmentRefsPlural: RescriptRelay.resolverFragmentRefs<
+  'a,
+> => array<RescriptRelay.fragmentRefs<'a>> = "%identity"
+
+let applyCodesplitMetadata: ('node, array<(string, dict<Js.Json.t> => unit)>) => 'node

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) {
+    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) {
+                      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,144 @@
+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,52 @@
+/*** 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=?,
+) => 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=?,
+  ) => Disposable.t,
+  bool,
+)

package/src/RescriptRelay_Query.bs.js

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var React = require("react");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Js_promise2 = require("rescript/lib/js/js_promise2.js");
+var ReactRelay = require("react-relay");
+var RelayRuntime = require("relay-runtime");
+var RescriptRelay_Internal = require("./RescriptRelay_Internal.bs.js");
+
+function useQuery(convertVariables, node, convertResponse) {
+  return function (variables, fetchPolicy, fetchKey, networkCacheConfig) {
+    var __x = ReactRelay.useLazyLoadQuery(node, RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(convertVariables(variables)), {
+          fetchKey: fetchKey,
+          fetchPolicy: fetchPolicy,
+          networkCacheConfig: networkCacheConfig
+        });
+    return RescriptRelay_Internal.internal_useConvertedValue(convertResponse, __x);
+  };
+}
+
+function useLoader(convertVariables, node, mkQueryRef) {
+  return function () {
+    var match = ReactRelay.useQueryLoader(node);
+    var loadQueryFn = match[1];
+    var loadQuery = React.useMemo((function () {
+            return function (variables, fetchPolicy, networkCacheConfig) {
+              loadQueryFn(convertVariables(variables), {
+                    fetchPolicy: fetchPolicy,
+                    networkCacheConfig: networkCacheConfig
+                  });
+            };
+          }), [loadQueryFn]);
+    return [
+            mkQueryRef(Caml_option.nullable_to_opt(match[0])),
+            loadQuery,
+            match[2]
+          ];
+  };
+}
+
+function usePreloaded(node, convertResponse, mkQueryRef) {
+  return function (queryRef) {
+    var __x = ReactRelay.usePreloadedQuery(node, mkQueryRef(queryRef));
+    return RescriptRelay_Internal.internal_useConvertedValue(convertResponse, __x);
+  };
+}
+
+function $$fetch(node, convertResponse, convertVariables) {
+  return function (environment, variables, onResult, networkCacheConfig, fetchPolicy) {
+    ReactRelay.fetchQuery(environment, node, convertVariables(variables), {
+            networkCacheConfig: networkCacheConfig,
+            fetchPolicy: fetchPolicy
+          }).subscribe({
+          next: (function (res) {
+              onResult({
+                    TAG: "Ok",
+                    _0: convertResponse(res)
+                  });
+            }),
+          error: (function (err) {
+              onResult({
+                    TAG: "Error",
+                    _0: err
+                  });
+            })
+        });
+  };
+}
+
+function fetchPromised(node, convertResponse, convertVariables) {
+  return function (environment, variables, networkCacheConfig, fetchPolicy) {
+    return Js_promise2.then(ReactRelay.fetchQuery(environment, node, convertVariables(variables), {
+                      networkCacheConfig: networkCacheConfig,
+                      fetchPolicy: fetchPolicy
+                    }).toPromise(), (function (res) {
+                  return Promise.resolve(convertResponse(res));
+                }));
+  };
+}
+
+function retain(node, convertVariables) {
+  return function (environment, variables) {
+    return environment.retain(RelayRuntime.createOperationDescriptor(node, convertVariables(variables)));
+  };
+}
+
+function commitLocalPayload(node, convertVariables, convertWrapRawResponse) {
+  return function (environment, variables, payload) {
+    environment.commitPayload(RelayRuntime.createOperationDescriptor(node, convertVariables(variables)), convertWrapRawResponse(payload));
+  };
+}
+
+exports.useQuery = useQuery;
+exports.useLoader = useLoader;
+exports.usePreloaded = usePreloaded;
+exports.$$fetch = $$fetch;
+exports.fetchPromised = fetchPromised;
+exports.retain = retain;
+exports.commitLocalPayload = commitLocalPayload;
+/* react Not a pure module */