Escalando la arquitectura: Múltiples entidades

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

Clase anteriorSiguiente clase

Carlos Alex Becerra Chavita

student•

Que buen curso!!!

Rolando Mamani Salas

student•

Verdad que si

Williams Wilman Alvarez Zabala

student•

Confirmo 3 años después! Que curso bueno!

Jonathan Gonzalez Botero

student•

Me parece que es muy practico el curso, ya con lo que aprendimos del componente mensajes podemos crear cualquier entidad sin problema, se vuelve muy modular nuestra programa

Diego Alejandro Cifuentes Arango

student•

Totalmente de acuerdo, este curso ha sido el mejor que he tomado de backend, el problema sería, como lo conecto a un fronted :/

Esteban Diez Giraldo

student•

Hola Diego. En un framework como react, ya sería solo cuestión de llamar las APIs de tu backend. Te recomiendo mucho el curso de react.js que dicta el profe Leonidas.

Iván Darío Sánchez Jiménez

student•

Una observación, si vemos en cada definición de modelo indicamos el nombre de la collection en singular pero si la vemos dede mongo la colecction se crea en plural.

Juan Jose Vega

student•

Igual con messages

HUGO ANDRES DIAZ BERNAL

student•

He buscado solución a esta observación y aun no la encuentro, pero la explicación posiblemente debe estar en la documentación de mongo

Seba Cardoso

student•

Solución al reto:

// controls.js
const store = require('./store')

const getAllUsers = () => {
  return new Promise((resolve, reject) => {
    resolve(store.list())
  })
}

module.exports = {
  getAllUsers
}

// network.js
router.get('/', (req, res) => {
  controller.getAllUsers()
    .then((users) => {
      response.success(req, res, users, 200)
    })
    .catch(e => {
      response.error(req, res, 'Unexpected Error', 500, e)
    })
})

// store.js
const Model = require('./model')

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

module.exports = {
  list: getAllUsers
}

Gabriel Rodriguez

student•

El "confío en ti" del final hace más genial este curso todavía.

Carlos Santaniello

student•

Pregunta de examen: ¿Cuántas entidades podemos tener en nuestra aplicación?

Juan Carlos Montilla Sánchez

student•

Cuantas queramos definir

Edward Fernandez

student•

¡Hola a todos!

Esta es mi propuesta al reto planteado:

En network.js añadí el método get:

// network.js
router.get('/', function (req, res) {
    const filterUser = req.query.name || null;

    controller.getUser(filterUser)
        .then(data => {
            response.success(req, res, data, 200);
        })
        .catch(error => {
            response.error(req, resp, 'Internal Error', 500, error);
        })
});

Luego en controller.js añadí el método getUser:

// controller.js
function getUser(filterUser) {
    return new Promise(async (resolve, reject) => {
        return resolve(store.list(filterUser));
    });
}

module.exports = {
    getUser
}

Finalmente añadí el método list (getUser) en el store.js:

// store.js
async function getUser(filterUser) {
    let filter = {};

    if (filterUser) {
        filter['name'] = filterUser;
    }

    const users = await Model.find(filter);
    return users;
}

module.exports = {
    list: getUser
}

Saludos a todos :)

Juan David Vásquez Rojas

student•

Si escribo 'mongoose.model('User', mySchema)' o 'mongoose.model('Message', mySchema)' en los archivos model.js de cada componente, ¿Porqué en Mongo atlas las colecciones se llaman 'messages' y 'users'? ¿De dónde toman esos nombres de las colecciones?

Juan Pedraza

student•

De ahí mismo, en la línea 'moongose.model('nombreDeLaColección',mySchema) ahí estamos definiendo el nombre de las colecciones de la BD

Andrés Muñoz

student•

mongoose tiene eso por defecto volver plurales los nombres de las colecciones si están en singular, si en verdad quieres que una colección tenga nombre singular, le puedes configurar al momento de instanciar el schema

Wilmar Yoan Malaver Malaver

student•

para listar los usuarios seria parecido a lo que se realizo para listar los mensajes verdad.

Luis Angel Vásquez Nepomuceno

student•

Hola Yoan

Si, es la misma idea.

En los materiales del curso viene el repo del profesor por si quieres una guía e igual si tienes alguna otra duda, aquí estamos.

freddy conto mena

student•

es interesante pero al final si tienes 15 modulos serian 15 de todo es mejor tener 4 carpetas models, router, controllers, validations y meterlo todo separado

Gilberto Santamaria

student•

Para el caso de proyectos como el curso, si es mejor tener una carpeta por modulo/entidad, pero en caso de proyectos más grandes si es mejor manejarlo como tu dices. Por eso es bueno hacer una planeación antes de empezar a codear.

Elias Guillermo Ruiz Gonzalez

student•

orden de creacion de elementos: modelo, store, controller, network

Platzi Team

student•

Saludos, Porque en Mensajes se indican explicitamente Return New Promise y en User no, es como si fueran implicitas. Me pueden aclarar.?

function addMessage (user, message){
   // trabajar con promesas para indicar cuando algo sale bien o sale mal
    return new Promise ((resolve, reject)=>{
        if (!user || !message) {
            console.error('[error messageController addMessage] no hay valor para el parametro user o message')
            reject ('Los datos son incorrectos')
            return false

No esta usando return new Promise

function addUser (name){
    // Se crea el objeto user con las propiedades
    if (!name){
        return Promise.reject('Invalid name')
    }
    const user = {
        name,
    }

    //Se guarda el objeto user usando el metodo store.add creado en el archivo store.js
    return store.add(user)
}

Guillermo López

student•

fijate que en el metodo addUser del archivo store.js

function addUser(user){
    const myUser = new Model(user);
    return myUser.save(); //el .save() devuelve una promesa
}

por lo tanto en el controller al llamar a store.add(user) ya estas recibiendo una promesa, por lo que solo usas el Promise.reject para que controle si no viene el parametro name

Francisco Garcia [C6]

student•

model.js

const mongoose = require('mongoose');

const Schema = mongoose.Schema;

const mySchema = new Schema( {
    name: String
});

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

store.js

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

function addUser(user) {
    const myUser = new Model(user);
    return myUser.save();
}

async function getUser(filterUser) {
    let filter = {};
    if (filterUser !== null) {
        filter = { user: filterUser };
    }
    const user = await Model.find(filter);
    return user;
}

module.exports = {
    add: addUser,
    list: getUser,
}

controller.js

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

function addUser(name) {
    if (!name) {
        return Promise.reject('Invalid Name');
    }
    const user = {
        name
    };

    return store.add(user);
}

function getUsers(filterUser) {
    return new Promise((resolve, reject) =&gt; {
        resolve(store.list(filterUser));
    })
}


module.exports = {
    addUser,
    getUsers
}

network.js

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

router.get('/', (req, res) =&gt; {
    const filterUser = req.query.user || null;
    controller.getUsers(filterUser)
    .then((data) =&gt; {
        response.success(req, res, data, 200);
    })
    .catch( e =&gt; {
        response.error(req, res, 'Unespected Error', 500, e);
    })
})


 router.post('/', (req, res) =&gt; {
     controller.addUser(req.body.name)
         .then(data =&gt; {
             response.success(req, res, data, 201);
         })
         .catch(err =&gt; {
             response.error(req, res, 'Internanl error', 500, err);
         });
 });

 module.exports = router;

Pedro Roberto Capriles Morales

student•

Reto: Listar usuarios:

user/store.js

async function getUsers() {
  const users = await Model.find();
  return users;
}

module.exports = {
  add: addUser,
  lists: getUsers
};

user/controller.js

function getUsers() {
  return store.lists();
}

module.exports = {
  addUser,
  getUsers
};

user/network.js

router.get("/", function(request, response) {
  controller
    .getUsers()
    .then(data => {
      responseType.success(request, response, data, 200);
    })
    .catch(error => {
      responseType.error(request, response, "Internal error", 500, error);
    });
});

Resultado:

Pedro Iván Juárez Cornejo

student•

me quize adelantar y me marco el mismo error por el export XD

Fabián Ignacio Toro Riquelme

student•

Alguien me puede decir si trabajar con async await todo el rato en vez de promesas es contra producente? Lo encuentro más facil con async await ¿Hay diferencia?

Johann Pino

student•

No hay diferencia, la sintaxis async/await permite trabajar con promesa de manera mas fácil para leer y depurar. Tienes que pensar que async/await es azucar sintactica de las promesas.

Sergio Armando Medina Chaparro

student•

Azúcar sintactica 🤣🤣

Angel Bulnes

student•

network.js

/**
 * @route GET /user/
 * @description Endpoint for listing users
 * @access public
 */
router.get("/", async (req, res) => {
  const filter =  req.query.name || null;
  try {
    const users = await controller.getUsers(filter);
    response.success(req, res, users);
  } catch (err) {
      response.error(req, res, 'Internal error', 500, err);
  }
});

controller.js

/**
 * Controller logic for listing users
 * @param {string} filter Filter by name
 * @returns Promise
 */
const getUsers = (filter) =>{
    let userFilter = {};
    if (filter){
        userFilter = {'name': filter};
    }
    return store.list(userFilter);
}

store.js

/**
 * List users in database
 * @param {object} filter Filter object with property name
 */
function getUsers(filter){
    return Model.find(filter);
}

Juan Jose Vega

student•

Este pequeño momento de mi vida se llama felicidad

Juan Jose Molina

student•

Esta fue la solucion a el reto

EN NETWORK.JS

router.get('/', function (req,res) {
    const nameToSearch = req.query.nm
    controller.getUser(nameToSearch).then((data)=>{
        response.success(req,res,data,200)
    }).catch((e) => {
        response.error(req,res,"error",500,e)
    })
})

EN CONTROLLER.JS

}
function getUser(name){
    return store.list(name)
}
module.exports = {
    addUser,
    getUser
}

EN STORE.JS

function getUser(name){
    let filterUser = {}
    if(name){
        filterUser = {
            name: name
        }
    }
   const users = Model.find(filterUser)
   return users
}

Andrés Muñoz

student•

Donde puedo aprender más acerca de esta forma de organizar los componentes en: model, store, controller y network ? Existen otras formas de estructurar los componentes ? hay una forma standard ?

Xavier Medina Veintimilla

student•

¡Hola! :D

Si, este es una arquitectura llamada MVC por sus siglas en inglés Model View Controller. Por acá te dejo una lectura para que aprendas más de ellos.

Nunca pares de aprender 💚