Sistema de tipado

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 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.

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.