Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Queries y Resolvers

4/25
Recursos

Una query permite ejecutar una petición al API, dentro de una query debes indicar la consulta que quieres ejecutar y los campos que deseas obtener. GraphQL te va a devolver la información que solicitaste dentro del objeto data.

El resultado de tu petición no se va a ejecutar de manera mágica, para ello debes definir el objeto resolvers, este objeto va a contener una propiedad del mismo nombre que la query que va a resolver o ejecutar.

Aportes 24

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

este es un post en medium que quiero compartir de las buenas practicas en los resolves en graphQL:
https://medium.com/paypal-engineering/graphql-resolvers-best-practices-cd36fdbcef55

Como hacemos un return de una sola linea, se puede hacer el return implícito , para tener en cuenta

const resolvers = {
	hello  : () => {
		return 'Hola Mundo';
	},
	saludo : () => 'Saludo'
};

Aun no me quedo claro para que se utiliza GraphQL…

Es posible llamar a más de un resolver:

graphql(schema, '{ hello, saludo }', resolvers).then((data) => {
    console.log(data)
})
'use strict'

const { graphql, buildSchema } = require('graphql');

// schema
const schema = buildSchema(`
    type Query {
        hello: String,
        saludo: String
    }
`);

// resolvers
const resolvers = {
    hello: () => 'Hola mundo',
    saludo: () => 'Hola a todos'
}

// execute query
graphql(schema, '{ saludo }', resolvers).then((data) => {
    console.log(data);
});

Deira y Dara!

Yo lo veo así: El schema es definir el nombre de la función y el tipo de dato de retorno, luego el resolver es el código a ejecutar y luego graphql es llamar la función para que se ejecute

Muy interesante GraphQL

Un schema, si comprendi bien, es como la estructura base que describe los componentes que hay en la API.

Pueden retornar 2 queries sin problemas:

const { graphql, buildSchema } = require("graphql");

//*Definiendo el esquema
const schema = buildSchema(`
    type Query {
        hello: String
        pokemon: String
    }
`)
//*Lo arriba es: Tipo -> Query. Nombre de query -> Hello. Dato que retorna -> String

//* Configurar los resolvers para que la query sí regrese información
const resolvers = {
    hello: () => { return "Hello World!" },
    pokemon: () => { return "Pikachu" }
}

//*Ejecutar el query hello
graphql(schema, '{ hello, pokemon }', resolvers).then((data) => {
    console.log(data)
})

La forma en la que lo veo, la Query es el SET
Y MUTATION es POST.

Importante los resolvers deben ser funciones con el mismo nombre de las queries

mas curso de graphql por fis

Una Querie permite ejecutar una solicitud hacía la API para traer información. En el Querie se debe indicar la información deseada y qué campos de esa consulta se quiere obtener. Se pueden pedir tantos campos como se desee.

Resolvers

Los Resolvers son los que darán la respuesta a las Queries. A partir del ejemplo anterior, para que el hello obtenga una respuesta el resolver debe tener una propiedad hello con un valor.

Para que el Resolver sea tomado en cuenta hay que enviarlo como tercer parámetro a la hora de ejecutar el Querie.

const resolver = {
    hello: () => {
        return 'Hello world'
    }
}
graphql(schema, `{ hello }`, resolver).then((data) => {
    console.log(data);
})
.catch((err) => {console.log(err);});

Con está implementación el valor que tendrá hello será “Hello world”.

¡Ahhhhhhhh! Con razón es tan útil. En una API REST (hecha con Spring Boot y Java) tendríamos que “armar” la respuesta con un objeto, por ejemplo. Aquí es más práctico.

Como se puede resolver un tipo escalar, por ejemplo
date, datatime, binary, entre otros

// Directive introduced in ECMAScript version 5
// Indicate that the code should be executed in "strict mode"
// More info: https://www.w3schools.com/js/js_strict.asp
'use strict';

const { graphql, buildSchema } = require('graphql');

// Build the schema
const schema = buildSchema(`
  type Query {
    hello: String,
    hola: String
  }
`);

// Configure resolvers
const resolvers = {
  hello: () => "Hello, world!",
  hola: () => "Hola, Mundo!"
}

// Query the schema
graphql(schema, '{ hello, hola }', resolvers).then((data) => {
  console.log(data);
});
const resolvers = {
  hello: () => {
    return "ya avanzo en graph";
  },
  saludar: () => {
    return "hola ";
  },
};

Excelente

Excelente clase, corta pero densa

Un resolver es un objeto que debe tener una propiedad igual al query del schema, esta propiedad debe ser una función
que se ve a ejecutar cuando se llame al query.

les comparto un blog de platzi, donde se explica un poco mas los conceptos de graphql

Para hacer más facil el proceso de ejecutar index.js se puede usar Nodemon:

npm install -g nodemon

y para ejecutar el archivo:

nodemon index.js

Así cada vez que guardamos, Nodemon busca cambios, y de haberlos vuelve a ejecutar el archivo automaticamente.

'use strict'

const { graphql, buildSchema } = require('graphql')

//definiendo el esquema
const schema = buildSchema(`
    type Query {
        hello: String
        saludo: String
    }
`)

//configurar los resolvers
const resolvers = {
    hello: () => {
        return 'Hola mundo'
    },
    saludo: () => {
        return 'Hola a todos'
    }
}

//ejecutar el query hello
graphql(schema, '{saludo}', resolvers).then((data) => {
    console.log(data)
})