rescript-relay 0.0.0-autocodesplit-09ee6f6c

package/src/RescriptRelay_Query.res

@@ -0,0 +1,177 @@
+open RescriptRelay
+
+type useQueryConfig = {
+  fetchKey?: string,
+  fetchPolicy?: fetchPolicy,
+  networkCacheConfig?: cacheConfig,
+}
+
+@module("react-relay")
+external useLazyLoadQuery: (queryNode<'node>, 'variables, useQueryConfig) => 'response =
+  "useLazyLoadQuery"
+
+let useQuery = (
+  ~convertVariables: 'variables => 'variables,
+  ~node: 'm,
+  ~convertResponse: 'response => 'response,
+) => {
+  /**
+    React hook for using this query.\n\n\
+                Prefer using `Query.useLoader()` or \
+                `YourQueryName_graphql.load()` in combination with \
+                `Query.usePreloaded()` to this whenever you can, as that will \
+                allow you to start loading data before your code actually \
+                renders.*/
+  (~variables: 'variables, ~fetchPolicy=?, ~fetchKey=?, ~networkCacheConfig=?) => {
+    useLazyLoadQuery(
+      node,
+      RescriptRelay_Internal.internal_cleanObjectFromUndefinedRaw(variables->convertVariables),
+      {
+        ?fetchKey,
+        ?fetchPolicy,
+        ?networkCacheConfig,
+      },
+    )->(RescriptRelay_Internal.internal_useConvertedValue(convertResponse, _))
+  }
+}
+
+type useQueryLoaderOptions = {
+  fetchPolicy?: fetchPolicy,
+  networkCacheConfig?: cacheConfig,
+}
+
+@module("react-relay")
+external useQueryLoader: queryNode<'node> => (
+  Js.Nullable.t<'queryRef>,
+  ('variables, useQueryLoaderOptions) => unit,
+  unit => unit,
+) = "useQueryLoader"
+
+let useLoader = (
+  ~convertVariables: 'variables => 'variables,
+  ~node: 'm,
+  ~mkQueryRef: option<'queryRef> => option<'queryRef>,
+) => {
+  () => {
+    let (nullableQueryRef, loadQueryFn, disposableFn) = useQueryLoader(node)
+    let loadQuery = React.useMemo1(
+      () => (~variables, ~fetchPolicy=?, ~networkCacheConfig=?) =>
+        loadQueryFn(variables->convertVariables, {?fetchPolicy, ?networkCacheConfig}),
+      [loadQueryFn],
+    )
+    (nullableQueryRef->Js.Nullable.toOption->mkQueryRef, loadQuery, disposableFn)
+  }
+}
+
+@module("react-relay")
+external usePreloadedQuery: (queryNode<'node>, 'queryRef) => 'response = "usePreloadedQuery"
+
+let usePreloaded = (
+  ~node,
+  ~convertResponse: 'response => 'response,
+  ~mkQueryRef: 'queryRef => 'queryRef,
+) => /** Combine this with `Query.useLoader` or \
+                `YourQueryName_graphql.load()` to use a query you've started \
+                preloading before rendering. */
+(~queryRef: 'queryRef) => {
+  usePreloadedQuery(node, queryRef->mkQueryRef)->(
+    RescriptRelay_Internal.internal_useConvertedValue(convertResponse, _)
+  )
+}
+
+@module("react-relay")
+external fetchQuery: (
+  Environment.t,
+  queryNode<'node>,
+  'variables,
+  option<fetchQueryOptions>,
+) => Observable.t<'response> = "fetchQuery"
+
+let fetch = (
+  ~node,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => {
+  /**\n\
+                This fetches the query in a one-off fashion, and returns a \
+                `Belt.Result.t` in a callback for convenience. Use \
+                `Query.fetchPromised` if you need this but with promises.\n\n\
+                Please *avoid* using `Query.fetch` unless you really need it, \
+                since the data you fetch here isn't guaranteed to stick around \
+                in the store/cache unless you explicitly use it somewhere in \
+                your views.*/
+  (
+    ~environment: Environment.t,
+    ~variables: 'variables,
+    ~onResult,
+    ~networkCacheConfig=?,
+    ~fetchPolicy=?,
+  ) => {
+    open Observable
+
+    fetchQuery(
+      environment,
+      node,
+      variables->convertVariables,
+      Some({?networkCacheConfig, ?fetchPolicy}),
+    )
+    ->subscribe(
+      makeObserver(
+        ~next=res => onResult(Ok(res->convertResponse)),
+        ~error=err => onResult(Error(err)),
+      ),
+    )
+    ->ignoreSubscription
+  }
+}
+
+let fetchPromised = (
+  ~node,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => {
+  /**Promise variant of `Query.fetch`.*/
+  (~environment: Environment.t, ~variables: 'variables, ~networkCacheConfig=?, ~fetchPolicy=?) => {
+    fetchQuery(
+      environment,
+      node,
+      variables->convertVariables,
+      Some({?networkCacheConfig, ?fetchPolicy}),
+    )
+    ->Observable.toPromise
+    ->Js.Promise2.then(res => res->convertResponse->Js.Promise2.resolve)
+  }
+}
+
+@module("relay-runtime")
+external createOperationDescriptor: (queryNode<'node>, 'variables) => operationDescriptor =
+  "createOperationDescriptor"
+
+let retain = (~node, ~convertVariables: 'variables => 'variables) => {
+  /**Calling with a set of variables will make Relay _disable \
+                garbage collection_ of this query (+ variables) until you \
+                explicitly dispose the `Disposable.t` you get back from this \
+                call.\n\n\
+                Useful for queries and data you know you want to keep in the \
+                store regardless of what happens (like it not being used by \
+                any view and therefore potentially garbage collected).*/
+  (~environment: Environment.t, ~variables: 'variables) => {
+    environment->Environment.retain(createOperationDescriptor(node, variables->convertVariables))
+  }
+}
+
+let commitLocalPayload = (
+  ~node,
+  ~convertVariables: 'variables => 'variables,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => {
+  /** This commits a payload into the store _locally only_. Useful \
+                  for driving client-only state via Relay for example, or \
+                  priming the cache with data you don't necessarily want to \
+                  hit the server for. */
+  (~environment: Environment.t, ~variables: 'variables, ~payload: 'rawResponse) =>
+    environment->Environment.commitPayload(
+      createOperationDescriptor(node, variables->convertVariables),
+      payload->convertWrapRawResponse,
+    )
+}

package/src/RescriptRelay_Query.resi

@@ -0,0 +1,62 @@
+open RescriptRelay
+
+let useQuery: (
+  ~convertVariables: 'variables => 'variables,
+  ~node: queryNode<'a>,
+  ~convertResponse: 'response => 'response,
+) => (
+  ~variables: 'variables,
+  ~fetchPolicy: fetchPolicy=?,
+  ~fetchKey: string=?,
+  ~networkCacheConfig: cacheConfig=?,
+) => 'response
+
+let useLoader: (
+  ~convertVariables: 'variables => 'variables,
+  ~node: queryNode<'a>,
+  ~mkQueryRef: option<'queryRef> => option<'queryRef>,
+) => unit => (
+  option<'queryRef>,
+  (~variables: 'variables, ~fetchPolicy: fetchPolicy=?, ~networkCacheConfig: cacheConfig=?) => unit,
+  unit => unit,
+)
+
+let usePreloaded: (
+  ~node: queryNode<'a>,
+  ~convertResponse: 'response => 'response,
+  ~mkQueryRef: 'queryRef => 'queryRef,
+) => (~queryRef: 'queryRef) => 'response
+
+let fetch: (
+  ~node: queryNode<'a>,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => (
+  ~environment: Environment.t,
+  ~variables: 'variables,
+  ~onResult: result<'response, Js.Exn.t> => unit,
+  ~networkCacheConfig: cacheConfig=?,
+  ~fetchPolicy: fetchPolicy=?,
+) => unit
+
+let fetchPromised: (
+  ~node: queryNode<'a>,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => (
+  ~environment: Environment.t,
+  ~variables: 'variables,
+  ~networkCacheConfig: cacheConfig=?,
+  ~fetchPolicy: fetchPolicy=?,
+) => promise<'response>
+
+let retain: (
+  ~node: queryNode<'a>,
+  ~convertVariables: 'variables => 'variables,
+) => (~environment: Environment.t, ~variables: 'variables) => Disposable.t
+
+let commitLocalPayload: (
+  ~node: queryNode<'a>,
+  ~convertVariables: 'variables => 'variables,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) => (~environment: Environment.t, ~variables: 'variables, ~payload: 'rawResponse) => unit

package/src/RescriptRelay_RelayResolvers.bs.js

@@ -0,0 +1,13 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var ResolverFragments = require("relay-runtime/lib/store/ResolverFragments");
+
+function makeRelayResolver(node, convertFragment, resolver) {
+  return function (fRef) {
+    return resolver(convertFragment(ResolverFragments.readFragment(node, fRef)));
+  };
+}
+
+exports.makeRelayResolver = makeRelayResolver;
+/* relay-runtime/lib/store/ResolverFragments Not a pure module */

package/src/RescriptRelay_RelayResolvers.res

@@ -0,0 +1,21 @@
+open RescriptRelay
+
+@module("relay-runtime/lib/store/ResolverFragments")
+external readFragment_: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "readFragment"
+
+type resolver<'fragment, 't> = 'fragment => option<'t>
+
+// This is abstract just to hide the implementation details that don't need to be known anyway.
+type relayResolver
+external mkRelayResolver: 'a => relayResolver = "%identity"
+
+let makeRelayResolver = (
+  ~node,
+  ~convertFragment: 'fragment => 'fragment,
+  resolver: resolver<'fragment, 't>,
+) => {
+  let relayResolver = fRef => {
+    resolver(readFragment_(node, fRef)->convertFragment)
+  }
+  relayResolver->mkRelayResolver
+}

package/src/RescriptRelay_RelayResolvers.resi

@@ -0,0 +1,10 @@
+open RescriptRelay
+
+type resolver<'fragment, 't> = 'fragment => option<'t>
+type relayResolver
+
+let makeRelayResolver: (
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  resolver<'fragment, 't>,
+) => relayResolver

package/src/RescriptRelay_Subscriptions.bs.js

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var RelayRuntime = require("relay-runtime");
+
+function subscribe(node, convertVariables, convertResponse) {
+  return function (environment, variables, onCompleted, onError, onNext, updater) {
+    return RelayRuntime.requestSubscription(environment, {
+                subscription: node,
+                variables: convertVariables(variables),
+                onCompleted: onCompleted,
+                onError: onError,
+                onNext: onNext !== undefined ? (function (response) {
+                      onNext(convertResponse(response));
+                    }) : undefined,
+                updater: updater !== undefined ? (function (store, response) {
+                      updater(store, convertResponse(response));
+                    }) : undefined
+              });
+  };
+}
+
+exports.subscribe = subscribe;
+/* relay-runtime Not a pure module */

package/src/RescriptRelay_Subscriptions.res

@@ -0,0 +1,50 @@
+open RescriptRelay
+
+type updaterFn<'response> = (RecordSourceSelectorProxy.t, 'response) => unit
+type subscriptionConfig<'node, 'variables, 'response> = {
+  subscription: subscriptionNode<'node>,
+  variables: 'variables,
+  onCompleted?: unit => unit,
+  onError?: Js.Exn.t => unit,
+  onNext?: 'response => unit,
+  updater?: updaterFn<'response>,
+}
+
+@module("relay-runtime")
+external requestSubscription_: (
+  Environment.t,
+  subscriptionConfig<'node, 'variables, 'response>,
+) => Disposable.t = "requestSubscription"
+
+let subscribe = (
+  ~node,
+  ~convertVariables: 'variables => 'variables,
+  ~convertResponse: 'response => 'response,
+) => {
+  (
+    ~environment: Environment.t,
+    ~variables: 'variables,
+    ~onCompleted=?,
+    ~onError=?,
+    ~onNext=?,
+    ~updater=?,
+  ) => {
+    requestSubscription_(
+      environment,
+      {
+        ?onCompleted,
+        subscription: node,
+        variables: variables->convertVariables,
+        ?onError,
+        onNext: ?switch onNext {
+        | Some(onNext) => Some(response => onNext(response->convertResponse))
+        | None => None
+        },
+        updater: ?switch updater {
+        | Some(updater) => Some((store, response) => updater(store, response->convertResponse))
+        | None => None
+        },
+      },
+    )
+  }
+}

package/src/RescriptRelay_Subscriptions.resi

@@ -0,0 +1,14 @@
+open RescriptRelay
+
+let subscribe: (
+  ~node: subscriptionNode<'a>,
+  ~convertVariables: 'variables => 'variables,
+  ~convertResponse: 'response => 'response,
+) => (
+  ~environment: Environment.t,
+  ~variables: 'variables,
+  ~onCompleted: unit => unit=?,
+  ~onError: Js.Exn.t => unit=?,
+  ~onNext: 'response => unit=?,
+  ~updater: (RecordSourceSelectorProxy.t, 'response) => unit=?,
+) => Disposable.t