Sistema de Tipado en GradQL: Queries y Mutations

Contenido del curso

Introducción

Fundamentos de GraphQL

Tipado en GraphQL

GraphQL en la Tienda con Express.js

Autenticación con GraphQL y JSON Web Tokens

Bonus

22
Anidamiento dinámico en GraphQL: optimización de consultas SQL
18:07 min

Conclusiones

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0011:04

Sistema de Tipado en GradQL: Queries y Mutations

Curso de GraphQL con Node.js

Clase 6 de 24

Clase 6 / 24

Recursos

¿Qué es el Tied System de GradQL?

GradQL revoluciona la forma en que interactuamos con las aplicaciones al ofrecer un sistema de tipado robusto que asegura un contrato entre el cliente y servidor. Este mecanismo permite una mayor comprensión y previsibilidad de las consultas, minimizando errores. De hecho, se ha demostrado que el uso de tipado puede reducir los errores en más de un 15%. Este sistema no solo aporta claridad, sino que también asiste en mantener la integridad de los datos al exigir tipos específicos en las consultas, incrementando así la confianza en los resultados que se obtienen.

¿Cómo funciona el sistema de tipado en GradQL?

El sistema de tipado de GradQL trabaja a través de declaraciones explícitas en las consultas. Por ejemplo, cuando especificamos una consulta con la palabra reservada query, indicamos que estamos buscando información. Cada consulta debe declarar el tipo de datos que espera retornar, como un string, número, o lista.

query {
  hello: String
}

En este ejemplo, la consulta hello está configurada para retornar un String. El resolver es el encargado de ejecutar esta lógica.

¿Qué sucede cuando no se cumple con el tipo esperado?

GradQL impone un contrato estricto y verificable. Si el resultado retornado no coincide con el tipo especificado, como retornar un entero en lugar de un string, el sistema intenta manejarlo o produce un error.

¿Cómo lidiar con los errores de tipado?

Cuando regresamos datos no coincidentes con el tipo declarado, GradQL notificará el error, proporcionando retroalimentación inmediata. Este proceso ayuda a garantizar que el cliente reciba lo que se espera, incrementando la fiabilidad de la aplicación.

¿Cómo estructura GradQL sus consultas y operaciones?

A diferencia de REST APIs, donde se utiliza un patrón específico como GET, POST, PATCH y DELETE, GradQL simplifica con solo dos palabras reservadas: query y mutation.

¿Qué son las queries y mutations?

Query: Sirve para realizar solicitudes de datos, similar a un GET en REST.
Mutation: Se utiliza para realizar cambios en los datos, análogo a las operaciones de creación, edición y eliminación (POST, PATCH, DELETE).

type Query {
  getPerson(name: String, age: Int): String
}

En el ejemplo anterior, getPerson es una query que recibe dos argumentos, name y age, permitiendo filtrar los datos con mayor precisión.

¿Cómo se definen argumentos en las consultas de GradQL?

Las consultas de GradQL permiten la definición y el manejo de múltiples argumentos, proporcionando flexibilidad al recibir datos más específicos.

query getPerson($name: String, $age: Int) {
  getPerson(name: $name, age: $age)
}

Aquí, la consulta getPerson recibe dos argumentos: name de tipo String y age de tipo Int. En el resolver correspondiente, estos argumentos se capturan y combinan para personalizar la respuesta.

¿Cómo influyen los argumentos en la documentación de las consultas?

Uno de los beneficios de GradQL es su capacidad para generar documentación automáticamente. Al definir tipos y argumentos, la documentación se genera en tiempo real, permitiendo a los desarrolladores ver la estructura exacta de las consultas y su funcionalidad, asegurando así una mayor facilidad de uso y actualización.

¿Qué beneficios ofrece GradQL sobre las REST APIs tradicionales?

GradQL representa un avance significativo sobre REST APIs al centralizar todas las consultas a través de POST, retornando siempre un estado 201. Esta simplificación mejora la eficiencia y consistencia de la transmisión de datos. Además, GradQL soporta suscripciones para datos en tiempo real, lo cual es invaluable para aplicaciones modernas que requieren actualizaciones instantáneas.

Con el dominio de estas características y prácticas, los desarrolladores pueden maximizar el potencial de GradQL, logrando aplicaciones más seguras, eficientes, y escalables. ¡Sigue explorando y profundizando en GradQL para liberar todo su potencial!

Andrés Esteban Rodríguez Jiménez

Hace 3 años

Sistema de tipado

GraphQL proporciona un conjunto de tipos escalares predeterminados que puedes utilizar en tus esquemas. Estos tipos escalares son:

Int: representa un entero de 32 bits con signo.
Float: representa un valor de punto flotante de precisión doble con signo.
String: representa una secuencia de caracteres UTF‐8.
Boolean: representa un valor booleano (true o false).
ID: el tipo escalar de ID representa un identificador único. Aunque se serializa como una cadena, su propósito principal es identificar objetos o servir como clave para un caché.

Para implementar el sistema de tipado en GraphQL, define una variable llamada typeDefs que contenga un Template Literal String (**``**) con la estructura de tu esquema. Por ejemplo:

const typeDefs = `
	type Query {
		hello: String
	}
`

Es importante destacar que GraphQL no se basa en los métodos HTTP como GET, PUT, PATCH o DELETE para realizar las operaciones. En su lugar, todas las operaciones se realizan a través de una solicitud POST. Al usar GraphQL, todas las respuestas tendrán un código de estado 201 independientemente del tipo de operación.

Para diferenciar entre las diferentes operaciones que se pueden realizar (como consultar, actualizar o eliminar datos), se utilizan dos palabras clave reservadas: Query para las consultas y Mutation para las operaciones de modificación de datos.

Veamos un ejemplo de su estructura:

Estructura de una Query:

const typeDefs = `
	type Query {
		nombreDeLaQuery: TipoDeDatoQueRetorna
	}
`;

// esta función es la que se encarga de resolver la consulta que se haga
const resolvers = {
  Query: {
    nombreDeLaQuery: () => 'Dato retornado',
  },
};

const useGraphql = async (app) => {
  // Aquí asociamos la consultas y sus resoluciones
  const server = new ApolloServer({
    typeDefs,
    resolvers,
  });
};

Ejemplo de una Query:

// una definición de tipos puede recibir parámetros los cuales debemos definir su tipo de dato
const typeDefs = `
  type Query {
    hello: String
    getPerson(name: String, age: Int): String
  }
`;

// los argumentos se envían en el segundo parámetro de la función
const resolvers = {
  Query: {
    hello: () => 'Hola mundo',
    getPerson: (_, args) => `Hello, mi name is ${args.name}, I'm ${args.age} years old`,
  },
};

Al realizar una consulta, puedes enviar argumentos junto con ella. Los argumentos se pasan como parámetros en la función del resolver correspondiente. Por ejemplo:

{
	getPerson(name: "Juanito", age: 18)
}

La respuesta sería un JSON con la siguiente estructura:

{
	"data": {
		"getPerson". "Hello, mi name is Juanito, I'm 18 years old"
	}
}

Esta es la forma que maneja el sistema de tipos en GraphQL.

Introducción

Integración de GraphQL con Node.js y Express

Integración de GradQL en API REST existente

Organización del Código para Implementar GraphQL

Fundamentos de GraphQL

Creación de tu primer servidor GradQL con Apollo Server Express

Consultar GraphQL desde Insomnia y Postman

Tipado en GraphQL

Sistema de Tipado en GradQL: Queries y Mutations

Tipos escalares de GraphQL y validación automática

Validación de Nullables y Listas en GradQL

Creación y Manejo de Tipos de Datos en GraphQL

Integración de Archivos GradQL y Live Reloading en Node.js

GraphQL en la Tienda con Express.js

Cómo separar resolvers GraphQL por entidad

Conexión de Base de Datos y Consultas en GraphQL con SQLite

Creación de productos con mutations e inputs en GraphQL

Uso de Variables y Alias en GradQL para Optimizar Consultas

Actualización y Eliminación de Productos con GraphQL

Anidamiento de Entidades con GradQL en APIs

Autenticación con GraphQL y JSON Web Tokens

Autenticación de Usuarios con JWT en GraphQL y Node.js

Creación de Mutación para Categorías con Validación de Roles

Autenticación de JSON Web Tokens en GraphQL con Passport

Validación de Roles y Sesiones con GradQL y Express

Validación de Datos en GradQL con Scalars Personalizados

Bonus

Anidamiento dinámico en GraphQL: optimización de consultas SQL

Conclusiones

Comparativa entre WPI y GradQL: Ventajas y Desventajas

Creación de Servidores GradQL con Node.js

Sistema de Tipado en GradQL: Queries y Mutations