A Brief Introduction to GraphQL

Introduction

GraphQL is a query language for API(Application Programming Interface) and is an alternative to building APIs. It allows for the definition of the structure of the data required and prevents the return of an excessive amount of data from the server.

Many API developers use GraphQL to build APIs because GraphQL APIs are fast, flexible, and user-friendly. And also GraphQL APIs allows user to request what exactly they need. GraphQL is developed by Facebook in 2012 and publicly released in 2015.

 

GraphQL Vs REST

1. Multiple endpoints

REST APIs have multiple endpoints whereas GraphQL APIs have only one endpoint. In the case of REST APIs, API fetches data on basis of endpoints whereas, in the case of GraphQL, API fetches data on the basis of queries that users make on the client-side.

 

2. REST APIs have a problem with multiple round trips

This means that API will hit multiple endpoints to get the required data. For example: Suppose the user wants to get the title of all the blogs. For this the endpoints that API will hit be ‘https:pythonsansar.com/blog/title’. One can see that API hit two endpoints to get the title of the blogs(/blog/title).
But in the case of GraphQL, same to fetch the same data, the user schema looks like this

query{
    blog{
        title
    }
}

 

3. Over fetching problem

Suppose a user wants to fetch the name of the authors. For this, API will hit the endpoint ‘https://pythonsansar.com/author’. This will return other information such as the email of the author, date joined, id, etc. along with the name. Since the API returns unnecessary data other than the name of the author, it is known as an over-fetching problem.

 

4. Under fetching problem

As we can see that when API hits the endpoint ‘https://pythonsansar.com/author’, the returned data is not the required one(which is only the name of the author). This is called the under fetching problem in REST APIs.

 

5. REST APIs are slower than GraphQL APIs.

In this blog, we are going to make a simple Books API using a graphene library provided by python. I assume that you have already installed python on your machine and graphene is supported by django>=1.11. I am using conda for creating a virtual environment and if you don’t have conda on your machine I suggest you install conda(Installation of Conda) or user pipenv or virtualenv for creating a virtual environment.

 

Implementation

Step1: Setting up a virtual environment and installing required libraries

Open your command prompt

C:\> mkdir Book
C:\> cd Book
C:\Book\> conda create -n graphql_tutorial python=3.10

 

Activate environment

C:\Book\> conda activate graphql_tutorial

 

After activating your virtual environment, you will see the name of the environment left-hand side of your current path, then run the following commands:

(graphql_tutorial)C:\Book\> pip install django 
(graphql_tutorial)C:\Book\> pip install grahene-django 
(graphql_tutorial)C:\Book\> pip install django-graphql-jwt
(graphql_tutorial)C:\Book\> code .

I am using VS Code for this demonstration. So, command code. will open the current directory in VS code. If you are using any other IDEs then make sure to open the created folder in your favorite IDE.

 

Step 2: Creating a Django project and adding graphene to your Django project

(graphql_tutorial)C:\Book\> django-admin startproject Books

 

Make sure that your virtual environment is activated and that you are on the right path. Then run your Django project using the following command:

(graphql_tutorial)C:\Book\> cd Books
(graphql_tutorial)C:\Book\Books\> python manage.py runserver

If you see the Django welcome page, then you are doing great till now. If you didn’t see the Django Welcome page, kindly revisit the steps and try again.

Step 3: Creating an app with the name API

(graphql_tutorial)C:\Book\Books\> python manage.py startapp Api

After creating an app, open your settings.py file and add your app and graphene inside INSTALLED_APPS
settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'Api',
    'graphene_django',
    'django_filters',
]

GRAPHENE = {
    "SCHEMA" : 'Books.schema.schema',
    "MIDDLEWARE": [
        "graphql_jwt.middleware.JSONWebTokenMiddleware",
    ],
}

 

Creating Book model
Api > models.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=50)
    author = models.CharField(max_length=50)
    description = models.TextField()

    def __str__(self):
        return self.title

We created a Book model having fields like title, author, and description. Now migrate the changes in the database with the following command:

(graphql_tutorial)C:\Book\Books\> python manage.py makemigrations
(graphql_tutorial)C:\Book\Books\> python manage.py migrate

 

After migrating the changes, register the previously created model in your app’s admin.py file
Api > admin.py

 from django.contrib import admin
 from .models import Book

 # Register your models here.
 admin.site.register(Book)

 

Also, add the urls.py file inside the Api folder

Api > urls.py

from django.contrib import admin
from django.urls import path

urlpatterns = [
    
]

 

Now, create a superuser account by running the following command

(graphql_tutorial)C:\Book\Books\> python manage.py createsuperuser

 

After creating a superuser account, open the link http://127.0.0.1:8000/admin/ to your browser and log in with previously created user credentials. Then you will see something like this

 

Then add some data in your database manually(later we will learn to add data in the database with graphql). This looks something like this

 

Now, we are going to write a schema for our API. Create a new file with the name schema.py in your app
Api > schema.py

import graphene
from .models import Book
from graphene_django import DjangoObjectType


class BookType(DjangoObjectType):
    class Meta:
        model = Book
        fields= "__all__"

class BookQuery(graphene.ObjectType):
    book_element = graphene.List(BookType)

    def resolve_book_element(root, info, **kwargs):
        return Book.objects.all()

 

Now, add the schema.py file in the Books folder(Django project) and the following code

Books > schema.py

import graphene
import Api.schema

class Query(Api.schema.BookQuery):
    pass

schema = graphene.Schema(query=Query)

 

Now, open the urls.py file of your Django project and add the following:

Books > urls.py

from graphene_django.views import GraphQLView
from django.contrib import admin
from django.urls import path, include


urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('Api.urls')),
    path('graphql/', GraphQLView.as_view(graphiql=True)),
]

 

Now, open the link http://127.0.0.1:8000/graphql/ in your browser and make a query as shown below:

Conclusion

In this tutorial, we came to know the difference between REST API and Graphql API. Gaphql provides more flexibility and is user-friendly. There is no problem with over and under fetching in Graphql. Also, there is no problem with multiple round trips.

Check out:

• How to Handle Imbalance Datasets in Machine Learning
• Implement An Infinite Scrolling With Django
• How to Create Word Cloud in Python
• *args and **kwargs in Python