Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Resolver de tipos

13/25
Recursos

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.

Aportes 17

Preguntas 5

Ordenar por:

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

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

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.

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

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

Y aqui esta el alcance de GraphQL!

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.

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

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

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

'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
        }
    }
}```

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

gracias

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

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;

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.

'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```

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
}
'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.length > 0 ?
                    await db.collection('students').find({
                        _id: { $in: ids }
                    }).toArray() :
                    []
            } catch (error) {
                console.error(error)
            }
            return peopleData
        }
    }
}