← GraphQL Course4 / 12

Schema Types: Enums, Lists, Interfaces & Unions

Model richer domains in your schema — fixed choices with enums, polymorphism with interfaces and unions, and reusable shapes with input types.

Ad 728×90

Enums for a fixed set of values

Why: when a field can only be one of a known set — a status, a role, a direction — an enum makes that explicit in the schema. The server and tooling enforce it, so an invalid value is rejected before any resolver runs.

enum Status {
  DRAFT
  PUBLISHED
  ARCHIVED
}

type Post {
  id: ID!
  title: String!
  status: Status!
}

Interfaces for shared fields

Why: an interface defines fields that several types share, so a field can return "any type that implements this interface". Clients query the common fields directly and use inline fragments (... on Type) for the type-specific ones.

interface Media {
  id: ID!
  title: String!
}

type Movie implements Media {
  id: ID!
  title: String!
  runtime: Int!
}

type Podcast implements Media {
  id: ID!
  title: String!
  episodes: Int!
}

Querying an interface

Why: when a field returns an interface, you select the shared fields normally and reach into concrete types with "... on Type". __typename tells you which concrete type each result actually is — useful for rendering. This is GraphQL polymorphism in action.

query {
  search(term: "space") {
    __typename
    id
    title
    ... on Movie {
      runtime
    }
    ... on Podcast {
      episodes
    }
  }
}

Unions for unrelated types

Why: a union is like an interface but for types that share NO fields — a search result that might be a User, a Book, or a Comment. You query each branch with "... on Type". Use an interface when types share fields, a union when they do not.

union SearchResult = User | Book | Comment

type Query {
  search(term: String!): [SearchResult!]!
}

Input types for arguments

Why: passing many arguments to a field is unwieldy, and you cannot reuse an object type as an argument. An input type is a dedicated shape for arguments — essential for mutations (next lessons) that accept structured data.

input CreateBookInput {
  title: String!
  pages: Int
  status: Status = DRAFT     # arguments can have defaults
}

type Mutation {
  createBook(input: CreateBookInput!): Book!
}