GraphQL — The Query language for APIsArun RajeevanBlockedUnblockFollowFollowingMar 6GraphQL is a query language for your API, and a server-side runtime for executing queries by using a type system you define for your data.
Note: GraphQL is often confused with being a database technology.
This is a misconception, GraphQL is a query language for APIs — not databases.
Challenges in API design:1.
Increased mobile usage creates need for efficient data loadingTo minimizes the amount of data that needs to be transferred over the network.
Variety of different frontend frameworks and platformsDifferent types of frontend frameworks and platforms that run client applications makes it difficult to build and maintain one API that would fit the requirements of all.
Fast development & expectation for rapid feature developmentWith REST APIs, the way data is exposed by the server often needs to be modified to account for specific requirements and design changes on the client-side.
This hinders fast development practices and product iterations.
Data Fetching with REST vs GraphQLWith a REST API, you would typically gather the data by accessing multiple endpoints.
In the example, these could be /users/<id> endpoint to fetch the initial user data.
Secondly, there’s likely to be a /users/<id>/posts endpoint that returns all the posts for a user.
The third endpoint will then be the /users/<id>/followers that returns a list of followers per user.
With REST, you have to make three requests to different endpoints to fetch the required data.
You’re also overfetching since the endpoints return additional information that’s not needed.
In GraphQL on the other hand, you’d simply send a single query to the GraphQL server that includes the concrete data requirements.
The server then responds with a JSON object where these requirements are fulfilled.
Using GraphQL, the client can specify exactly the data it needs in a query.
Notice that the structure of the server’s response follows precisely the nested structure defined in the query.
No more Over- and UnderfetchingOne of the most common problems with REST is that of over- and underfetching.
This happens because the only way for a client to download data is by hitting endpoints that return fixed data structures.
It’s very difficult to design the API in a way that it’s able to provide clients with their exact data needs.
Rapid Product Iterations on the FrontendA common pattern with REST APIs is to structure the endpoints according to the views that you have inside your app.
This is handy since it allows for the client to get all required information for a particular view by simply accessing the corresponding endpoint.
The major drawback of this approach is that it doesn’t allow for rapid iterations on the frontend.
With every change that is made to the UI, there is a high risk that now there is more (or less) data required than before.
Consequently, the backend needs to be adjusted as well to account for the new data needs.
This kills productivity and notably slows down the ability to incorporate user feedback into a product.
With GraphQL, this problem is solved.
Thanks to the flexible nature of GraphQL, changes on the client-side can be made without any extra work on the server.
Since clients can specify their exact data requirements, no backend engineer needs to make adjustments when the design and data needs on the frontend change.
Insightful Analytics on the BackendGraphQL allows you to have fine-grained insights about the data that’s requested on the backend.
As each client specifies exactly what information it’s interested in, it is possible to gain a deep understanding of how the available data is being used.
This can for example help in evolving an API and deprecating specific fields that are not requested by any clients any more.
Benefits of a Schema & Type SystemGraphQL uses a strong type system to define the capabilities of an API.
All the types that are exposed in an API are written down in a schema using the GraphQL Schema Definition Language (SDL).
This schema serves as the contract between the client and the server to define how a client can access the data.
Once the schema is defined, the teams working on frontend and backends can do their work without further communication since they both are aware of the definite structure of the data that’s sent over the network.
Frontend teams can easily test their applications by mocking the required data structures.
Once the server is ready, the switch can be flipped for the client apps to load the data from the actual API.