Resolver de tipos

Clase 13 de 25 • Curso Práctico de GraphQL con JavaScript

Resumen

GraphQL necesita de un resolver para el tipo de dato padre y una función para el campo del nested type para poder extraer su información.

Paolo Donato Torregrosa Navarro

student•

Este curso no lo quería tomar al principio pero resulta ser realmente interesante, tome la primera clase y ahora quiero hacerlo todo! no conocía a este profesor tan bueno

Fernando Cordero

student•

No se porque pero no a mi no me devuelve el arreglo de people con información, siempre lo muestra vació. Revise el código por todos lados, compare con el código de los enlaces. Tengo todo igual, alguno tiene idea de porque me esta pasando esto?

Juan Jose Vega

student•

tiene que haber un error en addPeople Ya revisaste si la DB los guardo?

silvana murgo

student•

A mi me pasaba lo mismo y empece a debugger con console.log los ID que insertaba y trataba de buscar. Y mi error era que cuando guardaba la relacion en addPeople ponia 2 veces el id del curso :face_with_head_bandage:

Fix

addPeople: async (root, { courseID, personID }) => {
    let db, course, person;
    console.log(`courseid ${courseID}`);
    console.log(`pid ${personID}`);
    try {
      db = await connectDB();
      course = await db
        .collection('courses')
        .findOne({ _id: ObjectID(courseID) });
      console.log(course);
      person = await db
        .collection('students')
        .findOne({ _id: ObjectID(personID) });
      console.log(person);
      if (!course || !person) {
        throw new Error("Person or Course doesn't exists");
      }
      await db
        .collection('courses')
        .updateOne(
          { _id: ObjectID(courseID) },
          { $addToSet: { people: ObjectID(personID) } }
        );
    } catch (error) {
      console.error(error);
    }
    return course;
  },

Julian Franco

student•

Un refactor para el resolver de people para no abrir conexion a la base de datos si no es necesario y no hacer ternarias:

const peopleResolver = async ({ people }) => {
  try {
    if (!people || people.length === 0) return [];
    const db = await connectDB();
    const ids = people.map(id => ObjectID(id));
    const peopleData = await db
      .collection('students')
      .find({ _id: { $in: ids } })
      .toArray();
    return peopleData;
  } catch (err) {
    console.log(`Err in people types: ${err.message}`);
  }
};

Aca verificamos si hay people en la collection antes de abrir la conexion y retornamos el Array vacio de una vez. Tambien nos ahorramos las ternarias dentro de la funcion. Coloque la excepcion de people.length === 0 pensando a futuro la posibilidad de remover una persona de people que dejaria un Array vacio en la base de datos.

Cesar David Ramírez Dimaté

student•

Me suena. Sobretodo por el tema de no tener que abrir una conexión a base de datos innecesaria.

Reinaldo Mendoza

student•

Muy buena la idea, solo abrirla si es estrictamente necesario

Steve Anthony Luzquiños Agama

student•

Quizás esta explicación le se útil a alguien, graphql tools va a intentar popular el campo students, ya que este campo es un nested type.

Este intento de popular el tipo Course se llama resolución de tipos. En "Cristiano", el resolver un tipo consiste en ejecutar una callback del mismo nombre que el nested type, para así "llenar" el campo people con "algo", este "algo" debe ser un array del tipo Student (también sería válido un array vacío).

Es debido a este comportamiento que cuando el profesor le pide a GraphQL el campo people, GraphQL puede devolverle un array con objetos del tipo Student, y si no hay ningún estudiante matriculado en el curso, un array vacío.

José Vinicio Flores Arias

student•

Y aqui esta el alcance de GraphQL!

David Behar

student•

Exacta mente qué son los resolvers, esta clase me confundió porque estamos agregando los tipos a la raíz de los resolvers, osea

const resolvers = {
  ...
  Course { ... }
}

IT Desarrollo invertirOnline.com

student•

En realidad lo que estas agregando es el resolvers de los types que tienes definido en tu schema.

David Behar

student•

Eso qué significa, jeje 😅

Angelo Zambrano

student•

Creo que todo este código se puede simplificar con el método de Mongoose populate(<Field>): /* TypeScript */

Jairo Campos Ruiz

student•

Por lo que puedo ver creo que no es exactamente porque si tu haces populate siempre va a buscar la información de cada estudiante pero si lo haces de esta manera solo irá a buscarlo en caso de que se le pida mediante la consulta de graphql.

Con lo cual si en la consulta no se pide la info de los estudiantes te ahorras mucho trabajo de la base de datos buscando esta info. Esto en una aplicación con muchas peticiones se nota.

Miguel Angel Reyes Moreno

student•

¿Por qué hicimos ...types? Me quedó esa duda.

Alex Paul Chirino Caicedo

student•

Los 3 puntos (...) en JS se encarga de desempaquetar (deconstruir) un arreglo u objeto.

Por ejemplo, si tu objeto padre es:

const parent = {
	childOne: 'This is a string',
}

Y luego tienes un objeto hijo (cuyos valores quieres agregárselos al padre) como el siguiente:

const children = {
	childTwo: 'Another string',
	childThree: 'Another one',
}

Puedes hacerlo utilizando la sintaxis de los 3 puntos (...):

const parent = {
	childOne: 'This is a string',
	...children,
}

Que es equivalente a que el objeto padre lo declares manualmente:

const parent = {
	childOne: 'This is a string',
	childTwo: 'Another string',
	childThree: 'Another one',
}

Miguel Angel Reyes Moreno

student•

Excelente 😎

Danilo Valenzuela

student•

¿Cómo puedo hacer un resolver para types sin necesidad de GraphQL tools?

Reinaldo Mendoza

student•

Por lo que dice el profesor sera mas complicado

Andrés Felipe Castañeda

student•

GraphQL es lo mejor que he visto de los cursos que llevo hasta ahora!

Jhon Manuel Angulo Moncada

student•

excelente funcionalidad, aplicable para la mayoría de proyectos.

Fernando Cordero

student•

'use strict'
 
const connectDb = require('./db')
const { ObjectID } = require('mongodb')

module.exports = {
    Course: {
    people: async ({ people }) => {
        let db
        let peopleData
        let ids

        try {
            db = await connectDb()
            ids = people ? people.map(id => ObjectID(id)) : []
            peopleData = ids.lenght > 0 
               ? await db.collection('students').find(
                    { _id: { $in: ids} }
                ).toArray()
                : []
        } catch (error) {
            console.log(error)    
        }
        return peopleData
        }
    }
}```

Cesar David Ramírez Dimaté

student•

Tienes mal escrito lenght, es length.

Platzi Team

student•

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

gracias

Daniel Esteves

student•

Hola! Debes crear un archivo de tipo Scalar.graphql y guardar los tipos de datos que necesites; más información aquí: https://github.com/danestves/GraphQL-CMS-Backend/tree/master/src/graphql/types

Diego Fernando Caviedes Camaho

student•

que plugin utiliza para mongo en vsCode?

Pablo Estornut

student•

Después de aplicar los cambios de este video, al hacer el mutation addPeople, no me devuelve el curso con people correcto sino un array vacío en el momento de ejecutar por primera vez el mutation, después sí.

Jesus Rodriguez

student•

asegurate de que esta linea sea correcta ids = people ? people.map( id => ObjectID(id))

Cristian David Franco Garcia

student•

En mutations.js agregue las siguientes instrucciones para que este método nos retorne el curso con sus nuevos cambios(id de la persona) y así no obtener campos nulos de person la primera vez que se agrega una persona al curso.

Cesar David Ramírez Dimaté

student•

Entiendo. Cuando ejecutras

mutation {
  addPeople(
    courseID: "60ee342200a30f84ee38faaf"
    personID: "60983f4961f3eb28d34942df"
  ) {
    _id
    title
  }
}

Es para que no devuelva

{
  "data": {
    "addPeople": null
  }
}

sino

{
  "data": {
    "addPeople": {
      "_id": "60ee342200a30f84ee38faaf",
      "title": "Curso de ejemplo 1"
    }
  }
}

De igual manera puedes seguir usando la variable course, no hay necesidad de crear updateCourse sino vuelves a llamar la consulta en mongo y la asignas a course.

Jose Eduardo Romero Baltazar

student•

Woow esta clase ah sido la mejor, no sabia el potencial de graph

Alejandro Cadena Florián

student•

No sé si hice algo mal previamente, o ha cambiado node.js, pero en la parte de

people.map(id => ObjectID(id))

no me funciona a mi, así que asumí que estaba tomando a id como un objeto e hice

people.map(id => ObjectID(id._id))

Codigo completo de esa pieza (el codigo es un tanto distinto al del profesor porque hace parte de una funcion reutilizable para no estar llamando a la db cada rato):

case "mapArrayInCollection":
                // Tomaremos los ids del array al cual mapearemos. Ejemplo: En Course, queremos mapear el array de Students, esto sera un array de _id de students.
                let ids = relation != null ? relation.map(id => ObjectID(id._id)) : [];
                // Tomaremos de la base de datos los valores correspondientes y los devolveremos como el respectivo array.
                let arrayData = ids.length > 0 ? await collection.find({_id: {$in: ids}}).toArray() : [];

                return arrayData;

Reinaldo Mendoza

student•

en realidad es para convertir id a un objeto id de mongo, esta dificil saber cual es el error porque no esta el contexto para saber que respresenta cada variable, map es una funcion superior de js, recorre todo un array aplicando la funcion que le pases como parametro a cada uno de los elementos

Yerlinson Maturana Serna

student•

'use strict'

const connectDB = require('./db');
const { ObjectID } = require('mongodb')

const types = {
  Course: {
    people: async ({ people }) => {
      try {
        const db = await connectDB()
        const ids = people ? people.map(id => ObjectID(id)) : []
        const peopleData = ids.length > 0 ? 
          await db.collection('students').find(
            { _id: { $in: ids } }
          ).toArray() : []
        return peopleData
      } catch (error) {
        console.error(error)
      }
    }
  }
}

module.exports = types```

Francisco Garcia [C6]

student•

Muy interesante :-)

types.js

'use strict'

const connectDb = require('./db')
const { ObjectID, ObjectId } = require('mongodb')

module.exports = {
    Course: {
        people: async ({ people }) => {
            let db
            let peopleData
            let ids
            try {
                db = await connectDb()
                ids = people ? people.map(id => ObjectId(id)) : []
                peopleData = ids.length > 0 ? await db.collection('students').find({ _id: { $in: ids } }).toArray() : []
            } catch (error) {
                console.error(error)
            }

            return peopleData
        }
    }
}

resolvers.js

'use strict'

const mutations = require('./mutations')
const queries = require('./queries')
const types = require('./types')

module.exports = {
  Query: queries,
  Mutation: mutations,
  ...types
}

addPeople: async (root, { courseID, personID }) => {
    let db, course, person;
    console.log(`courseid ${courseID}`);
    console.log(`pid ${personID}`);
    try {
      db = await connectDB();
      course = await db
        .collection('courses')
        .findOne({ _id: ObjectID(courseID) });
      console.log(course);
      person = await db
        .collection('students')
        .findOne({ _id: ObjectID(personID) });
      console.log(person);
      if (!course || !person) {
        throw new Error("Person or Course doesn't exists");
      }
      await db
        .collection('courses')
        .updateOne(
          { _id: ObjectID(courseID) },
          { $addToSet: { people: ObjectID(personID) } }
        );
    } catch (error) {
      console.error(error);
    }
    return course;
  },

const peopleResolver = async ({ people }) => {
  try {
    if (!people || people.length === 0) return [];
    const db = await connectDB();
    const ids = people.map(id => ObjectID(id));
    const peopleData = await db
      .collection('students')
      .find({ _id: { $in: ids } })
      .toArray();
    return peopleData;
  } catch (err) {
    console.log(`Err in people types: ${err.message}`);
  }
};

'use strict'
 
const connectDb = require('./db')
const { ObjectID } = require('mongodb')

module.exports = {
    Course: {
    people: async ({ people }) => {
        let db
        let peopleData
        let ids

        try {
            db = await connectDb()
            ids = people ? people.map(id => ObjectID(id)) : []
            peopleData = ids.lenght > 0 
               ? await db.collection('students').find(
                    { _id: { $in: ids} }
                ).toArray()
                : []
        } catch (error) {
            console.log(error)    
        }
        return peopleData
        }
    }
}```

case "mapArrayInCollection":
                // Tomaremos los ids del array al cual mapearemos. Ejemplo: En Course, queremos mapear el array de Students, esto sera un array de _id de students.
                let ids = relation != null ? relation.map(id => ObjectID(id._id)) : [];
                // Tomaremos de la base de datos los valores correspondientes y los devolveremos como el respectivo array.
                let arrayData = ids.length > 0 ? await collection.find({_id: {$in: ids}}).toArray() : [];

                return arrayData;

'use strict'

const connectDB = require('./db');
const { ObjectID } = require('mongodb')

const types = {
  Course: {
    people: async ({ people }) => {
      try {
        const db = await connectDB()
        const ids = people ? people.map(id => ObjectID(id)) : []
        const peopleData = ids.length > 0 ? 
          await db.collection('students').find(
            { _id: { $in: ids } }
          ).toArray() : []
        return peopleData
      } catch (error) {
        console.error(error)
      }
    }
  }
}

module.exports = types```

'use strict'

const connectDb = require('./db')
const { ObjectID, ObjectId } = require('mongodb')

module.exports = {
    Course: {
        people: async ({ people }) => {
            let db
            let peopleData
            let ids
            try {
                db = await connectDb()
                ids = people ? people.map(id => ObjectId(id)) : []
                peopleData = ids.length > 0 ? await db.collection('students').find({ _id: { $in: ids } }).toArray() : []
            } catch (error) {
                console.error(error)
            }

            return peopleData
        }
    }
}

Resolver de tipos

Introducción

Introducción al curso y prerequisitos del curso

¿Qué es GraphQL?

Conceptos básicos

Schema y types

Queries y Resolvers

Sirviendo el API en la web

Custom Types

Argumentos

Configuración de base de datos

Integrando una base de datos

Mutations e Inputs

Repaso - Creando el tipo Estudiante

Nested Types

Resolver de tipos

Errores

Conceptos avanzados

Alias y fragments

Variables

Enums

Interfaces - Tipo Monitor

Directivas

Unions

Consumiendo el API

Preparando API para producción

HTTP requests

Clientes de GraphQL

Consumiendo el API desde un frontend simple

Cierre del curso