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 131

Preguntas 32

Ordenar por:

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

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 鈥楥onnect 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
}```

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.

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> 

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:[email protected]: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 鈥榤odel鈥 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(鈥榤ongoose鈥).model

y para exportar:

module.exports = model.call(require(鈥榤ongoose鈥),鈥榤odelName鈥, 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:[email protected]?retryWrites=true&w=majority', options)
    .then(() => console.log('DB connected'))
    .catch((err) => {
        console.log(err);
    });

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 鈥渢est鈥濃 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 [email protected] 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})
Este curso iba genial hasta este momento.

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

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`);```

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

Creo que ya va siendo hora de que actualicen este curso

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 鈥淚nclude 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 鈥淏ackend 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/[email protected]/?

PD: AYUDENME PORFAVOR ESTOY ESTANCADO 馃槮

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.

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 (鈥榤ongoose鈥);
const Model = require(鈥./model鈥);

db.Promise = global.Promise;
db.connect(鈥榤ongodb+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!

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

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
};

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!!

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 鈥淪chemas鈥 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: 鈥渕essages鈥, documents: [[{_id ObjectIdHex(鈥5d9690f48896f23902f0d91b鈥)} {user Jorge} {message Mundo} {date 2019-10-04 00:23:16.566 +0000 UTC} {_v 0}]], ordered: true, writeConcern: { w: 鈥渕ajority鈥 }, 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: 鈥渁dmin鈥 }"

Para los que le sale este warning :
"Accessing non-existent property 鈥楳ongoError鈥 of module exports inside circular dependency"
pueden solucionarlo instalando una versi贸n anterior de mongoose.

npm i [email protected]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 ? 馃槙

No es necesario utilizar MLAB para la conexi贸n a la DB ya que desde la Interfaz de Mongo lo podemos hacer. Lo 煤nico que debemos hacer es:
**ir a Mongo / Connect / Connect your application **
aqu铆 vamos a tener una URL como esta

mongodb+srv://<user>:<password>@cluster0.f5dvk.mongodb.net/<dbname>?retryWrites=true&w=majority

Cambien tenemos algo interesante, podemos hacer la conexi贸n sin la necesidad de tener creada la DB con anterioridad, podemos dar el nombre directamente en la URL de arriba sustituyendo el <dbname> y autom谩ticamente Mongo se va a encargar de creerla. Solo es seguir los pasos de video omitiendo la parte de MLAB.

Si quieren ver la informaci贸n de su Db 煤nicamente deben dar clic en el tercer bot贸n (estando en la pantalla de inicio del Cluuster) que dice 鈥淐ollections鈥 y ah铆 estar谩n viendo su informaci贸n.

Para usar 鈥淓squemas en mongo鈥 se puede usar la librer铆a de @hapi/joy para validar esa informaci贸n, pero es mejor usar Mongoose

Mi conexi贸n a trav茅s de mongo Compass 馃榾

Genial!!! todo salio perfecto y fue super f谩cil! ya sabiendo esto es un gran paso!

驴hay alguna forma de ingresar los par谩metros de conexi贸n a MongoDB que no sea directamente en el c贸digo sino en variables de entorno, como por ejemplo, en un archivo .env ?

Ahora que s贸lo existe DB Atlas, les recomiendo que para las contrase帽as de usuario no pongan caracteres especiales. Me pase unos 15 min intentando saber el error de conexi贸n.

Hola, necesito ayuda.

Cuando quiero arrancar el server.js me tira en consola un error
\platzi\node\backend\node_modules\bson\index.js:1
锟斤拷伲锟斤拷,锟絏锟紷锟斤拷t&锟接:锟斤拷锟睫
锟絛锟斤拷x锟斤拷锟斤拷B锟斤拷\锟/锟斤拷锟斤拷锟
^
SyntaxError: Invalid or unexpected token

si comento las lineas de la conexion a mongo no me lo tira ya con el require(鈥榤ongoose鈥) da el problema.

Consulta, 驴No es mas sencillo realizar la conexi贸n a la Mongo dentro del archivo Server.js o en una archivo a parte database.js y lo requer铆s en server.js y listo?

tengo una duda como es que se conecta a la base de mongo desde el archivo store, si este archivo solo es llamado si se hace una peticion por POST o GET

Hola comunidad, por favor ayuda. Asigne el usuario y password de la bd MONGODB ATLAS, aparece este mensaje

[nodemon] restarting due to changes鈥
[nodemon] starting node server.js
[db] Conectada con exitos
La aplicacion esta escuchando en 3000
[response error]Error en el logeo

Buenas noches me podrian ayudar con este error:
Error: querySrv EREFUSED _mongodb._tcp.cluster0-2ijul.mongodb.net
at errnoException (dns.js:50:10)
at QueryReqWrap.onresolve [as oncomplete] (dns.js:238:19)
code: 鈥楨REFUSED鈥,
errno: 鈥楨REFUSED鈥,
syscall: 鈥榪uerySrv鈥,
hostname: 鈥榑mongodb._tcp.cluster0-2ijul.mongodb.net鈥 }

Buen d铆a,

Solicito su ayuda con el siguiente error:

ReferenceError: Model is not defined
at Object.addMessage [as add] (鈥backendNode\components\message\store.js:12:23)

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

La linea 12 es la misma del v铆deo.

Gracias.

10:48 hay un salto en el que getMessages() pasa de devolver list a devolver 鈥渓ist鈥 y es justo un error que tengo no entiendo

Que forma mas fea de ordenar los archivos y carpetas

npm i mongoose

Muy interesante saber que no es necesario crear manualmente la colecci贸n sino que autom谩ticamente al insertar el primer registro esta es generada.

Podarais actualizar un poco ya que la instalaci贸n ha quedado obsoleta.

Me sale esto y no lo he podido solucionar

(node:9984) UnhandledPromiseRejectionWarning: Error: queryTxt ETIMEOUT castillo-phuxs.mongodb.net
at QueryReqWrap.onresolve [as oncomplete] (dns.js:202:19)
(node:9984) 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(). (rejection id: 1)
(node:9984) [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.

Me daba el error de 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. y lo solucion茅 con useUnifiedTopology: true.
.
Tambi茅n el de UnhandledPromiseRejectionWarning: MongooseServerSelectionError: Could not connect to any servers in your MongoDB Atlas cluster. y lo solucion茅 con quitando < > a la contrase帽a en la URI. Aqu铆 no se pod铆a conectar y los mensajes no llegaban.

Otra forma de export el model es鈥

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