Why schema defines the API contract in GraphQL - See It in Action

Understanding Why Schema Defines the API Contract in GraphQL

📖 Scenario: Imagine you are building a simple online bookstore. You want to create a GraphQL API so that clients can ask for book details in a clear and predictable way.

🎯 Goal: You will create a GraphQL schema that acts as a contract between the client and server. This schema will define exactly what data can be requested and how it is structured.

📋 What You'll Learn

Create a GraphQL schema with a Book type containing id, title, and author fields

Add a Query type with a field book that returns a Book by id

Define the schema as the API contract so clients know what queries are allowed

Use clear and exact names for types and fields as specified

💡 Why This Matters

🌍 Real World

GraphQL schemas are used in real APIs to clearly define what data clients can request and how to ask for it.

💼 Career

Understanding schema as an API contract is essential for backend developers and API designers working with GraphQL.

1

Define the Book type

Create a GraphQL type called Book with fields id of type ID!, title of type String!, and author of type String!.

GraphQL

# Your code here
type Book {
  # Define fields here
}

Hint

Use type Book { ... } and define each field with its type and exclamation mark for required fields.

2

Add the Query type with a book field

Add a Query type with a field called book that takes an argument id of type ID! and returns a Book.

GraphQL

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

# Your code here
type Query {
  # Define book field here
}

Hint

Define type Query { book(id: ID!): Book } so clients can query a book by its ID.

3

Explain the schema as the API contract

Add a comment explaining that this schema defines the API contract by specifying what queries clients can make and what data they will get back.

GraphQL

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

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

# Your comment here explaining the API contract

Hint

Write a clear comment starting with # This schema defines the API contract.

4

Complete the schema with a root schema definition

Add the root schema definition that sets query to Query, completing the schema contract.

GraphQL

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

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

# This schema defines the API contract by specifying exactly what queries are allowed and what data clients will receive.

# Your code here to complete the schema

Hint

Add schema { query: Query } at the end to complete the schema.

Practice

1. What is the main purpose of a GraphQL schema in an API?

easy

A. To define the types of data and queries the API supports

B. To store user data permanently

C. To style the API responses with colors

D. To encrypt the data sent over the network

Solution

1. Step 1: Understand what a schema represents

   A GraphQL schema acts like a menu that lists what data and operations are available in the API.

2. Step 2: Identify the schema's role in API communication

   It defines the types and queries so clients know exactly what they can ask for and expect.

3. Final Answer:

   To define the types of data and queries the API supports -> Option A

4. Quick Check:

   Schema = API contract [OK]

Hint: Schema is the API's menu of data and queries [OK]

Common Mistakes:

• Thinking schema stores data permanently
• Confusing schema with styling or encryption
• Believing schema handles data encryption

2. Which of the following is the correct way to define a simple GraphQL schema type for a User with an id and name?

easy

A. type User { id: Int name: String }

B. type User { id: Int, name: String }

C. type User { id Int, name String }

D. type User (id: Int, name: String)

Solution

1. Step 1: Recall GraphQL type syntax

   Fields inside a type are defined with a name, colon, then type, separated by commas or new lines.

2. Step 2: Check each option's syntax

   type User { id: Int, name: String } correctly uses colons and commas to separate fields: id: Int, name: String.

3. Final Answer:

   type User { id: Int, name: String } -> Option B

4. Quick Check:

   Correct field syntax = type User { id: Int, name: String } [OK]

Hint: Use colon between field and type, commas optional but clearer [OK]

Common Mistakes:

• Omitting colons between field and type
• Using parentheses instead of braces
• Missing commas causing syntax errors

3. Given this schema snippet:

type Query { user(id: Int): User }

What will happen if a client queries for { user(id: 1) { id name } } but the schema does not define the name field on User?

medium

A. The query will return an error about the unknown field 'name'

B. The query will return the user with an empty 'name' field

C. The query will ignore the 'name' field and return only 'id'

D. The query will return null for the entire user

Solution

1. Step 1: Understand schema validation

   GraphQL validates queries against the schema. If a field is not defined, it causes an error.

2. Step 2: Apply to the given query

   The 'name' field is missing in the User type, so the query asking for it will fail with an error.

3. Final Answer:

   The query will return an error about the unknown field 'name' -> Option A

4. Quick Check:

   Query fields must exist in schema [OK]

Hint: Query fields must match schema exactly [OK]

Common Mistakes:

• Assuming missing fields return empty or null silently
• Thinking GraphQL ignores unknown fields
• Believing partial data is returned without error

4. You wrote this schema:

type Query { getUser(id: Int): User }

But your API returns an error when querying { getUser(id: 5) { id name } }. What is the likely mistake?

medium

A. The Query type must be named 'query' in lowercase

B. The query syntax is invalid because of missing commas

C. The argument 'id' should be non-nullable with an exclamation mark

D. The User type is not defined or missing fields

Solution

1. Step 1: Check schema completeness

   The Query type is correctly named with uppercase 'Query', which is standard in GraphQL.

2. Step 2: Consider User type definition

   If the User type is missing or lacks requested fields like 'id' or 'name', the query will error.

3. Final Answer:

   The User type is not defined or missing fields -> Option D

4. Quick Check:

   Missing type or fields cause query errors [OK]

Hint: Check if all types and fields exist in schema [OK]

Common Mistakes:

• Thinking Query must be lowercase
• Assuming nullable arguments cause errors
• Blaming query syntax when schema is incomplete

5. You want to extend your GraphQL API to include a new type Book with fields id, title, and author. How does defining this in the schema help your API users?

hard

A. It hides the Book type from users to keep it private

B. It automatically fills the database with book data

C. It tells users exactly what data they can request and how to ask for it

D. It encrypts the Book data before sending it

Solution

1. Step 1: Understand schema role in API design

   Defining a new type in the schema acts like adding a new menu item, showing users what data is available.

2. Step 2: Explain benefit to API users

   This helps users know what fields exist and how to write queries to get that data without errors.

3. Final Answer:

   It tells users exactly what data they can request and how to ask for it -> Option C

4. Quick Check:

   Schema defines API contract for users [OK]

Hint: Schema shows users what data and queries exist [OK]

Common Mistakes:

• Thinking schema fills or encrypts data
• Believing schema hides types from users
• Confusing schema with database content