Interface types in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Querying an Interface Field

Given the GraphQL schema with an interface Character and two types Human and Droid implementing it, what is the output of this query?

query {
  characters {
    id
    name
    ... on Human {
      homePlanet
    }
    ... on Droid {
      primaryFunction
    }
  }
}

GraphQL

interface Character {
  id: ID!
  name: String!
}

type Human implements Character {
  id: ID!
  name: String!
  homePlanet: String
}

type Droid implements Character {
  id: ID!
  name: String!
  primaryFunction: String
}

query {
  characters {
    id
    name
    ... on Human {
      homePlanet
    }
    ... on Droid {
      primaryFunction
    }
  }
}

A SyntaxError: Cannot query field 'homePlanet' on type 'Droid'

B [{"id": "1", "name": "Luke Skywalker"}, {"id": "2", "name": "R2-D2"}]

C [{"id": "1", "name": "Luke Skywalker", "homePlanet": "Tatooine"}, {"id": "2", "name": "R2-D2", "primaryFunction": "Astromech"}]

D [{"id": "1", "name": "Luke Skywalker", "primaryFunction": "Astromech"}, {"id": "2", "name": "R2-D2", "homePlanet": "Tatooine"}]

💡 Hint

Remember that inline fragments allow querying fields specific to the implementing types.

The query uses inline fragments to fetch fields specific to each implementing type of the Character interface. Humans have 'homePlanet', and Droids have 'primaryFunction'. The result includes these fields accordingly.

🧠 Conceptual

intermediate

Purpose of GraphQL Interface Types

What is the main purpose of using interface types in GraphQL schemas?

A To enforce that only one type can exist in the schema with certain fields.

B To define a set of fields that multiple types must implement, enabling polymorphic queries.

C To create a union of unrelated types without shared fields.

D To restrict queries to only scalar fields.

💡 Hint

Think about how interfaces help with querying different types that share common fields.

Interfaces define a contract of fields that multiple types implement, allowing clients to query those fields polymorphically regardless of the concrete type.

📝 Syntax

advanced

Correct Interface Implementation Syntax

Which of the following GraphQL type definitions correctly implements the interface Vehicle with fields id and speed?

GraphQL

interface Vehicle {
  id: ID!
  speed: Int!
}

A

type Car implements Vehicle {
  id: ID
  speed: Int!
  wheels: Int!
}

B

type Car {
  id: ID!
  speed: Int!
  wheels: Int!
  implements Vehicle
}

C

type Car implements Vehicle {
  id: ID!
  wheels: Int!
}

D

type Car implements Vehicle {
  id: ID!
  speed: Int!
  wheels: Int!
}

💡 Hint

Check that all interface fields are present with correct types and syntax.

Option D correctly implements the Vehicle interface by including all required fields with correct types and syntax. Option D has wrong syntax for implements. Option D has a nullable id which violates the interface. Option D misses the speed field.

🔧 Debug

advanced

Debugging Interface Query Error

Given this query:

query {
  vehicles {
    id
    speed
    wheels
  }
}

and this schema:

interface Vehicle {
  id: ID!
  speed: Int!
}

type Car implements Vehicle {
  id: ID!
  speed: Int!
  wheels: Int!
}

type Bike implements Vehicle {
  id: ID!
  speed: Int!
}

Why does the query cause an error?

A Because 'wheels' is not a field on the Vehicle interface and cannot be queried directly on the interface type.

B Because the interface Vehicle must include the 'wheels' field.

C Because the query is missing inline fragments to specify type-specific fields.

D Because 'speed' is missing from the Bike type implementation.

💡 Hint

Fields queried on an interface must be declared in the interface itself.

The query tries to fetch 'wheels' directly on the interface type 'Vehicle', but 'wheels' is only defined on 'Car'. To query 'wheels', inline fragments are needed to specify the 'Car' type.

❓ optimization

expert

Optimizing Interface Queries with Fragments

You have a GraphQL interface Animal implemented by Dog and Cat. Both have fields id and name. Dogs have barkVolume, Cats have clawSharpness.

Which query is the most efficient and clear way to fetch all animals with their common and specific fields?

A

query {
  animals {
    ...AnimalFields
  }
}

fragment AnimalFields on Animal {
  id
  name
  ... on Dog {
    barkVolume
  }
  ... on Cat {
    clawSharpness
  }
}

B

query {
  animals {
    id
    name
    ... on Dog {
      barkVolume
    }
    ... on Cat {
      clawSharpness
    }
  }
}

C

query {
  animals {
    id
    name
    barkVolume
    clawSharpness
  }
}

D

query {
  animals {
    id
    name
  }
  dogs {
    barkVolume
  }
  cats {
    clawSharpness
  }
}

💡 Hint

Fragments help reuse fields and keep queries organized.

Option A uses a fragment to define common and type-specific fields once, then spreads it in the query. This improves clarity and maintainability. Option A repeats fields inline. Option A queries fields not present on all types causing errors. Option A queries separate root fields, not using the interface.