Integrando una base de datos

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 “platzi-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 “ObjectID 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 “producció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 “primary”, ver la sección de “connect”. En esta sección se indica como conectarse por medio de url. Un ejemplo “mongodb+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 “mongodb”: “^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 ‘cluster0.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 ‘tópico’ sigue mal escrito. ¡No tiene tilde! ‘programació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 “getCourses”:[]

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 “useNewUrlParser” 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
        }
    }
}

‘use strict’

const { MongoClient } = require(‘mongodb’)
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(‘Could 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!!