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

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Escalando la arquitectura: M煤ltiples entidades

25/33
Recursos

Aportes 73

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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
}

El 鈥渃onf铆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=鈥楯uan鈥"
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 鈥渟鈥 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 鈥渟鈥 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 鈥渦sers鈥 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