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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Escalando la arquitectura: Múltiples entidades

25/33
Recursos

Aportes 68

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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
}

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

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

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:

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?

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

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
}

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

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

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

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

Reto cumplido!

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