reason-apollo-hooks

Reason bindings for the official @apollo/react-hooks

Installation

yarn add reason-apollo-hooks reason-apollo @apollo/react-hooks

Follow the installation instructions of graphql_ppx.

Then update your bsconfig.json

"bs-dependencies": [
  ...
+ "reason-apollo-hooks",
+ "reason-apollo"
]

Setting up

Add the provider in the top of the tree

/* Create an InMemoryCache */
let inMemoryCache = ApolloInMemoryCache.createInMemoryCache();

/* Create an HTTP Link */
let httpLink =
  ApolloLinks.createHttpLink(~uri="http://localhost:3010/graphql", ());

let client =
  ReasonApollo.createApolloClient(~link=httpLink, ~cache=inMemoryCache, ());

let app =
 <ReasonApolloHooks.ApolloProvider client>
   ...
 </ReasonApolloHooks.ApolloProvider>

Usage with reason-apollo

To use with reason-apollo's ReasonApollo.Provider already present in your project:

let client = ... // create Apollo client

ReactDOMRe.renderToElementWithId(
  <ReasonApollo.Provider client>
    <ReasonApolloHooks.ApolloProvider client>
      <App />
    </ReasonApolloHooks.ApolloProvider>
  </ReasonApollo.Provider>,
  "root",
);

Available hooks

useQuery

module UserQueryConfig = [%graphql {|
  query UserQuery {
    currentUser {
      name
    }
  }
|}];

module UserQuery = ReasonApolloHooks.Query.Make(UserQueryConfig);

[@react.component]
let make = () => {
  /* Both variant and records available */
  let (simple, _full) = UserQuery.use();

  <div>
  {
    switch(simple) {
      | Loading => <p>{React.string("Loading...")}</p>
      | Data(data) =>
        <p>{React.string(data##currentUser##name)}</p>
      | NoData
      | Error(_) => <p>{React.string("Get off my lawn!")}</p>
    }
  }
  </div>
}

Using the full record for more advanced cases

[@react.component]
let make = () => {
  /* Both variant and records available */
  let (_simple, full) = UserQuery.use(());

  <div>
  {
    switch(full) {
      | { loading: true }=> <p>{React.string("Loading...")}</p>
      | { data: Some(data) } =>
        <p>{React.string(data##currentUser##name)}</p>
      | any other possibilities =>
      | { error: Some(_) } => <p>{React.string("Get off my lawn!")}</p>
    }
  }
  </div>
}

Using fetchPolicy to change interactions with the apollo cache, see apollo docs.

let (_simple, full) = UserQuery.use(~fetchPolicy=NetworkOnly, ());

useMutation

module ScreamMutationConfig = [%graphql {|
  mutation ScreamMutation($screamLevel: Int!) {
    scream(level: $screamLevel) {
      error
    }
  }
|}];

module ScreamMutation = ReasonApolloHooks.Mutation.Make(ScreamMutationConfig);

[@react.component]
let make = () => {
  /* Both variant and records available */
  let ( screamMutation, _simple, _full ) = ScreamMutation.use();
  let scream = (_) => {
    screamMutation(
      ~variables=ScreamMutationConfig.make(~screamLevel=10, ())##variables,
      ()
    )
      |> Js.Promise.then_(result => {
          switch(result) {
            | Data(data) => ...
            | Error(error) => ...
            | NoData => ...
          }
          Js.Promise.resolve()
        })
      |> ignore
  }

  <div>
    <button onClick={scream}>
      {React.string("You kids get off my lawn!")}
    </button>
  </div>
}

Cache

There are a couple of caveats with manual cache updates.

TL;DR

If you need to remove items from cached data, it is enough to just filter them out and save the result into cache as is.
If you need to add the result of a mutation to a list of items with the same shape, you simply concat it with the list and save into cache as it.
When you need to update a field, you have to resort to raw javascript to use spread operator on Js.t object in order to preserve __typename that apollo adds to all queries by default.

An example of cache update could look like this:

module PersonsQueryConfig = [%graphql
{|
  query getAllPersons  {
    allPersons  {
      id
      age
      name
    }
  }
|}
];

module PersonsQuery = ReasonApolloHooks.Query.Make(PersonsQueryConfig);

module PersonsReadQuery = ApolloClient.ReadQuery(PersonsQueryConfig);
module PersonsWriteQuery = ApolloClient.WriteQuery(PersonsQueryConfig);

external cast: Js.Json.t => PersonsQueryConfig.t = "%identity";

let updatePersons = (~client, ~name, ~age) => {
  let query = PersonsQueryConfig.make();
  let readQueryOptions = ReasonApolloHooks.Utils.toReadQueryOptions(query);

  // can throw exception of cache is empty
  switch (PersonsReadQuery.readQuery(client, readQueryOptions)) {
  | exception _ => ()
  | cachedResponse =>
    switch (cachedResponse |> Js.Nullable.toOption) {
    | None => ()
    | Some(cachedPersons) =>
      // readQuery will return unparsed data with __typename field, need to cast it since
      // it has type Json.t, but we know it will have the same type as PersonsReadQuery.t
      let persons = cast(cachedPersons);

      // to remove items, simply filter them out
      let updatedPersons = {
        "allPersons":
          Belt.Array.keep(persons##allPersons, person => person##age !== age),
      };

      // when updating items, __typename must be preserved, but since it is not a record,
      // can't use spread, so use JS to update items
      let updatedPersons = {
        "allPersons":
          Belt.Array.map(persons##allPersons, person =>
            person##name === name ? [%bs.raw {| {...person, age } |}] : person
          ),
      };

      PersonsWriteQuery.make(
        ~client,
        ~variables=query##variables,
        ~data=updatedPersons,
        (),
      );
    }
  };
};

reason-apollo-hooks parses response data from a query or mutation using parse function created by graphql_ppx. For example, when using @bsRecord directive, the response object will be parsed from a Js.t object to a reason record. In this case, the response data in reason code is not the same object that is stored in cache, since react-apollo saves data in cache before it is parsed and returned to the component. However, when updating cache, the data must be in the same format or apollo cache won't work correctly and throw errors.

If using directives like @bsRecord, @bsDecoder or @bsVariant in graphql_ppx, the data needs to be serialized back to JS object before it is written in cache. Since there is currently no way to serialize this data (see this issue in graphql_ppx), queries that will be updated in cache shouldn't use any of those directive, unless you will take care of the serialization yourself.

By default, apollo will add field __typename to the queries and will use it to normalize data and manipulate cache (see normalization). This field won't exist on parsed reason objects, since it is not included in the actual query you write, but is added by apollo before sending the query. Since __typename is crucial for the cache to work correctly, we need to read data from cache in its raw unparsed format, which is achieved with readQuery from ApolloClient.ReadQuery defined in reason-apollo.

Getting it running

npm install
npm start

lukashambsch/reason-apollo-hooks