TM

python
popayán
 Describe tus datos

type Project {
name: String
tagline: String
contributors: [User]
}
 Pide lo necesario

query {
project(name: "GraphQL") {
tagline
}
}
 Obtén los resultados

{
"project": {
"tagline": "A query language
for APIs"
}
}
¿Qué es GraphQL?
Es un lenguaje de consultas para API’s.

Proporciona una descripción completa de

los datos.
Permite consumir exactamente lo que se
necesita.

Facilita la evolución de las API’s a lo largo

del tiempo.
¿Qué es un API?
Una Application Programming Interface es
un conjunto de funciones y procedimientos
que permiten utilizar recursos de un
software por otro.

- Wikipedia
Pensemos en un API como un enchufe que
permite consumir un servicio sin importar
que equipo lo consuma.

- David Berlind
2015, What is an API, Exactly?
Un poco de Historia
●
Desarrollado por Facebook en 2012

●
Publicado como open-source en 2015

●
Mantenido desde 2018 por la GraphQL
Foundation
Pensando en
Grafos
En GraphQL, la capa de negocio es
modelada como un grafo, definiendo
diferentes tipos de nodos y como se
relacionan entre sí.
Diferencias con
REST
●
Consulta lo que necesites
●
Múltiples recursos en una sola petición
●
Cambia los verbos y estados HTTP por dos
conceptos: Query y Mutation
●
Es una especificación en lugar de un estilo de
arquitectura
●
Diseñado como una capa de abstracción
●
Auto-documentado
Schema
El schema es la estructura fundamental.

Alberga los objects types Query y Mutation,

quienes determinan los servicios de
consulta y modificación.

El SDL (Schema Definition Language)

permite diseñar nuestra API GraphQL.
schema {
query: Query
mutation: Mutation
}
Introspection
System
 {
__schema {
types {
name
Obtiene información
fields {
sobre el schema. description
}
}
}
}
Type System
Son un conjunto de tipos que describen
completamente los datos con los que puede
interactuar.

Engloban los siguientes conceptos:

Scalars, Objects, Enums, Interfaces y
Unions.
Root Query Type
Elemento principal para poder consultar los
campos de un object type.
query {
group(name: "Python Popayán") {
date
members {
name
email
}
}
}
Scalar Types
 Int
Nos permite definir
Float
los campos de
String
nuestros objects o
Boolean
interface.
ID
Type Modifiers
Afectan la validación de los datos, permitiendo
que un campo sea requerido u opcional.
String! Cadena no nula

[String] Lista

[String]! Lista sin elementos nulos

[String!]! Lista no nula sin elementos nulos

 Ejemplo 1

myField: [String!]

myField: null // valid

myField: [] // valid
myField: ['a', 'b'] // valid
myField: ['a', null, 'b'] // error
 Ejemplo 2

myField: [String]!

myField: null // error

myField: [] // valid
myField: ['a', 'b'] // valid
myField: ['a', null, 'b'] // valid
Object Types and
Fields
Componente más básico de un esquema
GraphQL.

Permite definir entidades para nuestra API.

Es la fuente única y definitiva de

información sobre los datos.
type Teacher { type Course {
id: ID! id: ID!
name: String description: String
age: Int teachers: [Teacher]
} }
Enumeration Types
Los Enums son un
enum Language {
tipo especial de
PYTHON
scalar que está
JAVA
restringido a un
C#
conjunto de valores
}
permitidos.
Interface
El type interface permite que los campos
especificados dentro de ésta, también se
definan en los objects que la implementen.
 type Student
implements Profile {
interface Profile { username: String!
username: String! email: String!
email: String! name: String!
} age: Int
course: String
}
Fragments
Agrupa campos en una declaración
reutilizable en distintas consultas.
 query {
fragment fields on course(id: 1) {
Course { ...fields
title }
description courses {
date ...fields
} }
}
Inline Fragments
Hermanos menores de los fragments ya que
estos se embeben en la consulta
directamente.
query {
search(text: 'an') {
... on Friend {
lastname
}
... on Event {
date
}
}
}
Union Types
Son útiles para agrupar varios object types
en una consulta.
 union SearchResult = Friend | Place | Event

Para resolver el problema de que no todos

los object types tiene los mismos campos,
se hace uso de los inline fragments.
Variables
Para generar consultas dinámicas, debemos
aplicar el concepto de variables, de la
misma forma como en los lenguajes de
programación.
query result($var: String) {
person(name: $var) {
name
friends {
name
lastName
}
}
}
Directives
Aprovechando el uso de variables, podemos
cambiar dinámicamente la estructura y la
forma de nuestras consultas con las
directives include y skip.
query result($var: String, $bool: Boolean) {
person(name: $var) {
name @include(if: $bool)
friends @skip(if: $bool) {
name
lastName
}
}
}
Aliases
Útil para diferenciar la consulta a un mismo
recurso evitando la ambigüedad.
query {
resource1: user(id: 1) {
name
}
resource2: user(id: 2) {
last_name
}
}
Resolvers
Cada object type y sus respectivos fields
están respaldados por una función o
método resolver.

Cuando se ejecuta la consulta, se llama al

resolver correspondiente devolviendo el
object type solicitado.
resolverPerson(_, args) {
return sql.raw(
'SELECT * FROM PERSON
WHERE id = {args.id}'
);
}
resolverPerson(id) {
return request('http://example/
api/person/${id}')
}
resolverPerson(id) {
return Person.find(id)
}
Adquieren una gran importancia ya que la
fuente de los datos puede proceder de
cualquier parte.

Esa característica dota a GraphQL de una

mayor flexibilidad.
Root Mutation Type
Elemento principal para poder crear,
actualizar y eliminar un object type.

Todo lo que produzca una alteración en el

object type se considera una mutación.
mutation {
createGroup(
name: "Python Popayán",
yearCreation: 2017
) {
name
}
}
Como parte de la especificación, siempre se
debe pedir un campo como mínimo antes
de ejecutar una mutación.
Input Types
Encapsulan argumentos complejos.

Muy útiles en el caso de las mutaciones.

input PersonInput {
name: String!
lastName: String
}
mutation create($person: PersonInput) {
createPerson(person: $person) {
id
}
}
Vitaminas
Apollo Client es un cliente GraphQL
sofisticado que facilita el consumo de la API.

Tanto Apollo Client como Apollo Server son

librerías open-source incluidas en la
plataforma Apollo escrito en React.
Apollo Client soporta múltiples plataformas

●
Polymer
●
Angular ●
lit-apollo
●
Vue js ●
iOS nativo con Swift
●
Meteor ●
Android nativo con
●
Ember
Java
Relay es un framework de JavaScript
creado con el propósito de mejorar la
arquitectura de GraphQL.
GraphiQL
Es un editor, explorador e IDE para una API
desarrollada con GraphQL.

Permite interactuar con la API y utilizar los

conceptos descritos anteriormente.
Implementaciones
en Python
Graphene
La implementación más popular de
GraphQL en el lenguaje de programación
Python.
import graphene

class Query(graphene.ObjectType):
hello = graphene.String()

def resolve_hello(self, info):

return 'world'

schema = graphene.Schema(query=Query)

result = schema.execute('{ hello }')

print(result.data['hello'])
Integración con
Frameworks
pip install graphene-django pip install flask-graphql
Autenticación
 Sesiones

Tanto Django como Flask gestionan el envió de

cookies.

Ideal cuando no tiene una aplicación móvil.

 Argumentos

Envié un token en la consulta si tiene algunos

campos que requieren autenticación.
 Cabeceras HTTP

Utilice JWT (Json Web Tokens) para gestionar

las autorizaciones a su API.

Ideal si necesita comunicarse con un front-

end.
pip install django-graphql-jwt pip install flask-graphql-auth
Ariadne
Una nueva implementación de GraphQL
para Python inspirada en Apollo Server.
Bibliografía
●
https://graphql.org/
●
https://howtographql.com
●
https://graphene-python.org/
●
https://ariadne.readthedocs.io/
●
https://graphqlhub.com
●
https://youtu.be/MqIw9-39rnU
●
https://apis.guru/graphql-voyager/
●
https://github.com/chentsulin/awesome-graphql