Cómo crear un acortador de URL con Django y GraphQL

El autor seleccionó a Girls Who Code para recibir una donación como parte del programa Write for DOnations.

Introducción

GraphQL es un estándar API creado y de código abierto por Facebook como alternativa a las API REST. A diferencia de las API REST, GraphQL utiliza un sistema tipificado para definir su estructura de datos, donde toda la información enviada y recibida debe cumplir con un esquema predefinido. También expone un único punto final para todas las comunicaciones en lugar de múltiples URL para diferentes recursos y resuelve el problema de la sobrecaptación de datos al devolver solo los datos solicitados por el cliente, lo que genera respuestas más pequeñas y concisas.

En este tutorial, creará un backend para un acortador de URL (un servicio que toma cualquier URL y genera una versión más corta y legible) mientras profundiza en los conceptos de GraphQL, como consultas y mutaciones, y herramientas, como la interfaz GraphiQL. Es posible que ya haya utilizado dichos servicios antes, como bit.ly.

Dado que GraphQL es una tecnología independiente del lenguaje, se implementa sobre varios lenguajes y marcos. Aquí, utilizará el lenguaje de programación de propósito general Python, el marco web Django y la biblioteca Graphene-Django como implementación de GraphQL Python con integraciones específicas para Django.

Prerrequisitos

• Para continuar con este tutorial, necesitarás tener instalada la versión 3.5 de Python o una versión superior en tu máquina de desarrollo. Para instalar Python, sigue nuestro tutorial sobre Cómo instalar y configurar un entorno de programación local para Python 3 para tu sistema operativo. Asegúrate de crear e iniciar también un entorno virtual; para seguir el ejemplo de este tutorial, puedes nombrar el directorio de tu proyecto como shorty.

• Se desea tener conocimientos básicos de Django, pero no es obligatorio. Si tienes curiosidad, puedes seguir esta serie sobre desarrollo de Django creada por la comunidad de DigitalOcean.

Paso 1: Configuración del proyecto Django

En este paso, instalará todas las herramientas necesarias para la aplicación y configurará su proyecto Django.

Una vez que haya creado el directorio de su proyecto e iniciado su entorno virtual, como se describe en los requisitos previos, instale los paquetes necesarios mediante pip, el administrador de paquetes de Python. Este tutorial instalará la versión 2.1.7 de Django y la versión 2.2.0 o superior de Graphene-Django:

pip install "django==2.1.7" "graphene-django==2.2.0"

Ahora tienes todas las herramientas necesarias en tu cinturón de herramientas. A continuación, crearás un proyecto de Django usando el django-admincomando. Un proyecto es el código fuente predeterminado de Django: un conjunto de carpetas y archivos con todo lo necesario para comenzar el desarrollo de una aplicación web. En este caso, llamarás a tu proyecto shortyy lo crearás dentro de tu carpeta actual especificando al .final:

django-admin startproject shorty .

Después de crear tu proyecto, ejecutarás las migraciones de Django. Estos archivos contienen código Python generado por Django y son responsables de cambiar la estructura de la aplicación de acuerdo con los modelos de Django. Los cambios pueden incluir la creación de una tabla, por ejemplo. De forma predeterminada, Django viene con su propio conjunto de migraciones responsables de subsistemas como Django Authentication, por lo que es necesario ejecutarlas con el siguiente comando:

python manage.py migrate

Este comando utiliza el intérprete de Python para invocar un script de Django llamado manage.py, responsable de administrar diferentes aspectos de su proyecto, como crear aplicaciones o ejecutar migraciones.

Esto dará un resultado similar al siguiente:

OutputOperations to perform:  Apply all migrations: admin, auth, contenttypes, sessionsRunning migrations:  Applying contenttypes.0001_initial... OK  Applying auth.0001_initial... OK  Applying admin.0001_initial... OK  Applying admin.0002_logentry_remove_auto_add... OK  Applying admin.0003_logentry_add_action_flag_choices... OK  Applying contenttypes.0002_remove_content_type_name... OK  Applying auth.0002_alter_permission_name_max_length... OK  Applying auth.0003_alter_user_email_max_length... OK  Applying auth.0004_alter_user_username_opts... OK  Applying auth.0005_alter_user_last_login_null... OK  Applying auth.0006_require_contenttypes_0002... OK  Applying auth.0007_alter_validators_add_error_messages... OK  Applying auth.0008_alter_user_username_max_length... OK  Applying auth.0009_alter_user_last_name_max_length... OK  Applying sessions.0001_initial... OK

Una vez que la base de datos de Django esté lista para funcionar, inicie su servidor de desarrollo local:

python manage.py runserver

Esto dará:

OutputPerforming system checks...System check identified no issues (0 silenced).March 18, 2020 - 15:46:15Django version 2.1.7, using settings 'shorty.settings'Starting development server at http://127.0.0.1:8000/Quit the server with CONTROL-C.

Este comando eliminará el mensaje de su terminal e iniciará el servidor.

Visita la http://127.0.0.1:8000página en tu navegador local. Verás esta página:

Para detener el servidor y volver a su terminal, presione CTRL+C. Siempre que necesite acceder al navegador, asegúrese de que el comando anterior esté en ejecución.

A continuación, finalizará este paso habilitando la biblioteca Django-Graphene en el proyecto. Django tiene el concepto de app, una aplicación web con una responsabilidad específica. Un proyecto se compone de una o varias aplicaciones. Por ahora, abra el shorty/settings.pyarchivo en el editor de texto que prefiera. En este tutorial se utilizará vim:

vim shorty/settings.py

El settings.pyarchivo administra todas las configuraciones de su proyecto. Dentro de él, busque la INSTALLED_APPSentrada y agregue la 'graphene_django'línea:

shorty/shorty/configuraciones.py

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

Esta adición le dice a Django que usarás una aplicación llamada graphene_django, que instalaste en el Paso 1.

En la parte inferior del archivo, agregue la siguiente variable:

shorty/shorty/configuraciones.py

...GRAPHENE = {    'SCHEMA': 'shorty.schema.schema',}

Esta última variable apunta a tu esquema principal, que crearás más adelante. En GraphQL, un esquema contiene todos los tipos de objetos, como recursos, consultas y mutaciones. Piensa en él como una documentación que representa todos los datos y funciones disponibles en tu sistema.

Luego de las modificaciones, guarde y cierre el archivo.

Ahora has configurado el proyecto Django. En el siguiente paso, crearás una aplicación Django y sus modelos.

Paso 2: Configuración de una aplicación y modelos de Django

Una plataforma Django suele estar compuesta por un proyecto y muchas aplicaciones. Una aplicación describe un conjunto de funciones dentro de un proyecto y, si está bien diseñada, puede reutilizarse en distintos proyectos Django.

En este paso, creará una aplicación llamada shortener, responsable de la función de acortamiento de URL. Para crear su esqueleto básico, escriba el siguiente comando en su terminal:

python manage.py startapp shortener

Aquí utilizó los parámetros , dando instrucciones para crear una aplicación llamada .startapp app_namemanage.pyshortener

Para finalizar la creación de la aplicación, abra el shorty/settings.pyarchivo

vim shorty/settings.py

Añade el nombre de la aplicación a la misma INSTALLED_APPSentrada que modificaste antes:

shorty/shorty/configuraciones.py

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

Guarde y cierre el archivo.

Una vez que hayas agregado tu shortenera shorty/settings.py, podrás continuar con la creación de los modelos para tu proyecto. Los modelos son una de las características clave de Django. Se utilizan para representar una base de datos de forma "Pythonic", lo que te permite administrar, consultar y almacenar datos mediante código Python.

Antes de abrir el models.pyarchivo para realizar cambios, este tutorial le brindará una descripción general de los cambios que realizará.

Su archivo de modelo — shortener/models.py—contendrá el siguiente contenido una vez que haya reemplazado el código existente:

shorty/acortador/modelos.py

from hashlib import md5from django.db import models

Aquí importará los paquetes necesarios para su código. Agregará la línea from hashlib import md5en la parte superior para importar la biblioteca estándar de Python que se utilizará para crear un hash de la URL. La from django.db import modelslínea es una herramienta de ayuda de Django para crear modelos.

Advertencia: En este tutorial, se hace referencia al hash como el resultado de una función que toma una entrada y siempre devuelve la misma salida. En este tutorial, se utilizará la función hash MD5 con fines demostrativos.

Tenga en cuenta que MD5 tiene problemas de colisión y debe evitarse en producción.

A continuación, agregará un modelo denominado URLcon los siguientes campos:

• full_url:la URL que se va a acortar.
• url_hash: un hash corto que representa la URL completa.
• clicks:cuántas veces se accedió a la URL corta.
• created_at:la fecha y hora en que se creó la URL.

shorty/acortador/modelos.py

...class URL(models.Model):    full_url = models.URLField(unique=True)    url_hash = models.URLField(unique=True)    clicks = models.IntegerField(default=0)    created_at = models.DateTimeField(auto_now_add=True)

Para generar el código, deberá url_hashaplicar el algoritmo hash MD5 al full_urlcampo y utilizar solo los primeros 10 caracteres devueltos durante el save()método del modelo, que se ejecuta cada vez que Django guarda una entrada en la base de datos. Además, los acortadores de URL suelen realizar un seguimiento de la cantidad de veces que se hizo clic en un enlace. Para lograrlo, deberá llamar al método clicked()cuando un usuario visite la URL.

Las operaciones mencionadas se agregarán dentro de su URLmodelo con este código:

shorty/acortador/modelos.py

...    def clicked(self):        self.clicks += 1        self.save()    def save(self, *args, **kwargs):        if not self.id:            self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]        return super().save(*args, **kwargs)

Ahora que has revisado el código, abre el shortener/models.pyarchivo:

vim shortener/models.py

Reemplace el código con el siguiente contenido:

shorty/acortador/modelos.py

from hashlib import md5from django.db import modelsclass URL(models.Model):    full_url = models.URLField(unique=True)    url_hash = models.URLField(unique=True)    clicks = models.IntegerField(default=0)    created_at = models.DateTimeField(auto_now_add=True)    def clicked(self):        self.clicks += 1        self.save()    def save(self, *args, **kwargs):        if not self.id:            self.url_hash = md5(self.full_url.encode()).hexdigest()[:10]        return super().save(*args, **kwargs)

Asegúrese de guardar y cerrar el archivo.

Para aplicar estos cambios en la base de datos, necesitará crear las migraciones ejecutando el siguiente comando:

python manage.py makemigrations

Esto le dará el siguiente resultado:

OutputMigrations for 'shortener':  shortener/migrations/0001_initial.py    - Create model URL

Luego ejecuta las migraciones:

python manage.py migrate

Verá la siguiente salida en su terminal:

OutputOperations to perform:  Apply all migrations: admin, auth, contenttypes, sessions, shortenerRunning migrations:  Applying shortener.0001_initial... OK

Ahora que ha configurado los modelos, en el siguiente paso creará el punto final GraphQL y una consulta.

Paso 3: creación de consultas

La arquitectura REST expone diferentes recursos en diferentes puntos finales, cada uno de los cuales contiene una estructura de datos bien definida. Por ejemplo, puede obtener una lista de usuarios en /api/users, esperando siempre los mismos campos. GraphQL, por otro lado, tiene un único punto final para todas las interacciones y utiliza consultas para acceder a los datos. La principal diferencia (y la más valiosa) es que puede utilizar una consulta para recuperar todos sus usuarios dentro de una única solicitud.

Comience creando una consulta para obtener todas las URL. Necesitará un par de cosas:

• Un tipo de URL, vinculado a su modelo previamente definido.
• Una declaración de consulta denominada urls.
• Un método para resolver su consulta, es decir, obtener todas las URL de la base de datos y devolverlas al cliente.

Crea un nuevo archivo llamado shortener/schema.py:

vim shortener/schema.py

Comience agregando las importdeclaraciones de Python:

shorty/acortador/esquema.py

import graphenefrom graphene_django import DjangoObjectTypefrom .models import URL

La primera línea importa la graphenebiblioteca principal, que contiene los tipos básicos de GraphQL, como List. DjangoObjectTypeEs un asistente para crear una definición de esquema a partir de cualquier modelo de Django, y la tercera línea importa el modelo creado previamente URL.

Después de eso, crea un nuevo tipo GraphQL para el URLmodelo agregando las siguientes líneas:

shorty/acortador/esquema.py

...class URLType(DjangoObjectType):    class Meta:        model = URL

Por último, agregue estas líneas para crear un tipo de consulta para el URLmodelo:

shorty/acortador/esquema.py

...class Query(graphene.ObjectType):    urls = graphene.List(URLType)    def resolve_urls(self, info, **kwargs):        return URL.objects.all()

Este código crea una Queryclase con un campo llamado urls, que es una lista de los definidos previamente URLType. Al resolver la consulta a través del resolve_urlsmétodo, se devuelven todas las URL almacenadas en la base de datos.

El shortener/schema.pyarchivo completo se muestra aquí:

shorty/acortador/esquema.py

import graphenefrom graphene_django import DjangoObjectTypefrom .models import URLclass URLType(DjangoObjectType):    class Meta:        model = URLclass Query(graphene.ObjectType):    urls = graphene.List(URLType)    def resolve_urls(self, info, **kwargs):        return URL.objects.all()

Guarde y cierre el archivo.

Ahora, todas las consultas deben agregarse al esquema principal. Piense en él como un contenedor para todos sus recursos.

Crea un nuevo archivo en la shorty/schema.pyruta y ábrelo con tu editor:

vim shorty/schema

Importe los siguientes paquetes de Python agregando las siguientes líneas. La primera, como ya se mencionó, contiene los tipos básicos de GraphQL. La segunda línea importa el archivo de esquema creado previamente.

shorty/shorty/esquema.py

import grapheneimport shortener.schema

A continuación, agregue la Queryclase principal. Esta contendrá, mediante herencia, todas las consultas y operaciones futuras creadas:

shorty/shorty/esquema.py

...class Query(shortener.schema.Query, graphene.ObjectType):    pass

Por último, crea la schemavariable:

shorty/shorty/esquema.py

...schema = graphene.Schema(query=Query)

La SCHEMAconfiguración que definió en el paso 2 apunta a la schemavariable que acaba de crear.

El shorty/schema.pyarchivo completo se muestra aquí:

shorty/shorty/esquema.py

import grapheneimport shortener.schemaclass Query(shortener.schema.Query, graphene.ObjectType):    passschema = graphene.Schema(query=Query)

Guarde y cierre el archivo.

A continuación, habilite el punto final GraphQL y la interfaz GraphiQL, que es una interfaz web gráfica que se utiliza para interactuar con el sistema GraphQL.

Abra el shorty/urls.pyarchivo:

vim shorty/urls.py

Para fines de aprendizaje, elimine el contenido del archivo y guárdelo, para que pueda comenzar desde cero.

Las primeras líneas que agregará son declaraciones de importación de Python:

shorty/shorty/urls.py

from django.urls import pathfrom django.views.decorators.csrf import csrf_exemptfrom graphene_django.views import GraphQLView

pathDjango utiliza esta función para crear una URL accesible para la interfaz GraphiQL. A continuación, importas el csrf_exempt, que permite a los clientes enviar datos al servidor. Puedes encontrar una explicación completa en la documentación de Graphene. En la última línea, importaste el código real responsable de la interfaz a través de GraphQLView.

A continuación, crea una variable llamada urlpatterns.

shorty/shorty/urls.py

...urlpatterns = [    path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),]

Esto unirá todo el código necesario para que la interfaz GraphiQL esté disponible en la graphql/ruta:

El shortener/urls.pyarchivo completo se muestra aquí:

shorty/shorty/urls.py

from django.urls import pathfrom django.views.decorators.csrf import csrf_exemptfrom graphene_django.views import GraphQLViewurlpatterns = [    path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),]

Guarde el archivo y ciérrelo.

De vuelta en la terminal, ejecute el python manage.py runservercomando (si aún no está en ejecución):

python manage.py runserver

Abra su navegador web en la http://localhost:8000/graphqldirección. Se le presentará esta pantalla:

GraphiQL es una interfaz en la que puedes ejecutar sentencias GraphQL y ver los resultados. Una de sus características es la Docssección que se encuentra en la parte superior derecha. Como todo en GraphQL está tipificado, obtienes documentación gratuita sobre todos tus tipos, consultas, mutaciones, etc.

Después de explorar la página, inserte su primera consulta en el área de texto principal:

query {  urls {    id    fullUrl    urlHash    clicks    createdAt  }}

Este contenido muestra cómo se estructura una consulta GraphQL: primero, se utiliza la palabra clave querypara indicar al servidor que solo se desea recuperar algunos datos. A continuación, se utiliza el urlscampo definido en el shortener/schema.pyarchivo dentro de la Queryclase. A partir de ahí, se solicitan explícitamente todos los campos definidos en el URLmodelo utilizando el estilo Camel Case, que es el valor predeterminado para GraphQL.

Ahora, haga clic en el botón de flecha de reproducción en la parte superior izquierda.

Recibirás la siguiente respuesta indicando que aún no tienes URL:

Output{  "data": {    "urls": []  }}

Esto demuestra que GraphQL está funcionando. En su terminal, presione CTRL+Cpara detener el servidor.

Ha logrado mucho en este paso: creó el punto final de GraphQL, realizó una consulta para obtener todas las URL y habilitó la interfaz de GraphiQL. Ahora, creará mutaciones para cambiar la base de datos.

Paso 4: creación de mutaciones

La mayoría de las aplicaciones tienen una forma de cambiar el estado de la base de datos agregando, actualizando o eliminando datos. En GraphQL, estas operaciones se denominan mutaciones. Parecen consultas, pero usan argumentos para enviar datos al servidor.

Para crear tu primera mutación, abre shortener/schema.py:

vim shortener/schema.py

Al final del archivo, comience agregando una nueva clase llamada CreateURL:

shorty/acortador/esquema.py

...class CreateURL(graphene.Mutation):    url = graphene.Field(URLType)

Esta clase hereda el graphene.Mutationhelper para tener las capacidades de una mutación GraphQL. También tiene una propiedad name url, que define el contenido que devuelve el servidor una vez que se completa la mutación. En este caso, será la URLTypeestructura de datos.

A continuación, agregue una subclase con el nombre Argumentsde la clase ya definida:

shorty/acortador/esquema.py

...    class Arguments:        full_url = graphene.String()

Esto define qué datos aceptará el servidor. Aquí, se espera un parámetro full_urlcon un nombre y Stringcontenido:

Ahora agregue las siguientes líneas para crear el mutatemétodo:

shorty/acortador/esquema.py

...    def mutate(self, info, full_url):        url = URL(full_url=full_url)        url.save()

Este mutatemétodo realiza gran parte del trabajo al recibir los datos del cliente y guardarlos en la base de datos. Al final, devuelve la propia clase que contiene el elemento recién creado.

Por último, crea una Mutationclase para contener todas las mutaciones de tu aplicación agregando estas líneas:

shorty/acortador/esquema.py

...class Mutation(graphene.ObjectType):    create_url = CreateURL.Field()

Hasta ahora solo tendrás una mutación llamada create_url.

El shortener/schema.pyarchivo completo se muestra aquí:

shorty/acortador/esquema.py

import graphenefrom graphene_django import DjangoObjectTypefrom .models import URLclass URLType(DjangoObjectType):    class Meta:        model = URL            class Query(graphene.ObjectType):    urls = graphene.List(URLType)    def resolve_urls(self, info, **kwargs):        return URL.objects.all() class CreateURL(graphene.Mutation):    url = graphene.Field(URLType)    class Arguments:        full_url = graphene.String()    def mutate(self, info, full_url):        url = URL(full_url=full_url)        url.save()        return CreateURL(url=url)class Mutation(graphene.ObjectType):    create_url = CreateURL.Field()

Cierre y guarde el archivo.

Para terminar de agregar la mutación, cambie el shorty/schema.pyarchivo:

vim shorty/schema.py

Modifique el archivo para incluir el siguiente código resaltado:

shorty/shorty/esquema.py

import grapheneimport shortener.schemaclass Query(shortener.schema.Query, graphene.ObjectType):    passclass Mutation(shortener.schema.Mutation, graphene.ObjectType):    passschema = graphene.Schema(query=Query, mutation=Mutation)

Guarde y cierre el archivo. Si no está ejecutando el servidor local, inícielo:

python manage.py runserver

Navegue hasta http://localhost:8000/graphqlsu navegador web. Ejecute su primera mutación en la interfaz web de GraphiQL ejecutando la siguiente declaración:

mutation {  createUrl(fullUrl:"https://www.digitalocean.com/community") {    url {      id      fullUrl      urlHash      clicks      createdAt    }  }}

Compuso la Mutación con el createURLnombre, el fullUrlargumento y los datos que desea en la respuesta definida dentro del urlcampo.

La salida contendrá la información de la URL que acaba de crear dentro del datacampo GraphQL, como se muestra aquí:

Output{  "data": {    "createUrl": {      "url": {        "id": "1",        "fullUrl": "https://www.digitalocean.com/community",        "urlHash": "077880af78",        "clicks": 0,        "createdAt": "2020-01-30T19:15:10.820062+00:00"      }    }  }}

Con esto, se agregó una URL a la base de datos con su versión hash, como se puede ver en el urlHashcampo. Intente ejecutar la consulta que creó en el último paso para ver su resultado:

query {  urls {    id    fullUrl    urlHash    clicks    createdAt  }}

La salida mostrará la URL almacenada:

Output{  "data": {    "urls": [      {        "id": "1",        "fullUrl": "https://www.digitalocean.com/community",        "urlHash": "077880af78",        "clicks": 0,        "createdAt": "2020-03-18T21:03:24.664934+00:00"      }    ]  }}

También puedes intentar ejecutar la misma consulta, pero pidiendo sólo los campos que desees.

A continuación, inténtalo una vez más con una URL diferente:

mutation {  createUrl(fullUrl:"https://www.digitalocean.com/write-for-donations/") {    url {      id      fullUrl      urlHash      clicks      createdAt    }  }}

La salida será:

Output{  "data": {    "createUrl": {      "url": {        "id": "2",        "fullUrl": "https://www.digitalocean.com/write-for-donations/",        "urlHash": "703562669b",        "clicks": 0,        "createdAt": "2020-01-30T19:31:10.820062+00:00"      }    }  }}

El sistema ahora puede crear URL cortas y listarlas. En el siguiente paso, permitirá a los usuarios acceder a una URL por su versión corta, redirigiéndolos a la página correcta.

Paso 5: Creación del punto final de acceso

En este paso, utilizará Django Views (un método que toma una solicitud y devuelve una respuesta) para redirigir a cualquiera que acceda al punto final a su URL completa.http://localhost:8000/url_hash

Abra el shortener/views.pyarchivo con su editor:

vim shortener/views.py

Para comenzar, importe dos paquetes reemplazando el contenido con las siguientes líneas:

shorty/acortador/vistas.py

from django.shortcuts import get_object_or_404, redirectfrom .models import URL

Estos se explicarán más detalladamente más adelante.

A continuación, creará una vista de Django llamada root. Agregue este fragmento de código responsable de la vista al final de su archivo:

shorty/acortador/vistas.py

...def root(request, url_hash):    url = get_object_or_404(URL, url_hash=url_hash)    url.clicked()    return redirect(url.full_url)

Esta recibe un argumento llamado url_hashdesde la URL solicitada por un usuario. Dentro de la función, la primera línea intenta obtener la URL de la base de datos usando el url_hashargumento. Si no la encuentra, devuelve el error HTTP 404 al cliente, lo que significa que falta el recurso. Luego, incrementa la clickedpropiedad de la entrada URL, asegurándose de rastrear cuántas veces se accede a la URL. Al final, redirige al cliente a la URL solicitada.

El shortener/views.pyarchivo completo se muestra aquí:

shorty/acortador/vistas.py

from django.shortcuts import get_object_or_404, redirectfrom .models import URLdef root(request, url_hash):    url = get_object_or_404(URL, url_hash=url_hash)    url.clicked()    return redirect(url.full_url)

Guarde y cierre el archivo.

A continuación, abra shorty/urls.py:

vim shorty/urls.py

Agregue el siguiente código resaltado para habilitar la rootVista.

shorty/shorty/urls.py

from django.urls import pathfrom django.views.decorators.csrf import csrf_exemptfrom graphene_django.views import GraphQLViewfrom shortener.views import rooturlpatterns = [    path('graphql/', csrf_exempt(GraphQLView.as_view(graphiql=True))),    path('str:url_hash/', root, name='root'),]

La rootVista será accesible en la /ruta de su servidor, aceptando a url_hashcomo parámetro de cadena.

Guarde y cierre el archivo. Si no está ejecutando el servidor local, inícielo ejecutando el python manage.py runservercomando.

Para probar su nueva incorporación, abra su navegador web y acceda a la http://localhost:8000/077880af78URL. Tenga en cuenta que la última parte de la URL es el hash creado por la mutación del paso 5. Se lo redireccionará a la página de la URL del hash, en este caso, el sitio web de la comunidad de DigitalOcean.

Ahora que la redirección de URL funciona, hará que la aplicación sea más segura implementando el manejo de errores cuando se ejecuta la mutación.

Paso 6: Implementación del manejo de errores

La gestión de errores es una buena práctica en todas las aplicaciones, ya que los desarrolladores no suelen controlar lo que se enviará al servidor. En este caso, se puede intentar prever los fallos y minimizar su impacto. En un sistema complejo como GraphQL, pueden ocurrir muchas cosas, desde que el cliente solicite los datos incorrectos hasta que el servidor pierda el acceso a la base de datos.

Como sistema tipificado, GraphQL puede verificar todo lo que el cliente solicita y recibe en una operación llamada Validación de esquema. Puedes ver esto en acción al realizar una consulta con un campo inexistente.

Navegue http://localhost:8000/graphqlnuevamente en su navegador y ejecute la siguiente consulta dentro de la interfaz GraphiQL, con el iDontExistcampo:

query {  urls {    id    fullUrl    urlHash    clicks    createdAt    iDontExist  }}

Dado que no hay ningún iDontExistcampo definido en su consulta, GraphQL devuelve un mensaje de error:

Output{  "errors": [    {      "message": "Cannot query field "iDontExist"" on type ""URLType"".""
No related posts.