A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Integrando una base de datos

9/25
Recursos

Aportes 56

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

A mi me funcion贸 este c贸digo, estoy usando Studio3T y MongoDb de manera local. Para este ejercicio no le configur茅 user y password a la bd, por esta raz贸n no lo envi茅 en la cadena de conexi贸n.

'use strict'

const { MongoClient } = require('mongodb')
const {
    DB_HOST,
    DB_PORT,
    DB_NAME
} = process.env

const mongoUrl = `mongodb://${DB_HOST}:${DB_PORT}/${DB_NAME}`
let connection

async function connectDB () {
    if (connection) return connection

    let client
    try {
        client = await MongoClient.connect(mongoUrl, {
            useNewUrlParser: true
        })
        connection = client.db(DB_NAME)
    }
    catch(error) {
        console.error ('No se pude conectar a la bd', mongoUrl, error)
        procces.exit(1)
    }

    return connection
}

module.exports = connectDB

quien se haya registrado a Mongo Atlas en vez de Mlab porque el registro a este 煤ltimo esta cerrado, y tenga el problema al seguir esta clase con la conexi贸n a la base de datos, debe cambiar la siguiente l铆nea de la configuraci贸n de mongoUrl en el archivo db.js:

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWD}@${DB_HOST}/${DB_NAME}`;```

Fue medio confuso realizar la conexi贸n desde Robo 3T, pero intentar茅 explicarla a acontinuaci贸n:

  1. Loguearse en https://cloud.mongodb.com, que es gratis el registro y puede ser con la cuenta de Google para quien lo prefiera.
  2. Luego de entrar, nos encontramos frente al panel principal de la aplicaci贸n, y en el men煤 lateral izquierda seleccionamos Clusters
  3. Ahora, a la derecha, seleccionamos CONNECT
  4. En la nueva ventana seleccionamos la tercera opci贸n: Connect using MongoDB Compass. Al menos en mi caso, elegir esta ruta me llev贸 a buen t茅rmino.
  5. En la siguiente secci贸n, copiamos la cadena de conexi贸n. Se puede usar el bot贸n Copy para realizar dicha copia.

    Aqu铆 vamos a poner la contrase帽a de nuestro usuario donde la cadena dice <password>
  6. Ahora, cuando abrimos Robo 3T, lo primero que aparece es una ventana en la mitad de la pantalla que nos pregunta a d贸nde nos queremos conectar. La primera vez posiblemente no salga nada en la lista, as铆 que damos click en Create:
  7. Ahora, en los detalles de la conexi贸n, le damos un nombre a la nuestra, que en este caso fue 鈥減latzi-connect鈥, y frente al bot贸n From SRV pegamos la cadena de conexi贸n extraida del punto 5.
  8. Luego de lo anterior, se oprime el bot贸n From SRV, y entonces la ventana muestra ahora otras cosas, como a continuaci贸n:
  9. Y listo, si todo sali贸 sin l铆os, llegamos a este punto, donde tenemos listada la conexi贸n en nuestra ventana MongoDB Connections

    Y al seleccionarla, oprimimos Connect
  10. Para crear la base de datos, colecciones y dem谩s, me fue bastante 煤til usar una serie de videos que comenc茅 a revisar desde este.

Espero sea 煤til para alguien como lo fue para mi.

Para la versi贸n de mongodb ^3.5.9 el c贸digo de la funci贸n connectDB en db.js debe quedar as铆:

async function connectDB() {
  if (connection) return connection.db();

  let client;
  try {
    
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    
    connection = await client.connect();

  } catch (error) {
    console.error("Could not connect to db", mongoUrl, error);
    process.exit(1);
  }
  
  return connection.db();
}

Eso solventa el problema de db.collection is not a function

Si utilizan docker-compose para mongo seria:

version: '3.7'

services:
  mongodb:
    image: mongo:latest
    environment:
      - MONGO_INITDB_ROOT_USERNAME=<username>
      - MONGO_INITDB_ROOT_PASSWORD=<password>
    ports:
      - "27017:27017"

y en db.js

...
const mongoUrl = `mongodb://${DB_USER}:${DB_PASSWD}@${DB_HOST}:${DB_PORT}`;
...

Tener presente la configuraci贸n de las variables de entorno del archivo .env

Para los que quieran hacerlo con mySQL usando localhost con Xampp

  1. Crean la base de datos
CREATE TABLE `courses` (
  `id` int(11) NOT NULL,
  `title` varchar(1000) COLLATE latin1_general_ci NOT NULL,
  `description` varchar(1000) COLLATE latin1_general_ci NOT NULL,
  `teacher` varchar(1000) COLLATE latin1_general_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;
  1. Instalan mysql
npm install --save mysql2
  1. resolvers.js

const mysql = require('mysql2/promise')
const dataDB = {
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'academy'
}


module.exports = {
  Query: {
    getCourses: async () => {
      const connection = await mysql.createConnection(dataDB)
      const [rows, fields] = await connection.execute('SELECT * FROM courses');
      return rows
    },
    getCourse: async (root, args) => {
      const connection = await mysql.createConnection(dataDB)
      const [rows, fields] = await connection.execute(`SELECT * FROM courses WHERE id = ${args.id}`);
      return rows[0]
    }
  }
}

Hola Devs:
Aqui les traigo mi solucion, usando clases para hacer la connection a la DB.
Connection a Mongo:

Las queries en el resolver:

Espero y les pueda ayudar de una manera diferente.
Recuerden, #NuncaParesDeAprender 馃挌

Vengo haciendo toda la carrera frontend, veo estas clases y quedo as铆 馃樁 jajaja

A los que les da el error 鈥淥bjectID is not a function鈥 al traer el curso por el ID, la manera correcta es importarlo con la d en min煤scula.

const { ObjectId } = require('mongodb')

Si a煤n as铆 les da error, instalar el npm de bson:

npm i bson

Como no explican como crear la conexi贸n con Robo 3T.

A los que les sale error de autenticaci贸n, aqu铆 la soluci贸n:
const mongoUrl= mongodb://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}

Quitenle el db name

Para no utilizar interfaz grafica genere esta funcion el archivo db.js que permite validar si ya existe la collecion y si no existe agregar la data que queramos

const main = async () => {
  const db = await connectDB();

  const collectionName = "courses";

  try {
    const exists =
      (await (
        await db.listCollections().toArray()
      ).findIndex((item) => item.name === collectionName)) !== -1;

    if (!exists) {
      console.log("Collection courses not exists:");

      await db.createCollection(collectionName);

      console.log("Sucessfull creation courses collection");

      const insertRes = await db.collection("courses").insertMany(coursesData);

      console.log("Sucessfull records inserted -> ", insertRes.insertedCount);
    }
  } catch (err) {
    console.error(err);
  }
};

main();

Algo que se me hizo interesante es que objectID esta un poco rezagado y la documentaci贸n prefiere que utilicemos objectId ya que es un poco mejor

const {ObjectId}  = require('mongodb')

getCourse: async(root,{id})=>{
      let db
      let course = [];
      try {
        db = await connectDB()
        course = db.collection('courses').findOne({_id: ObjectId(id)})
      }catch (err){
        console.error(err)
      }
      return course
    }

Cre茅 un poco de c贸digo reutilizable en resolver.js, por si les interesa:

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

function returnNeededData(collectionName){
    return new Promise(async (resolve, reject) => {
        let db, collection;
        try{
            db = await connectDb();
            collection = await db.collection(collectionName);
            resolve(collection);
        }catch(e){
            console.error(e);
            reject(e);
        }
    });
}

function returnCases(collection, caseString, relation){
    switch(caseString){
        case "returnAll":
            return collection.find().toArray();
        case "returnOne":
            return collection.findOne(relation);
    }
}

module.exports = {
    Query:  {
        getCourses: async () => {
            let courses = returnNeededData('courses')
                .then((collection) => returnCases(collection, "returnAll"));
            return courses;
        },
        getCourse: async (root, { id }) => {
            let course = returnNeededData('courses')
                .then((collection) => returnCases(collection, "returnOne", {_id: ObjectID(id)}));
            return course;
        }
    }
};

Parece que dentro de MongoClient el m茅todo db.getCollection ya no esta disponible. Yo investigu茅 y solucione que el m茅todo correcto es collection.

As铆 fue como lo solucion茅:

getCourses: async () => {
            let db;
            let courses = [];
            try {
                db = await connectDB();
                courses = await db.collection('courses').find({})
                    .toArray();
                return courses;
            } catch (error) {
                console.error(error);
            }

Si tienen dudas sobre como conectar la base de datos en Robo 3T o Studio 3T les dejo el enlace de un video en youtube donde lo explican muy bien https://www.youtube.com/watch?v=uXPv6xeuTKM&ab_channel=RedesPlus

Tambien les dejo la pagina de donde descargar los softwares https://robomongo.org/

mongoose (para la integracion con mongo) es mucho mas legible y escribes menos codigo

//   lib/resolvers.js
const connectDb = require('../database/connection')
const Course = require('../database/models/Course')
// connect to mongodb
;(async function () {
  await connectDb()
})()

module.exports = {
  Query: {
    getCourses: async () => await Course.find(),
    getCourse: async (root, args) => await Course.findById(args.id),
  },
}

//   database/connection.js
const mongoose = require('mongoose')

const connect = async function () {
  try {
    await mongoose.connect('mongodb://localhost:27017/graphql-test', {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })
    console.log('Mongo DB is connected...')
  } catch (error) {
    console.log('something went wrong')
    console.log(error)
  }
}

module.exports = connect


// database/models/Course.js
const mongoose = require('mongoose')
const { Schema } = mongoose

const courseSchema = new Schema({
  title: String,
  length: String,
})
module.exports = mongoose.model('Course', courseSchema)

Yo estuve teniendo errores, lo resolv铆 como lo explican en este enlace
https://support.glitch.com/t/cant-connect-to-mongodb-cluster-discord-js-mongoose-econreset/6371/13

B谩sicamente explican que se debe conectar a todos los fragmentos del cluster para que no haya evitar problemas de conexi贸n.

Ponen el ejemplo:

MongoUrl = `mongodb://${process.env.MONGOUSER}:${process.env.MONGOPASSWORD}@pydow-shard-00-00-15jok.mongodb.net:27017,pydow-shard-00-01-15jok.mongodb.net:27017,pydow-shard-00-02-15jok.mongodb.net:27017/PydowDatabase?ssl=true&replicaSet=Pydow-shard-0&authSource=admin&retryWrites=true`

En mi caso cree tres variables HOST en el archivo .env y la url me qued贸 como a continuaci贸n

mongoUrl=mongodb://${DB_USER}:${DB_PASSWS}@${DB_HOST_1}:${DB_PORT},${DB_HOST_2}:${DB_PORT},${DB_HOST_3}:${DB_PORT}/${DB_NAME}?ssl=true&replicaSet=Cluster0-shard-0&authSource=admin&retryWrites=true`

Espero les ayude鈥

En caso de que hallas creado la Base De Datos Mongo localmente puedes usar esto

const mongoUrl = `mongodb://localhost/${DB_NAME}`

En mi caso yo tengo instalado MongoDB en mi computadora y como no tengo configurado usuario y contrase帽a ya que s贸lo la uso para desarrollos aqu铆 mismo, esta l铆nea me fue suficiente:

`mongodb://${DB_HOST}:${DB_PORT}/${DB_NAME}`

Tengo una duda, tengo una API REST alojada en Heroku. Para la conexi贸n a la base de datos en 鈥減roducci贸n鈥 s贸lo puse: process.env.MONGODB_URI
.
La cual toma la cadena de conexi贸n que est谩 configurada en Heroku. 驴hacerlo de esta manera representa alg煤n problema de seguridad para la API o es una mala pr谩ctica?

Si les sali贸 error de conexi贸n, retirar puerto de esa manera me conect贸 a mongodb atlas

const mongoUrl = mongodb+srv://${DB_USER}:${DB_PASSWD}@${DB_HOST}/${DB_NAME};

Yo tambi茅n tuve problemas鈥 Creo que se deber铆a instalar el paquete de mongodb en vez de mongo
npm i -S mongodb
Adem谩s en la secci贸n de clusters de mongoAtlas, concretamente en el nodo que indica 鈥減rimary鈥, ver la secci贸n de 鈥渃onnect鈥. En esta secci贸n se indica como conectarse por medio de url. Un ejemplo 鈥渕ongodb+srv://<username>:<password>@<host>/<database_name>?retryWrites=true&w=majority鈥. Como ver茅is, no se requiere el puerto, ya lo indica Guillermo en el curso de platzi, que ya se ha mencionado en esta secci贸n.
Para conectarse a robo3T, yo mismo he seguido esta gu铆a https://medium.com/@samurc.net/crear-mongodb-atlas-y-conectarse-usando-robo-3t-ex-robomongo-15781eebd7f4

Espero sea de ayuda por si os ocurre como a m铆.

La clase ObjectID esta deprecada, solo cambien a ObjectId por si quieren usar la actual

Una herramienta muy 煤til que uso para la generaci贸n de datos de prueba y al instante obtener 1000 registros si necesito es. https://www.mockaroo.com/
muy recomendado si no tienen tanta creatividad para inventar datos como yo o aumentar el volumen de los mismos para mejores pruebas.

Yo lo hice de una manera diferente, hago un solo connect, y luego llamo a este mismo para cada query.

en db.js:

'use strict';
const { MongoClient } = require('mongodb');
const { DB_USER, DB_PASSWD, DB_HOST, DB_NAME } = process.env;

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWD}@${DB_HOST}/${DB_NAME}?retryWrites=true&w=majority`;
const client = new MongoClient(mongoUrl);

async function connectDB() {
  try {
    await client.connect();
    console.log('MongoDB connected');
    return client.db(DB_NAME);
  } catch (error) {
    console.error("Couldn't connect to db", mongoUrl, error);
    process.exit(1);
  }
}

module.exports = { connectDB };

y en resolvers.js:

'use strict';

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

const db = connectDB();

module.exports = {
  Query: {
    getCourses: async () => {
      try {
        const courses = (await db).collection('courses').find().toArray();
        return courses;
      } catch (error) {
        console.error(error);
      }
    },
    getCourse: async (root, { id }) => {
      try {
        const course = (await db)
          .collection('courses')
          .findOne({ _id: ObjectId(id) });
        return course;
      } catch (error) {
        console.error(error);
      }
    },
  },
};

Comparto la forma en que hice funcionar en mi caso que es usando 鈥渕ongodb鈥: 鈥淾4.3.1鈥, espero le sirva a alguien

async function connectDB () {
  if (connection) return connection

  let client

  try {
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })

    await client.connect()

    connection = client.db(DB_NAME)
  } catch (error) {
    console.log('Colud not connect to db', mongoUrl, error)
    process.exit(1)
  }

  return connection
}

Yo lo hice as铆

Enero 2022

'use strict'

// Biblioteca que me sirve para el Muck
const { find, filter} = require('lodash')

const connectDB = require('./db');

module.exports = {
    Query: {
        getCourses: () => {
            let courses;
            // Uso una promesa en la funci贸n 'connectDB'
            // en el archivo db.js
            // courses tendr谩 asignado el resultado
            // que se resuelva despu茅s de ejecutar la promesa 
            courses = connectDB()
            .then((db) => {
                // Hago la petici贸n a la base de datos
                return db.collection('courses').find().toArray();
                
            })
            .catch(e => {
                console.error(e);
                return e;
            });
            
            return courses;
          },
        getCourse: (_, { _id }) => find(cousrses, { _id })
    }
  }

https://www.youtube.com/watch?v=t_X7qFMmWhI

En este video se explica como conectar MongoDB a Robo3T

Si tuviste problemas para conectarte (como yo), la forma de usar el driver de Mongo con Node JS es de esta forma:

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@cluster0.z54zv.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;

seguramente el 鈥榗luster0.z54zv鈥 ser谩 diferente para cada quien, pero en s铆 es la misma base.

En este curso tome otro rumbo, pero sigo con las bases del mismo, realice la implementaci贸n con sql server y estamos desarrollando una implementaci贸n para la empresa

Me funciono si en dg.js agrego lo siguiente:

const mongoUrl =`mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&w=majority`

Estoy usando Compass, para insertar los documentos se hace de la siguiente manera

[
  {    
    "title": "Mi titulo 1",
    "teacher": "Mi profesor",
    "description": "Una descripcion",
    "topic": "Programacion"
  },
  {      
    "title": "Mi titulo 2",
    "teacher": "Mi profesor",
    "description": "Una descripcion",
    "topic": "Programacion"
  },
  {      
    "title": "Mi titulo 3",
    "teacher": "Mi profesor",
    "description": "Una descripcion",
    "topic": "Programacion"
  } 
]

El 鈥榯贸pico鈥 sigue mal escrito. 隆No tiene tilde! 鈥榩rogramaci贸n鈥

Hola muchachos si aun est谩n incursionando, para los que tienen Docker instalado en sus maquinas, podr铆an crear un archivo docker-compose.yml en la ra铆z de su proyecto y colocar el siguiente c贸digo.

version: '3.1'

services:
  db_mongo:
    image: mongo
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${DB_USER}
      MONGO_INITDB_ROOT_PASSWORD: ${DB_PASS}
    ports:
      - ${DB_PORT}:${DB_PORT}

De esta manera crean un contenedor con mongo sin necesidad de preocuparse por la instalaci贸n en sus m谩quinas. Tengan en cuenta que la data encerrada en ${} son las variables de entorno que creamos en nuestro archivo .env.

Con respecto a la cadena de conexi贸n para la base de datos tuve que agregarle un queryparam a lo 煤ltimo, de esta manera 鈥

const mongoConnectionString = `mongodb://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?authSource=admin`;

Por 煤ltimo a帽adir una propiedad m谩s al objeto de opciones de conexi贸n, quedando as铆 鈥

client = await MongoClient.connect(mongoConnectionString, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

Como cliente para conectarme por medio de interfaz gr谩fica utilic茅 MongoDB Compass.

Y de esta manera tuve exito al ejecutar nuevamente las queries ya conectadas a la base de datos mongo.

tengo el siguiente error 馃槙

MongoServerSelectionError: connection <monitor> to 34.***.***.133:2***7 closed
    at Timeout._onTimeout (/home/cristian/dev/Github/Cristian/curso de GraphQL/node_modules/mongodb/lib/core/sdam/topology.js:438:30)
    at listOnTimeout (internal/timers.js:549:17)
    at processTimers (internal/timers.js:492:7) {
  reason: TopologyDescription {
    type: 'Single',
    setName: null,
    maxSetVersion: null,
    maxElectionId: null,
    servers: Map {
      'cluster0-shard-00-00.pvzn0.mongodb.net:27017' => [ServerDescription]
    },
    stale: false,
    compatible: true,
    compatibilityError: null,
    logicalSessionTimeoutMinutes: null,
    heartbeatFrequencyMS: 10000,
    localThresholdMS: 15,
    commonWireVersion: null
  }
}

Les recomiendo que vean el curso de MongoDB, al menos hasta la parte de la instalaci贸n, para que se les haga m谩s f谩cil la configuraci贸n de la conexi贸n.

A los que les salga

Warning: Accessing non-existent property 'MongoError' of module exports inside circular dependency

solo es un error de version

https://stackoverflow.com/questions/66049860/cannot-connect-to-mongodb-because-of-wrong-uri

Estoy usando la version 15.4 de GraphQL y para la consulta por id no se debe poner el root y args, es decir queda de esta manera la funci贸n. https://graphql.org/graphql-js/passing-arguments/

getCourse: async ({ id }) => {
let db
let course

    console.log(id)

    try {
        db = await connectDb()
        course = await db.collection('courses').findOne({ _id: ObjectId(id) })
    }catch(error) {
        console.log(error)
    }
    return course
}

Si alguien tiene este problema:

MongoParseError: URI does not have hostname, domain name and tld

puede ser que tenga problema con el encoding de la password cuando tiene caracteres especiales. Para ello cambien su password por el resultado de la misma una vez encodeada. Pueden usar esta pagina https://www.urlencoder.org/

Para aquellos que tienen alg煤n problema de conexi贸n con la base de datos, publico el c贸digo que me funciono.

'use strict'

const { MongoClient } = require('mongodb')
const {
  DB_USER,
  DB_PASSWD,
  DB_HOST,
  DB_PORT,
  DB_NAME
} = process.env

const mongoUrl = `mongodb://${DB_USER}:${DB_PASSWD}@${DB_HOST}:${DB_PORT}/`
let connection

async function connectDB() {
  if (connection) return connection

  let client
  try {
    client = await MongoClient.connect(mongoUrl, {
      useNewUrlParser: true
    })
    connection = client.db(`${DB_NAME}`)
  } catch (error) {
    console.log('Could not connect to db', mongoUrl, error)
    process.exit(1)
  }

  return connection
}

module.exports = connectDB

Desde un principio me pasa que tengo que definir el argumento recibido de getCourse() como _id en lugar de cualquier otra variable, pues si no lo hago de ese modo me devuelve vac铆as las consultas, me pregunto por qu茅 si claramente funciona con cualquier variable mientras la uses con ese nombre dentro del resolver.

Porque me corre graphiql pero no me trae nada de mi base de datos?
me refiero a que me trae 鈥済etCourses鈥:[]

tengo un problema con mongo local, cuando ejecuto me dice que mongoDb no es una funcion, no ehh podido resolver el probelma

'use strict'
const { MongoClient } = require('mongodb')
const {
    DB_USER,
    DB_PASSWD,
    DB_HOST,
    DB_PORT,
    DB_NAME
} = process.env

/* const mongoUrl = `mongodb://${DB_USER}:${DB_PASSWD}@${DB_HOST}:${DB_PORT}/${DB_NAME}` */
const mongoUrl = 'mongodb://localhost:27017'


let connection;

const connectDb = async () => {
if (connection) return connection

let client
try {
    client = await MongoClient.connect(mongoUrl, {
        useNewUrlParser: true
    })
    Connection = client.db(DB_NAME)
    
} catch (error) {
    console.error('no pudo conectrse', mongoUrl, error)
    process.exit(1)
}
return connection;
}

module.export = connectDb




server is listening at http://localhost:4000
TypeError: connectDb is not a function
    at getCourses (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/lib/resolvers.js:13:22)
    at resolveFieldValueOrError (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:467:18)
    at resolveField (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:434:16)
    at executeFields (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:275:18)
    at executeOperation (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:219:122)
    at executeImpl (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:104:14)
    at execute (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/graphql/execution/execute.js:64:35)
    at getGraphQLParams.then.then.optionsData (/home/enmanuelcastillo/Escritorio/proyecto/graphQl-practica/node_modules/express-graphql/index.js:152:16)
    at process._tickCallback (internal/process/next_tick.js:68:7)

alguien con buen ojo que me ayude , tengo mongo instalado en la PC

Tengo problemas para conectarme con la base de datos, estoy usando Mongo Atlas, adjunto el c贸digo y errores que me arroja, si alguien pudiera ayudarme, me seria de mucha ayuda.
Las variables de entorno para crear el url las revise y seg煤n yo est谩n correctas.

'use strict'
const { MongoClient } = require('mongodb')
const {
  DB_USER,
  DB_PASSWORD,
  DB_HOST,
  DB_PORT,
  DB_NAME
} = process.env

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`

let connection

async function connectDB() {
  if (connection) return connection
  let client
  try {
    client = await MongoClient.connect(mongoUrl, {
      useNewUrlParser: true
    })
    connection = client.db(`${DB_NAME}`)
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error)
    process.exit(1)
  }
  return connection
}
module.exports = connectDB

uuuoo uooo tranquilo viejo, como llego a esa parte de robo 3T, me siento un little bit extraviada 馃槮 pero a ver vamos a hacerle con el curso que sugieren abajo 馃槃
hubiera estado padre que viniera esa parte, por que soy un beb茅 en esto.

A mi no me estaba dando error, simplemente no me regresaba nada: y si el error esta en la url de la conexion.

//mongodb+srv://db_user_node:[email protected]/platzi-courses
const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`;

Mi ambiente de desarrollo es en Linux - Ubuntu. Finalmente quedo as铆:
db.js

'use strict'

// const { MongoClient } = require('mongodb');
const MongoClient = require('mongodb').MongoClient

const { DB_USER, DB_PASSWD, DB_HOST, DB_NAME } = process.env

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWD}@${DB_HOST}/${DB_NAME}?retryWrites=true&w=majority`

let connection

async function connectDB () {
  if (connection) return connection

  let client
  try {
      client = await MongoClient.connect(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true
    })
    connection = client.db(DB_NAME)
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error)
    process.exit(1)
  }

  return connection
}

module.exports = connectDB

resolverts.js

'use strict'

const connectDB = require('./db')

module.exports = {
  Query: {
    getCourses: async () => {
      let db
      let courses = []
      try {
        db = await connectDB()
        courses = await db.collection('courses').find({}).toArray()
      } catch (error) {
        console.error(error)
      }

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

Ojo y el package.json en la parte de dependencies:

  "dependencies": {
    "dotenv": "^8.2.0",
    "express": "^4.17.1",
    "express-graphql": "^0.11.0",
    "graphql": "^15.3.0",
    "graphql-tools": "^6.0.12",
    "mongodb": "^3.5.9"
  },

mongodb debe estar en 3.5.9

Gracias a Luis_LiraC, que me indico como instalar la ultima version.

Desinstalar mongo con sudo npm uninstall mongo mongodb, borrar la carpeta de node_modules, el package-lock.json y luego instalar todo de nuevo, junto con la versi贸n m谩s reciente de mongodb con sudo npm i [email protected]

Tengo error de db.collection is not a function en el archivo resolver.js
Intent茅 con db.getCollection y no me funcion贸

Al hacer

console.log(db) 

me di cuenta que no me est谩 trayendo los collections, a este punto no s茅 qu茅 mas hacer.
Mi uri es

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`

Para los que los estan haciendo con mongoose aca dejo el code

'use strict'

const connectdb = require('./db')

module.exports = {

    Query: {
        getCourses: async() => {
            let db
            let courses = []
            try {
                db = await connectdb()
                courses = await db.connection.collection('courses').find().toArray()
                return courses
            } catch (error) {
                console.log(error)
            }
        },
        getCourse: (root, args) => courses.find((course) => course._id === args.id)
    }

}```

Si les sale un warning al momento de las consultas pueden agregar que la topologia sea verdadera en el cliente:

client = await MongoClient.connect(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true
    })

Despu茅s de unas horas de investigaci贸n, en las cuales le铆 algunas cosas interesantes ademas de lo que necesitaba.
Encontr茅 una correcci贸n en la cadena de conexi贸n

const mongoUrl = `mongodb://${DB_USER}:${DB_PASSWD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?AuthMechanism=SCRAM-SHA-1`

Un error mas en que dec铆a el el 鈥渦seNewUrlParser鈥 se iba a deprecar, resulta que env铆a la clave en formato texto y tambi茅n la correg铆 de la siguiente manera

    client = await MongoClient.connect(mongoUrl, {
      /*useNewUrlParser: true,*/
      useUnifiedTopology: true })

No entiendo porqu茅, para qu茅 ni c贸mo se utiliza Robo3T. Hubiera sido mejor conectar directamente por mongo atlas. Desde esta clase ya me perd铆, pero bueno

Personalmente no me funcion贸 con la librer铆a mongo adem谩s que esta es super antigua decid铆 hacerlo con el driver oficial mongodb y el c贸digo quedar铆a as铆:

const { MongoClient } = require('mongodb')
const { DB_USER, DB_PASSWORD, DB_HOST, DB_NAME } = process.env
const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`
let connection

async function connectDb() {
  if (connection) return connection

  let client
  try {
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })
    await client.connect()
    connection = client.db(DB_NAME)
  } catch (error) {
    console.error('Could not connect to DB ', error)
    process.exit(1)
  }
  return connection
}

module.exports = connectDb

Yo lo uso con mongo compass de esta manera
DB.JS

const { MongoClient } = require('mongodb')

let connection
async function connectDB() {

    if (connection) return connection

    //connection url
    const url = 'mongodb://localhost:27017/graphqlplatzi'

    let db


    try {
        db = await MongoClient.connect(url, {
            useNewUrlParser: true,
            useUnifiedTopology: true
        })

        connection = db.db('graphqlplatzi')
        console.log('Connected successfully!');
    } catch (err) {
        console.error(err);
    }

    return connection
}

module.exports = connectDB

RESOLVER.JS

'use strict'

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

module.exports = {
    Query: {
        getCourses: async() => {
            let db
            let courses = []

            try {
                db = await connectDb()
                courses = await db.collection('courses').find({}).toArray()
            } catch (error) {
                console.error(error)
            }

            return courses

        },
        getCourse: async(root, { id }) => {
            let db
            let course

            try {
                db = await connectDb()
                course = await db.collection('courses').findOne({ _id: ObjectID(id) })
            } catch (error) {
                console.error(error)
            }

            return course
        }
    }
}

鈥榰se strict鈥

const { MongoClient } = require(鈥榤ongodb鈥)
const {
DB_USER,
DB_PASSWORD,
DB_HOST,
DB_NAME,
DB_PORT
} = process.env

const mongoUrl = mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?retryWrites=true&w=majority;
let connection
async function connectDB () {
if (connection) return connection

let client
try {
client = await MongoClient.connect(mongoUrl, {
useNewUrlParser: true,
useUnifiedTopology: true
})
connection = client.db(DB_NAME)
} catch (error) {
console.error(鈥楥ould not connect to db鈥, mongoUrl, error)
process.exit(1)
}

return connection
}

module.exports = connectDB

asi quedo mi archivo db.js por si alguien necesita ayuda!!