6

In the ever-evolving landscape of API development, GraphQL has emerged as a powerful and efficient alternative to traditional REST APIs. Developed and open-sourced by Facebook, and utilized by giants like Netflix (with their solution Falcore), GraphQL offers a flexible and robust way to interact with data. But why exactly is GraphQL gaining such traction, and how does it differentiate itself from REST? Let’s dive in.

Why GraphQL Over REST? The Core Benefits

One of the most significant advantages of GraphQL over REST lies in its ability to address common challenges faced in data fetching:

1. No More Under or Over Fetching: With REST, we often receive extra data that isn’t always necessary. This leads to inefficient data transfer. GraphQL allows you to specify exactly what data you need, no more, no less. This means you fetch only the relevant information, leading to faster loading times and reduced bandwidth consumption.
2. Data Need Change? No Problem! In a REST API, if data requirements change, it often necessitates changing the REST API endpoint, which can be time-consuming and impact production. GraphQL’s flexible querying allows frontend and backend teams to independently fetch data based on evolving needs without constant API modifications.
3. GraphQL Schema and Type System: GraphQL introduces its own Schema Definition Language (SDL) and a robust type system. This means your API’s capabilities are clearly defined in a schema. This defined schema empowers both frontend and backend teams to work independently, allowing for efficient development and even the creation of mock data to facilitate parallel workstreams.

Understanding the Building Blocks of GraphQL: Types

GraphQL APIs are defined by a strong schema. This schema specifies the available types, which can be thought of as the blueprint for your data.

For example, consider the following types:

• type Post:
  • title: String!
  • author: Person!
• type Person:
  • name: String!
  • age: Int!
  • posts: [Post!]!

Here, we’ve defined a Person and a Post type. A Post has an author of type Person, and a Person can have many posts. This allows us to build powerful relationships like “One to Many” directly within our schema. The [] denotes a list, and ! signifies a required field.

Root Types: Query, Mutation, and Subscription

GraphQL APIs are built around three fundamental “root types” that define how clients interact with the data:

1. Query: Fetching Data with Precision

Query is analogous to REST’s GET requests. It’s used for fetching data.

Example:

GraphQL

type Query {
  allPerson: [Person!]!
  allPerson(last: Int!): [Person!]!
}

In the above example, allPerson is a root field.

Basic Query:

GraphQL

{
  allPerson {
    name
  }
}

This query will fetch the name of all persons. GraphQL excels at nested queries, allowing you to retrieve related data with a single request.

Nested Query Example:

GraphQL

{
  allPerson {
    name
    age
    posts {
      title
    }
  }
}

How amazing is that! With just one query, you can fetch a person’s name, age, and the titles of all their posts. This eliminates the need for multiple round trips to the server, a common issue with REST APIs.

2. Mutation: Changing Data

Mutation operations are used to change data on the server, similar to REST’s POST, PUT, and DELETE operations.

Example type Mutation:

GraphQL

type Mutation {
  createPerson(name: String!, age: String!): Person!
  updatePerson(id: ID!, name: String!, age: String!): Person!
  deletePerson(id: ID!): Person!
}

Using a Mutation:

GraphQL

mutation {
  createPerson(name: "Bob", age: 30) {
    name
    age
    id
  }
}

When this mutation is executed, it will create data with the provided arguments. The response will include the specified payload, such as name, age, and id. This allows for a combined “insert + data retrieval” in a single server call.

3. Subscription: Real-time Updates

Subscription enables real-time data updates in your application. This is crucial for scenarios where instant information is needed, such as new comments appearing or likes being added.

How Subscriptions Work:

When a client subscribes to an event, a direct connection is established with the server. Whenever that event occurs, the server sends the updated data to the client over this connection. This is essentially a stream of data pushed from the server to the client.

Example type Subscription:

GraphQL

type Subscription {
  newPerson: Person!
}

How to Use a Subscription (Basic Example):

GraphQL

subscription {
  newPerson {
    name
    age
    id
  }
}

This means that whenever a newPerson is created (perhaps via a mutation), the server will automatically send the new person’s data (name, age, id) to the subscribing client.

More Full Subscription Examples:

Let’s consider some more complex real-world scenarios where subscriptions shine:

A. Subscribing to New Comments on a Post:

First, define the Comment type and add it to your Post type (if not already present):

GraphQL

type Comment {
  id: ID!
  content: String!
  author: Person!
  post: Post!
}

# (Assuming Post type already exists)
type Post {
  id: ID!
  title: String!
  content: String
  author: Person!
  comments: [Comment!] # Add comments field to Post
}

Then, define a subscription for new comments:

GraphQL

type Subscription {
  commentAdded(postId: ID!): Comment!
}

A client can then subscribe to new comments for a specific post:

GraphQL

subscription OnCommentAdded($postId: ID!) {
  commentAdded(postId: $postId) {
    id
    content
    author {
      name
    }
  }
}

When a new comment is added to the specified postId (perhaps through a createComment mutation), all clients subscribed to commentAdded for that postId will receive the new comment’s id, content, and the name of its author in real-time.

B. Subscribing to Live Updates for a Stock Price:

Imagine an application tracking stock prices.

GraphQL

type StockPrice {
  symbol: String!
  price: Float!
  timestamp: String! # Or a more appropriate DateTime type
}

type Subscription {
  stockPriceUpdated(symbol: String!): StockPrice!
}

A client interested in real-time updates for a specific stock:

GraphQL

subscription OnStockPriceUpdated($symbol: String!) {
  stockPriceUpdated(symbol: $symbol) {
    symbol
    price
    timestamp
  }
}

As the server updates the price for a particular stock symbol (e.g., “AAPL”), it will push these updates to all subscribed clients, keeping their displays current without constant polling.

C. Subscribing to User Status Changes (e.g., Online/Offline):

For a chat application, knowing a user’s online status is critical.

GraphQL

enum UserStatus {
  ONLINE
  OFFLINE
  AWAY
}

type User {
  id: ID!
  username: String!
  status: UserStatus!
}

type Subscription {
  userStatusChanged(userId: ID): User! # userId is optional to subscribe to all status changes
}

A client could subscribe to a specific user’s status:

GraphQL

subscription OnUserStatusChanged($userId: ID!) {
  userStatusChanged(userId: $userId) {
    id
    username
    status
  }
}

Or, to all user status changes:

GraphQL

subscription OnAnyUserStatusChanged {
  userStatusChanged {
    id
    username
    status
  }
}

This allows applications to instantly reflect when a user comes online, goes offline, or changes their status.

---

GraphQL: A Modern API Standard

GraphQL is more than just a query language; it’s a new API standard that provides a more efficient and powerful way to interact with data. It enables declarative data fetching, allowing clients to ask for exactly what’s needed, leading to leaner, faster, and more flexible applications. As you explore the world of API development, understanding GraphQL’s capabilities for queries, mutations, and subscriptions will undoubtedly give you a significant advantage.