Schema definition in GraphQL - Interactive Code Practice

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'

AString

BID!

CInt

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using String instead of ID for unique identifiers.

Forgetting the exclamation mark for required fields.

The ID! type is used for unique identifiers and the exclamation mark means it is required.

2fill in blank

medium

Complete the code to add a name field of type String to the User type.

GraphQL

type User { name: [1] }

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

AString

BInt

CBoolean

DFloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using Int or Boolean for text fields.

Forgetting to specify the type.

The String type is used for text fields like names.

3fill in blank

hard

Fix the error in the schema by completing the type definition correctly.

GraphQL

type User { id: ID, name: [1] }

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

AString!

BInt!

CBoolean!

DFloat!

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the exclamation mark for required fields.

Using wrong types like Int or Boolean for names.

The name field should be a required string, so use String!.

4fill in blank

hard

Fill both blanks to define a Query type with a user field returning a User by ID.

GraphQL

type Query { user(id: [1]): [2] }

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

AID!

BUser

CString

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using String instead of ID for the id argument.

Returning String or Boolean instead of User.

The user query takes a required ID! argument and returns a User type.

5fill in blank

hard

Fill all three blanks to define a Mutation type with createUser taking a name and returning a User.

GraphQL

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

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

AString!

BUser

CID!

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using optional types instead of required with !.

Mixing up return types and argument types.

The createUser mutation takes a required String! name and returns a User. The User type has an id of type ID!.

Practice

1. What is the purpose of the schema block in a GraphQL schema definition?

easy

A. It specifies the database connection details.

B. It defines the main entry points like query and mutation types.

C. It creates new object types with fields.

D. It lists all the scalar types available.

Solution

1. Step 1: Understand the role of the schema block

   The schema block in GraphQL defines the entry points for the API, such as which types are used for queries and mutations.

2. Step 2: Differentiate from other schema parts

   Object types with fields are defined using type, not the schema block. Database connections and scalar types are not defined here.

3. Final Answer:

   It defines the main entry points like query and mutation types. -> Option B

4. Quick Check:

   Schema block = entry points (query, mutation) [OK]

Hint: Remember schema block sets query and mutation roots [OK]

Common Mistakes:

• Confusing schema block with type definitions
• Thinking schema block defines database details
• Assuming schema block lists scalar types

2. Which of the following is the correct syntax to define a simple object type Book with a title field of type String in GraphQL?

easy

A. schema Book { title: String }

B. object Book { title: String }

C. type Book { title: String }

D. define Book { title: String }

Solution

1. Step 1: Recall GraphQL syntax for object types

   GraphQL uses the keyword type to define object types, followed by the type name and fields inside curly braces.

2. Step 2: Check each option

   Only type Book { title: String } uses the correct keyword type and proper syntax. Others use invalid keywords like object, schema, or define.

3. Final Answer:

   type Book { title: String } -> Option C

4. Quick Check:

   Object type syntax = type + name + fields [OK]

Hint: Use 'type' keyword to define objects in GraphQL [OK]

Common Mistakes:

• Using 'object' or 'define' instead of 'type'
• Confusing schema block with type definition
• Missing curly braces around fields

3. Given the schema definition:

type Query {
  book: Book
}
type Book {
  title: String
  pages: Int
}

What fields can be queried under book?

medium

A. Only title

B. No fields, book is scalar

C. Only pages

D. title and pages

Solution

1. Step 1: Identify the type of book field in Query

   The book field in Query returns a Book object type.

2. Step 2: Check fields inside Book type

   The Book type has two fields: title (String) and pages (Int), so both can be queried.

3. Final Answer:

   title and pages -> Option D

4. Quick Check:

   Object fields = title + pages [OK]

Hint: Object fields are all listed inside its type definition [OK]

Common Mistakes:

• Assuming only one field is accessible
• Thinking book is a scalar, not an object
• Ignoring fields inside the Book type

4. Identify the error in this GraphQL schema snippet:

schema {
  query: Query
}
type Query {
  book: Book
}
type Book {
  title String
}

medium

A. Missing colon ':' after 'title' field name

B. Missing curly braces around Query type

C. Schema block should be named 'type Schema'

D. Book type cannot be used in Query

Solution

1. Step 1: Check field syntax in Book type

   The field title String is missing a colon ':' between the field name and type. It should be title: String.

2. Step 2: Verify other parts of the schema

   The schema block and Query type are correctly defined with proper braces and names.

3. Final Answer:

   Missing colon ':' after 'title' field name -> Option A

4. Quick Check:

   Field syntax requires colon ':' [OK]

Hint: Always put ':' between field name and type [OK]

Common Mistakes:

• Omitting colon ':' after field names
• Confusing schema block syntax
• Misnaming schema block as a type

5. You want to add a mutation to create a new Book with fields title (String) and pages (Int). Which schema definition correctly adds this mutation?

hard

A. type Mutation { createBook(title: String, pages: Int): Book } schema { mutation: Mutation }

B. schema { mutation: Mutation } type Mutation { createBook(title String, pages Int): Book }

C. type Mutation { createBook(title: String, pages: Int): Book } schema { query: Query }

D. type Mutation { createBook(title: String, pages: Int): Book }

Solution

1. Step 1: Define the Mutation type with correct field syntax

   The mutation field createBook must have arguments with colons, e.g., title: String, and return type Book. schema { mutation: Mutation } type Mutation { createBook(title String, pages Int): Book } has missing colons, so it's invalid.

2. Step 2: Link the Mutation type in the schema block

   The schema block must include mutation: Mutation to expose the mutation. type Mutation { createBook(title: String, pages: Int): Book } schema { mutation: Mutation } correctly includes this after defining Mutation.

3. Final Answer:

   type Mutation { createBook(title: String, pages: Int): Book } schema { mutation: Mutation } -> Option A

4. Quick Check:

   Mutation type + schema mutation entry = correct [OK]

Hint: Mutation must be linked in schema block with correct syntax [OK]

Common Mistakes:

• Omitting colons in argument definitions
• Not linking mutation type in schema block
• Only defining mutation type without schema entry