Why schema design affects usability in GraphQL - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a GraphQL type for a user with an ID.

GraphQL

type User { id: [1] }

Drag options to blanks, or click blank then click option'

AInt

BString

CID

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using String instead of ID for unique identifiers.

Using Int which may not be unique or descriptive enough.

The ID scalar type is used to represent unique identifiers in GraphQL schemas, improving usability by clearly indicating unique keys.

2fill in blank

medium

Complete the code to make the 'name' field required in the User type.

GraphQL

type User { name: [1] }

Drag options to blanks, or click blank then click option'

AString!

BString

CID

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the exclamation mark, making the field optional.

Using incorrect types like Boolean for a name.

Adding an exclamation mark ! after the type makes the field non-nullable, ensuring the 'name' must always have a value, which improves schema usability.

3fill in blank

hard

Fix the error in the query by completing the field name correctly.

GraphQL

{ user(id: "1") { [1] } }

Drag options to blanks, or click blank then click option'

Aname

Busername

Cid

Demail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'username' which is not defined in the schema.

Using 'email' when the schema does not include it.

The schema defines the user's name field as name. Using the correct field name ensures the query returns the expected data.

4fill in blank

hard

Fill both blanks to define a query that fetches a list of users with their IDs and names.

GraphQL

type Query { users: [1] { id: [2] } }

Drag options to blanks, or click blank then click option'

A[User]

BID

CString

DUser

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'User' instead of '[User]' for a list.

Using 'String' instead of 'ID' for the id field.

The query returns a list of users, so the type is a list [User]. The id field uses the ID scalar type for unique identification.

5fill in blank

hard

Fill all three blanks to define a mutation that creates a user with a required name and returns the user's ID.

GraphQL

type Mutation { createUser(name: [1]): [2] { id: [3] } }

Drag options to blanks, or click blank then click option'

AString!

BUser

CID

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Making the name optional by omitting the exclamation mark.

Returning a Boolean instead of a User.

Using String instead of ID for the id field.

The mutation requires a non-nullable String! for the name, returns a User type, and the id field is of type ID.

Practice

1. Why is good schema design important in GraphQL APIs?

easy

A. It makes data easier to find and use

B. It increases the size of the database

C. It hides all data from users

D. It slows down query responses

Solution

1. Step 1: Understand schema design purpose

   Good schema design organizes data clearly for easy access.

2. Step 2: Identify impact on usability

   Clear design helps users and developers find and use data quickly.

3. Final Answer:

   It makes data easier to find and use -> Option A

4. Quick Check:

   Good design = easier data use [OK]

Hint: Good design means easy data access [OK]

Common Mistakes:

• Thinking schema size affects usability directly
• Assuming schema hides data by default
• Believing good design slows queries

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

easy

A. type User { id Int, name String }

B. User type { 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

   GraphQL types use curly braces with fields and types separated by colon.

2. Step 2: Check each option's syntax

   type User { id: Int name: String } uses correct syntax: type User { id: Int name: String }.

3. Final Answer:

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

4. Quick Check:

   Correct syntax uses colon and braces [OK]

Hint: Use colon between field and type inside braces [OK]

Common Mistakes:

• Omitting colon between field and type
• Using parentheses instead of braces
• Placing type keyword incorrectly

3. Given this GraphQL schema snippet:

type Query { user(id: ID!): User }
type User { id: ID! name: String }

What will the query { user(id: "1") { name } } return if the user with id 1 has name "Alice"?

medium

A. { "data": { "user": { "id": "1" } } }

B. { "data": { "user": { "name": "Alice" } } }

C. { "error": "User not found" }

D. { "data": { "user": null } }

Solution

1. Step 1: Understand the query request

   The query asks for the user's name with id "1".

2. Step 2: Match schema and data

   Since user with id "1" exists and name is "Alice", the response includes that name.

3. Final Answer:

   { "data": { "user": { "name": "Alice" } } } -> Option B

4. Quick Check:

   Query requests name, response includes name [OK]

Hint: Response matches requested fields only [OK]

Common Mistakes:

• Expecting id field when not requested
• Assuming error if user exists
• Confusing null with valid data

4. Consider this GraphQL schema snippet:

type User { id: ID! name: String }

Which of the following schema definitions will cause an error when querying { user { id name } }?

medium

A. type Query { user: String }

B. type Query { user: [User] }

C. type Query { user: User! }

D. type Query { user: User }

Solution

1. Step 1: Check the return type of user field

   Query expects user field to return a User object or list of Users.

2. Step 2: Identify invalid return type

   type Query { user: String } returns a String instead of User, causing a type mismatch error.

3. Final Answer:

   type Query { user: String } -> Option A

4. Quick Check:

   Return type must match queried fields [OK]

Hint: Return type must match requested object type [OK]

Common Mistakes:

• Confusing non-null with wrong type
• Assuming list type always causes error
• Ignoring type mismatch errors

5. You want to design a GraphQL schema for a blog where each Post has an author and comments. To improve usability, which schema design choice is best?

hard

A. Make author and comments fields return String with JSON data

B. Only include post title and ignore author and comments

C. Separate author and comments into unrelated types without linking

D. Embed author and comments fields inside Post type with proper types

Solution

1. Step 1: Consider usability for users and developers

   Embedding author and comments as fields with proper types makes data easy to query and understand.

2. Step 2: Evaluate other options

   Ignoring fields or using strings with JSON reduces clarity and usability; separating without links causes confusion.

3. Final Answer:

   Embed author and comments fields inside Post type with proper types -> Option D

4. Quick Check:

   Linked types improve usability [OK]

Hint: Link related data with proper types for clarity [OK]

Common Mistakes:

• Ignoring related data in schema
• Using strings instead of typed fields
• Separating related data without connections