What is GraphQL (An Overview)

By: Arif Khan.

An Overview

Giving clients only the data they ask for and nothing more is a top priority for the query language and server-side runtime for application programming interfaces (APIs) known as GraphQL.

The goal of GraphQL is to make APIs quick, adaptable, and developer-friendly. Even within the GraphiQL integrated development environment (IDE), it is deployable. Developers can create GraphQL requests as an alternative to REST that combine data from various sources into a single API call.

In addition, GraphQL allows API administrators the freedom to add or remove fields without affecting already-running queries. Developers are free to use any technique they like when creating APIs, and the GraphQL definition will guarantee that they work consistently for clients.

GraphQL Terms.

Developers of APIs use GraphQL to build a schema that lists all the potential data that users of the service may query. Object types make up a GraphQL schema and specify the kinds of objects that can be requested as well as their fields.

GraphQL checks the queries against the schema as they come in. The verified requests are then carried out by GraphQL.

Each field in a schema is connected to a resolver function by the API developer. The resolver is invoked during execution to create the value.

GraphQL defers to the API designer for the majority of other decisions, with the exception of specifying and evaluating the syntax for API queries (described in the graphql-spec repository). Developers can use a variety of programming languages, including JavaScript (graphql.js), Scala (Sangria), Python (Graphene Python), Ruby (graphql-ruby), and PHP (graphql-php), without following any specific guidelines provided by GraphQL. There are no network, authorisation, or pagination requirements with GraphQL.

The most frequent GraphQL operations from the client’s perspective are probably queries and mutations. A query would be comparable to reading if we were to consider them in terms of the create, read, update, and delete (CRUD) paradigm. Mutations handle the other three (create, update, and delete).

The benefits and drawbacks of GraphQL in business environment

Consider testing GraphQL in a professional or enterprise setting. It has benefits and drawbacks.

Benefits

• In a GraphQL application, a GraphQL schema establishes a single source of truth. It gives a company a method to federate all of its APIs.
• Calls to GraphQL are processed in a single round trip. Client requests are fulfilled without any over fetching.
• Strongly defined data types minimize errors in client-server communication.
• It is introspective in GraphQL. A customer may ask for a list of the available data types. For automatically creating documentation, this is perfect.
• With GraphQL, an application API can develop without affecting already-running queries.
• There are numerous free and open source GraphQL extensions that provide functionality not found in REST APIs.
• No particular application architecture is required by GraphQL. It is compatible with current API management tools and may be added on top of an existing REST API.

Drawbacks

• For developers accustomed to REST APIs, learning GraphQL involves a steep curve.
• Because GraphQL places a large portion of the effort of a data query on the server, server developers must deal with additional complexity.
• GraphQL could need different API management techniques than REST APIs, depending on how it is implemented, especially when taking into account rate restrictions and pricing.
• Compared to REST, caching is more complicated.
• The added responsibility of creating maintainable GraphQL schema falls on API maintainers.

GraphQL Query Examples

Viewing some sample queries and responses is the easiest approach to understand GraphQL. We’ll examine three examples that were taken from the GraphQL project website, graphql.org.

The first example demonstrates how a client can create a GraphQL query to ask an API to retrieve particular fields in a particular shape.

{
  person {
    name
  }
}

A GraphQL API would deliver the following outcome in JSON format:

{
  "person": {
    "name": "King"
  }
}

A client may additionally provide parameters in a GraphQL query, as shown in the following example:

{
  person(id: "01220") {
    name
    location
  }
}

The result will be as follows:

{
  "data": {
    "person": {
      "name": "King”,
      "location": "Canada"
    }
  }
}

Things start to become more intriguing from here. Users can construct reusable segments and assign variables using GraphQL.

If necessary, you might ask for a list of IDs followed by a number of records for each ID. With GraphQL, you could create a query that uses just one API request to fetch all the information you need.

The Query will look like as follows:

query PersonComparison($first: Int = 3) {
  leftComparison: person(location: USA) {
    ...comparisonFields
  }
  rightComparison: person(location: OZ) {
    ...comparisonFields
  }
}

fragment comparisonFields on Character {
  name
  friendsConnection(first: $first) {
    totalCount
    edges {
      node {
        name
      }
    }
  }
}

The result will be produced as:

{
  "data": {
    "leftComparison": {
      "name": "King",
      "friendsConnection": {
        "totalCount": 4,
        "edges": [
          {
            "node": {
              "name": "Jones"
            }
          },
          {
            "node": {
              "name": "James"
            }
          },
          {
            "node": {
              "name": "Babar"
            }
          }
        ]
      }
    },
    "rightComparison": {
      "name": "Martha",
      "friendsConnection": {
        "totalCount": 3,
        "edges": [
          {
            "node": {
              "name": "Uncle Tom"
            }
          },
          {
            "node": {
              "name": "Lisa"
            }
          },
          {
            "node": {
              "name": "Kult"
            }
          }
        ]
      }
    }
  }
}

The GraphQL Explorer on GitHub is a simple way for GitHub users to quickly gain practical experience using GraphQL.

Open Source and GraphQL

Facebook created GraphQL, which it used for mobile applications for the first time in 2012. In 2015, the GraphQL specification became open source. These days, the GraphQL Foundation is in charge of it.

Wide range of opensource applications are using GraphQL.

• GraphQL platform Apollo, with its front-end Apollo Client library and back-end Apollo Server framework (Apollo Server).
• Offix is an offline client that enables the execution of GraphQL changes and queries even when an application is not accessible.
• Graphback is a command-line tool for creating Node.js servers with GraphQL support.
• OpenAPI-to-GraphQL is a command-line interface and library used to convert APIs described by OpenAPI Specifications or Swagger into GraphQL.

Keep Updated, by reading informative technology articles. You are welcome to comment.