Abstract type resolution in GraphQL - Mini Project: Build & Apply

Abstract Type Resolution in GraphQL

📖 Scenario: You are building a simple GraphQL API for a library system. The library has different types of items: Books and Magazines. Both share some common fields but also have their own unique fields.To handle this, you will use GraphQL's abstract types (interfaces) to define a common structure and then resolve the specific types when querying.

🎯 Goal: Create a GraphQL schema with an Item interface and two types Book and Magazine that implement this interface. Then, write a resolver function to correctly resolve the abstract type Item to either Book or Magazine based on the data.

📋 What You'll Learn

Define an interface called Item with fields id and title

Create two types Book and Magazine implementing Item

Add a unique field author to Book and issueNumber to Magazine

Write a resolver function __resolveType for the Item interface to return the correct type

Create a query items that returns a list of Item objects

💡 Why This Matters

🌍 Real World

Abstract type resolution is used in GraphQL APIs to handle data that can be one of several types sharing common fields, such as different media types in a library or different user roles in an application.

💼 Career

Understanding abstract types and resolvers is essential for backend developers working with GraphQL to build flexible and efficient APIs that serve diverse data types.

1

Define the Item interface and types

Create a GraphQL schema with an interface called Item that has fields id (ID!) and title (String!). Then define two types Book and Magazine that implement Item. Book should have an additional field author (String!), and Magazine should have an additional field issueNumber (Int!).

GraphQL

# Define the Item interface and Book, Magazine types
# Your code here

Need a hint?

Use the interface keyword for Item. Use implements Item for Book and Magazine.

2

Add the items query returning a list of Item

Add a query type with a field called items that returns a list of Item (use [Item!]! to indicate a non-null list of non-null items).

GraphQL

interface Item {
  id: ID!
  title: String!
}

type Book implements Item {
  id: ID!
  title: String!
  author: String!
}

type Magazine implements Item {
  id: ID!
  title: String!
  issueNumber: Int!
}

type Query {
  # Define the items query here
  # Your code here
}

Need a hint?

Define a Query type with a field items returning a list of Item.

3

Create sample data for items

Create a JavaScript array called items with two objects: one representing a Book with id '1', title 'GraphQL Guide', and author 'John Doe'; and one representing a Magazine with id '2', title 'Tech Monthly', and issueNumber 42.

GraphQL

interface Item {
  id: ID!
  title: String!
}

type Book implements Item {
  id: ID!
  title: String!
  author: String!
}

type Magazine implements Item {
  id: ID!
  title: String!
  issueNumber: Int!
}

type Query {
  items: [Item!]!
}

// Create the items array with sample data
// Your code here

Need a hint?

Create an array named items with two objects matching the described fields.

4

Write the __resolveType resolver for Item

Write a resolver function called Item with a method __resolveType that takes an object obj and returns the string 'Book' if obj has the author field, or 'Magazine' if obj has the issueNumber field.

GraphQL

interface Item {
  id: ID!
  title: String!
}

type Book implements Item {
  id: ID!
  title: String!
  author: String!
}

type Magazine implements Item {
  id: ID!
  title: String!
  issueNumber: Int!
}

type Query {
  items: [Item!]!
}

const items = [
  { id: '1', title: 'GraphQL Guide', author: 'John Doe' },
  { id: '2', title: 'Tech Monthly', issueNumber: 42 }
];

const resolvers = {
  Item: {
    __resolveType(obj) {
      // Your code here
    }
  }
};

Need a hint?

Check for the presence of author or issueNumber fields to decide the type.