Introduction:
- GraphQL is a query language for your API. It was developed and open-sourced by Facebook in 2015. It allows clients to define the structure of the data they need, and the server will return only the requested data.
- One of the key features of GraphQL is its ability to make a single request to the server and retrieve multiple resources in a single request, rather than making multiple REST API requests. This allows for a more efficient use of network resources and can improve the performance of the application.
- GraphQL also allows for real-time updates, as clients can subscribe to changes in the data and receive updates in real-time. It also supports a wide variety of client and server platforms, and can be integrated with existing systems.
- In summary, GraphQL allows for more flexible and efficient communication between the client and the server, it allows client to ask for exactly what they need, nothing more or less, it also allows for real-time updates and can be integrated with existing systems.
Benefits of Graph QL
Here are some of the benefits of using GraphQL:
1. Flexibility: Clients can define the structure of the data they need, allowing for more efficient use of network resources and improved performance.
2. Reduced Over-Fetching and Under-Fetching: With GraphQL, clients can request only the data they need, reducing the amount of unnecessary data transferred over the network.
3. Real-time updates: GraphQL allows for real-time updates, as clients can subscribe to changes in the data and receive updates in real-time.
4. Strongly-typed schema: GraphQL has a strongly-typed schema, which allows for better documentation and more predictable responses.
5. Better developer experience: GraphQL provides a more developer-friendly experience, with an easy-to-use query language, clear error messages, and an introspection system that allows for self-documenting APIs.
6. Platform Agnostic: GraphQL supports a wide variety of client and server platforms, and can be integrated with existing systems.
7. Better performance: By allowing clients to ask for exactly what they need, GraphQL can improve the performance of the application, as it reduces the number of requests needed to be made to the server.
8. Easy to evolve and maintain: With a GraphQL API, it’s easy to add new fields, without having to worry about breaking existing client code, which results in less maintenance and fewer chances of introducing bugs.
Design Principles of GraphQL
Even though GraphQL does not control the way API is built, it does offer some guidelines.
- Hierarchical – A GraphQL query is hierarchical. Fields are nested within other fields and the query is shaped like data that it returns.
- Product-Centric – GraphQL is driven by the data needs of the client and the language and runtime that support the client.
- Strong Typing – A GraphQL server backed by the GraphQL type system. In the schema, each data point has a specific type against which it will be validated.
- Client-specified Queries – A GraphQL server provides the capabilities that the clients are allowed to consume.
- Introspective – The GraphQL language can query the GraphQL server’s type system.
The Query and Mutation Types:
Most types in your schema will just be normal object types, but there are two types that are special within a schema:
schema {
query: Query
mutation: Mutation
}
Every GraphQL service has a query type and may or may not have a mutation type. These types are the same as a regular object type, but they are special because they define the entry point of every GraphQL query. The query will look like,
Input:
query {
hero {
name
}
droid (id: “2000”) {
name
}
}
Output:
{
“data”: {
“hero”: {
“name”: “R2-D2”
},
“droid”: {
“name”: “C-3PO”
}
}
}
GraphQL Clients:
- GraphQL clients have emerged to speed the workflow for developer teams and improve the efficiency and performance of applications.
- They handle tasks like network requests, data caching, and injecting data into the user interface.
- There are many GraphQL clients, but the leaders in the space are Relay and Apollo.
- Relay aims to be the connective between React Components and the data that is fetched from the GraphQL server.
- Apollo Client is a community-driven effort to build more comprehensive tooling around GraphQL.
Advantages of GraphQL
1.Declarative Data Fetching:
- GraphQL embraces declarative data fetching with its queries. The client selects data along with its entities with fields across relationships in one query request.
- GraphQL decides which fields are needed for its UI, and it almost acts as UI-driven data fetching.
- It offers a great separation of concerns: a client knows about the data requirements; the server knows about the data structure and how to resolve the data from a data source (e.g., database, Microservice, third party API).
2.No Over Fetching with GraphQL
- There is no over-fetching in GraphQL. A mobile client usually over-fetches data when there is an identical API as the web client with a RESTful API.
- With GraphQL, the mobile client can choose a different set of fields, so it can fetch only the information needed for onscreen.
3.Single Source of Truth
- The GraphQL schema is the single source of truth in GraphQL applications. It provides a central location, where all available data is described.
- The GraphQL schema is usually defined on the server-side, but clients can read (query) and write (mutation) data based on the schema.
4.GraphQL Embraces Modern Trends
- GraphQL embraces modern trends on how applications are built. You may only have one backend application, but multiple clients on the web, phones, and smartwatches depending on its data.
- GraphQL can be used to connect both worlds, but also to fulfill the requirements of each client application–network usage requirements, nested relationships of data, fetching only the required data–without a dedicated API for each client.
5.Strongly-Typed GraphQL
- GraphQL is a strongly typed query language because it is written in the expressive GraphQL Schema Definition Language (SDL).
- Being strongly typed makes GraphQL less error-prone, can be validated during compile-time, and can be used for supportive IDE/editor integrations such as auto-completion and validation.
