What is GraphQL?

Client and server communication follows a traditional approach of REST APIs which is good but nowadays applications have become more powerful and complex which requires a more flexible approach rather than REST, so here GraphQL comes into the picture. In this article, we will go through all the concepts of graphQL.

What is GraphQL?

GraphQL is an open-source data query language for APIs and It is a server-side runtime for executing the query. The server's GraphQL runtime takes care of executing the query and ensuring that the right data is fetched and sent back.

It is an alternative to REST, where clients make multiple requests to different endpoints to get the data they require but in GraphQL clients can request exactly the data they need in a single query.

It was developed by Facebook and made open source for the whole world.

Example: Let's take an example, Suppose We have a REST API for a blog. If we want to get a blog post and its author information then We have to make two separate requests to the server:

1. one for the blog post.
2. another for the author's details.

But In GraphQL, we will request both in one query and It will reduce network overhead.

Key Features of GraphQL

GraphQL has several features that set it apart from traditional REST APIs, offering developers a more flexible and efficient way to manage data. Let's explore these features as follows:

1. Flexible Queries: Clients can request exactly the data they need, avoiding over-fetching and under-fetching.
   
2. Strongly Typed: GraphQL schemas provide clear data structures and types, reducing runtime errors.
   
3. Real-time Updates: GraphQL supports subscriptions for real-time data interactions.
   
4. Single Endpoint: Unlike REST, GraphQL typically uses a single endpoint for all data requests.
   
5. Introspection: Clients can explore the schema's capabilities through introspection queries.
   
6. Batching: Multiple queries can be sent in a single request to minimize network overhead.
   
7. Efficient for Mobile: GraphQL can be more efficient for mobile devices by reducing data transfer.
   
8. Versioning: It eliminates the need for versioning in APIs, as changes can be made without breaking existing clients.

Key Components of GraphQL

For Better Understanding of GraphQL, let's see some key components of GraphQL which are as follows:

1. Schema

It defines the data types that can be queried and their relationships. GraphQl uses it's own language that is Schema Definition Language (SDL) for writing the schema. It is human readable language and It does not depends upon any specific language or framework. Schemas has two main types:

1. Queries (for retrieving data)
2. Mutations (for modifying data).

2. Types

GraphQL defines custom types to define the structure of data. There are two main types of Type:

• Scalar Types: It represent values like integers, strings, booleans, and floats.
• Object Types: It represent complex objects with fields. Fields can be scalars or other object types. For example, A "User" object type with fields like "id", "name", and "email".

3. Queries

It is used to retrieve data from a GraphQL server. It specify what type of data we want to retrieve from fields of which types. It is similar to GET requests in REST APIs but allow to request exactly the data we need. It is reducing over-fetching or under-fetching.

4. Mutations

It is used to modify data on the server. It can be used for creating, updating, or deleting data. Mutations are similar to POST, PUT, or DELETE requests in REST APIs.

GraphQL basic Schema Design

let's take an example to understand the basics of graphQL Schema design

Example:

type Book {

  id: ID!

  title: String!

  author: String!

}

type Query {

  books: [Book!]!

  book(id: ID!): Book

}

type Mutation {

  createBook(title: String!, author: String!): Book

  updateBook(id: ID!, title: String, author: String): Book

  deleteBook(id: ID!): Boolean

}

Explanation:

We have defined three main types:

• Book
• Query
• Mutation

Book Type:

The Book type represents a book object with three fields:

• id: An ID field, which is non-nullable (! indicates that it cannot be null).
• title: A String field, which is non-nullable.
• author: A String field, which is non-nullable.

Query Type:

It defines two query fields:

• books: Returns a list of Book objects, ! indicates a non-null list of non-null Book objects.
• book(id: ID!): Takes an id argument and returns a single Book object.

Mutation Type:

It defines three mutation fields:

• createBook: Creates a new book with title and author arguments and returns a Book.
• updateBook: Updates an existing book with id, title, and author arguments and returns a Book.
• deleteBook: Deletes a book with the given id and returns a Boolean indicating success.

Conclusion

GraphQL is a powerful and flexible data query language for APIs. It is offering a more efficient alternative to traditional REST APIs. It allows clients to request exactly the data they need and reducing network overhead. It provides features like strong typing, real-time updates, and a single endpoint.