reason-apollo-client instead

reason-apollo-hooks

Reason bindings for the official @apollo/react-hooks

reason-apollo-hooks

Installation ⬆️

yarn add reason-apollo-hooks [email protected] @apollo/react-hooks

BuckleScript <= 5.0.0

yarn add [email protected] [email protected] @apollo/react-hooks

Follow the installation instructions of graphql_ppx_re.

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 =
 <ApolloHooks.Provider client>
   ...
 </ApolloHooks.Provider>

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>
    <ApolloHooks.Provider client>
      <App />
    </ApolloHooks.Provider>
  </ReasonApollo.Provider>,
  "root",
);

Available hooks ⬆️

useQuery ⬆️

open ApolloHooks

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

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

  <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) = useQuery(UserQuery.definition);

  <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) = useQuery(~fetchPolicy=NetworkOnly, UserQuery.definition);

Using errorPolicy to change how errors are handled, see apollo docs.

let (simple, _full) = useQuery(~errorPolicy=All, UserQuery.definition);

Using skip to skip query entirely, see apollo docs.

let (simple, _full) =
  useQuery(
    ~skip=
      switch (value) {
      | None => true
      | _ => false
      },
    UserQuery.definition,
  );

useMutation ⬆️

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

[@react.component]
let make = () => {
  /* Both variant and records available */
  let ( screamMutation, simple, _full ) =
    useMutation(~variables=ScreamMutation.makeVariables(~screamLevel=10, ()), ScreamMutation.definition);
  let scream = (_) => {
    screamMutation()
      |> Js.Promise.then_(((simple, _full)) => {
           // Trigger side effects by chaining the promise returned by screamMutation()
           switch (simple) {
             // You *must* set the error policy to be able to handle errors
             // in then_. See EditPersons.re for more
           | ApolloHooks.Mutation.Errors(_theErrors) => Js.log("OH NO!")
           | NoData => Js.log("NO DATA?")
           | Data(_theData) => Js.log("DATA!")
           };
           Js.Promise.resolve();
         })
      |> ignore
  }

  // Use simple (and/or full) for (most) UI feedback
  <div>
    {switch (simple) {
     | NotCalled
     | Data(_) => React.null
     | Loading => <div> "Screaming!"->React.string </div>
     | NoData
     | Error(_) => <div> "Something went wrong!"->React.string </div>
     }}
    <button onClick={scream} disabled={simple === Loading}>
      {React.string("You kids get off my lawn!")}
    </button>
  </div>
}

If you don't know the value of the variables yet you can pass them in later

[@react.component]
let make = () => {
  /* Both variant and records available */
  let ( screamMutation, _simple, _full ) = useMutation(ScreamMutation.definition);
  let scream = (_) => {
    screamMutation(~variables=ScreamMutation.makeVariables(~screamLevel=10, ()), ())
      |> Js.Promise.then_(((simple, _full)) => {
           ...
         })
      |> ignore
  }

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

useSubscription ⬆️

In order to use subscriptions, you first need to set up your websocket link:

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

/* Create an HTTP Link */
let httpLink =
  ApolloLinks.createHttpLink(~uri="http://localhost:3010/graphql", ());
+
+/* Create a WS Link */
+let webSocketLink =
+  ApolloLinks.webSocketLink({
+    uri: "wss://localhost:3010/graphql",
+    options: {
+      reconnect: true,
+      connectionParams: None,
+    },
+  });
+
+/* Using the ability to split links, you can send data to each link
+   depending on what kind of operation is being sent */
+let link =
+  ApolloLinks.split(
+    operation => {
+      let operationDefition =
+        ApolloUtilities.getMainDefinition(operation.query);
+      operationDefition.kind == "OperationDefinition"
+      && operationDefition.operation == "subscription";
+    },
+    webSocketLink,
+    httpLink,
+  );

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

let app =
 <ApolloHooks.Provider client>
   ...
 </ApolloHooks.Provider>

Then, you can implement useSubscription in a similar manner to useQuery

module UserAdded = [%graphql {|
  subscription userAdded {
    userAdded {
      id
      name
    }
  }
|}];


[@react.component]
let make = () => {
  let (userAddedSubscription, _full) = ApolloHooks.useSubscription(UserAdded.definition);

  switch (userAddedSubscription) {
    | Loading => <div> {ReasonReact.string("Loading")} </div>
    | Error(error) => <div> {ReasonReact.string(error##message)} </div>
    | Data(_response) =>
      <audio autoPlay=true>
      <source src="notification.ogg" type_="audio/ogg" />
      <source src="notification.mp3" type_="audio/mpeg" />
    </audio>
  };
};

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 PersonsQuery = [%graphql
{|
  query getAllPersons  {
    allPersons  {
      id
      age
      name
    }
  }
|}
];

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

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

let updatePersons = (~client, ~name, ~age) => {
  let query = PersonsQuery.make();
  let readQueryOptions = ApolloHooks.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.

Fragment ⬆️

Using fragments.

Fragments can be defined and used like this:

// Fragments.re
module PersonFragment = [%graphql
  {|
  fragment person on Person {
      id
      name
      age
  }
|}
];

module PersonsQuery = [%graphql
{|
  query getAllPersons  {
    ...Fragments.PersonFragment.Person
  }
|}
];

See examples/persons/src/fragments/LoadMoreFragments.re.

Getting it running

yarn
yarn start

Contributors ✨

Thanks goes to these wonderful people (emoji key):

_{Gabriel Rubens} 💻 📖 🤔	_{Ariel Schiavoni} 📖	_Matt 💻	_{Tomasz Cichocinski} 🐛 💻	_{Thibaut Mattio} 💻	_{Emilio Srougo} 🐛	_{Mike Anderson} 💻
_{Yuri Jean Fabris} 💻	_{Margarita Krutikova} 💻 👀 🤔	_{Kyrylo Yakymenko} 🐛 💻	_{Lukas Hambsch} 🐛	_{Jaap Frolich} 💻 👀 🤔	_{Rickard Laurin} 🐛	_{Medson Oliveira} 💻 👀 🤔
_soulplant 💻	_mbirkegaard 💻	_{Dragoș Străinu} 📖	_{Brad Dunn} 📖