Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Argumentos

7/25
Recursos

Vamos a instalar una nueva dependencia para facilitar el trabajo con GraphQL, vamos a correr el siguiente comando:

npm i graphql-tools

Podemos pasar argumentos con distintos tipos de información dentro de las peticiones que hagamos en GraphQL, su sintaxis quedaría de la siguiente manera:

nombreQuery(campo: tipo): tipo

Dentro del resolver los argumentos de la petición pasarían como segundo parámetro, el primero es root y el segundo es args.

Aportes 20

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Tal vez si usas find en vez de filter podemos evitar el course.pop() 😃

como se puede pedir un curso de GraphQL avanzado en @platzi?

graphql-tools esta deprecado, ahora deberiamos usar @graphql-tools/schema y seguira funcionando con el ejemplo de la clase 😄

Para versiones recientes se debe hacer:

yarn add @graphql-tools/schema

o si usan npm

npm i @graphql-tools/schema

despues deben importarlo de la siguiente manera y continuar con la leccion

const { makeExecutableSchema } = require('@graphql-tools/schema')

Argumentos

Instalamos npm i graphql-tools

index.js:

const { makeExecutableSchema } = require("graphql-tools");
const express = require("express");
const { graphqlHTTP } = require("express-graphql");
require('dotenv').config();
const { readFileSync } = require("fs");
const { join } = require("path");
const resolvers = require("./lib/resolvers");

const app = express();
const port = process.env.PORT || 3000;

//*Definiendo el esquema
const typeDefs = readFileSync(join(__dirname, "lib", "schema.graphql"), "utf-8");
const schema = makeExecutableSchema({ typeDefs, resolvers });
//* Nos traemos el schema desde donde se encuentra

//* Configurar los resolvers para que la query sí regrese información

app.use('/api', graphqlHTTP({
    schema,
    rootValue: resolvers,
    graphiql: true
}));

app.listen(port, () => {
    console.log(`Server running on port ${port}/api`);
});

resolvers.js:

const courses = [
    {
        _id: '1',
        title: 'My title',
        teacher: 'My teacher',
        description: 'My description',
        topic: 'Programming',
    },
    {
        _id: '2',
        title: 'My title 2',
        teacher: 'My teacher 2',
        description: 'My description 2',
        topic: 'Programming 2',
    },
    {
        _id: '3',
        title: 'My title 3',
        teacher: 'My teacher 3',
        description: 'My description 3',
        topic: 'Programming 3',
    },
]

module.exports = {
    Query: {
        getCourses: () => { return courses },
        getCourse: (root, args) => {
            const course = courses.find(course => course._id === args.id)
            return course
        }
    },
}

Y podemos hacer un query como el siguiente:

{
    getCourse(id: "2"){
        title
        description
    }
}

Hola
si te sale este error

This package has been deprecated and now it only exports makeExecutableSchema.
And it will no longer receive updates.
We recommend you to migrate to scoped packages such as @graphql-tools/schema, @graphql-tools/utils and etc.
Check out https://www.graphql-tools.com to learn what package you should use instead!
Server is listening at https://localhost:3000/api

lo que debes hacer es cambiar los imports

import { makeExecutableSchema } from 'graphql-tools'

por

import { makeExecutableSchema } from '@graphql-tools/schema'

Para que se más fácil trabajar con GraphQl conforme el proyecto crezca es recomendable instalar graphql-tools con npm.

Para usar graphql tools hay que realizar los siguientes cambios:

// index.js
const { makeExecutableSchema } = require('graphql-tools');
const typeDefs = readFileSync(
    join(__dirname, 'lib', 'schema.graphql'),
    'utf-8'
);
const schema = makeExecutableSchema({typeDefs, resolvers});

También hay que configurar los resolvers:

module.exports = {
    Query : {
        getCourses: () => {
            return courses
        }
    }
};

Query con parámetros

Schema:

"Returns one course"
# ! means it's an obligatory parameter
getCourse(id: ID!): [Course]

Resolver:

getCourse: (root, args) => {
	return courses.find(course => course._id === args.id)
}

A mi me costo un poco de trabajo debuggear con la estructura que indico el profesor y para hacerlo a prueba de Jr lo hice asi el resolver:

const Query = {
  getCourses: () => {
      return courses
  },
  getCourse: (root, args) =>{
    const course = courses.filter(course => courses._id == args.id) 
    console.log(course.pop())
    return course.pop()
  }
}

module.exports = Query

Cuando definimos el schema con la propiedad _id, ¿no debería definirse de la misma manera en Query? Es decir, que quede así:

type Query {
  "Devuelve un curso"
  getCourse(_id: ID!): Course
}

En vez de así:

type Query {
  "Devuelve todos los cursos"
  getCourses: [Course]
  "Devuelve un curso"
  getCourse(id: ID!): Course
}

Ahora el paquete makeExecutableSchema se trabaja así:

npm i @graphql-tools/schema

Se importa de la siguiente manera.

const { makeExecutableSchema } = require("@graphql-tools/schema");
 getCourse: (root, args) =>{
            const course = courses.find((course) => 
                course._id === args.id
            )
            return course
        }

Si estan usando Ubuntu o WSL, van a tener inconvenientes con graphql-tools si su version de node es inferior a 12.X.

Para actualizarla:

curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
sudo apt-get install -y nodejs

Me gustaría conectarlo a un Oracle o Sql server

el.pop() de array borra el ultimo elemento de un array no ?

argumento para query por id

Pensé que iba a explicar los argumentos a nivel de GraphQL como está en la documentación 😅 GraphQL - Arguments.

type Starship {
  id: ID!
  name: String!
  length(unit: LengthUnit = METER): Float
}

Todo va excelente hasta aqui