# GraphQL: la alternativa flexible a REST para programar API

Las aplicaciones web utilizan [API, en inglés Application Programming Interfaces](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/application-programming-interface-api/ "Application Programming Interface (API)") o interfaces de programación de aplicaciones en castellano, para el intercambio y tratamiento de datos, de modo que, si otros servicios han de acceder a datos de tu proyecto web, debes **desarrollar e implementar una interfaz de este tipo**. También aquí existen estándares asentados como SOAP o [REST](https://www.ionos.es/digitalguide/servidores/know-how/rest-la-solucion-http-para-paginas-web/ "REST: la solución HTTP para páginas web") (Representational State Transfer), que fijan una **estructura elemental para tu API** compatible con cualquier lenguaje usual de programación –la segunda arquitectura en especial se ha convertido en los últimos años en una solución excelente debido a su **simplicidad**.

Pero, aunque el triunfo de la arquitectura de REST impresiona, existen alternativas, como GraphQL, igualmente convincentes. El **lenguaje de consulta y [entorno de tiempo de ejecución](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/que-es-un-runtime-environment/ "¿Qué es un runtime environment?") de la casa Facebook** puede competir perfectamente con SOAP y REST, si bien sus facultades saltan a la luz en las consultas de mayor complejidad.

## ¿Qué es GraphQL?

[GraphQL](http://GraphQL.org/ "Página oficial de GraphQL") es un **lenguaje de consulta similar a SQL** **desarrollado por Facebook en 2012,** **que incluye un entorno de tiempo de ejecución y un sistema de tipos.** Originalmente estaba destinado exclusivamente a su aplicación interna. La causa fue la remodelación de las aplicaciones móviles nativas de Facebook para iOS y Android, las cuales mostraban un rendimiento cada vez más bajo debido a un aumento de la complejidad. En especial para la **entrega de los datos del hilo de noticias**, la multinacional debía encontrar una solución que representara una relación satisfactoria entre la información que se solicitaba y las consultas al servidor. En 2015, Facebook **liberalizó el acceso al código fuente de GraphQL**, que en aquel momento gestionaba casi en solitario el acceso a los datos de las aplicaciones móviles. Desde 2017, el proyecto se desarrolla bajo la **licencia gratuita OWFa-1.0** (Open Web Foundation).

## Así funciona GraphQL

Para entender el funcionamiento de GraphQL, es necesario explicar los tres componentes elementales que caracterizan al proyecto de código abierto:

- **Lenguaje de consulta**: en primer lugar, el concepto GraphQL describe un lenguaje de consulta (Query Language) que facilita a los programas **el acceso a una API**. Mientras otras arquitecturas de interfaz solo permiten consultas estrictas que a menudo solo garantizan acceder a un solo recurso, las consultas GraphQL se distinguen por una gran **flexibilidad**. Esta se demuestra, en concreto, por el hecho de **no existir un límite para el número de recursos consultados** y porque se pueden definir exactamente los campos de datos que se van a consultar. GraphQL permite tanto consultas de lectura como de escritura.
- **Sistema de tipos**: GraphQL trabaja con un sistema propio de tipos que permite describir a una API con tipos de datos. Las **estructuras de datos** definidas de este modo son las que crean el marco para las consultas. Cada tipo consta de uno o varios campos que, a su vez, contienen **sus propios tipos de datos**. Este sistema individual sirve a GraphQL como punto de orientación para **validar consultas** y poder rechazar las erróneas.
- **Entorno de tiempo de ejecución**: por último, GraphQL también ofrece distintos entornos de tiempo de ejecución para servidores para llevar a cabo consultas GraphQL. Este es el propósito de las **bibliotecas disponibles para distintos lenguajes de programación**, por ejemplo, Go, Java, JavaScript, PHP, Python o Ruby, que otorgan una gran libertad al usuario a la hora de elegir el lenguaje de su **API GraphQL**. No obstante, el entorno de tiempo de ejecución es exclusivamente responsable de la **conversión (análisis) y validación de las consultas**, además de la **serialización de las respuestas** (conversión del objeto en un orden correspondiente de bits). Guardar y calcular los datos (por ejemplo, en un banco de datos) corresponde al ámbito de funciones de tu aplicación web.

La interacción del lenguaje de consulta, el sistema de tipos y el entorno de tiempo de ejecución genera una estructura API extremadamente versátil **no solo para cualquier plataforma o aplicación**, sino que también puede ajustarse perfectamente a las propiedades de tu aplicación web: puedes integrar la interfaz de GraphQL **sin problemas en el código de tu proyecto,** independientemente del marco de trabajo que utilices, sea Django, Rails o Node.js.

## ¿Qué distingue a GraphQL?

Una de las características principales de GraphQL es la sencillez del lenguaje de consulta, que facilita a los desarrolladores el acceso a la interfaz. Al utilizar GraphQL es fácil darse cuenta de que **las respuestas que se obtienen reflejan exactamente las consultas que se han formulado**. El formato de salida es el ligero y popular formato JavaScript [JSON](https://www.json.org/json-es.html "Introducción a JSON") (JavaScript Object Notation). Por lo tanto, enviar una consulta exacta no debería suponer ningún desafío, siempre que conozcas la estructura de los datos que tu aplicación necesita y la formules en la consulta. Junto a la **sencillez en la creación de consultas**, GraphQL destaca especialmente por las siguientes características:

- **Estructura jerárquica**: las bases de datos que pueden consultarse con API de GraphQL tienen una estructura jerárquica. Es posible generar **relaciones** de forma automática entre los objetos que permiten **formular (y responder) consultas complejas en una única solicitud**. El intercambio de mensajes entre el servidor y el cliente (también llamados “round trips”) no es necesario. Esta jerarquía de datos es especialmente idónea para **bases de datos orientadas a grafos** como [JanusGraph](http://janusgraph.org/ "JanusGraph: base de datos escalable de grafos de la Fundación Linux") y para **interfaces de usuario** que también suelen ordenarse jerárquicamente.
- **Tipificación estricta**: cada nivel en una consulta GraphQL corresponde a un determinado tipo, y cada tipo describe un **conjunto de campos disponibles**. No obstante, este sistema de tipos no solo puede determinar automáticamente si una **consulta está formulada de manera correcta o incorrecta**: como SQL y gracias a la estricta tipificación, GraphQL puede emitir mensajes de error ya durante el desarrollo o el envío de consultas.
- **Flexibilidad**: GraphQL permite formular consultas flexibles y otorga al usuario una gama de **libertades y ventajas en el desarrollo y ajuste de tu interfaz**. Normalmente se requieren pocos reajustes del lado del servidor, aunque el equipo de desarrolladores puede actuar de manera totalmente independiente respecto del equipo responsable del componente cliente. Además, todos los **cambios o las ampliaciones de las API** se pueden ejecutar **sin versionado**, ya que, si es necesario añadir campos adicionales, se puede hacer fácilmente sin **perjudicar a los clientes existentes**.

## GraphQL vs. REST: ¿qué diferencia a ambos conceptos API?

Ya hemos mencionado el gran éxito de REST en la World Wide Web de la misma forma que hemos hecho hincapié en GraphQL como una alternativa seria a esta consolidada arquitectura para servicios web, basada en HTTP y orientada a recursos. Lo que lo hizo posible fue, sobre todo, un desarrollo que fue el que motivó a Facebook a la concepción de GraphQL: la **creciente relevancia y complejidad de las aplicaciones web móviles.** Es en especial en las aplicaciones de Android, iOS, etc., donde se demuestra la gran fortaleza de GraphQL como base para API: **con una única consulta se puede acceder a todos los datos.**

La instancia servidor de GraphQL entrega exactamente la información definida en la consulta, de manera que **no se envíen ni más ni menos datos de los necesarios a través de la interfaz**. En otras API REST comparables puedes consultar solamente un registro por consulta, con lo cual este se emite en su totalidad. Si hacemos una comparación directa entre GraphQL y REST, se demuestra que **el concepto de consulta de Facebook es considerablemente más preciso y eficaz**, lo cual beneficia al rendimiento de tu aplicación. Este vale la pena especialmente para usuarios de dispositivos móviles, cuya conexión a internet es frecuentemente débil.

Mientras que, por un lado, la libertad de las consultas en GraphQL genera muchas ventajas, por el otro puede conllevar, sin embargo, **serios problemas de seguridad**, sobre todo, si quieres ofrecer **API abiertas** a través de las cuales no puedes controlar el comportamiento de las consultas de clientes de terceros. Podría ocurrir que una gran cantidad de consultas provocara un fallo o caída del servidor (de forma intencionada o inintencionada). Esta situación, de la que debes protegerte debidamente, no es tan inminente si implementas una API REST. Implementar GraphQL en el backend de tal forma que rinda y funcione de manera segura es bastante más difícil.

Además, la implementación de un **método de almacenamiento en caché** es mucho más complicado para las consultas invariables de GraphQL que para consultas a través de una interfaz REST. Estas se pueden guardar temporalmente (por ejemplo, en el navegador) con los **métodos de almacenamiento en caché de la especificación HTTP**.

## Tutorial de GraphQL con un ejemplo

GraphQL te ofrece, gracias a la amplia oferta de bibliotecas disponibles, múltiples opciones a la hora de escoger el lenguaje de programación base. Esta es también una de las mayores ventajas a la hora de **implementar una interfaz de GraphQL en tu aplicación**. De esta manera, si te gusta Phyton, puedes recurrir a la [biblioteca Graphene](https://github.com/GraphQL-python/graphene "Directorio en GitHub de Graphene") o trabajar con la biblioteca [GraphQL-java](https://github.com/GraphQL-java/GraphQL-java "github.com: GraphQL-java") si tu proyecto se basa en Java. Si tu aplicación web se basa en el entorno de tiempo de ejecución de JavaScript Node.js, [GraphQL.js](https://github.com/GraphQL/GraphQL-js/ "Repositorio de GraphQL.js en GitHub") puede servir, entre otros, como base para su implementación.

---

### Nota

Puedes encontrar un listado de las bibliotecas para GraphQL y aplicaciones clientes disponibles para distintos lenguajes de programación en la [página oficial de GraphQL](https://graphql.org/code/ "Bibliotecas y clientes para GraphQL").

---

En el siguiente tutorial de GraphQL te explicamos cómo empezar a utilizar el framework API para una **aplicación JavaScript**, donde, además de la mencionada **biblioteca GraphQL.js**, también se emplea el **marco web** [Express](https://expressjs.com/ "Página oficial del framework para webapps Express").

### Paso 1: instalación de la biblioteca

Para poder utilizar bibliotecas GraphQL, **debes** **instalarlas primero**. Para instalar la biblioteca JavaScript GraphQL.js utiliza el gestor de paquetes de JavaScript [npm (Node Package Manager)](https://www.npmjs.com/ "Gestor de paquetes para JavaScript: npm") y el siguiente comando:

```none
npm install --save graphql
```

Como alternativa, puedes adquirir la **biblioteca** también desde el gestor de paquetes y dependencias [Yarn](https://classic.yarnpkg.com/lang/en/ "Página oficial de Yarn") desarrollado, entre otros, por Facebook (principalmente) y Google:

```none
yarn add graphql
```

En cualquier caso, es necesario tener instalada una versión actual de Node.js (recomendamos Node v6.0.0 o superior).

### Paso 2: el primer esquema de consultas

Para que tu aplicación pueda procesar consultas GraphQL, necesitas un esquema que defina el **tipo “Query”** (es decir, “consulta”) y el **punto de acceso a tu interfaz** (también llamado raíz API) que incluye la función “resolver”. Para realizar una interfaz **GraphQL** que únicamente emita el mensaje “¡Hola, mundo!”, el código que se escribiría en el archivo *server.js* creado para este fin sería este:

```none
var { graphql, buildSchema } = require('graphql');
// construye esquema basado en el concepto GraphQL
var schema = buildSchema(`
type Query {
hello: String
}
`);
// la raíz API provee una función “resolver” para cada punto final que accede
var root = {
hello: () => {
return '¡Hola, mundo!';
},
};
// ejecuta consulta GraphQL '{ hello }' y emite la respuesta correcta
graphql(schema, '{ hello }', root).then(response => {
console.log(response);
});
```

Si ejecutas este código con **Node.js** introduciendo en la terminal este comando:

```none
node server.js
```

deberías obtener este mensaje de respuesta:

```none
{ data: { hello: '¡Hola, mundo!' } }
```

### Paso 3: tu propio servidor GraphQL con Express

Tras haber generado una consulta sencilla en los pasos anteriores y haberla ejecutado en la terminal de comandos, es el momento de poner en marcha un **servidor API GraphQL**. Con él podrás, por ejemplo, acceder a la interfaz utilizando un navegador web corriente. Para ello, instala primero el **framework de aplicaciones** **Express** previamente mencionada, así como la biblioteca express-GraphQL con este comando:

```none
npm install express express- graphql --save
```

A continuación, modifica la consulta GraphQL “¡Hola, mundo!” de tal modo que, en lugar de un sencillo script, se convierta en la base de tu servidor GraphQL. Para ello, implementa el **módulo Express** y utiliza la biblioteca express-GraphQL para integrar el servidor API con **el punto final HTTP “/graphql”**:

```none
var express = require('express');
var graphqlHTTP = require('express-graphql');
var { buildSchema } = require('graphql');
// construye un equema basado en el concepto GraphQL
var schema = buildSchema(`
type Query {
hello: String
}
`);
// la raíz API provee una función “resolver” para cada punto final que accede
var root = {
hello: () => {
return '¡Hola Mundo!';
},
};
var app = express();
app.use('/graphql', graphqlHTTP({
schema: schema,
rootValue: root,
graphiql: true
}));
app.listen(4000);
console.log('GraphQL-API-Server auf localhost:4000/graphql ausführen');
```

Como en el ejemplo anterior, abre el archivo *server.js* con Node.js, con la diferencia de que esta vez no ejecutas una consulta, sino que **inicias tu servidor API**:

```none
node server.js
```

En el código del servidor Express GraphQL no solo se especifica el **esquema y la raíz API**, sino que también se genera el **punto final HTTP “/graphql”**. Mediante la entrada “graphiql: true” se activa, entre otros, la herramienta homónima que te facilita la **entrada de consultas a través de una interfaz gráfica de usuario**. Para ello, abre tu navegador e introduce la siguiente dirección:

```none
http://localhost:4000/graphql
```

Una vez instalados los componentes necesarios mencionados, creado tu primer esquema de consulta y puesto en marcha tu propio servidor, tal como se describe en los pasos de este tutorial para GraphQL, estás preparado para familiarizarte con **las posibilidades de entrada de consultas.**

Puedes encontrar más información al respecto, así como explicaciones detalladas sobre el diseño de backends y frontends de GraphQL en [la sección de tutoriales](https://www.GraphQL.com/tutorials/ "GraphQL.com: GraphQL-Tutorials") de la página oficial de desarrollo de la API de Facebook.


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/graphql/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/graphql/) for AI/LLM consumption.