Schema definition in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this GraphQL query?

Given this GraphQL schema:

type Book {
  id: ID!
  title: String!
  author: Author!
}

type Author {
  id: ID!
  name: String!
  books: [Book!]!
}

type Query {
  book(id: ID!): Book
}

And this query:

{
  book(id: "1") {
    title
    author {
      name
    }
  }
}

Assuming the data has a book with id "1" titled "GraphQL Basics" by author "Alice", what is the expected output?

A {"data": {"book": {"title": "GraphQL Basics", "author": {"name": "Alice"}}}}

B {"data": {"book": {"title": "GraphQL Basics"}}}

C {"data": {"book": {"author": {"name": "Alice"}}}}

D {"errors": [{"message": "Field 'author' not found"}]}

💡 Hint

Remember the query asks for both title and author.name.

The query requests the book's title and the author's name. Option A correctly includes both fields in the response.

🧠 Conceptual

intermediate

Which GraphQL type correctly defines a non-nullable list of nullable strings?

In GraphQL schema definition, how do you define a field that is a list which cannot be null, but can contain null strings?

A String!

B [String!]

C [String!]!

D [String]!

💡 Hint

Think about the placement of the exclamation mark ! and what it means for the list and its items.

[String]! means the list itself cannot be null, but its items can be null. Other options either make items non-null or the list nullable.

📝 Syntax

advanced

Identify the syntax error in this GraphQL schema snippet

What is wrong with this GraphQL type definition?

type User {
  id: ID!
  name: String
  email: String!
  friends: [User]
  age: Int!
}

A Field 'age' cannot be non-nullable without a default value.

B Missing exclamation mark on 'friends' field to indicate non-null list.

C No syntax error; this schema is valid.

D Cannot have a field 'friends' of type [User] without specifying non-null on User.

💡 Hint

Check if all fields follow GraphQL type syntax rules.

All fields are correctly defined. Lists and non-null types are valid as shown. Non-null fields do not require default values in schema.

❓ optimization

advanced

How to optimize a GraphQL schema for fetching nested data efficiently?

You have a schema with types Post and Comment. Each post has many comments. Which schema design helps avoid the N+1 query problem when fetching posts with comments?

A Define <code>comments</code> field on <code>Post</code> as a list and resolve each comment individually in the resolver.

B Use a batch loader or data loader in the resolver to fetch all comments for multiple posts in one query.

C Remove the <code>comments</code> field and fetch comments separately after fetching posts.

D Make <code>comments</code> a scalar string field containing serialized comments.

💡 Hint

Think about how to reduce multiple database calls when resolving nested fields.

Using a batch loader or data loader batches requests to fetch comments for many posts in one query, avoiding the N+1 problem.

🔧 Debug

expert

Why does this GraphQL schema cause a circular reference error?

Consider this schema snippet:

type Employee {
  id: ID!
  name: String!
  manager: Employee
  subordinates: [Employee!]
}

When trying to generate schema documentation, a circular reference error occurs. Why?

A Because the schema lacks a terminating condition or depth limit for recursive references.

B Because the <code>manager</code> field is nullable but <code>subordinates</code> list items are non-nullable, causing conflict.

C Because <code>Employee</code> references itself directly without using an interface or union type.

D Because GraphQL does not support recursive type definitions referencing themselves.

💡 Hint

Think about how recursive types can cause infinite loops in tools processing the schema.

The schema itself is valid, but tools generating documentation or introspection may fail without limits on recursion depth, causing circular reference errors.