Conocer y comprender cómo se realizan las conexiones hacia los servidores a través de internet y sus implicaciones en el desarrollo de servidores

1

Bienvenida y presentación del curso

2

Qué es Node y cómo instalarlo

3

¿Qué son y cómo se usan las peticiones HTTP?

4

Métodos, cabeceras y estados

5

Cuerpo y query de la petición

Crear un servidor HTTP en Javascript, y comenzar a escuchar y responder peticiones desde un cliente .

6

Crear un servidor HTTP desde NodeJS

7

¿Cómo pueden venir las peticiones?

8

Recibir información desde el cliente: Body y Query

9

Información contextual: Leer las cabeceras

10

Tipos de respuesta: Vacía, plana, con datos y estructurada

11

Respuestas coherentes

12

Servir archivos estáticos

13

Errores: Cómo presentarlos e implicaciones en la seguridad

Comprender y desarrollar la arquitectura básica de un backend en NodeJS, y comunicarse entre módulos

14

Conceptualmente: Rutas, controladores y bases de datos

15

Rutas y capa de red: Responsabilidades y límites

16

Controladores: Definiendo la lógica de negocio

17

Almacenando la información en una base de datos

Utilizar una base de datos para definir, modelar, almacenar y recuperar la información de nuestra aplicación

18

Tipos de Bases de Datos: Relacionales y No Relacionales

19

Crear y Configurar tu Base de Datos con MongoDB

20

MongoDB: Almacenar y leer datos

21

MongoDB: Actualizar datos

22

MongoDB: Consultar datos

23

MongoDB: Eliminar Datos

24

Gestionar conexiones a la base de datos desde la API

Uso de entidades para crear aplicaciones escalables

25

Escalando la arquitectura: Múltiples entidades

26

Relacionando nuestras entidades

27

Cómo recibir ficheros desde NodeJS

28

Guardar el fichero en el servidor

Conocer el protocolo de websockets, e implementar comunicación cliente/servidor con SocketIO.

29

WebSockets: Qué son, por qué son interesantes y cómo usarlos

30

Manejo de Websockets con NodeJS

31

Conectar la API al servidor de WebSockets

Revisión de lo aprendido, y próximos pasos

32

Revisión y próximos pasos

33

Tips para escalar nuestro proyecto

No tienes acceso a esta clase

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

MongoDB: Almacenar y leer datos

20/33
Recursos

En esta clase vamos a utilizar mongoose para crear los esquemas de nuestra base de datos. También utilizaremos mLab como nuestra base de datos.

Aportes 150

Preguntas 34

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Para quienes tuvieron problemas con la conección a la db:
.
Mongoose no funciona con la uri que nos entrega mongodb atlas por defecto (mongodb+srv). Cuando le las click a ‘Connect Yout Aplication’ en las sección (1) Choose your driver version hay que seleccionar la versión de node 2.2.12 or later
.
Además le agregué un catch (mas otras cosas) a connect().
.
El código de esa parte quedó así:
.
.
store.js


const db = require('mongoose');
const Model = require('./model');

const uri =
  'mongodb://<user>:<pass>@<cluster_primary>,<cluster_secondary>/<nombre_de_la_coleccion>?ssl=true&replicaSet=Main-shard-0&authSource=admin&retryWrites=true';

db.Promise = global.Promise;

db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('[db] Conectada con éxito'))
  .catch(err => console.error('[db]', err));

function addMessage(message) {
  const myMessage = new Model(message);
  myMessage.save();
}

function getMessages() {
  return list;
}

module.exports = {
  add: addMessage,
  list: getMessages,
  //get
  // update
  // delete
};

Hola! Me salía un error en la consola que decía: ReferenceError: Model is not defined.

Luego de unos minutos de inspeccionar el código me di cuenta que era debido a que habíamos exportado Model pero nunca lo habíamos importado en store.js y lo estabamos queriendo usar.

Me parecía raro ya que en el video en ningún momento se había importado, aunque sí se hizo y por algún error de edición no salió (minuto 10.23)

Para importarlo en store.js, sólo hay que escribir la siguiente línea:
const Model = require(’./model’)

Es muy mala práctica tener la URI de una base de datos dentro del código, les recomiendo usar un archivo de configuración (.env) que guarde la URI como una variable de entorno, instalen esta librería, dotenv e impleméntanla como dice. Así mismo, creen un archivo .gitignore y añadan .env para proteger su URI.

En cuanto al codigo de la clase lo unico que agregue fue el nombre de la base de datos y me funciono.

const db = require('mongoose');
const Model = require('./model');

db.Promise = global.Promise;
// mongodb+srv://db_user_platzi_videos:[email protected]/test?retryWrites=true&w=majority
db.connect('mongodb+srv://db_user_platzi_videos:[email protected]/test?retryWrites=true&w=majority', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    dbName: 'telegrom'
});

console.log('[db] conectada con exito');

function addMessage(message) {
    // list.push(message);
    const myMessage = new Model(message);
    myMessage.save();
}

async function getMessages() {
    // return list;
    const messages = await Model.find();
    return messages;
}```

npm i mongoose

Como mLab ahora forma parte de atlas, comparto aca la manera de realizar la conexión una vez que la base de datos ha sido creada:

const user =user';
const pass = 'user1234';
const host = myCluster.mongodb.net';
const database = 'dbName';
const uri = `mongodb+srv://${user}:${pass}@${host}/${database}?retryWrites=true&w=majority`;

db.Promise = global.Promise;
db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
	.then(() => {
		console.log('[db connection] Database connected')
	})
	.catch( error => {
		console.error('[db connection] Connection failed', error.message) 
	});

No se aprecia ni tampoco lo comenta explicitamente pero en el 10:18 al 10:19
se agrega la importación de model.js

const Model = require('./model')

Dejo el codigo de store.js para ayudar a los nuevos

const db = require("mongoose")
const Model = require('./model')

db.Promise = global.Promise
db.connect('mongodb+srv://<user>:<password>@cluster0-yjahj.mongodb.net/<database>?retryWrites=true&w=majority',{
    useNewUrlParser: true,
    useUnifiedTopology: true
})

console.log("[db] Conectada con exito")

const addMessage = message => {
    const myMessage = new Model(message)
    myMessage.save()
}

const getMessage = async () => {
    return await Model.find()
}

module.exports = {
    add: addMessage,
    list: getMessage,
    //get
    //update
    //delete
}```

Para mayor seguridad en los datos de conexión, debemos crear un archivo .env en la raíz del proyecto

//CONFIG
PORT=
CORS=*

//MONGO
DB_USER=
DB_PASSWORD=
DB_HOST=
DB_NAME=

Instalamos la dependencia dotenv que nos permite leer variables de entorno

npm install dotenv

Posteriormente creamos un archivo config.js que puede ser en la misma carpeta de store.js

require('dotenv').config();

const config = {
  dev: process.env.NODE_ENV !== 'production',
  port: process.env.PORT || 3000,
  cors: process.env.CORS,
  dbUser: process.env.DB_USER,
  dbPassword: process.env.DB_PASSWORD,
  dbHost: process.env.DB_HOST,
  dbName: process.env.DB_NAME
};

module.exports = { config };

Y por último en el archivo store.js creamos la conexón a la base de datos de mongoDB Atlas

const db = require('mongoose');
const { config } = require('./config');

const user = encodeURIComponent(config.dbUser);
const pass =encodeURIComponent(config.dbPassword);
const host = encodeURIComponent(config.dbHost);
const database = encodeURIComponent(config.dbName);
const uri = `mongodb+srv://${user}:${pass}@${host}/${database}?retryWrites=true&w=majority`;

db.Promise = global.Promise;
db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
	.then(() => {
		console.log('[db connection] Database connected')
	})
	.catch( error => {
		console.error('[db connection] Connection failed', error.message) 
	});<code> 

Me estaba volviendo loco por un error.

A la final era que en el store.js había que traer el modulo de model.

const Model = require(’./model’);

Por si a alguien más le pasa esto.

Creo que ya va siendo hora de que actualicen este curso

Este curso iba genial hasta este momento.

Para quienes deseen usar docker (con docker compose) les dejo una pequeña guía.

  1. Crear el archivo docker-compose.yml en la carpeta raiz de proyecto
version: "3.7"
services:
  db:
    image: mongo:4
    volumes:
      - type: volume
        source: mongo_data
        target: /data/db
      - ./mongo/init.js:/docker-entrypoint-initdb.d/init-mongo.js:ro
    ports:
      - "27017-27019:27017-27019"
    environment:
      - MONGO_INITDB_DATABASE=chatdb
      - MONGO_INITDB_ROOT_USERNAME=root
      - MONGO_INITDB_ROOT_PASSWORD=root

  mongo-express:
    image: mongo-express:0.54
    ports:
      - 8081:8081
    environment:
      ME_CONFIG_MONGODB_SERVER: db
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: root

volumes:
  mongo_data:
  1. Crear una carpeta de nombre mongo en la carpeta raiz del proyecto y dentro de ella, crear un archivo con nombre init.js, el cual es un script para crear un usuario con permisos de lectura y escritura sobre la base de datos, que en este caso la llamé chatdb (la ruta y el nombre del archivo puede cambiarse pero debe ser un archivo .js, ya que éste se monta en el directorio /docker-entrypoint-initdb.d bajo el nombre init-mongo.js. Esto es necesario para poder acceder a la base de datos por cuestiones de permisos):
db.createUser({
  user: "admin1",
  pwd: "admin1",
  roles: [
    {
      role: "readWrite",
      db: "chatdb"
    }
  ]
})
  1. Correr el comando para iniciar los contenedores (teniendo docker-compose instalado)
docker-compose up -d
  1. En el archivo store.js, usar las siguientes líneas para iniciar el cliente de la base de datos (yo utilicé el nombre de usuario y contraseña admin1, pero esos datos se pueden cambiar)
...
const url = `mongodb://admin1:admin1@localhost:27017/chatdb`
db.connect(url, {
  useNewUrlParser: true,
  useUnifiedTopology: true
});
...

Esta configuración solo es para pruebas o desarrollo. Para producción es mejor usar atlas u otro servicio que ya esté listo para usarse.

chicos el problema del TypeError: Cannot read property ‘model’ of undefined, lo que succede es que al parecer mongoose tiene algun tipo de bug y no esta funcionando el codigo de siempre para que les funcione primero:

declaren const model = require(‘mongoose’).model

y para exportar:

module.exports = model.call(require(‘mongoose’),‘modelName’, mySchema)

Si tienen problemas al realizar la conexión con mongo lo pueden hacer de la siguiente manera.

db.Promise = global.Promise;
const options = {
    keepAlive: 1,
    useUnifiedTopology: true,
    useNewUrlParser: true,
};
db.connect('mongodb+srv://userdb:password@url?retryWrites=true&w=majority', options)
    .then(() => console.log('DB connected'))
    .catch((err) => {
        console.log(err);
    });

creo que habría que actualizar el curso…

Batallé mucho para conectar con Mongo DB Atlas,
Aquí tienen un ejemplo para los que les sale error de conexión, o cualquier otro error en store.js
Igualmente, tuve que usar npm i [email protected] para poder importar mongoose.

const db = require('mongoose');
db.Promise = global.Promise;
db.connect(
     'mongodb+srv://db_user_raulacosta:[email protected]/Telegrom',
    {
        useNewUrlParser:true,
        useUnifiedTopology: true
    }
     );
 console.log(`[DB] Conectada con éxito`);```

La estructura el proyecto me parece desordenada, no se separa por objetivos, en de la Escuela de Js tiene mejor estructura

Para los que no han conseguido hacer esto debido a la mala organización del curso, deben crearse una cuenta en MongoDB Atlas, hacen todos los pasos de este video y luego se descargan en Mongo Compass donde van a poder ver y administrar los datos que se van almacenando, la base de datos por defecto es “test”… Luego debería andar todo 200.

Es muy importante que, cuando creen la DB en mongo, en la parte de NETWORK ACCES le den acceso a cualquier IP(OJO con esto, en proyectos reales y pasen a PROD. no se debe dar acceso a cualquiera) para que se conecte a la DB o en su defecto si tienen conocimiento le den acceso a la IP que especifiquen UDS. Esto es importante, porque cuando estén trabajando les va a denegar el acceso.

👋

Para aquell@s que tenga dificultades con la creación de la base de datos en MongoDB pueden seguir estos pasos e introducirlos en el flujo de su proyecto.

Saludos.


const db = require('mongoose')
const Model = require('./model')

db.Promise = global.Promise 

db.connect('mongodb+srv://usuario:[email protected]/test?retryWrites=true&w=majority',{
    useNewUrlParser: true,
    useUnifiedTopology: true,
    dbName:'telegram'

})
console.log('[db: Conectada con éxito]')


function addMessage(message){
   
    const myMessage = new Model (message)
    myMessage.save()
}

async function getMessages() {
    const messages = await Model.find();
    return messages; 
}

module.exports = {
    add: addMessage,
    list: getMessages,

}```

Obviamente debe haber una forma mejor, pero despues de tanto dar asi fue como logre conectarme al servidor de atlas mongodb para poder continuar la clase.

const Model = require('./model');
const MongoClient = require('mongodb').MongoClient;
const uri = 'mongodb+srv://Telegrom:[email protected]/TelegromDB?retryWrites=true&w=majority'
const client = new MongoClient(uri, { 
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

function addMessage(message) {
  client.connect(err => {
    const collection = client.db('TelegromDB').collection('chat');
    const myMessage = new Model (message);
    collection.insertOne(myMessage, err =>{
      // console.log(collection)
      console.log("Mensage guardado")
    })
  });
  client.close();
}```
const MONGO_URI = `mongodb+srv://${USER}:${PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&w=majority`;
db.Promise = global.Promise
db.connect(MONGO_URI, {useNewUrlParser: true, useUnifiedTopology: true})

Para evitarse de problemas en MONGO ATLAS:

Habilitar IP para conexiones de forma abierta

SECURITY => Network Access => ADD IP ADDRESS=> 0.0.0.0 Everyone

Para el tema la cadena de conexión :

DEPLOYMENT=> Database => Connect => Connect your application => VERSION 2.2.12 OR LATER

Crear Base de datos

DEPLOYMENT => Database => Collections => Create database

Crear el usuario:

SECURITY => Database Acccess

Ejemplo

const mongoString = 'mongodb://USERNAME:<YOUR_PASSWORD>@ac-4nj9je2-shard-00-00.gv0tf3b.mongodb.net:27017,ac-4nj9je2-shard-00-01.gv0tf3b.mongodb.net:27017,ac-4nj9je2-shard-00-02.gv0tf3b.mongodb.net:27017/?ssl=true&replicaSet=atlas-1023g3-shard-0&authSource=admin&retryWrites=true&w=majority'
db.connect(mongoString, { useNewUrlParser: true })
console.log("[CONNECTING MONGO]");
db.connection.on("error", function (error) {
    console.log("[ERR] MONGO CONNECT... , ", error)
})
db.connection.on("open", function () {
    console.log("[SUCCESS] CONNECTED to MongoDB database.")
})

Para aquellos que se les presente un problema como el mío…
.
Node.js me arrojaba este warning:
DeprecationWarning: collection.ensureIndex is deprecated. Use createIndexes instead.
.
Esto se debe a que faltaba agregar una propiedad en la configuración que hacemos en la conexión a MongoDB Atlas con mongoose. El código quedaría de la siguiente forma:

const db = require('mongoose');
const Model = require('./model');

const uri = "mongodb+srv://db_user:<password>@cluster0.dioxv.mongodb.net/<db_name>?retryWrites=true&w=majority";

db.Promise = global.Promise;

db.connect(uri, {
    useNewUrlParser: true, 
    useUnifiedTopology: true,
    useCreateIndex: true
})
.then(() => console.log('[db] Conectada con éxito'))
.catch(e => console.error('[db]', e));

Les comparto mi codigo. Agregue un archivo de configuracion en el que uso la libreria dotenv para encapsular los datos de conexion a la BD en un archivo de variables de entorno. Eso le agrega una capa de seguridad a nuestra BD ya que no es bueno dejar informacion sensible en nuestro codigo.

store.js

const db = require("mongoose");
const { config } = require("../../config/config");
const model = require("./model");

const DB_USER = encodeURIComponent(config.db_user)
const DB_PASSWORD = encodeURIComponent(config.db_password)
const DB_HOST = config.db_host
const DB_NAME = encodeURIComponent(config.db_name)

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

db.Promise = global.Promise;
db.connect(mongo_uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
  .then(() => {
    console.log("[db] Conectada con exito")
  })
  .catch(e => {
    console.error(e)
    console.log("[db] Error de conexión")
  })

config.js

require("dotenv").config();

const config = {
  port: process.env.PORT || 3000,
  cors: process.env.CORS,
  db_user: process.env.DB_USER,
  db_password: process.env.DB_PASSWORD,
  db_host: process.env.DB_HOST,
  db_name: process.env.DB_NAME,
};

module.exports = { config };

En el video se corta pero recuerden importar el Model. Si hacen esto y ponen el nombre de su db como indica osk1dav, todo da perfecto

Hola Devs:
-Aca les tengo mi solucion al dia de hoy, tuve problemas para conectarme a la collection , que en mi caso se llama ChatApp, les traigo como hice todo, haciendo uso tambien de TypeScript:
El Store del componente Message:

El Model del componente Message, aqui lo que hice es agregar un parametro mas en el Schema, que seria la collection a la que me quiero conectar, y listo, problema resuelto:

-Aca les dejo el commit exacto de esta clase, por si lo necesitan, asi como tambien el model del archivo .env que utilice para leer los datos para conectarme a la DB: Click Aqui
-Recuerda, #NuncaParesDeAprender 💚

no estaria entendiendo el:
"Error en el controlador"
a que haria referencia, cual es mi error!?

El método para agregar no se hizo con una promesa. ¿Por qué?

No puedo ingresar a mLab con la cuenta de Mongo DB Atlas.

Ayuda!

En el minuto 10:19, el profesor añade el require de Model sin explicarlo. Puede generar confusión a la hora de hacer un GET, porque si no se importa ese módulo, se ejecuta el response.error.

No comprendo según la lectura anterior debemos hacer nuestra base de datos en https://www.mongodb.com/cloud/atlas pero desde aca nos muestra como hacerlo en https://mlab.com/
Segui lo que me decia el articulo anterior y no puedo hacer la conexion de mi base de datos con lo programado en esta clase!

const db = require('mongoose')
const Model = require('./model')

db.Promise = global.Promise
db.connect('mongodb+srv://dn_user_platzinodejs:[email protected]/platzinodejs_db?retryWrites=true&w=majority', {
    useNewUrlParser : true,
    useUnifiedTopology: true
    })
    .then((resolve) => {
        console.log('[DB] Success contected')
    })
    .catch((reject) => {
        console.log(`[DB] fail contected ${reject}`)
    })

const addMessage = (message) => {
    const myMessage = new Model(message);
    myMessage.save()
}

const getMessages = async () => {
    const messages = await Model.find()
    return messages
}

module.exports = {
    add :addMessage,
    list: getMessages
}

para que saliera sin errores, hice esta conexión con la ultima versión de mongodb que es mongo 3.6.3 ademas agregue un catch para el caso de que no sirva la conexión y se evite un loop

db.connect(`mongodb+srv://<user>:<pasword>@
    <port>/telegram?retryWrites=true&w=majority`,
    { useNewUrlParser: true, useUnifiedTopology: true  })
        .then(()=>{
            console.log('[db]Conectada con exito')
        }).catch(error=> console.error(Error))  ```

Conectándose a una instancia de Mongo en un contenedor

Bueno, este curso ya está como viejo y es una verdadera pena que el equipo de Platzi no lo haya actualizado aún. Sin embargo, los conceptos que se abordan en este curso son un maravilloso punto de partida para trabajar con el Stack MEAN.

Yo estoy trabajando este proyecto usando un contenedor de mongo con un Bind Mount a mi carpeta del curso. De esta manera puedo ejecutar el proyecto y aprovechar la instancia de Mongo que viene con el contenedor. Muy parecido a como se trabaja en ambientes profesionales usando Docker como herramienta de desarrollo.

He optado por este enfoque debido a que el curso está desactualizado y debido a esto se me facilita conectarme a un contenedor de Docker que ya venga con Mongo listo. Para poder trabajar el proyecto desde afuera del contenedor hice un Bind Mount que me permite trabajar el proyecto usando VSCode.

Prerequisitos:

  • Tener Docker instalado

Pasos:

$ docker run -it --name platzi-websocket -p 3011:3011 -v /Users/Yo/platzi/WebSocket:/app mongo:latest bash

Una vez dentro de la terminal vamos a la carpeta en la que podremos ver nuestro proyecto. Ahora procederemos a instalar todas las dependencias que necesitamos en el contenedor para poder ejecutar nuestra aplicación desde acá:

cd app
apt-get uddate
apt-get upgrade -y
apt-get install -y curl
apt-get install -y nodejs
npm i express
npm i -g nodemon
npm i mongoose

Debemos recordar que nuestro servidor estaba escuchando en el puerto 3000. Yo no uso ese puerto porque lo uso para escuchar a otra cosa, entonces tenía puesto el puerto 3010. Sin embargo, definí que mi contenedor iba a tener abierto el puerto 3011, por lo que necesito decirle a mi server que escuche por ese puerto:

Como paso siguiente voy a hacer la configuración de mi modelo:

El Storage que es el que se encargará de comunicarse con Mongo, usando el modelo para crear persistencia en la base de datos:

Para mi el servicio es el que se encarga de comunicarse con el modelo y dónde está la lógica de negocio:

Finalmente tendremos el controlador que se comunicará con el FrontEnd para servir las API:

Una vez acondicionado nuestro contenedor vamos a correr nuestro proyecto como en la clase tras anterior:

nodemon server

Deberíamos poder ver en la consola los outputs para nuestro servidor y deberíamos de poder acceder a los endpoints desde por ejemplo Postman que es lo que yo uso:

Hola!
Para quienes quieran mejorar la seguridad del backend en caso de querer subir el proyecto a GitHub, recomiendo que creen un archivo con la configuración de la conexión de la base de datos y a eso exportarlo al archivo propio de la conexión y simplemente agregarlo asignando el valor de lo exportado en el archivo de configuración a una variable o constante y poner en los parámetros de conexión, la configuración.
.
Espero les sirva!!

Hola! estuve dos dias trancada con esto, el codigo quedo igual al que hizo el profesor, al no ser por la parte de conexion tiene una pequeña modificacion:

const db = require (‘mongoose’);
const Model = require(’./model’);

db.Promise = global.Promise;
db.connect(‘mongodb+srv://mrezendes:pswrd@cluster0.esz9h.mongodb.net/<nombre db>?retryWrites=true&w=majority’, {
useNewUrlParser:true,
useUnifiedTopology: true,
});

el resto del codigo tal cual lo hizo el profe, si estan teniendo errores sugiero verificar: haber colocado en el link los datos que solicita, nombre user, password y nombre de la db. Y por otro lado que no les falte ninguna coma, ningun require y ningun espacio de mas, sobre todo en los require, me trajo un problema que me costo mucho visualizar, por un espacio de mas no me funcionaba el codigo 😄 jajaj espero le sea de ayuda a alguien que pueda trancarse por aqui. Saludos!

En esta clase vamos a utilizar mongoose para crear los esquemas de nuestra base de datos. También utilizaremos mongo Atlas como nuestra base de datos.

Lo primero es crear un servidor de base de datos en mongo Atlas, en el momento de ingresar creamos un cluster gratuito donde despues podemos crear nuestra base de datos en la pestaña de Browser Collections (colecciones), ahi podremos crear la base de datos con nuestras colecciones.

Posteriormente crearemos un usuario desde la página principal de mongo Atlas en la pestaña de QuicStart creamos un nombre de usuario y una contraseña (puede ser una autogenerada pero debemos recordar cual es)

Luego en el cluster para poder obtener los datos de conección damos clic en la pestaña de connect, donde usaremos la pestaña MongoDB Compass. donde tendremos la url de conexión.

Con la url de conexión podemos dirigirnos al código

lo primero sera instalar mongoose para manejar la conexión de la base de datos desde el código

npm i mongoose

Por el uso de mongo atlas es recomendable que se cree los archivos de ambiente .env y .env.example donde estaran los datos de conexión con la base de datos

.env

//CONFIG
DB_USER=<username>
DB_PASSWORD=<password>
DB_HOST=cluster0.gxkowbp.mongodb.net
DB_NAME=telegram

creamos el modelo de datos para exportarse y enviar y recibir datos a mongo

model.js

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const mySchema = new Schema({
    user: String,
    message: {
        type: String,
        required: true,
    },
    date: Date,
});

const model = mongoose.model('Message', mySchema);
module.exports = model;

posteriormente pasamos a formar la uri y la conexión de la base de datos

store.js

const db = require('mongoose');
const Model = require('./model');
require('dotenv').config();

db.Promise = global.Promise;

const uri = `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASSWORD}@${process.env.DB_HOST}/${process.env.DB_NAME}?retryWrites=true&w=majority`;

db.connect(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true
});
console.log('[db] Conectada con éxito')

function addMessage(message) {
    const myMessage = new Model(message);
    myMessage.save();
}

async function getMessages() {
    return await Model.find();
}

module.exports = {
    add: addMessage,
    list: getMessages,
    //get
    //update
    // delete
}

Okay si leyendo la clase pasada, ahora se tiene que utilizar Mongo atlas, voy a dejar un ejemplo de como me funcionó a mi la coneccion a la base de datos. Usando instancias de esta

store.js (es el mismo de esta clase donde hará las funciones para obtener mensajes)

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

const db = new MongoLib();
db.connect();

Ahora siguiendo la clase de donde explican como hacer conección con atlas les debería de quedar así

config/index.js

const { MongoClient, ObjectId } = require('mongodb');
const { config } = require('../config');
console.log('myConfig', config);
const USER = encodeURIComponent(config.dbUser);
const PASSWORD = encodeURIComponent(config.dbPassword);
const DB_NAME = config.dbName;
const URI = `mongodb+srv://${USER}:${PASSWORD}@${config.dbHost}/${DB_NAME}?retryWrites=true&w=mayority`;
console.log('URI', URI);
class MongoLib {
  constructor() {
    this.client = new MongoClient(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);
          } else {
            console.log('conection added');
            resolve(this.client.db(this.db));
          }
        });
      });
    }
    return MongoLib.connection;
  }
}

module.exports = MongoLib;

Hola amigos!, para los que tienen el error

  • [db] MongoError: bad auth : Authentication failed.

Mongo atlas, nos entrega el url de conecion de la siguiente manera

mongodb://tuUserName:<password>

Es necesario retirar los < y > para que funcione, nos quedaria algo asi.

mongodb://tuUserName:tupassword

Es necesario utilizar el driver 2.2.12 o later para que funcione la coneccion.

Les dejo mi codigo completo 😃 espero ayudar.

Archivo Store.js

const MongoClient = require('mongodb').MongoClient;
const model = require("./model")

const db = require('mongoose');
const Model = require('./model');

const uri =
  'mongodb://tusuer:[email protected]:27017,cluster0-shard-00-01.ps4fu.mongodb.net:27017,cluster0-shard-00-02.ps4fu.mongodb.net:27017/myFirstDatabase?ssl=true&replicaSet=atlas-117l5p-shard-0&authSource=admin&retryWrites=true&w=majority';

db.Promise = global.Promise;

db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('[db] Conectada con éxito'))
  .catch(err => console.error('[db]', err));

function addMessage(message) {
  const myMessage = new Model(message);
  myMessage.save();
}

function getMessages() {
  return list;
}

module.exports = {
  add: addMessage,
  list: getMessages,
  //get
  // update
  // delete
};

Siguiendo las recomedaciones del curso de Backend con Node.js

const db = require('mongoose');
const config = require('../../config');   
const Model = require('./model');

const USER = encodeURIComponent(config.dbUser);
const PASSWORD = encodeURIComponent(config.dbPassword);
const HOST = encodeURIComponent(config.dbHost);
const NAME = encodeURIComponent(config.dbName)
const uri = `mongodb+srv://${USER}:${PASSWORD}@${HOST}/${NAME}?retryWrites=true&w=majority`;

db.Promise = global.Promise;

db.connect(uri, {
    useNewUrlParser: true,
    useuseUnifiedTopology: true
}).then(()=> console.log('[db] Conectada con éxito'))
.catch(err => console.error('[db]', err));


function addMessage(message) {

    const myMessage = new Model(message); 
    myMessage.save();
}


async function getMessages() {
   const messages = await Model.find();
   return messages;
}

module.exports = {
    add : addMessage,
    list: getMessages
}

Para no subir sus credenciales al repositorio remoto como github pueden crear un archivo nuevo e ignorarlo con .gitignore
components/message/dbUserData.js
en el exportan sus credenciales como user y password , en mi caso cree un archivo llamado dbUserData.js con solo unas cuantas lineas

module.exports = {
    password: ' ******* ',
    user: ' ***** '
}

solo remplacen los asteriscos por sus datos y pueden importarlo al archivo store.js

const dbUserData = require('./dbUserData');

const dbUser = dbUserData.user;
const dbPassword = dbUserData.password;
db.connect(`mongodb+srv://${dbUser}:${dbPassword}@cluster0.d54r6.mongodb.net/platziNode?retryWrites=true&w=majority`,{
    useNewUrlParser: true,
    useUnifiedTopology: true,
    dbName: 'messages'
});

De esta manera sus datos estarán seguros en su repositorio local y nadie podrá verlos en su repositorio remoto si es que tienen su repositorio publico.

deben actualizar esta parte del curso… mLab redirige a mongodb y ahi el formato de la url de conexion es distinta… el profesor menciono que no hay problemas y en efecto muestra conexion exitosa pero cuando intento crear un mensaje me sale error y no puedo avanzar mas de ahi porque no explican con los recursos actuales.

my store.js

const db = require('mongoose');
const Model =  require('./model');

db.Promise= global.Promise;
db.connect('mongodb+srv://db_user_node:[email protected]/test?retryWrites=true&w=majority', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});

console.log('[db] Conectada con el server db');

function addMessage(message) {
    const myMessage = new Model(message);
    myMessage.save();
}

async function getMessages() {
    const message = await Model.find();
    return message; 
}

module.exports = {
    add: addMessage,
    list: getMessages
}```

Con mongo compass también funciona muy bien, por defecto usa el puerto 27017. En mi caso yo ya lo tenia instalado en mi máquina para usarlo con otros proyectos.
Quedaría de la sgte. manera:

const mongoose = require('mongoose')

const URL = 'mongodb://localhost:27017/telegrom'
const CONFIG = {
    useNewUrlParser: true,
    useUnifiedTopology: true,
}
const DB = mongoose.connection


mongoose.connect(URL, CONFIG)
    .catch(err => console.log(err))

DB.on('open', _ => {
    console.log('BD conectada a: ', URL)
})

DB.on('error', err => console.log(err))

Si mongoose os da error, intentad con la opción que os da MongoDB Atlas, dentro de Connert to Cluster dadle al checkbox de “Include full driver code example” y reemplazarlo por el de la clase.

y para manejar errores con un simple if/else, arreglado

const MongoClient = require('mongodb').MongoClient;
MongoClient.Promise = global.Promise;
const uri = "mongodb+srv://<nombre de usuario>:<constraseña>@cluster0.vhbgd.mongodb.net/<Nombre de la coleccion>?retryWrites=true&w=majority";

const client = new MongoClient(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true
})

client.connect(err => {
    const collection = client.db("test").collection("devices")
    // perform actions on the collection object
    if (err) {
        console.error("[db-error]:", err)
    } else {
        console.log("[db]: Connect success")
    }
    client.close();
})

Habrá mejores formas seguro, pero siendo un novatillo total, funciona 🤣

Espero que sirva de ayuda 😄

Lo facil que es usar mongoose es genial. Pero si exploramos la documentacion nos damos cuenta que hay un millon de cosas que podemos hacer, como verificaciones en el modelo y promesas en los metodos para saber si la informacion se guarda correctamente o no…

Me gusta mucho el curso, en este momento quisiera saber si mongoose aun continua siendo necesario, es decir, ¿estas funciones no está todavía como parte nativa al instalar mongodb?
Si el profe ve los comentarios quisiera saber, sino algún compañero con un poco más de experiencia, les agradezco pura vida!

Buenos dias alguien me puede explicar esto que esta lanzando mongodb desde windows no se si pasa lo mismo desde otros sistemas operativos la advertencia es la siguiente:

Deprecation Warning: 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.

alguien sabe algo del tema que no entendi muy bien los que tenemos nuestros servidores locales espero me aclaren que pasa gracias.

A qui mi código por si a les sirve, recuerden no poner datos importantes en el código

const dbname = process.env.DBNAME;
const contrasena = process.env.PASSWORD;

const db = require('mongoose');
const Model = require('./model');

const uri2 = "mongodb+srv://db_user_cursoNodeJS:"+contrasena+"@cluster0.0pgxi.mongodb.net/"+dbname+"?retryWrites=true&w=majority";

db.Promise = global.Promise;
db.connect(uri2,{
      useNewUrlParser:true,
      useUnifiedTopology: true
})
      .then(() => console.log('[Date Base Connect] DB conectada con éxito'))
      .catch(err => console.error('[db]', err));

const addMessage = (message) => {
      const myMessage = new Model(message);
      myMessage.save();

}

const getMessage = async  () => {
      const message = await Model.find();
      return message;
}

module.exports = {
      addMessage,
      getMessage,
}

Lo bueno es que me funciona todo correctamente hasta insomnia y lo malo es que primero no se donde se puede ver los datos que fueron enviados a la base de datos y en la base de datos no se si llegaron los datos que le envié. 😦 alguien me puede ayudar, muchas gracias!!

A las personas que quieran poner un poco más de seguridad para escalar este proyecto pueden usar variables de entorno en un archivo .env y junto con la librería dotenv pueden hacer que todas esas contraseñas no sean públicas en el código.

//Archivo .env
DB_HOST='mongodb+srv://'
DB_USER=':'
DB_PASS=''
DB_URL =''
//store.js
const db = require('mongoose');
const dotenv = require('dotenv').config({path:`${__dirname}/.env`});
const host = process.env.DB_HOST;
const username = process.env.DB_USER;
const password = process.env.DB_PASS;
const url = process.env.DB_URL; 
const uri = `${host}${username}${password}${url}`;
console.log(uri);

db.Promise = global.Promise
db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('[db] Conectada con éxito'))
  .catch(err => console.error('[db]', err));

Por favor ayuda!! hice la conexion tal cual en el video, no me genera ningun error pero a la hora de generar el post me dice que los datos estan incompletos y el metodo get dejo de funcionar, solo arroja el error, esto sucedio luego de añadir el codigo de conexion a la base de datos.

<h1>Almacenar y leer datos</h1>

En esta clase vamos a utilizar mongoose para crear los esquemas de nuestra base de datos. También utilizaremos mongo atlas como nuestra base de datos.


Instalaciones necesarias

npm i mongoose // Nos permite crear schemas

<h3>Mongoose</h3>

Mongoose nos permite crear esquemas para validar que los datos cumplan con un formato especifico, esta es una buena practica y deberia hacerse.

Mongoose es una herramienta de modelado de objetos de MongoDB diseñada para funcionar en un entorno asincrónico.
Mongoose admite tanto promesas como devoluciones de llamada.

<h3>Creando un schema y un model</h3>

En el archivo components/message/model.js

const mongoose = require('mongoose'); // Importar libreria
const Schema = mongoose.Schema; // Obtener el objeto schema

const mySchema = Schema({
    user: String,
    message: {
        type: String,
        required: true
    },
    date: Date
});  // Crear una instancia del objeto Schema


// Crear un modelo
// Parametro 1: Nombre de la colleccion en la bd
// Parametro 2: El nombre del schema al que esta relacionado
const model = mongoose.model('Message', mySchema);

// Exportamos el modelo
module.exports = model;


<h3>Usar el modelo en el storage</h3>

En el archivo components/message/storage.js

const db = require('mongoose'); // Importar libreria
const Model = require('./model'); // Importamos el modelo

/* El usuario y la contraseña deberian ser variables de entorno */
const USER_BD = process.env.USER_BD;
const PASSWORD_BD = process.env.PASSWORD_BD;

// String de coneccion a la base de datos
const uri = `mongodb+srv://${USER_BD}:${PASSWORD_BD}@cluster0.x6rhq.mongodb.net/<dbname>?retryWrites=true&w=majority`;


db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('[db] Conectada con éxito'))
  .catch(err => console.error('[db]', err));


const list = [];

function addMessage(message) {
    const myMessage = new Model(message);
    myMessage.save();
}

async function getMessage() {
    const messages = await Model.find();
    return messages;
}

module.exports = {
    add: addMessage,
    list: getMessage
    // get
    // update
    // delete
}

Por el momento hay un control de flujo en el archivo controller.js que se encarga de verificar que haya un mensaje y un usuario en cada mensaje enviado, ahora también se puede hacer desde la base de datos con la opción required, mi pregunta es la siguiente: ¿Cual de las dos formas me asegura que no entre información indeseada a la base de datos? y ¿Cual de ellas es la mejor forma de validar esta información?

Si alguien tiene problemas con conectar a la base de datos, probablemente sea por las versiones. Si a alguien le interesa, yo lo solucioné conectando a un servidor local de MongoDB, solo descarguen MongoDB del sitio oficial, es gratis. Para la visualización pueden descargar Compass desde la misma página, también es gratuito. El código que conecta con la base de datos local es el siguiente:

uri='mongodb://127.0.0.1/<database_name>'
db.Promise = global.Promise;

db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('[db] Connected successfully'))
  .catch(err => console.error('[db]', err));

Muy bien todo. Pero puede mejorarse la forma de conexión?

Tengo este error:

TypeError: Schema is not a constructor

Si van a subir su proyecto a GitHub su información de conexión a la base de datos queda expuesta, lo que hice fue crear un archivo llamado config.js y exporte la string de conexión después en store la inlcluí e ignore el archivo en .gitignore.

config.js

const connection = 'mongodb+srv://;

exports.connection = connection;

store.js

const config = require('./config');

db.connect(config.connection, {
	useNewUrlParser: true,
	dbName: 'telegrom'
});

.gitignore

ProJectName/components/message/config.js

De esta manera su información no queda expuesta en su repositorio

Buenos días, les sugiero que la ruta de MONGO_URI la guarden como una variable de entorno y la ignoren al momento de subir de su repo local al remoto.

Hola comunidad, tengo una duda muy urgente sobre la conexion de la base de datos y esta clase, en la clase anterior te redirige a un video del curso “Backend con Javascript” ya que en este se usa Mlab y este ya no esta disponible, pero en Mongo DB Atlas en connect te da 3 opciones con 3 links diferentes, y ninguno se parece al de este video…

Todo funcionaba perfecto con el mock, guardaba los mensajes en el array de prueba y todo funcionaba correctamente…

Adjunto mi codigo, de store.js y el log de mi terminal al trata de hacer un post de un mensaje…

LINK: flickr.com/photos/185642399@N02/?

PD: AYUDENME PORFAVOR ESTOY ESTANCADO 😦

A fecha de 13/11/2023, no es necesario que hagan pasos extra para conectar a la base de datos con el uri que les pasa mongodb (Como lo muestra el primer comentario que aparece).

Con la uri de la version mas reciente que les da MongoDB es mas que suficietne para que se conecten a la base de datos y puedan hacer sus peticiones

Asi me funcionó en pleno 2023:

const mongoose = require("mongoose");
const Model = require("./model");

const uri =
  "mongodb+srv://<your_db_user>:<your_db_password>@cluster0.duqltua.mongodb.net/<your_db_name>?retryWrites=true&w=majority";

mongoose.Promise = global.Promise;

mongoose
  .connect(uri, { useNewUrlParser: true })
  .then(() => {
    console.log("[db] Connection successfully established");
  })
  .catch(() => {
    console.log("[db] Connection failed");
  });

const addMessage = (message) => {
  const myMessage = new Model(message);
  myMessage.save();
};

const getMessage = async () => {
  const messages = await Model.find();
  return messages;
};

module.exports = {
  add: addMessage,
  list: getMessage,
};

Si tienes problemas para conectar la base de datos esta fué mi solución

async function main() {
  try {
    await db.connect(
      "[URL_DB]",
      {
        useNewUrlParser: true,
        useUnifiedTopology: true,
      }
    );

    console.log("[DB]: Base de datos conectada correctamente");
  } catch (err) {
    console.log(err);
    console.log("[DB]: Base de datos no conectada");
  }
}

main()

Saludos carlos, El curso está excelente , pero ya mlab no es la misma UI, ya es muy difernte lo que hay que hacer , sería chevere que para los que están viendo este curso en el 2023 puedan seguir disfrutando sin problemas, hay muchos cambios

archivo docker-compose.yml y la cadena de conexion desde mongodb compass: mongodb://root:[email protected]:27017

version: '3.7'

services:

  mongo:
    image: mongo:latest
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: 123456
    ports:
      - 27017:27017
    volumes:
      - mongodb_data_container:/data/db
      
volumes:
  mongodb_data_container:

Para las nuevas versiones la conexión necesita la siguiente estructura

const db = require('mongoose');
const Model = require('./model');

db.set('strictQuery', false);
db.Promise = global.Promise;

async function main() {
    await db.connect('mongodb://127.0.0.1:27017/', {
        dbName: 'telegrom',
        user: 'root',
        pass: '123456'
    });
    console.log('[db] conectada con exito');
}

main().catch(err => console.log(err));> 

Estoy siguiendo el curso y logre conectar la base de datos, sin utilizar la base de datos del curso previamente instalando mongodb y mongoose v: 6.8.4, comparto el código:
//const db = require(‘mongoose’);
const mongoose = require(‘mongoose’);
const { db } = require(’./models’);
db.Promise = global.Promise;
mongoose.set(‘strictQuery’, false);
mongoose.connect(‘mongodb://127.0.0.1/telegram_database’, { useNewUrlParser: true });

//const list = [];
console.log(‘Connected to Mongo!’)
function addMessage(message) {

list.push(message);

}

function getMessage() {
return list[list.length - 1];
}

module.exports = {
add: addMessage,
list: getMessage,
//get
//update
//delete
}

hola ✋ para quienes usen mongo en local la coneccion seria asi :

``

const db = require('mongoose');

//la url que te proporciona mongo compaas y el nombre de la base de datos que quieras crear o utilizar 🍔

const URI = 'mongodb://localhost:27017/basedb'

db.Promise = global.Promise;
db.set('strictQuery', false);

db.connect(URI, {
    useNewUrlParser: true,
});

const connection = db.connection;

connection.once('open', () => {

    console.info(`Coneccion realizada con exito URI : ${URI} `)

}
```);

```

Ok, no voy a defender esta clase definitivamente el curso ya necesita una actualización, pero, pero, si uno quiere aprender puede encontrar la solución de los problemas en google y la sección de comentarios. Yo ya toy feli con mi base de datos conectada a mi backend 😃

const { default: mongoose } = require('mongoose');
const db = require('mongoose');

let URI='mongodb+srv://UsuarioyPass@enlacequeproveeMONGO/test'

main().catch(err=>console.log(err))
async function main(){
     await db.connect(URI,{
        useNewUrlParser: true,
     })
        console.log('conexion exitosa a la bd')
    }

npm i mongoose

Yo recomiendo poner el usuario y clave de la db en un archivo .env y llamarlos con process.en.VARIABLE_NAME para tener un mejor control de seguridad y mantenimiento futuro 😄

const uriBd= `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASSWORD}`

10:21 Agregamos una constante para traer el Model en el archivo store.js. Se hizo un corte en la grabación y olvidaron mencionarlo.
const Model = require(’./model’);

alguien que me ayude como resolver este problema, por favor:

(node:13176) 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.```

Les sugieron añadir este evento, por si no les funciona y no saben xq como a mi me paso, ya que la funcion que se pasa como segundo parametro en ‘connect’, es un callback al terminar esta funcion, pero no quiere decir que termino correctamente.

mongoose.connect(URI);
const db = mongoose.connection;
db.on('error', (e) => console.error('error', e));
db.once('open', () => console.log('Mongoose is connected'));

Otra opción a utilizar un mongoDB en la nube es instalarlo en local:
https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-os-x/

una vez instalado nos podemos conectar de la siguiente forma:

db.Promise = global.Promise;
db.connect("mongodb://localhost:27017/telegrom", {
  useNewUrlParser: true,
});
console.log("[db]: La base de datos conectada exitosamente");

Y para consultar la data podemos utilizar roboMongo u otro cliente de mongo:
https://robomongo.org/

investigando un poco, vi que desde mongoose 5 ya no se necesita hacer lo de las promesas porque ya las jala nativamente.

En caso de que alguién esté siguiendo todos los pasos actualizados que se encuentran en la sección de aportes y aun así esté generando un error de que no encuenta algunos modulos, puede ser la compatibilidad de la versión de Node, en mi caso estaba usando la versión

luis@luism:~/LUIS/platzi/backendNode$ node --version
v13.6.0

y no me estabá conectado, entonces actualicé la versión

luis@luism:~/LUIS/platzi/backendNode$ nvm use node
Now using node v16.6.2 (npm v7.20.3)

y reinstalé nuevamente el nodemon

npm i -g nodemon

de está forma fue la unica que me logró conectar la base

Estoy tomando el curso porque en mi trabajo comencé un proyecto (estoy en KT apenas) y tenía que aprender mongo, como la máquina está tras un proxy por el momento lo que hice fue trabajar de manera local en la base de datos, tal vez les sirva, este es el código

const { MongoClient } = require("mongodb");

const uri = "mongodb://localhost:27017/Telegrom";

const client = new MongoClient(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true
});

client.connect(err => {
    if(!err){
        console.log("coneccion a la base de datos completada");
    }else{
        console.log("hubo un error conectando a la db", err);
    }
    
    client.close();
})

para los que estan actualmente realizando el curso, pueden usar el mismo codigo que el profesor explica, y usar mongo db compass, es sencillo

Para los que estaban teniendo problemas al conectar la base de datos con MongoDB Atlas.

Presten mucha atencion al <password> y myFirstDataBase en el string de conexion.
El password va la clave sin los simbolos de mayor o igual, y myFirstDatabase deben de poner el nombre de base de datos que definieron en caso de ser telegrom por ejemplo.
Entonces seria asi.

mongodb+srv://db_user:password@cluster0.f9wum.mongodb.net/myFirstDatabase?retryWrites=true&w=majority

Si hacen todo eso al final les permitira conectar con la base de datos.

Para aquellos que tienes problemas con la conexión les comparto mi solución, soy novata pero me funcionó la conexión:

const db = require ('mongoose')

db.Promise = global.Promise;
db.connect('mongodb+srv://Yo:[email protected]/telegram?retryWrites=true&w=majority', {
    useNewUrlParser:true,
    useUnifiedTopology: true,
});

console.log('[db] Conectada con éxito');

function addMessage(message) {
    list.push(message);
}

function getMessages() {
    return list;
}

module.exports= {
    add: addMessage,
    list: getMessages,
    // get
    // update
    // delete
}

Código ES6:

import mongoose from "mongoose";

const Schema = mongoose.Schema;

const mySchema = new Schema({
    user: String,
    message: {
        type: String,
        required: true,
    },
    date: Date,
});
//el primer parametro es como se llamara nuestra collecion equivalente a tablas
const model =  mongoose.model('Message',mySchema);

export default model;

import db from "mongoose";
import Model from "./model.js"

db.Promise = global.Promise;
db.connect('mongodb://127.0.0.1:27017/telegrem',{
    useNewUrlParser:true,
    useUnifiedTopology:true,
}).then(()=>{
    console.log('[db connection] Conectada con éxito');
}).catch(e=>{
    console.error('[db connection] Connection failed', error.message)
});

function addMessage(message) {
    // list.push(message);
    const myMessage = new Model(message);
    myMessage.save();
}

async function getMessages() {
    // return list;
    const messages = await Model.find();
    return messages;
}
export default  {
    add:addMessage,
    list:getMessages,
    //get
    //uldate
    //delete
}

Por si les sirve a alguno, yo hice la conexion asi:

const { connect } = require('mongoose');
const Model = require('./model');

const CONECTOR =
//colocar la url que nos dio mylab/mongo
/*ejemplo mongodb+srv://username:[email protected]/name_db?retryWrites=true&w=majority';
*/
const OPTIONS = {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

connect(CONECTOR, OPTIONS, (MongoError) => {
  // si algo sale mal mostramos el error y paramos el servidor
  if (MongoError) {
    console.error(MongoError);
    process.exit(1);
  }
  console.log('Conectado con exito');
});

Aqui dejo el addMessage con async await, aunque si alguien me pudiera decir cual seria la mejor manera en este caso?

async function addMessage(user, message){
    if(!user || !message){
        console.error('MessageController: There isnt user or message')
        throw 'Datos invalidos'
        return
    }

    const fullMessage = {
        user, message,
        date: new Date()
    }
    return await store.add(fullMessage)
}

Esta clase ha sido difícil para mi, no he podido guardar los datos en la BD de Atlas. He intentado varias de las soluciones que proponían los compañeros pero me seguía saliendo este error:

(node:25432) UnhandledPromiseRejectionWarning: MongooseError: Operation messages.insertOne() buffering timed out after 10000ms
at Timeout.<anonymous> (C:\Users\Luis\Downloads\Platzi - Backend\curso-node\node_modules\mongoose\lib\drivers\node-mongodb-native\collection.js:149:23)
at listOnTimeout (internal/timers.js:557:17)
at processTimers (internal/timers.js:500:7)
(Use node --trace-warnings ... to show where the warning was created)
(node:25432) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag --unhandled-rejections=strict (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1)
(node:25432) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

Supongo que trataré de intalarme MongoDB en local y probar a hacer una conexión.

Muy buena clase!!

Esto esta buenisimo y refacil, se necesita muy poco codigo

Si les aparece __v en los documents de la collection pueden anadir versionKey: false al schema para evitar que guarde la version del documento

No entiendo este error, ya verifique usuario y contraseña.

(node:17968) UnhandledPromiseRejectionWarning: MongooseServerSelectionError: bad auth Authentication failed.

db.Promise = global.Promise
db.connect('mongodb+srv://admin:<admin1234>@platzichat-juqhn.mongodb.net/test?retryWrites=true&w=majority', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    dbName: 'PlatziChat'
})```

He seguido todos los pasos, en insomnia me aparece el siguiente mensaje

{
  "error": "Información inválida",
  "body": ""
}

En el console log me muestra el siguiente mensaje

[response error] Error en el control

Le agregué a router.post en .catch la impresión de la variable e console.log en el archivo network.js y me muestra el siguiente mensaje

ReferenceError: Model is not defined
    at Object.addMessage [as add] (C:\Users\jlcoronel\Documents\Node\BackendNode\components\message\store.js:13:23)
    at C:\Users\jlcoronel\Documents\Node\BackendNode\components\message\controller.js:18:15
    at new Promise (<anonymous>)
    at Object.addMessage (C:\Users\jlcoronel\Documents\Node\BackendNode\components\message\controller.js:4:12)
    at C:\Users\jlcoronel\Documents\Node\BackendNode\components\message\network.js:17:16
    at Layer.handle [as handle_request] (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\layer.js:95:5)
    at next (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\route.js:137:13)
    at Route.dispatch (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\route.js:112:3)
    at Layer.handle [as handle_request] (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\layer.js:95:5)
    at C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:281:22
    at Function.process_params (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:335:12)
    at next (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:275:10)
    at Function.handle (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:174:3)
    at router (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:47:12)
    at Layer.handle [as handle_request] (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\layer.js:95:5)
    at trim_prefix (C:\Users\jlcoronel\Documents\Node\BackendNode\node_modules\express\lib\router\index.js:317:13)
[response error] Error en el controlador

Mi funcion de conexion a la bd la modifiqué a

db.Promise = global.Promise;
db.connect('mongodb+srv://<user>:<contraseña>@curso-platzi-eu1qo.mongodb.net/test?retryWrites=true&w=majority', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
});
console.log('[db] Conectada con éxito');

Pintaba bien el ejemplo pero así…

los “Schemas” son = PropTypes (React), TypeScript(JavaScript) (?)

Que hermoso es ver las clases relacionadas a esta, que nos apoya para entender mejor lo que vamos viendo aquí. Gracias Platzi!!!

Excelente clase =)


const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const Collection = new Schema({
  user: String,
  message: {
    type: String,
    required: true
  },
  date: Date
});

const model = mongoose.model('Message', Collection);
module.exports = model;

Me sale el siguiente error:

_"(node:14594) UnhandledPromiseRejectionWarning: MongoError: not authorized on admin to execute command { insert: “messages”, documents: [[{_id ObjectIdHex(“5d9690f48896f23902f0d91b”)} {user Jorge} {message Mundo} {date 2019-10-04 00:23:16.566 +0000 UTC} {_v 0}]], ordered: true, writeConcern: { w: “majority” }, lsid: { id: {4 [73 229 42 243 246 179 74 56 130 106 240 236 73 10 141 6]} }, txnNumber: 1.000000, $clusterTime: { clusterTime: 6743736848205480018, signature: { hash: [121 108 141 238 86 200 14 40 34 142 227 45 248 135 146 62 166 12 113 150], keyId: 6743529190831685632.000000 } }, $db: “admin” }"

Para los que le sale este warning :
"Accessing non-existent property ‘MongoError’ of module exports inside circular dependency"
pueden solucionarlo instalando una versión anterior de mongoose.

npm i mongoose@5.11.15

y se fijan en su package.json que esté usando esa versión de mongoose 😄

Es normal que al ser la primera ves que vea backend siento que medio entiendo el proceso pero se que si lo intento hacer por mi mismo me va a dar un paro cerebral porque necesito familiarizarme más ? 😕