Almacenando la información en una base de datos

Debí seguir esta ruta antes de iniciar con la Escuela de JavaScript.

Cuando Realizamos getMessages de controller.js no me retornaba nada usando solo store.list - se le debe especificar que es una función,

//message/controller.js
const getMessages = () =>{
    return new Promise((resolve, reject) =>{
        resolve(store.list())
    });
}

Este curso es tan bueno que parece serie de película. Tipo “en el próximo capítulo descubrirás por qué, no te lo pierdas”.
Excelente profesor Carlos!!!

Lo que yo entiendo de MOCKS es que es un objeto que simula o imita el comportamiento de uno real con el fin de poder hacer testing sin la necesidad de tener una capa compleja de base de datos.

Hola Devs:
-Aca les traigo mi solucion hacinendo uso de TypeScript:
Capa de Network del componente Message:

Capa de Controller del componente Message:

Capa del Store del componente Message:

-Aca tienen el commit exacto de esta clase, recuerden que pueden enviar un PR si ven alguna mejora: Click Aqui
-Recuerda, #NuncaParesDeAprender 💚

No es más facil usar async await y el codigo queda más simple? Digo osea, queda entendible y facil de mantener segun yo

Que bonito es lo bonito!

No sienten que el profe como que se lo goza. Como que le mete misterio y emoción cuando acaba y nos introduce a la clase siguiente. Ya casi llegamos a la clase 20 y no se siente. Que increíble profesor

Codigo con arrow functions y async await:

//	Controller.js (getMessages)
const getMessages = () => {
    return new Promise((resolve, reject) => {
        if(storage.list()){
            resolve(storage.list())
        }else {
            reject('No messages saved')
        }
    })
}

//	Network (get '/'):
router.get('/', async (req, res) => {
    try {
        const allMessages = await controller.getMessages();
        response.success(req, res, allMessages, 200);
    } catch (error) {
        response.error(req, res, error, 400, 'Error getting getting messages');
    }
});

mocks (Simulando base de datos)

Qué locura, es hermoso el backend, aunque me toca ver las clases varias veces (;

En lo que llevo visto del curso no se utiliza el paradigma de programacion orientada a objetos(clases, constructores, objetos interfaces etc. ) esto tiene alguna ventaja en node ? es una mejor manera de hacer las cosas?. Gracias de antemano por responder

Un Mock es un intento de simular algo o una burla, si queremos una traducción más exacta.
Son muy usados en las pruebas unitarias para simular la interacción con la DB y así mantener las pruebas en el ambiente controlado de nuestro sistema - la interacción de distintos sistemas, ya sería una prueba de integración -
Por ejemplo, si el desarrollador del FrontEnd de nuestro Telegram, necesitará un Mock de la REST API que estamos creando en este curso, podría utilizar el paquete JSON Server.

Creamos un nuevo archivo store.js dentro la carpeta message que contendrá un mock con la simulación a una base de datos y lo exportamos como un modulo
components/message/store.js:

const list = []

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

function getMessages (){
    return list
}

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

procedemos a importar el modulo store dentro del controller del componente message y hacer uso de el para añadir un mensaje, al igual que tenemos la función para añadir un mensaje en el controller, creamos una nueva función asíncrona para poder obtener los mensajes
components/message/controller.js:

const store = require('./store') 

function addMessage (user,message){
    const fullMessage = {
        user,
        message,
        date: new Date(),
    }

    return new Promise((res,rej)=> {
        if (!user || !message){
            rej('data incorrecta')
            return 
        }
        store.add(fullMessage) 
        res(fullMessage)
    })
}

function getMessages (){ 
    return new Promise((res,rej)=> {
        res(store.list())
    })
} 

module.exports = {
    addMessage,
    getMessages 
}

luego procedemos a modificar el GET del network del componente message, importando y ejecutando la función creada en el controller para obtener los mensajes y modificando la lógica de tal manera que todo funcione correctamente y pasemos la lista de mensajes
components/message/network.js:

const express = require('express');
const response = require('../../network/response')
const controller = require('../message/controller')

var app = express()
app.get('/', (req,res)=> {
    controller.getMessages() 
        .then(list => response.sucess(req,res,list)) 
        .catch(error => response.error(req,res,"error al obtener mensajes", 500,error)) 
})

app.post('/', (req,res)=> {
    controller.addMessage(req.body.user, req.body.message)
        .then(fullMessage => response.sucess(req,res, fullMessage,201))
        .catch(error => response.error(req,res, error,500,"detalles del error"))
})

module.exports = app 

si hacemos una petición con el método GET a URL “/message”, el servidor nos responderá de esta forma:

{
	"error": "",
	"body": []
}

vemos una lista vacía, si queremos añadir mensajes podemos hacer una petición con el método POST a la url “/message” con el cuerpo del body

{
	"user": "Juan",
	"message": "Mensaje Uno"
}

y luego hacemos lo mismo pero cambiamos el contenido del mensaje

{
	"user": "Juan",
	"message": "Mensaje Dos"
}

estaríamos añadiendo 2 nuevos mensajes a la lista, si hacemos una petición con el método GET a la url “/message” nuevamente como al principio, esta ves el servidor nos responderá diferente y veremos:

{
	"error": "",
	"body": [
		{
			"user": "Juan",
			"message": "Mensaje Uno",
			"date": "2022-11-04T20:58:17.176Z"
		},
		{
			"user": "Juan",
			"message": "Mensaje Dos",
			"date": "2022-11-04T20:58:51.080Z"
		}
	]
}

se han añadido correctamente los 2 nuevos nuevos mensajes que enviamos con el método POST

Todos los cursos de este sujeto son una maravilla.

¡Node.Js es genial! 😄

Yo recomiendo iniciar por el curso de Fundamentos de node.js (dictado también por Carlos) y luego seguir en este.

¿Cómo se puede agregar un formulario en el frontend para hacer el post? Para que se asemeje más a un chat 😅

No es clara la forma en la que estructuras el proyecto, en especial con el router, tal vez no es tan necesario separarlos en carpetas tan alejadas.

En el minuto 7:47 al ejecutar el GET en INSOMNIA me salía un error:

TypeError: controller.getMessages is not a function

El error está en que en el archivo controller.js no se exportó el nuevo método getMessages al crear dicha función en el minuto 5:58

module.exports = {
addMessage,
getMessages
}

genial habia hecho esto pero no sabia que se llamaba mock

No conocía los Mocks

Que clase de brujería es esta !, no sabia que le llamaban mocks 👍!

cuando suben el repositorio

Que geniaaaal!!

En el network.js realice el metodo de la siguiente manera

router.get(’/’,async (req,res)=>{

try {
    const msg= await controller.getMessages();
   response.success(req,res,msg,201)  
} catch (e) {
    response.error('ERROR',500,'estamos presentando problemas en nuestra plataforma')
}

})

dentro de la carpeta message creamos el archivo store
store.js

const list = [];

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

function getMessages() {
    return list;
}

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

modificamos el controller de message
controller.js

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

function addMessage(user, message) {
    return new Promise((resolve, reject) => {
        if (!user || !message) {
            console.error('[messageController] No hay usuario o mensaje');
            return reject('Datos incorrectos');
        }
        const fullMessage = {
            user: user,
            message: message,
            date: new Date(),
        };
        store.add(fullMessage);
        resolve(fullMessage);
    });  
}

function getMessages() {
    return new Promise((resolve, _reject) => {
        resolve(store.list());
    });
}

module.exports = {
    addMessage,
    getMessages,
};

finalmente cambiamos el método get en network de la carpeta message
network.js

router.get("/", async(req, res) => {
    try {
      const allMessages = await controller.getMessages();
      response.success(req, res, allMessages, 200);
    } catch (error) {
      response.error(req, res, error, 500, "Error getting messages");
    }
});

En mi caso no me funcionaba el Get. Pero me di cuenta que en el “network.js” no me funcionaba el “success” como lo escribe el profesor. Me toco usar response.sucess(req, res, messageList, 200);

Aquí dejo mi codigo; donde utilize async/await y reestructure algunas cosas con javascript moderno

network.js

const express = require('express')
const response = require('../../network/response')
const { addMessage, getMessages } = require('./controller')
const router = express.Router()

router.get('/', async (req, res) => {
    try {
        const messagesList = await getMessages()
        response.success(req, res, messagesList, 200)
    } catch (error) {
        response.error(req, res, 'Unexpected Error', 500, error)
    }
})

router.post('/', async (req, res) => {
    try {
        const { body, query } = req
    
        const fullMessage = await addMessage(body.user, body.message)
        
        if(query.error === "ok") {
            return response.error(req, res, 'Error inesperado', 500, 'Error simulado')
        }
        
        response.success(req, res, fullMessage, 201)
    } catch (error) {
        response.warning(req, res, 'Información no valida', 400, 'No hay usuario o mensaje', 'messageController')
    }
})

module.exports = router

controller.js

const { add, list } = require('./store')

const addMessage = (user, message) => {
    return new Promise((resolve, reject) => {
        if(!user || !message) {
            return reject('Los datos son incorrecto')
        }

        const fullMessage = {
            user,
            message,
            date: new Date(),
        }
    
        add(fullMessage)
        resolve(fullMessage)
    })
    
}

const getMessages = () => {
    return new Promise((resolve, reject) => {
        resolve(list())
    })
}

module.exports = {
    addMessage,
    getMessages,
}

store.js

const list = []

const addMessage = (message) => {
    list.push(message)
}

const getMessage = () => {
    return list
}

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

El momento por el que he esperado años

hola estoy haciendo las pruebas con postman y noto que tengo que colocar en el header en campo content-length y la longitud exacta, si no lo hago no obtengo respuesta del servicio que estamos desarrollado en el curso, alguien me podria explicar el por que o alguna solucion???

❤️ quien este volviendo a tomar el curso!! no entendía bien como funcionan o para que los Mocks pero ahorra me queda mucho mas claro !! 😄

esta clase nos da un panorama más amplio de lo que estamos haciendo. Y se va a poner aún mejor cuando se elija una base de datos!!

Alguien ya ha intentado con una base de datos relacional como Sql server? cuando trato de imprimir mi query con .recordset solo me imprime un array vacío

tengo una duda, lo que el profesor llama “store” seria como el modelo en el patrón MVC? ya que en el modelo es donde esta la logica y las funciones que se conectan con la BD

mocks tiene que ver con TDD?

Asi me quedo mi controller, le agregue el extra de simular un id auto-increment.

const store = require("./store");

const getMessages = () =>
  new Promise((resolve, reject) => {
    resolve(store.list());
  });

const addMessage = (user, message) =>
  new Promise((resolve, reject) => {
    if (!user || !message) {
      reject("Faltan datos");
      return false;
    }

    const fullMessage = {
      id: store.list().length + 1,
      user,
      message,
      date: new Date()
    };

    store.add(fullMessage);

    resolve(fullMessage);
  });

module.exports = {
  getMessages,
  addMessage
};

No sabia de los mocks

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

function addMessage(user, message) {
    return new Promise((resolve, reject) => {
        if (!user || !message) {
            console.error('[messageController] no hay usuario o mensaje');
            reject('Datos incorrectos');
            return false;
        }
        const fullMessage = {
            user: user,
            message: message,
            date: new Date()
        };
        store.add(fullMessage);
        console.log(fullMessage);
        resolve(fullMessage);
    })
}

function getMessages() {
    return new Promise((resolve, reject) => {
        resolve(store.list());
    })
}

module.exports = {
    addMessage,
    getMessages
};

Separar físicamente nuestro código permite una fácil refactorización en los módulos que lo necesiten, así no afectará otros módulos.

Viendo esta clase, si considero que hizo falta un módulo un poco más específico de Bases de datos en este lado del Backend, pero bueno, si lo hicieron de esta manera por algo será

Me esta volando la cabeza, pero no me desanimará

Práctica:

Me confunde un poco cuando pone el .then con messageList como parametro, como hace el codigo para reconocer que es la lista ?