Escalando la arquitectura: Múltiples entidades

Que buen curso!!!

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

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.

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
}

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

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

¡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 😃

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

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

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

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) => {
        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) => {
    const filterUser = req.query.user || null;
    controller.getUsers(filterUser)
    .then((data) => {
        response.success(req, res, data, 200);
    })
    .catch( e => {
        response.error(req, res, 'Unespected Error', 500, e);
    })
})


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

 module.exports = router;

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:

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

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?

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

Este pequeño momento de mi vida se llama felicidad

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
}

Con Mongoose se hace bastante sencillo. Excelente.

Escalando la arquitectura: Múltiples entidades

Bien, ya hemos creado varios procesos, pero ahora es momento de escalar nuestra arquitectura creando relaciones de usuario. Pero para esto me gustaría hacer un par de reconfiguraciones en nuestro proyecto.

Primero nuestro archivo all-messages.controller.js lo vamos a renombrar a message.services.js y lo vamos a guardar dentro de una carpeta de services, de esta forma organizamos mejor nuestro proyectó.

Y ahora vamos a crear nuevas funcionalidades para administrar los usuarios de nuestra aplicación. Para esto vamos a crear los siguientes archivos en nuestras carpetas:

• /controller/user.controller.js
• /services/user.service.js
• /models/user.model.js
• /routes/user.router.js

Vamos a empezar creando el modelo del usuario:

const mongose = require('mongoose')

const Schema = mongose.Schema

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

const model = mongose.model('User', mySchema)

module.exports = model

Bien, ahora vamos a nuestro servicio y definamos nuestras acciones y luego crearemos las funcionalidades más complejas:

const UserModel = require('../models/user.model')

async function addUser(user) {
  try {
    const myUser = new UserModel(user)
    await myUser.save()
    console.log('Usuario guardado en la base de datos:', UserModel)
  } catch (error) {
    console.error('Error al guardar el usuario en la base de datos:', error)
  }
}

module.exports = {
  add: addUser,
}

Ahora, vamos a ir a nuestro controlador y definamos nuestra estructura:

const addUser = (name) => {
  if (!name) {
    return Promise.reject('Invalid name')
  }
  
  const user = {
    name,
  }

  return service.add(user)
}

module.exports = {
  addUser,
}

Y ahora, vamos a ir a nuestra carpeta de rutas y vamos a crear lo siguiente:

const express = require('express')
const router = express.Router()

const response = require('../utils/response')
const controller = require('../controllers/user.controller')

router.post('/', (req, res) => {
  const { name } = req.body
  controller.addUser(name)
    .then((data) => response.success(req, res, data, 201))
    .catch((err) => response.error(req, res, err, 400))
})

module.exports = router

Y luego, vamos a añadir nuestra ruta de usuario al index.js de las rutas:

const express = require('express')
const message = require('./message.router')
const user = require('./user.router')

const routes = (server) => {
  server.use('/message', message)
  server.use('/user', user)
}

module.exports = routes

Bien, ya tenemos nuestra estructura básica para empezar a crear nuestros usuarios.

vengo del 2023 y sigue siendo bueno :v
(aunque estoy usando ahora typescript )

aporte al reto
components/user/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 

components/user/store.js:

const Model = require('./model')

async function getUsers (filterUser){
    let filter = {}
    if(filterUser !== null){
        filter = { name: filterUser }
    }
    const users = await Model.find(filter)
    return users 
}


module.exports = {
    list: getUsers,
}

components/user/controller.js:

const store = require('./store')

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

module.exports = {
    list: getUsers,
}

components/user/network.js:

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

app.get('/', function (req,res){
    controller.list(req.query.name || null)
        .then(data => response.sucess(req,res,data,200))
        .catch(e => response.error(req,res,'error interno',500,e))
})

module.exports = app

los archivos completos quedarían de esta forma:
components/user/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 

components/user/store.js:

const Model = require('./model')

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

async function getUsers (filterUser){
    let filter = {}
    if(filterUser !== null){
        filter = { name: filterUser }
    }
    const users = await Model.find(filter)
    return users 
}


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

components/user/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((res,rej)=> {
        res(store.list(filterUser))
    })
}

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

components/user/network.js:

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

var app = express.Router()
app.post('/', function (req,res){
    controller.add(req.body.name)   
        .then(data => response.sucess(req,res,data,200))
        .catch(e => response.error(req,res,"error interno",500,e))
})

app.get('/', function (req,res){
    controller.list(req.query.name || null)
        .then(data => response.sucess(req,res,data,200))
        .catch(e => response.error(req,res,'error interno',500,e))
})

module.exports = app

si hacemos una petición con el método POST a la url “/user” con el cuerpo del body

{
    "name": "Juan"
}

y hacemos lo mismo con otro nombre de usuario

{
    "name": "Oscar"
}

podemos crear registros de usuarios en nuestra base de datos, para poder ver estos registros podemos hacer una petición GET a la url “/user” y veremos como respuesta de parte del servidor

{
	"error": "",
	"body": [
		{
			"_id": "6367f3b83760227e2ee1f917",
			"name": "Juan",
			"__v": 0
		},
		{
			"_id": "6367f591399f071c48b17016",
			"name": "Oscar",
			"__v": 0
		}
	]
}

si queremos solo filtrar un usuario en especifico podemos hacer la petición con el método GET añadiendo un query ?name=mombreusuario "/user?name=‘Juan’"
de esta forma el servidor nos respondera

{
	"error": "",
	"body": [
		{
			"_id": "6367f588399f071c48b17014",
			"name": "Juan",
			"__v": 0
		}
	]
}

y tendremos como respuesta solo el usuario que indicamos en el query

Reto cumplido

Controller.js

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

//Requerir toda la informacion para el usuario
function addUser(name) {
    if(!name){
        //DEvuelve la promesa reject
        return Promise.reject('Invalid name');
    }


    const user = {
        name,
    };
    return store.add(user);
}

//Mostar los usuarios
function getUsers(filterName) {
    return new Promise((resolve,reject) => {
        resolve(store.get(filterName));
    })
}



module.exports = {
    addUser,
    getUsers,
}

Store.js

const Model = require('./model')

//Funcion añadir usuario
function addUser(user) {
    const myUser = new Model(user);
    return myUser.save();
}


//Funcion de visualizar usuario
async function getUser(filterName){

    let filter = filterName ? { name: new RegExp(filterName,"i") } : {};

    const name = await Model.find(filter);
    if(name.length !== 0){
        return name;
        
    }else {
        console.log("Nombre de usuario no se encuentra en la base de datos");
        return "Nombre no encontrado";
    }
}


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

Network.js

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

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

//Solo el metodo get
router.get('/', (req,res) => {

    //Generar consultas
    const filterName = req.query.name || null;

    // ----

    controller.getUsers(filterName)
        .then((nameList) => {
            response.success(req,res, nameList, 200);
        }).catch(e => {
            response.error(req, res, 'Unexpect Error', 500, e);
        })
})


module.exports = router;

->get users

//...network.js
app.get('/', async (req, res) => {
  try {
    const userList = await controller.getUsers()
    response.success(req, res, userList, 200);
  } catch (error) {
    response.error(req, res, 'Unexpected Error', 500, e);
  }
})

//...controller.js
function getUsers() {
  return new Promise((resolve, reject) => {
    resolve(store.list())
  })
}
module.exports = {
  getUsers
}

//...store.js
async function getUsers() {
  return await Model.find();
}
module.exports = {
  list:getUsers
}

Me genero dudas que en el componente de messages y el de user, las promesas en el contralador se usaron de manera diferente.

En el llamado entre el network < controller < store, me causo inquietud la necesidad de crear otra promesa en el controller con (new promise), adicional a la de store.js con la funcion** async.**

El ejercicio lo resolvi, si crear la nueva promesa, solo le agregue un try-catch en el controlador, y dandole paso a la promesa creada en el store, hasta el network donde se recibe con el then-catch

En el minuto 6, creo entender que no es necesaria la new Promise en el controlador.

Excelente !!

async function getUser(filterUser) {
  console.log(filterUser)

  let filter = {};

  if (filterUser) {
    filter = { name: new RegExp(filterUser, 'i') };
  }

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

porque las collecciones se crean con una “s” de mas?? por que estamos poniendole message y user y en ambos casos se crean con messages y users? he probado con otros nombres y siempre se crea en mongo atlas con una “s” al final

Que buen curso!!!

Excelente! dejo mi solución:

// store.js
async function ListUsers () {
    const list = await Model.find();
    return list;
}

// controller.js
function GetAllUsers() {
    return Promise.resolve(store.all());
}

// network.js
router.get('/', (req, res) => {
    controller.GetAllUsers()
        .then((data) => { response.success(req, res, data, 200) })
        .catch((error) => { response.error(req, res, 'Error en GetAllUsers', 500, error) })
})

Wow va demasiado rápido pero pausando va

Mission Complete 😀

Saludos! les comparto mi solucion 😃

// store.js 
function getUsers(filterName) {
    let filter = {};

    if (filterName) {
        filter = { name: filterName };
    }

   // Utilizo la función exec que ejecuta el quey
  // y retorna una promesa
    return Model.find(filter).exec();
}

// controller.js
function getUsers(filterUser) {
    return store.list(filterUser);
}

// network.js
router.get('/', (req, res) => {
    const filterUser = req.query.name || null;
    controller
        .getUsers(filterUser)
        .then((userList) => {
            response.success(req, res, userList, 200);
        })
        .catch((err) => {
            response.error(req, res, 'Error Inesperado', 500, err);
        });
});

Listo 😃

Esta es mi respuesta al reto:

1.- Network:

router.route("/")
.get(async (req, res) => {
    try{
        const filterUser = req.query.user || null;
        const messageList = await controller.getUsers(filterUser)
        response.success(req, res, null, messageList)
    }
    catch(error){
        response.error(req, res, 500, error)
    }
})

2.- Controller

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

3.- Store

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

Todo excelente hasta ahora, con fe!

Hola!

Dejo mi solución al reto, excelente curso.
saludos!

• /components/user/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) => {
        resolve(store.list(filterUser));
    })
};

module.exports = {
    addUser,
    getUsers,
};

• /components/user/network.js

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

router.post('/', function(req, res) {
    controller.addUser(req.body.name)
        .then( data => {
            response.sucess(req, res, data, 201);
        })
        .catch(err => {
            response.error(req, res, 'Internal Error', 500, err);
        })
});

router.get('/', function(req, res){
    const filterUser = req.query.user || null;
    controller.getUsers(filterUser)
        .then((userList) => {
            response.sucess(req, res, userList, 200);
        })
        .catch(err => {
            response.reject(req, res, 'Invalid User', 500, err)
        })
});

module.exports = router;

• /components/user/store.js

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

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

async function getUsers(filterUser){
    let filter = {};
    if(filterUser != null) {
        filter = { name: filterUser}
    }
    const users = await model.find(filter);
    return users;
}

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

//network.js

router.get('/', function(req, res){
    const filterName = req.query.name || null ;
    controller.getUser(filterName)
        .then((userList) =>{
            response.success(req, res, userList, 200);
        })
        .catch(e =>{
            response.error(req, res, 'Error de users', 500, e);
        });
});



//controller.js

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



//store.js

async function getUser(filterName){
    let filter = {};
    if(filterName !== null){
        filter = { name : filterName };
    }
    const users = await Model.find(filter);
    return users;
}```

Confie en mi y pude 😄

router.get('/', (req, res) => {
    controller.getUsers()
        .then(data => {
            response.success(req, res, data, 200);
        })
        .catch(e => {
            response.error(req, res, 'Internal error', 500, e)
        });
});```

Network

router.get('/', function(req,res){
    controller.getUsers()
    .then(data => {
        response.success(req, res, data, 201);
    })
    .catch(e => {
        response.error(req, res, 'Internal Error', 500, e)
    })
})

Controller

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

store

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

Me perdí en que momento le damos el nombre “users” a la colección…

Reto realizado

Reto realizado!!, me marca error al subir la imagen.

Excelente clase

Reto cumplido!!

Listo!!

[
    {
        "_id": "5e7ace3bb71e6e0d20fec298",
        "name": "carlos ramirez",
        "email": "[email protected]",
        "__v": 0
    },
    {
        "_id": "5e7ad00ca9aca50ddd992b5c",
        "name": "Ana Maria",
        "email": "[email protected]",
        "__v": 0
    }
]```

Reto Completado 😁😁😁😁👀👀👀

Reto cumplido

router.get("/", function (req, res) {
    const filter = req.query.user || null;
    controller.getUsers(filter)
        .then((userList) => {
        response.success(req, res, userList, 200);
        })
        .catch((e) => {
        response.error(req, res, "Error inesperado", 500, e);
        });
});```

Muy bueno, es necesario tener cuidado con los nombres 😃

![](

La salida de mi petición GET

{
  "error": "",
  "body": [
    {
      "_id": "5eac51f92fe5302cf9a035cd",
      "name": "Jaime",
      "date": "2020-05-01T16:44:41.413Z",
      "__v": 0
    },
    {
      "_id": "5eac52032fe5302cf9a035ce",
      "name": "Ericsson",
      "date": "2020-05-01T16:44:51.214Z",
      "__v": 0
    },
    {
      "_id": "5eac520a2fe5302cf9a035cf",
      "name": "Juan",
      "date": "2020-05-01T16:44:58.743Z",
      "__v": 0
    }
  ]
}

network.js:
router.get('/', function(req, res){
    controller.getUser(req.query.name || null)
        .then( data => {
            response.success(req, res, data, 200);
        })
        .catch( e => {
            response.error(req, res, 'Internal error', 500, e);
        })
})

controller.js:
function getUser(name){
    if (!name){
        return Promise.reject('Invalid name');
    }
    return store.list(name);
}

store.js
function getUser(filterUser){
    let filter ={};
    if (filterUser !== null){
        filter = { name: filterUser };
    }
    const user = Model.find(filter)
    return Promise.resolve(user);
}

porque en adduser no ocupa la asincronia?

store.js

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

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

async function getUsers(filterUser) {
    let filter = {};
    if (filterUser != null) {
        filter = {
            user: new RegExp(filterUser, 'i')
        };
    }
    const users = await Model.find(filter);
    return users;
}

async function updateUser(id, name) {
    const foundUser = await Model.findOne({ _id: id });
    foundUser.name = name;
    const newUser = await foundUser.save();

    return newUser;
}

async function deleteUser(id) {
    return Model.deleteOne({ _id: id });
}

module.exports = {
    add: addUser,
    list: getUsers,
    update: updateUser,
    delete: deleteUser
};

network.js

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

router.get('/', function (req, res) {
    const filterUsers = req.query.user || null;
    controller.getUsers(filterUsers)
        .then((userList) => {
            response.success(req, res, userList, 200);
        })
        .catch((err) => {
            response.error(req, res, 'Unexpected Error', 500, err);
        })
});

router.post('/', function (req, res) {
    controller.addUser(req.body.name)
        .then((fullUser) => {
            response.success(req, res, fullUser, 201);
        })
        .catch((err) => {
            response.error(req, res, 'Informacion invalida', 400, 'Error en el controlador ' + err);
        });
});

router.patch('/:id', function (req, res) {
    controller.updateUser(req.params.id, req.body.name)
        .then((data) => {
            response.success(req, res, data, 200);
        })
        .catch((err) => {
            response.error(req, res, 'Error Interno', 500, 'Error en el controlador ' + err);
        });
});

router.put('/', function (req, res) {
    response.success(req, res, 'user updated');
});

router.delete('/:id', function (req, res) {
    controller.deleteUser(req.params.id)
        .then((data) => {
            response.success(req, res, `User ${req.params.id} deleted`, 200);
        })
        .catch((err) => {
            response.error(req, res, 'Error Interno', 500, 'Error en el controlador ' + err);
        });
});

module.exports = router;

controller.js

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

function addUser(name) {
    return new Promise(async (resolve, reject) => {
        if (!name) {
            console.error('[userController] name invalid');
            return reject('los datos son incorrectos');
        }
        const fullUser = {
            name: name,
            date: new Date()
        };
        const result = await store.add(fullUser);
        resolve(result);
    });
}

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

function updateUser(id, name) {
    return new Promise(async (resolve, reject) => {
        if (!id || !name) {
            console.error('[userController] No hay usuario o name');
            return reject('los datos son incorrectos');
        }
        const result = await store.update(id, name);
        resolve(result);
    });
}

function deleteUser(id) {
    return new Promise(async (resolve, reject) => {
        if (!id) {
            console.error('[userController] Id invalido');
            return reject('los datos son incorrectos');
        }
        store.delete(id)
            .then(() => {
                resolve();
            })
            .catch((err) => {
                reject(err);
            })
    });
}

module.exports = {
    addUser,
    getUsers,
    updateUser,
    deleteUser
};

me encanta este curso

Reto superado!!!

Buenas, acá comparto mi respuesta al reto:
 
user/network.js

router.get('/', function(req, res){
    const filterUsers = req.query.name || null
    controller.getUsers(filterUsers)
        .then((userList) => {
            response.success(req, res, userList, 200)
        })
        .catch(e => {
            response.error(req, res, 'Unexpected error', 500, e)
        })
})

user/controller.js

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

user/store.js

async function getUsers(filterUser){
    let filter = {}
    if(filterUser !== null){
        filter = { name: new RegExp(filterUser, 'i')}
    }
    const users = await Model.find(filter)
    return users
}

Mi codigo implementando con async await:

Network:

router.post('/', async (req, res) => {
    const { name } = req.body;

    try {
        const data = await controller.addUser(name);

        let finalData = {
            data: data,
            message: "User added successfully"
        }
        //  req, res, message, status
        response.success(req, res, finalData, 201);
    } catch (error) {
        // req, res, error, status, details
        response.error(req, res, "Error creating user", 400, error)
    }
});

Resto del codigo en mi github

Mi solucion al reto:
Network:

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

Controller:

const listUsers = () => {
    return new Promise( async (resolve, reject) => {
        try {
            const data = await storage.listAllUsers();
            resolve(data);
        } catch (error) {
            reject(error);
        }
    })
}

Storage:

const allUsers = async () => {
    try {
        const data = await Model.find();
        return data;
    } catch (error) {
        return new Error('Error getting users');
    }
    
}

Reto completado 😃

Store.js

Controller.js

network.js

Este curso está muy bueno, node.js es un mundo muy interesante.

Les comparto mi solución al reto
store.js

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

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

controller.js

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

module.exports = {
    addUser, 
    getUser,
}

network.js

router.get('/', function (req, res) {
    const filterUser = req.query.name || null;
    controller.getUser(filterUser)
      .then((userList)=>{
        response.success(req, res, userList, 200);
      })
      .catch(e => {
        response.error(req, res, 'Unspected Error', 500, e);
      })
  });

Me encanta este curso! Este profe le da mucha emoción a sus clases, se ve que domina el tema y es muy ameno escucharlo vídeo tras vídeo

Que chévere esta el cursiño!!

store.js

const getUsers = async user => {
  let filter = {};
  if (user !== null) {
    filter = { name: user };
  }
  const listUsers = await Model.find(filter);
  return listUsers;
};

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

controller.js

const getUsers = user => {
  return new Promise(async (resolve, reject) => {
    const listOfUsers = await store.list(user);
    resolve(listOfUsers);
  });
};

module.exports = {
  addUser,
  getUsers
};

network.js

router.get("/", (req, res) => {
  controller
    .getUsers(req.query.name || null)
    .then(data => {
      response.success(req, res, data, 200);
    })
    .catch(e => {
      response.error(req, res, "Internal Error", 500, e);
    });
});

Mi solución al reto:

// network.js

router.get("/", function (req, res) {
  const filterName = req.query.name || null;
  controller
    .getUser(filterName)
    .then((data) => {
      response.success(req, res, data, 200);
    })
    .catch((err) => {
      response.error(req, res, "Internal error", 500, err);
    });
});

// controller.js

function getUser(user) {
  return new Promise((resolve, reject) => {
    resolve(store.getAll(user));
  });
}

module.exports = {
  addUser,
  getUser,
};

// store .js

async function getUsers(name) {
  let filter = {};
  if (name != null) {
    filter = { name: name };
  }
  const users = await Model.find(filter);
  return users;
}

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

Mi solución al reto:

network.js

router.get("/", function (req, res) {
  const filterName = req.query.name || null;
  controller
    .getUser(filterName)
    .then((data) => {
      response.success(req, res, data, 200);
    })
    .catch((err) => {
      response.error(req, res, "Internal error", 500, err);
    });
});

controller.js

function getUser(user) {
  return new Promise((resolve, reject) => {
    resolve(store.getAll(user));
  });
}

module.exports = {
  addUser,
  getUser,
};

store.js

async function getUsers(name) {
  let filter = {};
  if (name != null) {
    filter = { name: name };
  }
  const users = await Model.find(filter);
  return users;
}

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

mi solución.

//network.js
router.get('/', async function (req, res) { 
    try {
        const result = await controller.getUser(req.query.user || null);
        return response.success(req, res, result, 201);
    } catch (error) {
        response.error(req, res, 'Error interno', 500, error);
    }
 })

//controller.js
 function getUser(name){
     return store.getUsers(name);
 }

//store.js
async function getUsers(user){
    let Users = {};
    if( user !== null ){
        Users = { name: user }
    }
    const UserList = await Model.find(Users);
    return UserList;

}

Hola Devs:
Aca les comparto mi avance del proyecto usando TypeScript:
-El Network del componente User:

-El Controller del componente User:

-El Store del componente User:

-El Model del componente User:

-Le hice una pequena mejora agregandole la fecha de registro y demas, me parecio un dato importante.
-Aca les dejo el commit exacto de esta clase por si quieren checar o colaborar: Click Aqui
-Recuerda, #NuncaParesDeAprender 💚

Porque Me está apareciendo el error en toda mi aplicación?

MongooseError: Operation `messages.find()` buffering timed out after 10000ms
    at Timeout.<anonymous> (/Users/juanjoselondonodavid/Documents/Learning/Backend-node/MessagesApp/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js:184:20)
    at listOnTimeout (internal/timers.js:549:17)
    at processTimers (internal/timers.js:492:7)

Las funciones de get, esta es de network.js

router.get('/', (req, res) => {
      const filterUser = req.query.user || null;
      controller.list(filterUser)
      .then((userList) => {
            response.success(req, res, userList, 200);
      })
      .catch(e => {
            response.error(req,res, 'Unexpected Error', 500, e);
      })
});

esta es de controller.js

const getUser = (filterUser) => {
      return new Promise((resolve,reject) => {
            resolve(store.getUser(filterUser));
      })
}

y por ultimo store.js

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

Challenger complete !! 😄

store.js

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

const getUsers = async (filterName) => {
  let filter = {};
  if (filterName !== null) {
    filter = {
      name: filterName,
    };
  }
  const users = await Model.find(filter);
  return users;
};

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

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

controller.js

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

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

const addUser = (name) => {
  if (!name) {
    return Promise.reject("Invalid name");
  }

  const user = {
    name,
  };

  return store.add(user);
};

module.exports = {
  getUsers,
  addUser,
};

network.js

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

// GET
router.get("/", (req, res) => {
  console.log(req.query.name);
  const filterUsers = req.query.name || null;
  controller
    .getUsers(filterUsers)
    .then((userList) => {
      console.log(data);
      response.success(req, res, userList, 200);
    })
    .catch((err) => {
      response.error(req, res, "Internal error", 500, err);
    });
});

// POST
router.post("/", (req, res) => {
  controller
    .addUser(req.body.name)
    .then((data) => {
      response.success(req, res, data, 201);
    })
    .catch((err) => {
      response.error(req, res, "Internal error", 500, err);
    });
});

module.exports = router;

súper genial, práctica:

Estuvo facil el reto xD