No desenvolvimento web, a demanda por APIs flexíveis nunca foi tão alta. Entre no GraphQL, uma linguagem de consulta para APIs que fornece uma abordagem revolucionária em comparação às APIs RESTful tradicionais.
Este artigo se aprofunda na importância do GraphQL, particularmente quando implementado no Django, lançando luz sobre seu impacto transformador no desenvolvimento de APIs.
Compreendendo o propósito do GraphQL:
Em sua essência, o GraphQL aborda alguns desafios comuns enfrentados com APIs RESTful. Em uma abordagem RESTful típica, vários endpoints são frequentemente necessários para buscar dados específicos, levando a uma busca excessiva ou insuficiente de informações.
O GraphQL, por outro lado, permite que os clientes solicitem precisamente os dados de que precisam em uma única consulta. Isso reduz significativamente a quantidade de dados transferidos pela rede, otimizando o desempenho e minimizando o uso de recursos.
GraphQL em Django: Uma dupla dinâmica:
Quando combinado com Django, um framework web Python de alto nível, o GraphQL desbloqueia uma dupla dinâmica para desenvolvedores.
O Django, conhecido por sua simplicidade e confiabilidade, integra-se perfeitamente com o GraphQL para fornecer uma solução de API robusta e eficiente.
A integração GraphQL-Django capacita os desenvolvedores a definir um esquema que espelha precisamente seus modelos de dados, permitindo que os clientes solicitem dados com precisão inigualável.
Vantagens do Graphql Sobre APIs RESTful:
- Eficiência: GraphQL minimiza a busca excessiva e insuficiente de dados, aumentando a eficiência na recuperação de dados.
- Flexibilidade: Clientes podem solicitar campos específicos, relacionamentos aninhados ou dados relacionados, oferecendo flexibilidade incomparável.
- Redução de idas e voltas: A capacidade do GraphQL de recuperar todos os dados necessários em uma única solicitação reduz o número de idas e voltas ao servidor.
- Simplicidade de versionamento: Diferentemente do REST, onde o versionamento pode levar a endpoints complexos, o GraphQL simplifica o processo, permitindo transições mais suaves e compatibilidade com versões anteriores.
Implementando Graphql no Django
A implementação do GraphQL no Django envolve a integração de uma biblioteca GraphQL, como o Graphene-Django. Esta biblioteca traduz perfeitamente os modelos Django em um esquema GraphQL, facilitando um processo de adoção direto.
Os desenvolvedores podem então definir consultas e mutações para adaptar precisamente a API às necessidades de seus aplicativos.
Em um aplicativo django pronto, instale o graphene-django:
pip install graphene-djangoApós instalar o pacote graphene-django, precisamos adicionar o pacote instalado nos aplicativos instalados na pasta settings.py do projeto:
# settings.py
. . .
INSTALLED_APPS = [
...
"django.contrib.staticfiles", # <---- Required for GraphiQL
"graphene_django"
]Uma vez que instalamos o pacote e adicionamos o pacote graphene_django, é necessário criar um esquema para um modelo. Digamos que este modelo é usado para armazenar novos livros para um aplicativo:
# models.py
from django.db import models
# Create your models here.
class Book(models.Model):
GENRE_CHOICES = [
('Fiction', 'Fiction'),
('Non-Fiction', 'Non-Fiction'),
('Science Fiction', 'Science Fiction'),
('Mystery', 'Mystery'),
('Fantasy', 'Fantasy'),
]
title = models.CharField(max_length=120)
author = models.ForeignKey("auth.User", on_delete=models.CASCADE)
genre = models.CharField(max_length=20, choices=GENRE_CHOICES)
description = models.TextField()Portanto, usaremos esse modelo para criar um novo esquema e exibir os dados conforme necessário.
No graphql_app também criaremos uma nova pasta chamada api/ onde serão armazenados os arquivos query.py e types.py:
# types.py
from django.contrib.auth.models import User
from graphene_django import DjangoObjectType
from graphql_app.models import Book
class BookType(DjangoObjectType):
class Meta:
model = Book
fields = "__all__"
class UserType(DjangoObjectType):
class Meta:
model = User
fields = "__all__"No types.py é usado o DjangoObejctType para gerar os modelos Book types baseados em modelos django.
Em outras palavras, ele gera automaticamente tipos GraphQL baseados nos campos do modelo que é usado na próxima etapa:
# query.py
import graphene
from django.contrib.auth.models import User
from graphql_app.models import Book
from graphql_app.api.types import BookType, UserType
class Query(graphene.ObjectType):
all_books = graphene.List(BookType)
all_users = graphene.List(UserType)
book_by_title = graphene.Field(BookType, title=graphene.String(required=True))
def resolve_all_books(root, info):
return Book.objects.all()
def resolve_all_users(root, info):
return User.objects.all()
def resolve_book_by_title(root, info, title):
try:
return Book.objects.get(title=title)
except Book.DoesNotExist:
return None
schema = graphene.Schema(query=Query)Explicação
No arquivo query.py são definidas todas as consultas necessárias para a aplicação. Já que temos livros e usuários.
No entanto, para começar a implementação, é necessário explicar o que significa a classe Query. No GraphQL, a classe Query serve como ponto de entrada para buscar dados do servidor.
Ela define a estrutura das consultas que os clientes podem executar para recuperar dados usando o graphene.ObjectType.
A classe Query é uma parte fundamental de um esquema GraphQL e conterá campos que representam diferentes tipos de consultas que um cliente pode fazer.
Portanto, na classe Query temos três consultas: all_books, all_users e book_by_title. Todas elas são definidas pelos tipos que criamos antes. Como o BookType e o UserType que exibirão os dados corretamente, quando buscarmos os dados do esquema graphql.
Além disso, essas consultas precisam ter seus próprios “resolvedores”, a consulta raiz do Django que é usada para recuperar corretamente os dados no grapqhql na sequência.
Então, se a consulta for chamada all_books, ela deverá ser resolve_all_books()…
Definindo o esquema graphql em settings.py:
Como já definimos todos os tipos e consultas, criando o esquema, é hora de definir o esquema no settings.py.
# settings.py
GRAPHENE = {
"SCHEMA": "graphql_app.api.schema.schema"
}O exemplo acima explica o caminho onde a variável schema fica.
Então o caminho para a arquivo schema.py deve parecer desta maneira:
“<nome_do_app>.<sub_pasta>.<nome_do_arquivo>.schema”.
Em outras palavras, ele deve apontar para onde o schema com todas as consultas está.
Resultado
Indo para o caminho da url você terá o seguinte resultado:
Também podemos usar o Postman para testar o esquema graphql:
Conclusão:
Em um cenário digital onde eficiência e flexibilidade são primordiais, o GraphQL surge como um divisor de águas no desenvolvimento de APIs.
Quando harmoniosamente integrado ao Django, essa dupla eleva a experiência de desenvolvimento, oferecendo uma solução concisa, poderosa e personalizável para criar APIs que atendem às demandas de aplicativos modernos.
À medida que a comunidade de desenvolvimento continua a adotar o GraphQL, seu potencial para remodelar a forma como interagimos com APIs se torna cada vez mais evidente, apontando para um futuro onde precisão e desempenho definem o padrão.
