• No over-fetching: Clients get exactly what they request
• No under-fetching: Get related data in a single request
• Strong typing: Schema defines exact API contract
• Introspection: Self-documenting APIs
• Version-free: Evolve API without versioning
• Developer experience: Better tooling and debugging
• Frontend independence: Different clients can request different data

1. Query: Read operations to fetch data
2. Mutation: Write operations to modify data
3. Subscription: Real-time operations for live data updates

# Query
query GetUser {
  user(id: "123") { name }
}

# Mutation
mutation CreateUser {
  createUser(input: { name: "John" }) {
    id
    name
  }
}

# Subscription
subscription UserUpdates {
  userUpdated(id: "123") {
    name
    status
  }
}

A GraphQL schema is a contract that defines the structure of the API, including all available operations, types, and relationships. It serves as the single source of truth for what data can be fetched and how.

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Query {
  user(id: ID!): User
  users: [User!]!
}

Scalars are primitive data types that represent leaf values in GraphQL. Built-in scalars include:

• String: UTF-8 character sequence
• Int: 32-bit signed integer
• Float: Double-precision floating-point
• Boolean: true or false
• ID: Unique identifier

You can also define custom scalars:

scalar Date
scalar Email
scalar URL

type User {
  id: ID!
  email: Email!
  birthDate: Date
}

In GraphQL, fields are nullable by default. The exclamation mark (!) makes a field non-nullable.

type User {
  id: ID!           # Required field
  name: String!     # Required field
  email: String     # Optional field (can be null)
  age: Int          # Optional field
  posts: [Post!]!   # Required array of required Posts
  tags: [String]    # Optional array of optional strings
}

Object types represent entities in your domain with named fields. They're the most common type in GraphQL schemas.

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
  createdAt: String!
}

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

Enums define a set of possible values for a field, providing type safety and validation.

enum UserRole {
  ADMIN
  MODERATOR
  USER
  GUEST
}

enum PostStatus {
  DRAFT
  PUBLISHED
  ARCHIVED
}

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

Input types are used for arguments in mutations and queries. They can only contain scalars, enums, lists, and other input types.

input CreateUserInput {
  name: String!
  email: String!
  age: Int
}

input UpdateUserInput {
  name: String
  email: String
  age: Int
}

type Mutation {
  createUser(input: CreateUserInput!): User!
  updateUser(id: ID!, input: UpdateUserInput!): User!
}