⚠️ Prefer the new https://github.com/reasonml-community/reason-apollo-client instead
Reason bindings for the official @apollo/react-hooks
Installation ⬆️
yarn add reason-apollo-hooks reason-apollo@0.19.0 @apollo/react-hooks
BuckleScript <= 5.0.0
yarn add reason-apollo-hooks@3.0.0 reason-apollo@0.17.0 @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.tobject in order to preserve__typenamethatapolloadds 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.
yarn
yarn startThanks goes to these wonderful people (emoji key):
This project follows the all-contributors specification. Contributions of any kind welcome!