MongoDB: Actualizar datos

Clase 21 de 33 • Curso de Node.js: Base de Datos con MongoDB y WebSockets

Resumen

placeholder

Joaquin Mayer

student•

En el minuto 07:29 también se puede poner findById(id) en vez de findOne({_id: id})

Ivan Arley Guerrero Sanchez

student•

de echo creo que es buena practica usar el findByid() para buscar por id y el findOne() para buscar por otro parametro

Steve Anthony Luzquiños Agama

student•

Pueden utilizar esto:

const updatedMessage = await Message.findOneAndUpdate(
  { _id: id },
  { message },
  { new: true }
)

return updatedMessage

Para encontrar el mensaje y actualizar en un solo paso.

Luis Miguel Gonón Xiap

student•

Gracias por tu aporte compañero, quisiera añadir que el tercer parametro lo que hace es devolver el documento modificado, mongoose por defecto devuelve el docuemnto sin modificar.

Junior Llancari

student•

Como puedo devolver el error si el mensaje no fue encontrado para hacer la edición de los datos?

Beatriz Pérez Santana

student•

¿Sería buena práctica utilizar async/await dentro de una promesa? 🧐 He estado buscando información y he encontrado esto:

"Si una función ejecutor asíncrona lanza un error, el error se perderá y no provocará que la promesa se rechace."
"Si una la función ejecutor de Promise esta utilizando await, esto normalmente es una señal de que en realidad no es necesario utilizar el constructor new Promise ya que el alcance de dicho constructor puede ser reducido." https://eslint.org/docs/rules/no-async-promise-executor https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Promise#Sintaxis

Carlos Hernández

teacher•

Lo ideal es que todas tus respuestas sean estándares. Una función asíncrona (async function) devuelve una promesa. . Si vamos a devolver una promesa que viene de otro módulo, no tiene sentido esperar a que se resuelva pudiendo pasar la referencia. Sin embargo, en caso de control de errores, podemos querer que la promesa se comporte de una forma determinada. . Ahí es cuando podemos usar los constructores, o las funciones Promise.reject() o Promise.resolve()

Sergio Armando Medina Chaparro

student•

Ese error del await en el minuto 06:37 es buenísimo

Carlos García

student•

Creo que en Mongoose podemos encontrar un registro y actualizarlo en la misma petición. https://mongoosejs.com/docs/tutorials/findoneandupdate.html

Francisco Garcia [C6]

student•

Ejecuta la actualiacion, validando en la base de datos se ve el cambio realizado y la respuesta esta bien. Pero al final muestra este error.

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

Juan Camilo Espitia

student•

Hola al parecer es un problema en la Promesa es como si faltara el async puede ser un typo, a mi me paso similar pero era porque no esta realizando un return.

Martin Alejandro Tecún Charles

student•

Yo tenía el mismo problema y lo que hice fue revisar el CATCH que ponemos en PATCH en el archivo NETWORK.JS.😀

Ya que en el mensaje nos está diciendo eso que falta un .catch en alguna función que tenga promesa.👍

Daniel Còrdova

student•

Si les aparece el siguiente error y no saben como eliminarlo aun si se les actualiza la informacion, se debe entonces eliminar el "RES.SEND('OK')", en mayus para que lo identifiquen en el archivo NETWORKS.JS, en la promesa ya que se considera redundante para el sistema cayendo en error logico.

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

Vanessa Cordero

student•

Muchas gracias

Sergio Medina

student•

Muchas gracias. Me sirvió. Claro en la parte 3:45 el profe quitó ese res.send('Ok'); en la línea 35 dl network.js. El problema es que se me olvidó hacer eso jaja.

Wandy Rafael Santana Evangelista

student•

Hola Devs: Aca les traigo mi solucion usando TypeScript en el proyecto: -El Network del componente Message:

-El Controller del componente Message:

-El Store del componente Message:

-Aca les dejo el commit exacto de esta clase:Click Aqui -Recuerda, #NuncaParesDeAprender 💚

Francisco Garcia [C6]

student•

Sales el suiente error en la consola. Sin embargo, esta actualizando y la respuesta que da es 200

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

Juan Teixeira

student•

Busca en la linea 32 de tu archivo components\message\network y tambien en network\response en la linea 9

si puedes sube el codigo para verlo y poder ayudarte.!

Elias Guillermo Ruiz Gonzalez

student•

++Validacion de errores++ El codigo funciona si se ingresan los parametros en forma correcta, sin embargo en mi caso aparecio un error al llamar a la funcion usando el formato de get localhost:3000/message/id=5ff67a187350d52c30af11d5 Si bien lo pude corregir modificando el llamado usando el formato de patch localhost:3000/message/5ff67a187350d52c30af11d5 El programa debe validar los errores, puede hacerse en dos formas ++Forma 1: Validar en store/updateText y en controller/updateMessage++ En store.js actualizar la funcion updatetext segun el siguiente codigo

async En controller.js actualizar la funcion function } Esta forma permite precision en la identificacion ++Forma 2: Validar en controller/updateM En controller.js actualizar la funcion function Esta forma es muy general y el programador ++Conclusion++ Aunque tenga mayor codificacion, recomendaría Espero que sirva de ayuda Saludos function updateText(id, message){ try{ const foundmessage=await Model.findOne({_id: id }) foundmessage.message = message; const newMessage= await foundmessage.save(); return newMessage; } catch(e){ console.log('Error en updateText: '+e); const newMessage=''; return newMessage; }; } updateMessage segun el siguiente codigo updateMessage(id, message){ return new Promise( async (resolve,reject)=>{ if(!id || !message){ reject('updateMessage:invalid data'); return false; } const result = await store.updateText(id, message); //verifica error if(result==''){reject('updateMessage: id no encontrado')} else{resolve(result);} ) } del problema, pero requiere mayor codificacion essage++ updateMessage segun el siguiente codigo updateMessage(id, message){ return new Promise( async (resolve,reject)=>{ if(!id || !message){ reject('updateMessage:invalid data'); return false; } try{ const result = await store.updateText(id, message); resolve(result); } catch(e){ reject('updateMessage: id no encontrado') } } ) } debe conocer de antemano "que puede fallar" para indicar el error, pero es mas sencilla de codificar. utilizar la forma 1

Felipe Muñoz

student•

gigante! cuando había un error me tiraba abajo toda la app, buena forma de capturar el error!

ROGER VEGA

student•

También se puede usar la función findByIdAndUpdate en store.js

async function updateText(id, message){
    const updatedMessage = await Model.findByIdAndUpdate(id, {message}, {new: true});
    return updatedMessage;
}

Robinson Matias Aguilar Bascuñan

student•

las promesas de por si no son asincronas? porque la necesidad de colocar un async await? no entiendo :c

Demian Arenas

student•

Las Promises lo que hacen es encapsular una tarea asincrona, para que después podamos usar los métedoso then y catch.

¿Por qué usa un async await dentro de un Promise? Porque esta interactuando con otro método que es asincrono, en este caso los métodos de store. Para obtener los datos de este método debe poner async await.

Jorge Gonzalez

student•

Es mucho mas facil de leer cuando se usa async y await, el profesor también pudo desarrollar el ejercicio con then y catch, pero tendria que escribir mas codigo y no seria muy legible .

por ejemplo con then y cath:

function updateMessage(id, message) {
	return new Promise ((resolve, reject) => {
		.....
		let result;
		store.updateText(id, message)
			.then(data => result = data)
		....
	})
}```

Neryt Alexander Herrera Iñiguez

student•

Version con arrow functions y async/await NETWORK:

//
router.patch('/:id', async (req, res) => {
    const { id } = req.params;
    const { message } = req.body;
    try {
        const data = await controller.updateMessage(id, message);
        response.success(req, res, data, 201);
    } catch (error) {
        console.log(error);
        response.error(req, res, "Error", 400, error)
    }
});

STORAGE:

const updateText = async (id, message) => {
    const requestedMessage = await Model.findById(id)
    requestedMessage.message = message;
    const messageUpdated = await requestedMessage.save();
    return messageUpdated;
}

CONTROLLER:

const updateMessage = (id, message) => {
    return new Promise( async (resolve, reject) => {
        if (id && message) {
            try {
                const data = await storage.updateText(id, message);
                resolve(data);
            } catch (error) {
                reject(new Error(error));
            }
        }else {
            reject(new Error('Missing params'));
        }
    });
};

Angelo Barbara

student•

Es necesario poner un asyc/away tanto en la promesa como en el updatetext del store.js?

Luis Lira

student•

No, de hecho lo puedes hacer solamente con Async/Await, yo estoy haciendo el curso sólo usando async/await:

async function updateMessage(id, message) {
  const foundMessage = await Model.findOne({ _id: id})
  foundMessage.message = message
  const newMessage = await foundMessage.save()
  return newMessage
}

Eden Gomez Gress

student•

Yo tengo un erreo en ese snipped de codigoque compartiste companero, me sale:

ID: 5e9a5b32e2cc2bf62a30d693
 Mensaje: Whats'upjjj  
(node:70910) UnhandledPromiseRejectionWarning: TypeError: Cannot set property 'message' of null
    at Object.updateText (/Users/eden/Desktop/platzi/node2020/components/message/store.js:32:24)
    at processTicksAndRejections (internal/process/task_queues.js:93:5)
    at async /Users/eden/Desktop/platzi/node2020/components/message/controller.js:40:20```

Antoni Bassols Lopez

student•

Me gustaría saber dónde puedo encontrar los métodos que estamos utilizando en Model.MÉTODO. Por ejemplo, hemos utilizado Model.findOne() y he visto que algún compañero ha comentado que en vez de findOne podemos usar findById. Me gustaría saber de dónde puedo obtener la información sobre qué opciones puedo utilizar que mejor se ajusten a lo que quiera hacer y cuál es su sintáxis. Gracias de antemano

Antoni Bassols Lopez

student•

Por si a alguien le sirve, siguiendo los vínculos de Model me he dado cuenta de que viene de la librería Mongoose que hemos importado, en la documentación de Mongoose se puede ver más sobre sus métodos, link de la documentación de Mongoose aquí.

Ariel Ezequiel Biazzo Genua

student•

Que grandeeee! Muchas gracias! Yo tambien las estaba buscando.

David Cruz Portilla

student•

Una pregunta, ¿por qué puso un guion bajo antes de id? lo dejo como _id: id

async function updateText(id, message) {
  const foundMessage = await Model.findOne({
    _id: id
  });
  foundMessage.message = message;
  const newMessage = await foundMessage.save();
  return newMessage;
}

Julian Ramirez Chacon

student•

Si miras los schemas en MongoDB , por defecto contienen una key con nombre _id., que es el id generado por Mongo

David Cruz Portilla

student•

Ahhhhh ya veo, entonces no significa algo más ese guion bajo? solo es como pone por defecto el id mongo?

Robert Romero Medina

student•

Me ha pasado un error y no he podido solucionarl, ayuda

Error: CastError: Cast to ObjectId failed for value "2" at path "_id" for model "Message"
    at C:\Users\RobertDev\Documents\Cursos\PLATZI\CursodeNode Js\components\message\controller.js:47:21```

Braulio Alejo Aguilar

student•

Intenta utilizando este codigo en store, a mi me funciono

async function updateText(id, message){
  const foundMessage= await Model.findById(id);

  foundMessage.message = message;

  const newMessage = await foundMessage.save();
  return newMessage;
}

Christian Huelmo

student•

En el archivo store.js cuando escribimos:

const foundMessage = await Model.findOne({ _id: id });

esto funciona perfecto si el id que pasamos existe, pero ¿cómo manejamos el error si el id no existe?

JESUS MANUEL GUTIERREZ MERINO

student•

Leyendo la documentacion: https://mongoosejs.com/docs/queries.html

Al ejecutar el metodo findOne, despues del filtro que le pasamos, tambien podemos pasarle un callback, donde nos regresa el error y el mensage, tal que asi:

        const db_message = await Model.findOne({
            _id: id
        }, (err, message) => {
            if (err) {
                console.error('NO SE ENCONTRO!!');
            } else {
                console.log(message);
            }
        });

Dentro del callback podemos decidir que hacer si no se encuentra el id, saludos :P

Usuario anónimo

user•

no es medio redundante estar pasando los mismos parametros siempre, se podria ahorrar la logica de network y pasarle directamente el controller no? asi no se arma lio con promesas async awaits y todo eso.

Carlos Hernández

teacher•

Podrías hacerlo, pero el componente dejaría de ser 100% reutilizable, y requeriría ser llamado únicamente desde una petición http. . Al separar la lógica de la capa de red, puedes reutilizar tu componente desde cualquier otra parte simplemente importándolo. . Imagina que en lugar de foto subes un vídeo, y quieres añadirle un procesamiento para comprimirlo. Podrías hacerlo en asíncrono, y, cuando termine, añadir la nueva URL del fichero. . El código de esa parte podría ser así:

const Controller = require('./components/video/controller');

function procesoLargoCallback(data) {
  return Controller.update(data.id, { 
    video: data.url 
  });
}

Baltazar Andersson

student•

Hecho en 2022, utilice la función de Mongo llamada findByIdAndUpdate, lo que quedo así:

async function updateText(id, message) {
  const newMessage = await Model.findByIdAndUpdate(
    id,
    { message: message },
    { new: true }
  );
  return newMessage;
}

Según leí, el uso del parámetro {new : true} es para que se retorne el documento después de que se haya actualizado.

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

[response error] Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
(node:17296) UnhandledPromiseRejectionWarning: Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
    at ServerResponse.setHeader (_http_outgoing.js:485:11)
    at ServerResponse.header (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:771:10)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:170:12)
    at ServerResponse.json (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:267:15)
    at ServerResponse.send (C:\Users\fgarcia\Platzi\CursoNodeJS\node_modules\express\lib\response.js:158:21)
    at Object.exports.error (C:\Users\fgarcia\Platzi\CursoNodeJS\network\response.js:9:31)
    at C:\Users\fgarcia\Platzi\CursoNodeJS\components\message\network.js:32:22
    at processTicksAndRejections (internal/process/task_queues.js:94:5)
(node:17296) 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:17296) [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.

//
router.patch('/:id', async (req, res) => {
    const { id } = req.params;
    const { message } = req.body;
    try {
        const data = await controller.updateMessage(id, message);
        response.success(req, res, data, 201);
    } catch (error) {
        console.log(error);
        response.error(req, res, "Error", 400, error)
    }
});

const updateText = async (id, message) => {
    const requestedMessage = await Model.findById(id)
    requestedMessage.message = message;
    const messageUpdated = await requestedMessage.save();
    return messageUpdated;
}

const updateMessage = (id, message) => {
    return new Promise( async (resolve, reject) => {
        if (id && message) {
            try {
                const data = await storage.updateText(id, message);
                resolve(data);
            } catch (error) {
                reject(new Error(error));
            }
        }else {
            reject(new Error('Missing params'));
        }
    });
};

async function updateMessage(id, message) {
  const foundMessage = await Model.findOne({ _id: id})
  foundMessage.message = message
  const newMessage = await foundMessage.save()
  return newMessage
}

ID: 5e9a5b32e2cc2bf62a30d693
 Mensaje: Whats'upjjj  
(node:70910) UnhandledPromiseRejectionWarning: TypeError: Cannot set property 'message' of null
    at Object.updateText (/Users/eden/Desktop/platzi/node2020/components/message/store.js:32:24)
    at processTicksAndRejections (internal/process/task_queues.js:93:5)
    at async /Users/eden/Desktop/platzi/node2020/components/message/controller.js:40:20```

async function updateText(id, message) {
  const foundMessage = await Model.findOne({
    _id: id
  });
  foundMessage.message = message;
  const newMessage = await foundMessage.save();
  return newMessage;
}

        const db_message = await Model.findOne({
            _id: id
        }, (err, message) => {
            if (err) {
                console.error('NO SE ENCONTRO!!');
            } else {
                console.log(message);
            }
        });

MongoDB: Actualizar datos

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

Bienvenida y presentación del curso

Qué es Node y cómo instalarlo

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

Métodos, cabeceras y estados

Cuerpo y query de la petición

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

Crear un servidor HTTP desde NodeJS

¿Cómo pueden venir las peticiones?

Recibir información desde el cliente: Body y Query

Información contextual: Leer las cabeceras

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

Respuestas coherentes

Servir archivos estáticos

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

Conceptualmente: Rutas, controladores y bases de datos

Rutas y capa de red: Responsabilidades y límites

Controladores: Definiendo la lógica de negocio

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

Tipos de Bases de Datos: Relacionales y No Relacionales

Crear y Configurar tu Base de Datos con MongoDB

MongoDB: Almacenar y leer datos

MongoDB: Actualizar datos

MongoDB: Consultar datos

MongoDB: Eliminar Datos

Gestionar conexiones a la base de datos desde la API

Uso de entidades para crear aplicaciones escalables

Escalando la arquitectura: Múltiples entidades

Relacionando nuestras entidades

Cómo recibir ficheros desde NodeJS

Guardar el fichero en el servidor

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

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

Manejo de Websockets con NodeJS

Conectar la API al servidor de WebSockets

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

Revisión y próximos pasos

Tips para escalar nuestro proyecto