The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

GraphQL Types

Next ►
►

In this section, we will delve into the core concept of GraphQL types. Understanding GraphQL types is fundamental to designing a robust and efficient GraphQL schema. Types in GraphQL define the shape of the data and how it can be queried. Let's explore the different types available in GraphQL and how to use them.

  1. Introduction to GraphQL Types

GraphQL types are the building blocks of a GraphQL schema. They define the structure of the data and the relationships between different pieces of data. The main types in GraphQL are:

  • Scalar Types
  • Object Types
  • Enum Types
  • Interface Types
  • Union Types
  • Input Object Types

  1. Scalar Types

Scalar types represent the leaves of the query. They are the basic data types that resolve to a single value. GraphQL comes with several built-in scalar types:

  • Int: A signed 32-bit integer.
  • Float: A signed double-precision floating-point value.
  • String: A UTF-8 character sequence.
  • Boolean: A true or false value.
  • ID: A unique identifier, often used to refetch an object or as a key for a cache.

Example

type User {
  id: ID!
  name: String!
  age: Int
  isActive: Boolean!
}

In this example, the User type has fields with different scalar types: ID, String, Int, and Boolean.

  1. Object Types

Object types are the most common type in a GraphQL schema. They represent a collection of fields, where each field has a type. Object types can reference other object types, creating a graph of data.

Example

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
}

Here, the Post type has a field author that references the User type, establishing a relationship between posts and users.

  1. Enum Types

Enum types are a special kind of scalar that is restricted to a particular set of allowed values. They are useful for representing a fixed set of options.

Example

enum Role {
  ADMIN
  USER
  GUEST
}

type User {
  id: ID!
  name: String!
  role: Role!
}

In this example, the Role enum type restricts the role field of the User type to one of the specified values: ADMIN, USER, or GUEST.

  1. Interface Types

Interface types are abstract types that define a set of fields that multiple object types can implement. They allow for polymorphism in the schema.

Example

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

type Hero implements Character {
  id: ID!
  name: String!
  superpower: String!
}

type Villain implements Character {
  id: ID!
  name: String!
  evilPlan: String!
}

In this example, both Hero and Villain types implement the Character interface, ensuring they have the id and name fields.

  1. Union Types

Union types are similar to interface types but do not require the types to share any fields. They are useful for fields that can return one of several different types.

Example

union SearchResult = User | Post

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

Here, the SearchResult union type allows the search query to return a list of either User or Post types.

  1. Input Object Types

Input object types are used for complex arguments in queries and mutations. They allow you to pass structured data as arguments.

Example

input UserInput {
  name: String!
  age: Int
  role: Role!
}

type Mutation {
  createUser(input: UserInput!): User!
}

In this example, the UserInput input type is used as an argument for the createUser mutation, allowing for a structured way to pass user data.

Practical Exercise

Task

Create a GraphQL schema that includes the following:

  1. A Book type with fields: id, title, author, and publishedYear.
  2. An Author type with fields: id, name, and books (a list of Book).
  3. An enum type Genre with values: FICTION, NONFICTION, SCIENCE, FANTASY.
  4. A Query type with a field booksByGenre that takes a Genre argument and returns a list of Book.

Solution

enum Genre {
  FICTION
  NONFICTION
  SCIENCE
  FANTASY
}

type Book {
  id: ID!
  title: String!
  author: Author!
  publishedYear: Int!
  genre: Genre!
}

type Author {
  id: ID!
  name: String!
  books: [Book!]!
}

type Query {
  booksByGenre(genre: Genre!): [Book!]!
}

Conclusion

In this section, we covered the various types available in GraphQL, including scalar types, object types, enum types, interface types, union types, and input object types. Understanding these types is crucial for designing a well-structured and efficient GraphQL schema. In the next section, we will explore GraphQL Scalars in more detail.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved