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).
typeQuery{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.
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!
Cabe resaltar que por defecto los parametros de la query son opcionales. Si queremos que sean obligatorios sus types deben tener un signo !:
getPerson(name:String!,age:Int!):String!
GraphQL viene con un conjunto de tipos escalares predeterminados listos para usar:
Int: Un entero de 32 bits con signo.
Float: Un valor de punto flotante de precisión doble con signo.
String: Una secuencia de caracteres UTF‐8.
Boolean: trueo false.
ID: El tipo escalar de ID representa un identificador único, que a menudo se usa para recuperar un objeto o como clave para un caché. El tipo de ID se serializa de la misma manera que una Cadena; sin embargo, definirlo como IDsignifica que no está destinado a ser legible por humanos.
Lo que el profesor dijo acerca de que GraphQL siempre retorna 201 no es correcto. En realidad, GraphQL no tiene un código de estado HTTP predeterminado para las respuestas, sino que depende del servidor GraphQL y de cómo este esté diseñado. En algunos casos, el servidor puede devolver un código 200 para indicar una respuesta exitosa, mientras que en otros puede devolver un código 400 para indicar un error. En resumen, el código de estado HTTP que devuelve una respuesta GraphQL dependerá del servidor y de cómo se manejen los errores.
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 hagaconst resolvers ={Query:{nombreDeLaQuery:()=>'Dato retornado',},};constuseGraphql=async(app)=>{// Aquí asociamos la consultas y sus resolucionesconst server =newApolloServer({ typeDefs, resolvers,});};
Ejemplo de una Query:
// una definición de tipos puede recibir parámetros los cuales debemos definir su tipo de datoconst typeDefs =` type Query {
hello: String
getPerson(name: String, age: Int): String
}
`;// los argumentos se envían en el segundo parámetro de la funciónconst 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.
Si queremos que las deficiones de los tipos typeDefs se vean con colores tenemos que colocar anteponerle gql
Lo importamos tambien: Import { gql } from "apollo-server";
E instalamos la extension GraphQL
Types
GraphQL has a strong type system that defines the structure and shape of the data. Types represent the objects that can be queried or mutated. The main types in GraphQL are:
Scalar types: These are built-in primitive types like String, Int, Float, Boolean, and ID (a unique identifier).
Object types: These represent complex objects with multiple fields. Each field has its own type.
Enum types: These define a specific set of allowed values.
Interface types: These define a contract for objects that implement them. An interface can specify common fields and functionality shared by multiple types.
Union types: These represent a type that can be one of several possible object types.
Input types: These are used as arguments for mutations to specify the data to be created or updated.
Queries
In GraphQL, queries are used to retrieve data from the server. A query describes the shape of the data you want to fetch and allows you to specify which fields you need. Queries are written in a structure similar to the shape of the desired response.
The "Query" type is special: it lists all of the available queries that clients can execute, along with the return type for each.
Mutations
Mutations in GraphQL are used to modify data on the server. They allow you to create, update, or delete data. Mutations are similar to queries in structure but are defined with the mutation keyword. Mutations can have input arguments to specify the data to be modified.
Subscriptions
Subscriptions in GraphQL enable real-time data communication between the server and clients. Subscriptions allow clients to subscribe to specific events or data changes and receive updates when those events occur. Subscriptions are defined similarly to queries and mutations but are prefixed with the subscription keyword.
