Migration from REST to GraphQL - Mini Project: Build & Apply

Migration from REST to GraphQL

📖 Scenario: You work for a company that currently uses REST APIs to fetch user data. The company wants to switch to GraphQL to make data fetching more flexible and efficient.You will build a simple GraphQL schema and resolver setup that mimics the existing REST data structure.

🎯 Goal: Create a GraphQL schema and resolver that fetch user information similar to the existing REST API response.Learn how to define types, queries, and resolve data in GraphQL.

📋 What You'll Learn

Define a GraphQL type User with fields id, name, and email

Create a query type Query with a field users that returns a list of User

Set up a resolver for users that returns the exact user data

Add a configuration variable maxUsers to limit the number of users returned

💡 Why This Matters

🌍 Real World

Many companies migrate from REST APIs to GraphQL to improve data fetching efficiency and flexibility in their applications.

💼 Career

Understanding how to define GraphQL schemas and resolvers is essential for backend developers working with modern API technologies.

1

Define the User type and sample data

Create a GraphQL type called User with fields id (ID!), name (String!), and email (String!). Also, create a constant userData as an array of three user objects with these exact values: {id: "1", name: "Alice", email: "[e-mail]"}, {id: "2", name: "Bob", email: "[e-mail]"}, {id: "3", name: "Charlie", email: "[e-mail]"}.

GraphQL

# Define the User type and userData array
# Your code here

Hint

Use gql`...` to define the GraphQL type. Create userData as an array of objects with exact fields and values.

2

Add Query type and maxUsers configuration

Add a Query type to the schema with a field users that returns a list of User. Also, create a constant maxUsers and set it to 2 to limit the number of users returned.

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
  }

  # Add Query type here
`;

const userData = [
  { id: "1", name: "Alice", email: "[e-mail]" },
  { id: "2", name: "Bob", email: "[e-mail]" },
  { id: "3", name: "Charlie", email: "[e-mail]" }
];

# Define maxUsers constant here

Hint

Add the Query type inside the gql template. Define maxUsers as a constant number.

3

Create resolver for users query with limit

Create a resolvers object with a Query field. Inside Query, define a users function that returns the first maxUsers entries from userData using slice(0, maxUsers).

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
  }

  type Query {
    users: [User]
  }
`;

const userData = [
  { id: "1", name: "Alice", email: "[e-mail]" },
  { id: "2", name: "Bob", email: "[e-mail]" },
  { id: "3", name: "Charlie", email: "[e-mail]" }
];

const maxUsers = 2;

# Create resolvers object with Query.users resolver here

Hint

Define resolvers as an object with a Query field. The users function returns a slice of userData.

4

Export schema and resolvers for server setup

Export typeDefs and resolvers using module.exports so they can be used in the GraphQL server setup.

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
  }

  type Query {
    users: [User]
  }
`;

const userData = [
  { id: "1", name: "Alice", email: "[e-mail]" },
  { id: "2", name: "Bob", email: "[e-mail]" },
  { id: "3", name: "Charlie", email: "[e-mail]" }
];

const maxUsers = 2;

const resolvers = {
  Query: {
    users: () => userData.slice(0, maxUsers)
  }
};

# Export typeDefs and resolvers here

Hint

Use module.exports to export both typeDefs and resolvers.

Practice

1. What is a key advantage of migrating from REST to GraphQL for database queries?

easy

A. REST automatically optimizes data fetching without changes.

B. You can request exactly the data you need in a single query.

C. GraphQL requires multiple requests to get all data.

D. GraphQL does not support querying nested data.

Solution

1. Step 1: Understand REST vs GraphQL data fetching

   REST often requires multiple requests or returns extra data, while GraphQL lets you specify exactly what you want.

2. Step 2: Identify the main benefit of GraphQL

   GraphQL reduces over-fetching and under-fetching by allowing precise queries in one request.

3. Final Answer:

   You can request exactly the data you need in a single query. -> Option B

4. Quick Check:

   GraphQL precise data fetching = C [OK]

Hint: GraphQL = one request, exact data [OK]

Common Mistakes:

• Thinking GraphQL needs multiple requests
• Believing REST auto-optimizes data fetching
• Assuming GraphQL can't query nested data

2. Which of the following is the correct way to define a simple GraphQL query to get a user's name and email?

easy

A. { user: { name, email } }

B. GET /user { name, email }

C. query { user { name, email } }

D. SELECT name, email FROM user

Solution

1. Step 1: Recognize GraphQL query syntax

   GraphQL queries start with the keyword 'query' followed by the fields requested inside braces.

2. Step 2: Compare options to GraphQL syntax

   query { user { name, email } } matches the correct GraphQL query format; others are REST, SQL, or invalid syntax.

3. Final Answer:

   query { user { name, email } } -> Option C

4. Quick Check:

   GraphQL query syntax = D [OK]

Hint: GraphQL queries start with 'query' keyword [OK]

Common Mistakes:

• Using REST or SQL syntax instead of GraphQL
• Omitting the 'query' keyword
• Incorrect braces placement

3. Given this GraphQL query:
query { book(id: "1") { title author { name } } }
What is the expected shape of the returned data?

medium

A. {"data": {"book": {"title": "Book Title", "author": {"name": "Author Name"}}}}

B. {"book": {"title": "Book Title", "author": "Author Name"}}

C. {"data": {"book": {"title": "Book Title", "author": "Author Name"}}}

D. {"data": {"book": ["title", "author"]}}

Solution

1. Step 1: Understand GraphQL nested response format

   GraphQL returns data inside a 'data' object, preserving nested structure matching the query.

2. Step 2: Match query fields to response structure

   The query requests 'title' and nested 'author' with 'name', so response nests 'author' as an object with 'name'.

3. Final Answer:

   {"data": {"book": {"title": "Book Title", "author": {"name": "Author Name"}}}} -> Option A

4. Quick Check:

   Nested data in 'data' key = A [OK]

Hint: GraphQL response nests data under 'data' key [OK]

Common Mistakes:

• Returning author as string instead of object
• Missing 'data' wrapper in response
• Using arrays instead of objects for fields

4. You migrated a REST endpoint to GraphQL but get an error: Cannot query field 'userName' on type 'User'. What is the likely cause?

medium

A. GraphQL does not support querying user names.

B. The REST endpoint is down.

C. The query syntax is missing curly braces.

D. The GraphQL schema does not define a 'userName' field on 'User' type.

Solution

1. Step 1: Analyze the error message

   The error says 'userName' is not a valid field on 'User' type, indicating schema mismatch.

2. Step 2: Understand GraphQL schema role

   GraphQL queries must match fields defined in the schema; missing fields cause errors.

3. Final Answer:

   The GraphQL schema does not define a 'userName' field on 'User' type. -> Option D

4. Quick Check:

   Schema field missing = A [OK]

Hint: Check schema fields match query fields [OK]

Common Mistakes:

• Blaming REST endpoint for GraphQL schema errors
• Ignoring schema definitions
• Assuming GraphQL can't query user names

5. During migration from REST to GraphQL, you want to avoid over-fetching user data. Which approach best achieves this?

hard

A. Define a GraphQL query that requests only the needed user fields like name and email.

B. Keep using the REST endpoint but add query parameters to limit fields.

C. Fetch all user data and filter unwanted fields on the client side.

D. Use multiple GraphQL queries to get each user field separately.

Solution

1. Step 1: Understand over-fetching in REST vs GraphQL

   REST often returns full objects; GraphQL lets you specify exactly which fields to fetch.

2. Step 2: Choose the best method to limit data fetched

   Defining a GraphQL query with only needed fields avoids over-fetching efficiently in one request.

3. Final Answer:

   Define a GraphQL query that requests only the needed user fields like name and email. -> Option A

4. Quick Check:

   Selective field query = B [OK]

Hint: Request only needed fields in GraphQL query [OK]

Common Mistakes:

• Fetching all data then filtering client-side
• Using multiple queries instead of one precise query
• Relying on REST query parameters only