How do I avoid redundant data lookups when resolving multiple nested graphql queries? - rest

Question

Is there a known solution or feature in GraphQL or Apollo for batching expensive, redundant, data lookups across multiple query and field resolvers?
Say we have Person & Pet types, and queries to fetch them:
type Query {
pets: [Pet]
people: [Person]
}
type Pet {
name: String
owner: Person
}
type Person {
name: String
}
And we have a web client that needs to get all of them to show on a page:
query PetsAndPeople {
pets {
name
owner {
name
}
}
people {
name
}
}
To resolve this query, our backend needs to make REST API calls to an external service, which happens to apply rate-limiting, or has a $ cost per query. The endpoints look like this:
GET /pets
[
{
"name": "Mittens",
"ownerId": 1
},
{
"name": "Rover",
"ownerId": 1
}
{
"name": "Spot",
"ownerId": 2
}
]
GET /person/1
{
"name": "John Doe"
}
GET /persons
[
{
"name": "John Doe"
},
{
"name": "Jane Smith"
}
]
The resolvers look like this:
{
Query: {
pets: () => fetchJSON(`${API}/pets`)
}
people: () => fetchJSON(`${API}/persons`)
},
Pet: {
name: (pet) => pet.name
person: (pet) => fetchJSON(`${API}/person/${pet.ownerId}`)
}
Person: {
name: (person) => person.name
}
}
So lets say the graphql response for the web client looks like this:
{
"pets": [
{
"name": "Mittens",
"owner": {
"name": "John Doe"
}
},
{
"name": "Rover",
"owner": {
"name": "John Doe"
}
},
{
"name": "Spot",
"owner": {
"name": "Jane Smith"
}
}
],
"people": [
{
"name": "John Doe"
},
{
"name": "Jane Smith"
}
]
}
To produce this, we had to make 4-5 REST calls on the graphql side to the external API:
GET /people to resolve all of the people's names
GET /pets to resolve all of the pets' names
GET /person/1 to resolve Mittens's owner's name
GET /person/1 to resolve Rover's owner's name (maybe apollo caches this, but I'm not sure)
GET /person/2 to resolve Spot's owner's name
Since there are restrictions on the external API (such as rate limits or $/query), I would ideally want only want to make 2 queries (GET /people and GET /pets), and then resolve the pet's owner's names based on the results of the GET /people instead of making the redundant GET /person/3 calls.
I'm wondering if there is a known solution to this problem (such as manually handling all the queries in a single top-level function somehow?)? Am I setting up my resolvers or schemas incorrectly? Is there some other Graphql or Apollo feature that I'm missing?
This is a bit of a contrived example but I have a real use case that is similar with even more nested resolvers (and so exponentially more queries being made redundantly).