Node interface pattern in GraphQL - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Node interface pattern in GraphQL?

It is a design pattern where objects implement a common interface called Node, which requires a unique ID field. This helps in fetching any object by its ID in a consistent way.

beginner

Why is the Node interface pattern useful in GraphQL?

It allows clients to fetch any object by its unique ID without knowing its type beforehand, simplifying queries and improving flexibility.

beginner

How do you define a Node interface in GraphQL SDL?

You define it with an ID field like this:

interface Node {
  id: ID!
}

intermediate

How do objects implement the Node interface in GraphQL?

Objects include the Node interface in their type definition and provide the id field. For example:

type User implements Node {
  id: ID!
  name: String
}

intermediate

What is the typical query to fetch a Node by ID using the Node interface?

You use a root field like node(id: ID!) that returns the Node interface. Then you use inline fragments to get fields based on the actual type. Example:

{
  node(id: "123") {
    id
    ... on User {
      name
    }
  }
}

What field must every type implementing the Node interface have?

A id

B name

C type

D value

The Node interface requires an 'id' field that uniquely identifies the object.

Which GraphQL feature allows fetching different fields based on the actual type of a Node?

A Subscriptions

B Directives

C Fragments

D Mutations

Fragments, especially inline fragments, let you select fields depending on the object's type.

Why use the Node interface pattern in a GraphQL API?

A To enforce authentication

B To create subscriptions

C To speed up mutations

D To fetch any object by ID in a uniform way

The Node interface pattern standardizes fetching objects by their unique ID.

How do you declare that a type implements the Node interface in GraphQL SDL?

A type User implements Node { ... }

B interface User implements Node { ... }

C type User extends Node { ... }

D type User inherits Node { ... }

You use 'implements' keyword with object types to implement interfaces.

What is the return type of a typical root query field that fetches a Node by ID?

A String

B Node

C ID

D Boolean

The root query field returns the Node interface type, which can be any implementing object.

Explain the Node interface pattern and why it is useful in GraphQL APIs.

Think about how clients can get any object by a single query.

Describe how you would define and use the Node interface in a GraphQL schema and query.

Consider schema SDL and example query structure.

Practice

1. What is the main purpose of the Node interface in GraphQL?

easy

A. To provide a unique ID for all object types

B. To define custom mutations for each type

C. To restrict queries to only one type

D. To automatically generate database schemas

Solution

1. Step 1: Understand the Node interface role

   The Node interface is designed to give every object type a unique identifier.

2. Step 2: Identify its main use

   This unique ID allows fetching any object by ID in a single query.

3. Final Answer:

   To provide a unique ID for all object types -> Option A

4. Quick Check:

   Node interface = unique ID for all types [OK]

Hint: Node interface always provides unique IDs for all types [OK]

Common Mistakes:

• Thinking Node defines mutations
• Believing Node restricts queries to one type
• Assuming Node auto-generates database schemas

2. Which of the following is the correct way to declare the Node interface in GraphQL SDL?

easy

A. interface Node { id: Boolean! }

B. interface Node { id: String }

C. interface Node { id: Int! }

D. interface Node { id: ID! }

Solution

1. Step 1: Recall the Node interface ID type

   The Node interface requires an id field of type ID!, which is a non-null unique identifier.

2. Step 2: Check each option's ID type

   interface Node { id: ID! } uses ID!, which is correct. Others use wrong types like String, Int, or Boolean.

3. Final Answer:

   interface Node { id: ID! } -> Option D

4. Quick Check:

   ID field in Node = ID! type [OK]

Hint: Node interface ID must be non-null ID type [OK]

Common Mistakes:

• Using String or Int instead of ID type
• Making ID nullable (missing !)
• Using Boolean as ID type

3. Given this query using the Node interface:

query { node(id: "123") { id ... on User { name } ... on Post { title } } }

What fields will be returned if the node with ID "123" is a Post?

medium

A. { "id": "123", "name": "Alice" }

B. { "id": "123", "title": "GraphQL Basics" }

C. { "id": "123" }

D. Error: Cannot query fragment on Post

Solution

1. Step 1: Understand the query structure

   The query fetches a node by ID and requests the id field plus fragments for User and Post types.

2. Step 2: Determine the node type and returned fields

   If the node is a Post, the title field from the Post fragment is returned along with id. The User fragment is ignored.

3. Final Answer:

   { "id": "123", "title": "GraphQL Basics" } -> Option B

4. Quick Check:

   Node query returns fields for actual type fragment [OK]

Hint: Fragments return fields only for matching node type [OK]

Common Mistakes:

• Expecting fields from non-matching fragments
• Ignoring the id field
• Assuming query causes error

4. You wrote this schema snippet:

interface Node { id: ID! }
type User implements Node { id: ID name: String }

Why will this schema cause an error?

medium

A. User's id field must be non-null (ID!) to match Node interface

B. User type cannot implement Node interface

C. id field type must be String, not ID

D. User type must not have extra fields like name

Solution

1. Step 1: Compare interface and type field definitions

   The Node interface requires id as ID! (non-null). The User type declares id as ID (nullable).

2. Step 2: Understand GraphQL type compatibility rules

   Implementing types must match or be more strict. Here, User's id is less strict (nullable), causing an error.

3. Final Answer:

   User's id field must be non-null (ID!) to match Node interface -> Option A

4. Quick Check:

   Implementing type fields must match interface exactly [OK]

Hint: Implementing type fields must be equal or stricter than interface [OK]

Common Mistakes:

• Thinking User can't implement Node
• Changing id type to String
• Removing extra fields like name

5. You want to fetch a list of mixed objects (Users and Posts) by their IDs using the Node interface. Which approach correctly fetches their specific fields in one query?

hard

A. Use a union type instead of Node interface

B. Query Users and Posts separately with two queries

C. Use a nodes(ids: [ID!]!) query returning [Node], then use inline fragments for User and Post fields

D. Fetch only the id field without fragments

Solution

1. Step 1: Understand Node interface usage for mixed types

   The Node interface allows fetching any object by ID in one query, returning a list of Nodes.

2. Step 2: Use inline fragments to get type-specific fields

   To get fields specific to Users and Posts, use inline fragments ... on User and ... on Post inside the query.

3. Final Answer:

   Use a nodes(ids: [ID!]!) query returning [Node], then use inline fragments for User and Post fields -> Option C

4. Quick Check:

   Node interface + fragments fetch mixed types in one query [OK]

Hint: Use nodes query with fragments for mixed type fields [OK]

Common Mistakes:

• Querying types separately instead of one query
• Using union instead of interface for this pattern
• Fetching only id without needed fields