Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Conexión de nuestros servicios con MongoDB

29/48
Recursos

Aportes 89

Preguntas 45

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Si tienen el siguiente error:

MongoError: MongoClient must be connected before calling 

Traten con esto:

  1. Quiten el número de puerto (${config.port}) del string de conexión en lib/mongo.js, debería quedar así:
const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;
  1. En el mismo archivo lib/mongo.js aumentar un parámetro al constructor del this.client. Debería quedar así:
this.client = new MongoClient(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });

Espero esto les sirva.

Con la configuración actual envía un warning

DeprecationWarning: current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor

Añadir lo siguiente al archivo de librería “MongoLib”

constructor() {
    this.client = new MongoClient(MONGO_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });
    this.dbName = DB_NAME;
  }

A diferencia de los JSON que escribimos comúnmente, para que express logre parcear correctamente el json, deben usar comillas dobles en la clave.


//bad 💥
{
	title: "lorem ipsum"
}

// bad 💥
{
	'title': 'lorem ipsum'
}


//Good ✨
{
	"title": "lorem ipsum"'
}

Para la solución del reto de tener diferentes bases de datos dependiendo de si estamos en desarrollo o en producción, encontré una libreria en npmjs que se llama dotenv-flow que permite manejar estas configuraciones.

  • Instalar el paquete
npm install dotenv-flow --save
  • Creé un nuevo archivo de configuracion .env.development de copia del .env y le cambie los parametros
  • En el archivo /config/index.js cambié la libreria a usar por dotenv-flow
require('dotenv-flow').config();
  • Agregue al .gitignore el archivo .env.development para que no sea cargada mis credenciales de desarrollo al repositorio
# dotenv environment variables file
.env
.env.test
.env.development
  • En el package.json modifiqué el script dev agregando a la variable de NODE_ENV=development
"scripts": {
  "dev": "DEBUG=app:* NODE_ENV=development nodemon index",
  "start": "NODE_ENV=production node index"
},

Con estos cambios logré separar las configuraciones del ambiente de producción al ambiente de desarrollo. El paquete de dotenv-flow se encarga basado en NODE_ENV cargar el archivo de configuración respectivo. Este paquete tiene más opciones, dejo el enlace del repositorio dotenv-flow

Hola Devs:
Aqui les traigo las correcion a varias parte del codigo del profesor, tal vez les ayuden a corregir sus errores:

Uno de ellos esta en la URI de Mongo, el profesor la tiene de estas manera:

const MONGO_URI = `mongodb+srv//${USER}:${PASSWORD}@${config.dbHost}:${config.port}/${DB_NAME}?retryWrites=true&w=majority`;

Y nosotros deberiamos borrar el PORT y dejarlo como nos indica Mongo que deberiamos hacer la conexion, de esta manera:

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

Otro Error seria en nuestro archivo movies.js en nuestra carpeta de servicios el metodo update tiene un error, el profesor llamo mal el metodo para actualizar, el profesor lo tiene de esta manera:

const updateMovieId = await this.mongoDB.create(this.collection, movieId, movie);

Y nosotros deberiamos cambiarlo al metodo update, de esta manera:

const updateMovieId = await this.mongoDB.update(this.collection, movieId, movie);

Y un plus o extra seria agregar un parametro mas que nos indica mongo a nuestra instancia de mongo client:

this.client = new MongoClient(MONGO_URI, { useNewUrlParser: true , useUnifiedTopology: true,});

Espero que corregir estos detalles ayude a que puedan resolver con exitos sus errores, recuerden #NuncaParesDeAprender 😃

En mi caso me arrojaba un error del PORT, y me di cuenta que en la conexión del cluster

mongodb+srv://<username>:<password>@cluster0-pm1ma.mongodb.net/test?retryWrites=true&w=majority

no especificaba el puerto así que lo borre y listo.

Algún heroe sin capa que explique esta linea a detalle:

const query = tags && {tags: {$in: tags}};

🤯 Cuando tienes un typo y pasas 1 hora de tu via averiguando porque tu proyecto no esta funcionando lol

Para conectarme a mi base de datos tuve que modificar mi endpoint de la siguiente manera

const MONGO_URI = `${config.dbConnectionType}://${USER}:${PASSWORD}@${config.dbHost}:${config.dbPort}`;

Donde dbConnectionType cambia a mongodb, también tuve que quitar la base de datos porque tenemos el código

          resolve(this.client.db(this.dbName));

En ese código realizamos de nuevo la conección a una base de datos específica, si alguien batalla por conectarse a base de datos privada, le ayudaré desde este mensaje.

Me da un error al hacer el create:

TypeError: Cannot read property ‘_id’ of undefined

hay un salto en el cuar se cambia el scrip de deleteMovie

Hasta aquí, si coloco un solo tag en la query, no busca y manda error, porque $in necesita que “tags” sea un array, mi solución fue convertir tags en array si es que es un string.

  async getMovies({ tags }) {

    typeof(tags) == 'string' ? 
	tags = [tags] : //si es string lo paso como array
	 tags

    const query = tags && { tags: { $in: tags } }
    console.log(query)
    const movies = await this.mongoDB.getAll(this.collection, query)
    return movies || []
  }

Seguro más adelante hay una solución más elegante.

también dejo la referencia de operadores de comparación ($in)
https://docs.mongodb.com/manual/reference/operator/query-comparison/

Si les arroja error prueben quitando el puerto, ya que en la cadena de conexión del cluster no se incluye el puerto.

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

además que en config tenemos port, no dbport.

Hola @glrodasz tu recomendarías tener una única clase Servicio que reciba en su constructor el nombre de la colleccion y que esta implemente los CRUD’s para todas? algo similar a esto…

const MongoLib = require('../lib/mongo');

class ServicesCRUD {
  constructor(_collection) {
    this.collection = _collection;
    this.mongoDB = new MongoLib();
  }

  async getDataByTags({ tags }) {
    const query = tags && { tags: { $in: tags } };
    const data = await this.mongoDB.getAll(this.collection, query);
    return data || [];
  }

  async getDataById({ ID }) {
    const data = await this.mongoDB.get(this.collection, ID);
    return data || [];
  }

  async createData({ data }) {
    const createdDataId = await this.mongoDB.create(this.collection, data);
    return createdDataId;
  }

  async updateDataById({ ID, data } = {}) {
    const updatedDataId = await this.mongoDB.update(this.collection, ID, data);
    return updatedDataId;
  }

  async deleteDataById({ ID }) {
    const deletedDataId = await this.mongoDB.delete(this.collection, ID);
    return deletedDataId;
  }
}

module.exports = ServicesCRUD;

buenas noches, la verdad estoy perdido y no entendí el challenge propuesto. Estoy algo aburrido porque no he podido entender casi nada 😦

Casi 2 horas leyendo documentacion y repitiendo videos, pero todo bien. Por fin!

Buenas, si se estan volviendo locos con la conexión o les tira un error el postman similar a este “Error: connect ECONNREFUSED”, vayan a mongo atlas - Clusters - Connect y se les abre un modal, tocan la opción del medio “Connect your application”, una vez dentro copian el trozo de código que les da el recuadro con los datos de su conexión y lo pegan dentro de su código mongo.js que hicieron en el video

const MONGO_URI = `mongodb+srv://db_user_platzivideo:${PASSWORD}@cluster0.lzplb.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;

F a hacer de nuevo todo el curso…

Esto sería la parte de delete

async deleteMovie({ moviedId} ) {
const deleteMovieId = await this.mongoDB.delete(this.collection, moviedId) ;
return deleteMovieId;
}

Hola si alguno le salia error con la conexion a la BD errores tales como:

the options [servers] is not supported
the options [caseTranslate] is not supported
the options [dbName] is not supported
the options [srvHost] is not supported
the options [credentials] is not supported

TypeError: Cannot read property 'then' of undefined
    at MongoLib.getAll (/home/paul/projects/platzi/platzi-backend-node/movies-api/lib/mongo.js:43:26)
    at MoviesService.getMovies (/home/paul/projects/platzi/platzi-backend-node/movies-api/services/movies.js:14:39)

la solucion a este error se realiza modificando el metodo connect del MongoLib

async connect() {
    if (!this.db) {
      await new Promise((resolve, reject) => {
        this.client.connect(err => {
          if (err) {
            reject(err);
            return;
          }
          this.db = this.client.db(this.dbName)
          console.log("Conencted successfuly to mongo".yellow)
          resolve(true);
        })
      })
    }
    return this.db;
  }

Espero les sirva

no entendi el challenge alguien me ayuda?

Tuve el siguiente error

internal/modules/cjs/loader.js:960
  throw err;
  ^

Error: Cannot find module 'dotenv'
Require stack:

Creyendo que hacia falta el modulo lo instale pero al parecer desinstalaba mongodb lo solucione instalando todo en una sola instrucción

npm install dotenv mongodb express --save

Apuntes de la clase:

Yo utilice clientes de en vez de películas …


index.js

const express = require('express');
const app = express();
const morgan = require('morgan');

// Configuraciones
const { config } = require('./config');
const clientsApi = require('./routes');

// Middleware
app.use(morgan('dev'));
app.use(express.urlencoded({ extended: true }));
app.use(express.json());

// Routes
clientsApi(app);

// Config port
app.listen(config.port, () => {
  console.log(`Server is listening in http://localhost:${config.port}`);
});

routes/index.js

const express = require('express');
const _ = require('underscore');
const ClientsService = require('../services/clients');

// Funcion de rutas de la aplicacion
const clientsApi = (app) => {
  const router = express.Router();
  app.use('/api/clients', router);

  // El objeto de tipo clase
  const clientsService = new ClientsService();

  // GET-------------
  router.get('/', async (req, res, next) => {
    // Propiedades de la cadena de texto de la ruta query
    const { tags } = req.query;
    try {
      // Obtenemos todos los clientes
      const clients = await clientsService.getClients({ tags });
      // Lo mostramos en json con la data ya obtenida
      res.status(200).json({
        data: clients,
        message: 'clients listed',
      });
    } catch (err) {
      next(err);
    }
  });

  // GET ID-------------
  router.get('/:clientId', async (req, res, next) => {
    // Obtenermos los parametros de la ruta (ID)
    const { clientId } = req.params;
    try {
      const client = await clientsService.getClient({ clientId });
      res.status(200).json({
        data: client,
        message: 'client listed',
      });
    } catch (err) {
      next(err);
    }
  });

  // POST---------------
  router.post('/', async (req, res, next) => {
    // Obtenemos de la req el cuerpo (contenido) de la data del cliente
    const { body: client } = req;
    if (
      client.name &&
      client.typeOfArrangement &&
      client.value &&
      client.payment &&
      client.date
    ) {
      try {
        const createdClientId = await clientsService.createClient({ client });
        res.status(201).json({
          data: createdClientId,
          message: 'client created',
        });
      } catch (err) {
        next(err);
      }
    } else {
      res.send('Wrong Request');
    }
  });

  // PUT--------------
  router.put('/:clientId', async (req, res, next) => {
    // Obtenermos los parametros de la ruta (ID)
    const { clientId } = req.params;
    // Obtenemos de la req el cuerpo (contenido) de la data del cliente
    const { body: client } = req;
    try {
      const updatedClientId = await clientsService.updateClient({
        clientId,
        client,
      });
      res.status(200).json({
        data: updatedClientId,
        message: 'client updated',
      });
    } catch (err) {
      next(err);
    }
  });

  // DELETE------------
  router.delete('/:clientId', async (req, res) => {
    // Obtenermos los parametros de la ruta (ID)
    const { clientId } = req.params;
    try {
      const deleteClientId = await clientsService.deleteClient({ clientId });
      res.status(200).json({
        data: deleteClientId,
        message: 'client deleted',
      });
    } catch (err) {
      next(err);
    }
  });
};

module.exports = clientsApi;

services/index.js

// Nos traemos el objeto clase MongoLib
const MongoLib = require('../lib/mongo');
const { clientsMock } = require('../utils/mocks/clients');

class ClientsService {
  constructor() {
    // Colleccion
    this.collection = 'clients';
    // Instanciamos nuestra libreria de mongo
    this.mongoLib = new MongoLib();
  }
  async getClients({ tags }) {
    // Si existen los tags le pasamos una query que va a recibir mongo que es { tags: { $in:tags } }
    const query = tags && { tags: { $in: tags } };
    const clients = await this.mongoLib.getAll(this.collection, query);
    return clients || [];
  }

  async getClient({ clientId }) {
    // Obtenemos un solo cliente
    const client = await this.mongoLib.get(this.collection, clientId);
    return client || {};
  }

  async createClient({ client }) {
    // Creamos un nuevo cliente
    const createdClientId = await this.mongoLib.create(this.collection, client);
    return createdClientId || {};
  }

  async updateClient({ clientId, client } = {}) {
    // Actulizamos la informacion del cliente con el id y la data
    const updatedClientId = await this.mongoLib.update(
      this.collection,
      clientId,
      client
    );
    return updatedClientId || {};
  }

  async deleteClient({ clientId }) {
    // Eliminamos la informacion del cliente
    const deletedClientId = await this.mongoLib.delete(
      this.collection,
      clientId
    );
    return deletedClientId || {};
  }
}

module.exports = ClientsService;

lib/mongo.js

// Capa de Librerias------------------------------
const { MongoClient, ObjectId } = require('mongodb');
const { config } = require('../config');

// encodeURLComponent Nos garantiza si hay caracteres especiales no haiga problema al conectarse
const USER = encodeURIComponent(config.dbUser);
const PASSWORD = encodeURIComponent(config.dbPassword);
const DB_NAME = encodeURIComponent(config.dbName);

// Conexion a la base de datos con mongo
const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

// Usar la Libreria mongo
class MongoLib {
  constructor() {
    this.client = new MongoClient(MONGO_URI, {
      // Tener la ultima configuracion de mongodb
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    this.dbName = DB_NAME;
  }

  // Conexion con promesas a una Base de Datos
  connect() {
    // Patron Singleton
    if (!MongoLib.connection) {
      // Promesa con async/await
      MongoLib.connection = new Promise((resolve, reject) => {
        // console.log(this.client);
        this.client.connect((err) => {
          if (err) {
            // Si se rechaza manda un error
            reject(err);
          }
          console.log('Connected succesfully to mongo');
          // Si se resuelve
          resolve(this.client.db(this.dbName));
          // console.log(this.client);
          // console.log(this.client.db());
          // console.log(this.client.db(this.dbName));
        });
      });
    }
    // Devolver en la funcion connect() la conexion a mongodb
    return MongoLib.connection;
  }

  // ------------Implementacion de Acciones---------

  // GETALL obtenemos toda la conexion
  getAll(collection, query) {
    return this.connect().then((db) => {
      // db.collection(collection) me crea una nueva coleccion con el nombre 'clients'
      // db es la respuesta a la peticion a la base de datos
      // db.collection.find() realiza una consulta sobre toda la coleccion o vista
      return db.collection(collection).find(query).toArray();
    });
  }

  // GET obtenemos una sola conexion
  get(collection, id) {
    return this.connect().then((db) => {
      // db.collection.findOne() realiza una consulta y devulve un solo documento
      return db.collection(collection).findOne({ _id: ObjectId(id) });
    });
  }

  // POST Creamos una nueva conexion
  create(collection, data) {
    return this.connect()
      .then((db) => {
        // db.collection.insertOne() inserta nuevos datos a la base de datos
        return db.collection(collection).insertOne(data);
      })
      .then((result) => result.insertedId);
  }

  // PUT Actualizar un dato de una conexion
  update(collection, id, data) {
    return this.connect()
      .then((db) => {
        // db.collection.update() actualiza con tres parametros la data
        // (1,2,3)
        // 1 => recibe un id de la data para actulizar
        // 2 => con $set actuliza la data en la base de datos
        // 3 => con upsert determina lo que se actuliza e inserta
        return db
          .collection(collection)
          .updateOne({ _id: ObjectId(id) }, { $set: data }, { upsert: true });
      })
      .then((result) => result.upsertedId || id);
  }

  // DELETE Elimina una conexion
  delete(collection, id) {
    return this.connect()
      .then((db) => {
        return db.collection(collection).deleteOne({ _id: ObjectId(id) });
      })
      .then(() => id);
  }
}

module.exports = MongoLib;

espero les sirvan… 😃 😃 😉

Si al momento ejecutar una consulta a Mongo desde postman tienen este error:
MongoError: MongoClient must be connected before calling MongoClient.proptype.db

Prueben sacar el puerto de la MONGO_URI:

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

Les comento que después de pasar mucho tiempo revisando videos y documentacion, se me prendio el bombillo para usar el console.log y ver que datos tenian las variables de entorno, y me di cuenta que devolvian “undefined”, y resulta que no tenia el archivo .env en la raiz, lo moví y todo funcionó perfecto

Hola a todos, si tenían el mismo problema que yo de conexión por

MongoClient must be connected before calling MongoClient.prototype.db
queryTxt ETIMEOUT clustermasjeed1-ekpfe.mongodb.net

Resulta que después de mucho investigar, encontré que se debe asociar cada clusters individual que se crea, por lo que quedaría algo así:

// CONFIG=
PORT=
CORS=

// MONGO=
DB_USER=
DB_PASSWORD=
DB_HOST_PRIMARY=
DB_HOST_SECOND_1=
DB_HOST_SECOND_2=
DB_NAME=

const MONGO_URI = `mongodb://${USER}:${PASSWORD}@${config.dbHostPrimary},${config.dbHostSecond1},${config.dbHostSecond2}/test?ssl=true&replicaSet=ClusterMasjeed1-shard-0&authSource=admin&retryWrites=true`;

Espero les sirva, y no gasten todo un día en ello.

Para los que les aparece error con _id
ingresen en index.js
app.use(express.json());

despues de declarar el servidor

al momento de hacer el insert solo registra el id, y no el titulo 😕

En esencia, lo que hicimos en esta clase fue lo siguiente:

Como ahora estamos utilizando MongoDB, ya no es necesaria la implementación con los mocks.

Pasamos de esta implementación con los mocks:

const { moviesMock } = require('../utils/mocks/movies');

class MoviesService {
  async getMovies() {
    const movies = await Promise.resolve(moviesMock);
    return movies || [];
  }

  async getMovie() {
    const movie = await Promise.resolve(moviesMock[0]);
    return movie || {};
  }

  async createMovie() {
    const createMovieId = await Promise.resolve(moviesMock[0].id);
    return createMovieId;
  }

  async updateMovie() {
    const updatedMovieId = await Promise.resolve(moviesMock[0].id);
    return updatedMovieId;
  }

  async deleteMovie() {
    const deletedMovieId = await Promise.resolve(moviesMock[0].id);
    return deletedMovieId;
  }
}

module.exports = MoviesService;

A una implementación con el lib que creamos de MongoDB, que a su vez está influida por nuestra librería de mongo que creamos:

const MongoLib = require('../lib/mongo');

class MoviesServices {

    constructor() {
        this.collection = 'movies';
        this.mongoDB = new MongoLib();
    }

    async getMovies({ tags }) {
        const query = tags && { tags: { $in: tags } }
        const movies = await this.mongoDB.getAll(this.collection, query);
        return movies || [];
    }

    async getMovie({ movieId }) {
        const movie = await this.mongoDB.get(this.collection, movieId);
        return movie || {};
    } 

    async createMovie({ movie }) {
        const createdMovieId = await this.mongoDB.create(this.collection, movie);
        return createdMovieId;
    }

    async updateMovie({ movieId, movie } = {}) {
        const updatedMovieId = await this.mongoDB.update(this.collection, movieId, movie);
        return updatedMovieId;
    }

    async partialUpdateMovie() {
        const updatedMovieId = await Promise.resolve(moviesMock[0].id);
        return updatedMovieId;
    }

    async deleteMovie({ movieId }) {
        const deletedMovieId = await this.mongoDB.delete(this.collection, movieId);
        return deletedMovieId;
    }

}

module.exports = MoviesServices

Me gustó mucho esta clase. A pesar de que tuvo algunos errores, pude resolverlos con el consejo del profesor de leer el stack.

a mi me salio este error y estube horas tratando de arreglarlo y revisando el codigo

C:\Users\Danie\Documents\Estudios\PLATZI\backendnodejs\node_modules\mongodb\lib\connection_string.js:281
        throw new error_1.MongoParseError(`${optionWord} ${Array.from(unsupportedOptions).join(', ')} ${isOrAre} not supported`);
        ^

En mi archivo mongo.js de la carpeta lib:
Previamente habia eliminado el ${config.dbPort}. y el codigo me seguia tirando el error, hasta que encontre en stackoverflow que si eliminaba el valor de u++seNewUrlParser: true, useUnifiedTopology: true ++ del codigo, esto funciono correctamente, mi codigo quedo asi finalmente

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

class MongoLIb {
  constructor() {
    this.client = new MongoClient(MONGO_URI, { });
    this.dbName = DB_NAME;
  }

si alguien sabe porque exactamente se soluciono por favor que me de el feedback.

Sin duda la clase más difícil hasta ahora… pero ánimo! No te rindas. Sigue intentando y podrás.

Tuve problemas para comprender por qué se hacía de esta forma pero en este video pude comprender mejor como hacerlo
UWU

Estuve buscando mi error por un largo rato, hasta que me di cuenta de que:

  1. antes de ir a postman no olviden el comando npm run dev en la consola de vscode
  2. se me habían añadido varios require arriba de módulos que no había pedido, en el archivo de mongo.js. Al borrarlos, funcionó perfecto.

Literalmente estuve revisando el código más de 3 horas, ya me dolía la cabeza.

Para los nuevos que estamos en el curso, les recomiendo de aquí en adelante que se lean detenidamente la documentación de las tecnologías que estamos utilizando. Que no importa si demoran 1 hora o más (insane jaja) buscando que está detrás del código, ya que eso los ayudará en el futuro a un mejor entendimiento y que no les explote la cabeza como yo ahora jajaja. Además en cada tecnología recomiendan una forma de escribir tu código, o de estructurar tu URI, por ejemplo en Mongo Atlas, recomiendan, hoy 2021, hacerlo de esta forma, pero si cambia en el futuro y te dice que lo hagas de forma diferente, sigas las recomendaciones y tratar de no copiar literalmente lo que hace/dice el profesor, ya que puede que hayan cambiado las configuraciones, estructuras, etc.

Resumen: Nunca pares de aprender!, pero recuerda que esto no es una carrera de velocidad sino de resistencia!

MongoDB y MongoConnections esta forma de implementarlo es buena, yo trataré de hacerlo con functions y const que me gusta más y para mi el codigo se ve mejor, aunque tmb son más cosas para exportar.

Excelente curso!!

Para los que quieran hacer uso de ES modules (ESM) y no hacer uso de CJS pattern, recomiendo instalar los paquetes de @babel/node y @babel/preset-env junto con obviamente el babel core @babel/core.

en el .babelrc agregar:

{
  "presets": ["@babel/preset-env"]
}

y luego simplemente en el package.json hacemos este agregado en el script dev

"dev": "DEBUG=app:* nodemon --exec babel-node index",

Saludos

Para el error:

MongoError: MongoClient must be connected before calling 

Revise el ejemplo que trae el apartado de Connect to Cluster0 ** y mi la constante ** MONGO_URI quedo asi:

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@cluster0.aokru.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;

Muy interesante el reto!

Buenas, alguien mas tiene este error cuando ejecutan un post desde postman? me devuelve un internal server error 500

How to pasar 3 horas buscando un error que era un simple typo el tutorial 😄
PD: Revisen bien su código antes de buscar soluciones por fuera de él 😦

Muy bueno, gracias!!

Va excelente el curso, Guillermo Rodas explica muy bien

Hola solo para decirles que no me funciono con el parser de express, y tuve que usar el modulo body-parser

Después de topar con pared varias veces logré generar la base local y que jalara.
_
Seguí las instrucciones para crearla en esta página. Pero tuve que hacer cambios en la manera en que se genera la URI para la conexión local, al menos en mi caso no funcionaba con la misma ya que no tengo un usuario ni password. Y no ocupa +srv.

let MONGO_URI = '';
if(config.dev){
  MONGO_URI = `mongodb://${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;
}else{
  MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}:${config.dbPort}/${DB_NAME}?retryWrites=true&w=majority`;
}

De esa manera revisa en que ambiente esta desarrollando y genera la URI en base a ello.
_
Y realicé los cambios Jhony Alexander Garcia Gómez comenta para poder tener ambas opciones en cuanto a ambientes de desarrollo y producción.

Por qué hace destructuring en todos los parámetros que reciben los métodos?

como se manejan las relaciones usando mongo db ?

Si alguien lo está intentando desde un serverMongo en local pruebe remover el DB_NAME del MONGO_URI, también reemplazar el useNewUrlParser:true por useUnifiedTopology:true

Solo use el config.dbHost y el nombre de la collection porque no tengo usuario/password en la local:
en el **.env: ** DB_HOST=mongodb://127.0.0.1:27017

Buenas noches por favor su ayuda con este error
adjunto URL ( https://gitlab.com/kerberos001/curso/-/tree/master/platzi-videos )

mongodb+srv://admin711:[email protected]/dbMovies?retryWrites=true&w=majority
listener http://localhost:3000
Connect succesFull
/home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/mongo_client.js:274
throw new MongoError(‘MongoClient must be connected before calling MongoClient.prototype.db’);
^

MongoError: MongoClient must be connected before calling MongoClient.prototype.db
at MongoClient.db (/home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/mongo_client.js:274:11)
at /home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/lib/mongo.js:28:41
at executeCallback (/home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/operations/execute_operation.js:74:5)
at /home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/operations/connect.js:209:23
at /home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/operations/connect.js:299:21
at QueryReqWrap.callback (/home/jorgemontenegro/Documentos/WORKSPACE/curso/platzi-videos/node_modules/mongodb/lib/core/uri_parser.js:56:21)
at QueryReqWrap.onresolve [as oncomplete] (dns.js:202:10) {
name: ‘MongoError’,
[Symbol(mongoErrorContextSymbol)]: {}
}
[nodemon] app crashed - waiting for file changes before starting…

Por su ayuda gracias …

Tengo este error

MongoParseError: Unescaped at-sign in authority section at parseConnectionString (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/node_modules/mongodb/lib/core/uri_parser.js:589:21) at connect (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/node_modules/mongodb/lib/operations/connect.js:297:3) at ConnectOperation.execute (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/node_modules/mongodb/lib/operations/connect.js:208:5) at executeOperation (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/node_modules/mongodb/lib/operations/execute_operation.js:81:17) at MongoClient.connect (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/node_modules/mongodb/lib/mongo_client.js:219:10) at /home/olivia/Documentos/ESTUDIOS/NODE/movies-api/lib/mongo.js:20:21 at new Promise (<anonymous>) at MongoLib.connect (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/lib/mongo.js:19:29) at MongoLib.getAll (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/lib/mongo.js:35:17) at MoviesService.getMovies (/home/olivia/Documentos/ESTUDIOS/NODE/movies-api/services/movies.js:12:39)

Tengo una duda, y que acerca si quisiera hacer consultas agregadas, por ejemplo cruzando colecciones y utilizando mapReduce, estas consultas también deberían ir dentro ‘…/lib/mongo’ , se supone que son consultas genéricas que aplica para todas las colecciones pero las consultas agregadas son más personalizadas, cual sería la ubicación? o crear un archivo js nuevo dentro de la carpeta lib?

excelente practica… al incio comence a tener errores pero revisando bien… me logro salir la eecucion con los servicios

Al hacer las pruebas salió bien todo, luego de arreglar algunos errores originados en no tipear bien algunos comandos.
Me pareció clara la explicación y solo queda por revisar mejor la documentación sobre Mongo para entender con más claridad lo hecho con las operaciones de creación, actualización, borrado y getall.

Les comparto algunos problemas que tuve con la conexión a MongoAtlas:

Estoy trabajando sobre Windows 10 con WSL Ubuntu.
A traves de wsl no tenia acceso al servidor de MongoAtlas, revisé si era problema de mi firewall, pero la conexion que hacia desde MongoDB Compass era exitoso entonces lo descarte.
Consultando en internet, llegué a explorar en la distribución de linux instalada, la el archivo /etc/resolv.conf y encontré visualizando este archivo que estaba dañado con unos caracteres especiales. Parece un problema del wsl que modifica este archivo automaticamente, por lo cual hice lo siguiente:

Crear el archivo /etc/wsl.conf con el siguiente contenido

[network]
generateResolvConf = false

y en el archivo /etc/resolv.conf borré el contenido que tenia y agregué lo siguiente

nameserver 8.8.8.8

Cerré la terminal y luego de esto pude acceder a MongoAtlas
Adicional a esto en la URL de conexión le quite el campo ${dbPort}

Espero sea de ayuda

Me sale un error: Mongolib is not defined, alguien sabe porque?

Hola ! a mi me da este error en el servidor :
MongoError: MongoClient must be connected before calling MongoClient.prototype.db
mi cadena de mongo está asi:
mongodb+srv://${aquí puse mi usu}:${aquí puse mi pass}@${config.dbHost}/test?retryWrites=true&w=majority

y en postman me sale esto:

There was an error connecting to http://localhost:3000/api/movies/.
Why this might have happened:
The server couldn’t send a response:
Ensure that the backend is working properly
Self-signed SSL certificates are being blocked:
Fix this by turning off ‘SSL certificate verification’ in Settings > General
Proxy configured incorrectly
Ensure that proxy is configured correctly in Settings > Proxy
Request timeout:
Change request timeout in Settings > General

¿Alguien me ayuda por favor?

Verifiquen que los parametros, que estan en la rutas sean los mismos que reciben en el servicio.

IdMovie =! IDMovie

Por lo que los parametros se pasan con llaves tiene que ser IGUALEEES

no se están validando los parámetros, debería de haber mayor control y uso de los errores.

Tenia el problema de 'database cannot contain the character “/” '
Y lo solucione quitando el ${config.dbPort} del MONGO_URI como dice en la documentación de mongo.

Tengo la duda de si se va a romper o si no hay problema dejándolo así.

Si les sale el error
MongoError: MongoClient must be connected before calling
tambien puede ser porque las variable de entorno llegan como undefined

Una alternativa puede ser Model View Controller(MVC) y se puede usar Moongose si se te dificulta el clean code architecture.

alguien me prodria indicar si el de patch es bien en routes/mongo.js

    const { movieId } = request.params;
    const { body: movie } = request;
    try {
      const updatedPartialMovieId = await moviesService.partialUpdateMovie({
        movieId,
        movie,
      });
      response.status(204).json({
        data: updatedPartialMovieId,
        message: 'Movie partial updated',
      });
    } catch (error) {
      next(error);
    }
  });
}```
services/movie.js


async partialUpdateMovie({ movieId, movie } = {}) {
const partialUpdatedMovieId = await this.mongoDB.updateOne(
this.collection,
movieId,
movie
);
return partialUpdatedMovieId;
}```

.env-development

NODE_ENV=develop
PORT=3000
CORS=*
DB_USER=admin
DB_PORT=27017
DB_PASSWORD=password
DB_HOST=db
DB_NAME=mongodb

mongo.js

if (config.environment === 'develop')
  MONGO_URI = `mongodb://${USER}:${PASSWORD}@${DB_HOST}:${DB_PORT}`;
else 
  MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?retryWrites=true`;

No me gustaba mucho platzi. La verdad que los cursos de React (Que era lo que mas me llamaba la atención), no me parecieron buenos, y un montón de otros cursos que la verdad, dejan mucho que desear.

Este curso es la excepción!, Es excelente y valió la pena el año de platzi por esto!
Muy buen profe aparte!

Usando asyn, await en la clase MongoLibrary queda así:

const { MongoClient, ObjectId } = require('mongodb')
const chalk = require('chalk')
const { config } = require('../config')

const USER = encodeURIComponent(config.dbUser)
const PWD = encodeURIComponent(config.dbPassword)
const DB = encodeURIComponent(config.dbName)
const HOST = encodeURIComponent(config.dbHost)
const MONGO_URI = `mongodb://${USER}:${PWD}@${HOST}:27017/${DB}?retryWrites=true&w=majority`
const MESSAGE = `Conexión exitosa con ${DB} mongo`

class MongoLibrary {
  constructor() {
    this.client = new MongoClient(MONGO_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })
    this.dbName = DB
  }

  connect() {
    if (!MongoLibrary.connection)
      MongoLibrary.connection = new Promise((resolve, reject) => {
        this.client.connect((err) => {
          if (err) reject(err)
          console.log(chalk.bold.yellow(MESSAGE))
          resolve(this.client.db(this.dbName))
        })
      })

    return MongoLibrary.connection
  }

  async getAll(collection, query) {
    const db = await this.connect()
    return await db.collection(collection).find(query).toArray()
  }

  async get(collection, id) {
    const db = await this.connect()
    return await db.collection(collection).findOne({ _id: ObjectId(id) })
  }

  async create(collection, model) {
    const db = await this.connect()
    const { insertedId } = await db.collection(collection).insertOne(model)
    return insertedId
  }

  async update(collection, id, model) {
    const db = await this.connect()
    const { upsertedId } = await db
      .collection(collection)
      .updateOne({ _id: ObjectId(id) }, { $set: model }, { upsert: true })
    return upsertedId ? upsertedId._id : id
  }

  async delete(collection, id) {
    const db = await this.connect()
    const { deletedCount } = await db
      .collection(collection)
      .deleteOne({ _id: ObjectId(id) })
    return deletedCount > 0
  }
}

module.exports = MongoLibrary

MI GIGA CHAD FAVORITO!

Sí a lguien le sale un error como este:

Error: querySrv ETIMEOUT _mongodb._tcp.cluster0.dn04q.mongodb.net
    at QueryReqWrap.onresolve [as oncomplete] (dns.js:196:19)

Lo más seguro es que sea algo relacionado con la conexión a internet. Encontré esta pregunta en stack overflow: link, en donde lo solucionan. En este otro link está la solución:
Aquí menciona que hay que cambiar las configuraciones de servidor DNS (Domain Name System) y están las opciones para cada SO. Espero que le sirva alguien porque yo estuve como 2 días tratando de solucionarlo.

buenas, les queria compartir el lib de mongo, pero pasado a la sintaxis de async await, a mi parecer queda mucho mas limpio:

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

const USER = encodeURIComponent(config.db_user);
const PASS = encodeURIComponent(config.db_pass);
const DB_NAME = config.db_name;

const MONGO_URI = `mongodb+srv://${USER}:${PASS}@${config.db_host}?retryWrites=true&w=majority`;

class MongoLib {
  constructor() {
    this.client = new MongoClient(MONGO_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    this.dbName = DB_NAME;
  }

  connect() {
    if (!MongoLib.connection)
      MongoLib.connection = new Promise((resolve, reject) => {
        this.client.connect((err) => {
          if (err) reject(err);
          console.log('Connected succefully to mongo');
          resolve(this.client.db(this.dbName));
        });
      });

    return MongoLib.connection;
  }

  async getAll(collection, query) {
    const db = await this.connect();
    const data = await db.collection(collection).find(query).toArray();
    const totalCount = await db.collection(collection).countDocuments();
    return { data, count: data.length, totalCount };
  }

  async get(collection, id) {
    const db = await this.connect();
    return db.collection(collection).findOne({ _id: ObjectId(id) });
  }

  async create(collection, data) {
    const db = await this.connect();
    const record = await db.collection(collection).insertOne(data);
    return record.insertedId;
  }

  async update(collection, id, data) {
    const db = await this.connect();
    const result = await db
      .collection(collection)
      .updateOne({ _id: ObjectId(id) }, { $set: data }, { upsert: true });
    return result.upsertedId || id;
  }

  async delete(collection, id) {
    const db = await this.connect();
    const record = await db
      .collection(collection)
      .deleteOne({ _id: ObjectId(id) });
    return id;
  }
}

module.exports = MongoLib;

Hola comunidad, hice este cambio:

  1. Recibir el nombre de la colección en el constructor de MongoLib
class MongoLib {
  constructor() {
    this.client = new MongoClient(url, { useNewUrlParser: true, useUnifiedTopology: true });
    this.dbName = config.dbName;
    this.collection = collection;
  }
}
  1. Utilizar el nombre de la colección en los métodos de la clase MongoLib
async getAll(query) {
  const db = await this.connect();
  const data = await db.collection(this.collection).find(query).toArray();
  return data;
}
  1. Actualizar la capa de servicios. Noten como se simplifica el código
class MoviesServive() {
  constructor() {
    // El nombre de la colección como parámetro del constructor de MongoLib
    this.db = new MongoLib('movies')
  }

  async getMovies() {
    const query = tags && { tags: { $in: tags } };
    const movies = await this.db.getAll(query);
    return movies;
  }
}

Me gustaría saber qué piensan de este cambio, si es más o menos confuso, si es escalable, etc.

Lo primero que se me viene a la cabeza es que este cambio no estaría tan bueno si en la capa de servicios existieran métodos que interactuaran con más de una colección, pero es solo una apreciación. Me gustaría leer sus comentarios.

Bonus: Refactorizar el método connect de la clase MongoLib

async connect() {
  if (!this.client.isConnected()) {
    await this.client.connect()
  }
  return this.client.db(this.dbName)
}

Me demoré un poco, pero logré crear mi primera película en la base de datos.

Dure unas horas con mi error y era que no coincidían bien los nombres de las llaves del .env con los del config.js y el mongo.js

Aquí deje un arreglo para delete

  // delete
  router.delete("/:movieId", async function (req, res, next) {
    const { movieId } = req.params;
    const { body: movie } = req;
    try {
      const deleteMovieId = await moviesService.deletedMovie({movie, movieId});
      res.status(200).json({
        data: deleteMovieId,
        message: 'movies deleted'
      })
    } catch (error) {
      next(error);
    }```

6 horas 6 horas revisando el código y era un @ infriltado

@${config.dbHost}

al final lo resulte dejando así

const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}${config.dbHost}/${DB_NAME}?retryWrites=true&w=majority`;

npm install mysql

.env

// MYSQL
DB_USER=root
DB_PASSWORD=
DB_HOST=localhost
DB_NAME=dbprueba

./lib/mysql.js

const mysql = require("mysql");
const { config } = require('../config');

const USER = encodeURIComponent(config.dbUser);
const PASSWORD = encodeURIComponent(config.dbPassword);
const DB_NAME = config.dbName;

// Create a connection to the database
class MysqlLib {
    constructor() {
        this.client = mysql.createConnection({
            host: `${config.dbHost}`,
            user: `${USER}`,
            password: `${PASSWORD}`,
            database: `${DB_NAME}`
        });
        this.dbName = DB_NAME;
    }

    connect() {
        if (!MysqlLib.connection) {
            MysqlLib.connection = new Promise((resolve, reject) => {
                this.client.connect(err => {
                    if (err) {
                        reject(err);
                    }

                    console.log('Connected succesfully to mysql');
                    resolve(this.dbName);
                });
            });
        }

        return MysqlLib.connection;
    }

    getAll(collection, query) {
        return new Promise((resolve, reject) => {
            this.client.query(`SELECT * FROM ${collection}`, (err, res) => {
                if (err) {
                    console.log("error: ", err);
                    reject(new Error("Error rows is undefined"));
                    return;
                }
                console.log("customers: ", res);
                resolve(res);
            }); 
        });
    }

    get(collection, id) {
        return new Promise((resolve, reject) => {
            this.client.query(`SELECT * FROM ${collection} WHERE id = ${id}`, (err, res) => {
                if (err) {
                    console.log("error: ", err);
                    reject(new Error("Error rows is undefined"));
                    return;
                }
                console.log("customers: ", res);
                resolve(res);
            }); 
        });
    }

    create(collection, data) {
        return new Promise((resolve, reject) => {
            this.client.query("INSERT INTO "+collection+" SET ?", data, (err, res) => {
                if (err) {
                    console.log("error: ", err);
                    reject(new Error("Error rows is undefined"));
                    return;
                }
                console.log("customers: ", res);
                resolve(res.insertId);
            }); 
        });
    }

    update(collection, id, data) {
        return new Promise((resolve, reject) => {
            this.client.query(`UPDATE ${collection} SET ? WHERE id = ${id}`, data, (err, res) => {
                if (err) {
                    console.log("error: ", err);
                    reject(new Error("Error rows is undefined"));
                    return;
                }
                console.log("customers: ", res);
                resolve(res.insertId || id);
            }); 
        });
    }

    delete(collection, id) {
        return new Promise((resolve, reject) => {
            this.client.query(`DELETE FROM ${collection} WHERE id = ?`, id, (err, res) => {
                if (err) {
                    console.log("error: ", err);
                    reject(new Error("Error rows is undefined"));
                    return;
                }
                console.log("customers: ", res);
                resolve(id);
            }); 
        });
    }

}

module.exports = MysqlLib;

./services.movies.js

const mysqlLib = require(’…/lib/mysql’);

class MoviesService {
constructor() {
this.collection = ‘movies’;
this.myDB = new mysqlLib();
}

async getMovies({ tags }) {
    const query = tags && { tags: { $in: tags } };
    const movies = await this.myDB.getAll(this.collection, query);
    return movies || [];
}

async getMovie({ movieId }) {
    const movie = await this.myDB.get(this.collection, movieId);;
    return movie || {};
}

async createMovie({ movie }) {
    const createMovieId = await this.myDB.create(this.collection, movie);
    return createMovieId;
}

async updateMovie({ movieId, movie } = {}) {
    const updatedMovieId = await this.myDB.update(this.collection, movieId, movie);
    return updatedMovieId;
}

async deleteMovie({ movieId }) {
    const deletedMovieId = await this.myDB.delete(this.collection, movieId);
    return deletedMovieId;
}

async updatePartialMovie() {
    const updatedPartialMovieId = await Promise.resolve(moviesMock[0].id);
    return updatedPartialMovieId;
}

}

module.exports = MoviesService;

creamos un archivo en lib/mysql.js

const mysql = require(“mysql”);
const { config } = require(’…/config’);

const USER = encodeURIComponent(config.dbUser);
const PASSWORD = encodeURIComponent(config.dbPassword);
const DB_NAME = config.dbName;

// Create a connection to the database
class MysqlLib {
constructor() {
this.client = mysql.createConnection({
host: ${config.dbHost},
user: ${USER},
password: ${PASSWORD},
database: ${DB_NAME}
});
this.dbName = DB_NAME;
}

connect() {
    if (!MysqlLib.connection) {
        MysqlLib.connection = new Promise((resolve, reject) => {
            this.client.connect(err => {
                if (err) {
                    reject(err);
                }

                console.log('Connected succesfully to mysql');
                resolve(this.dbName);
            });
        });
    }

    return MysqlLib.connection;
}

getAll(collection, query) {
    return new Promise((resolve, reject) => {
        this.client.query(`SELECT * FROM ${collection}`, (err, res) => {
            if (err) {
                console.log("error: ", err);
                reject(new Error("Error rows is undefined"));
                return;
            }
            console.log("customers: ", res);
            resolve(res);
        }); 
    });
}

get(collection, id) {
    return new Promise((resolve, reject) => {
        this.client.query(`SELECT * FROM ${collection} WHERE id = ${id}`, (err, res) => {
            if (err) {
                console.log("error: ", err);
                reject(new Error("Error rows is undefined"));
                return;
            }
            console.log("customers: ", res);
            resolve(res);
        }); 
    });
}

create(collection, data) {
    return new Promise((resolve, reject) => {
        this.client.query("INSERT INTO "+collection+" SET ?", data, (err, res) => {
            if (err) {
                console.log("error: ", err);
                reject(new Error("Error rows is undefined"));
                return;
            }
            console.log("customers: ", res);
            resolve(res.insertId);
        }); 
    });
}

update(collection, id, data) {
    return new Promise((resolve, reject) => {
        this.client.query(`UPDATE ${collection} SET ? WHERE id = ${id}`, data, (err, res) => {
            if (err) {
                console.log("error: ", err);
                reject(new Error("Error rows is undefined"));
                return;
            }
            console.log("customers: ", res);
            resolve(res.insertId || id);
        }); 
    });
}

delete(collection, id) {
    return new Promise((resolve, reject) => {
        this.client.query(`DELETE FROM ${collection} WHERE id = ?`, id, (err, res) => {
            if (err) {
                console.log("error: ", err);
                reject(new Error("Error rows is undefined"));
                return;
            }
            console.log("customers: ", res);
            resolve(id);
        }); 
    });
}

}

module.exports = MysqlLib;

en la terminal instalamos mysql
npm install mysql

.env

// MYSQL
DB_USER=root
DB_PASSWORD=
DB_HOST=localhost
DB_NAME=dbprueba

Si lo necesitan con Mysql aqui les dejo como hacerlo

Despues de dos días enteros pasando esta clase, por fin logre que me andara tanto el ejercicio que hizo el profe como el challenge. Como estoy trabajando con WSL seguí esta guía para poder instalar. Hubo un momento en el que me fallaba al tratar de darle derechos pero con este comando:
sudo mongod --dbpath ~/data/db extraído de esta guía pude echarlo a correr, espero que a alguien mas le sirva. Saludos devs!

Migrant

Hola, alguien que haya tenido un MongoError: bad auth : Authentication failed.?? tengo correctos el usuario y la pass porque me permite conectarme desde el Mongo Compass, pero desde Node hace la primera conexión y despues falla cuando hago la primera prueba Get con Postman

Este es el reto, conecte a una instancia local en un box de vagrant de ubuntu corriendo mongo.

// CONFIG
PORT=3000
CORS=*

// MONGO
DB_PORT=27017
DB_USER=db_user
DB_PASSWORD=2Z4F1ZAYlwgJCYzj
DB_HOST=192.168.17.10
DB_NAME=db_platzivideos

Este es el string de conexión
const MONGO_URI = `mongodb://${config.dbHost}/${DB_NAME}`;

Y mi instancia de mongo en ubuntu con las colección de movie.

=(

El nivel de “Traceo” de errores de Guillermo Rodas es admirable ❤️

Es un excelente profesor y profesional, lo admiro enormemente