What are fundamental graphql operations

Question

Accepted Answer

GraphQL defines three primary operation types that map to different ways of interacting with data. These operations are the entry points into any GraphQL schema and determine how clients can request or modify data. Each operation has distinct characteristics and use cases, with queries for fetching, mutations for changing state, and subscriptions for real-time updates. schema {
  query: Query
  mutation: Mutation
  subscription: Subscription
}

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

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

type Subscription {
  userCreated: User!
  userUpdated(id: ID!): User!
} **Purpose**: Fetch data without side effects. Equivalent to GET in REST. **Characteristics**: Can be executed multiple times with same result; support for caching; can be sent via GET or POST. **Key Features**: Field selection (choose exactly what you need), aliases (rename fields), fragments (reusable field sets), arguments (filtering, pagination). **Execution**: Runs in parallel; resolvers for fields can be batched. **Example**: `query GetUser { user(id: "123") { name email posts { title } } }` # Basic query with arguments
query GetUser($userId: ID!) {
  user(id: $userId) {
    id
    name
    email
  }
}

# Query with aliases and fragments
query GetUsers {
  active: users(status: ACTIVE) {
    ...UserFields
  }
  inactive: users(status: INACTIVE) {
    ...UserFields
  }
}

fragment UserFields on User {
  id
  name
  email
  createdAt
} **Purpose**: Create, update, or delete data with side effects. Equivalent to POST, PUT, PATCH, DELETE in REST. **Characteristics**: Executed serially (one after another) to ensure data consistency; can return the modified data. **Key Features**: Input types for structured arguments; can update multiple resources; can read back updated state. **Best Practice**: Always return the mutated object so clients can update their cache without additional queries. **Example**: `mutation CreateUser($input: UserInput!) { createUser(input: $input) { id name } }` # Single mutation with input type
mutation CreatePost($input: PostInput!) {
  createPost(input: $input) {
    id
    title
    author {
      id
      name
    }
    createdAt
  }
}

# Multiple mutations in one request (serial execution)
mutation CreateUserAndPost($userInput: UserInput!, $postInput: PostInput!) {
  user: createUser(input: $userInput) {
    id
    name
  }
  post: createPost(input: $postInput) {
    id
    title
  }
} **Purpose**: Establish persistent connections to receive real-time data when events occur. Equivalent to WebSockets or Server-Sent Events. **Characteristics**: Maintains an active connection; pushes data from server to client; requires transport layer like WebSockets. **Implementation**: Usually uses WebSockets (Apollo) or SSE; supports filtering via arguments. **Use Cases**: Live feeds, chat applications, real-time dashboards, collaborative editing. **Example**: `subscription OnUserCreated { userCreated { id name } }` # Basic subscription
subscription OnNewMessage {
  messageAdded(channelId: "general") {
    id
    text
    user {
      name
    }
    timestamp
  }
}

# Subscription with variables and payload
subscription OnPostUpdated($postId: ID!) {
  postUpdated(id: $postId) {
    id
    title
    comments {
      id
      content
    }
  }
} **Query names**: Use nouns describing the data being fetched (e.g., GetUser, ListProducts, SearchPosts). **Mutation names**: Use verbs describing the action (e.g., CreateUser, UpdatePost, DeleteComment). **Subscription names**: Use past-tense event names (e.g., UserCreated, MessageAdded, StatusChanged). **Anonymous operations**: Allowed but discouraged in production; named operations enable better debugging and performance tracking. The three operation types differ in how they are executed. Queries can be executed in parallel, making them efficient for fetching independent data. Mutations are executed serially to prevent race conditions when multiple mutations affect related data. Subscriptions maintain a persistent connection and deliver data asynchronously as events occur. Understanding these execution semantics is critical for designing performant GraphQL APIs.

What are fundamental graphql operations

GraphQL has three fundamental operations: Query for reading data, Mutation for writing/modifying data, and Subscription for real-time data streaming.

Scenario Questions

Follow-up Questions