No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Probando nuestros endpoints

20/25
Recursos

Aportes 22

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Muy entendible todo. La verdad me encanta este curso hasta ahora.

Si te preguntas cuántas funciones middleware puedes enviar como callback, la respuesta es: las que quieras. Esto siempre y cuando las separes con coma. Las puedes llamar si las definiste fuera, ejecutar o incluso llamar un array de funciones middlewares.
Ejemplo de la documentación Express

const cb0 = function (req, res, next) {
  console.log('CB0')
  next()
}

const cb1 = function (req, res, next) {
  console.log('CB1')
  next()
}

app.get('/example/d', [cb0, cb1], function (req, res, next) {
  console.log('the response will be sent by the next function ...')
  next()
}, function (req, res) {
  res.send('Hello from D!')
})

Si alguno ve este error en la consola:

Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client

Lo puede solucionar anteponiendo un return antes de los res. Esto sucede porque tenemos varios middlewares en los que se responde al cliente, y no se corta la ejecución de los mismos luego de enviado el primer res, por eso el error.

Quedaría así, (ejemplo para boomErrorHandler):

function boomErrorHandler(err, req, res, next) {
	if (err.isBoom) {
		const { output } = err;
		return res.status(output.statusCode).json(output.payload);
	}
	next(err);
}

Me ha gustado mucho el curso, el profe explica super claro todos los conceptos y practicar ayuda mucho a entender mejor lo conceptos, he estado desarrollando lo que hacemos para productos con los usuarios.


Asi sería mi Schema para los usuarios:

const Joi = require('joi');

const id = Joi.string().uuid();
const name = Joi.string().alphanum().min(3).max(15);
const lastname = Joi.string().alphanum().min(3).max(15);
const email = Joi.string().email();

const createUserSchema = Joi.object({
  name : name.required(),
  lastname : lastname.required(),
  email: email.required(),
});

const getUserSchema = Joi.object({
  id: id.required(),
});

module.exports = {createUserSchema, getUserSchema};
Y asi las ruta de usuarios:

const express = require("express");
const UserService = require("../services/userService");
const validatorHandler = require("../middlewares/validatorHandler");
const {createUserSchema, getUserSchema} = require("../schemas/userSchema");

const router = express.Router();
const service = new UserService();

router.get("/", async (req, res) =>{
  const users = await service.find();
  res.json(users);
});

router.post("/",
  validatorHandler(createUserSchema, "body"),
  async (req, res) =>{
    const body = req.body;
    const newUser = await service.create(body);
    res.status(201).json(newUser);
  }
);

router.delete("/:id", async (req, res) =>{
  const {id} = req.params;
  const answer = await service.delete(id);
  res.status(200).json(answer);
});

module.exports = router;

Les comparto una forma de personalizar los mensajes de la validación en el productSchema.js Ejemplo si queremos los mensajes en español

const name = joi.string().min(3).max(15).messages({
  'string.base': `" nombre "debe ser un tipo de 'texto'`,
  'string.empty': `"nombre "no puede ser un campo vacío`,
  'string.min': `"nombre" debe tener una longitud mínima de {#limit}`,
  'string.max': `"nombre" debe tener una longitud máxima de {#limit}`
});

resultado

Este curso es increíble, hace la diferencia un buen profesor. Me han quedado claro conceptos que no había entendido bien en cursos anteriores.

Muy buen curso, hasta el momento he entendido todo .
El tema de los middlewares lo habia escuchado pero recien ahora lo estoy empezando a entender.

Profe, tome este curso porque en mi emprendimiento ya era necesario crear una API.

El curso es muuuuuuuuuuy bueno, has tomado la información relevante con clases cortas y concisas. De Verdad muchas gracias! me ha servido TODO

Para quien tenga dudas con el código de porque el profe. puso, en validatorHandler.js

const data = req[property]; 

Se debe a que para obtener data dentro de un objeto se hace de dos formas.

const objeto = {
    name: "victor",
    number: 123
}
console.log(objeto.number)
const objeto = {
    name: "victor",
    number: 123
}
console.log(objeto["number"])

Consejo: pongan en las validaciones de price: .strict() ya que sino aceptará strings con números como “1000” y eso puede generarnos problemas después.

Si quieren validar que el name sea requerido pero si este contiene espacios en blanco, solamente es omitir el alphanum().

const name = Joi.string().min(3).max(15);

Sin duda uno de los mejores cursos que me he encontrado en Platzi. Gracias Platzi, Gracias Nicolas Molina eres la mera ley… =)

Para realizar ciertas restricciones con joi y poder requerir al menos un valor por ejemplo que para actualizar un usuario, por lo menos en el body venga un valor pueden usar la siguiente estructura:

Otra forma de aplicar middlewares es

router.use('/:id', validatorHandler(getProductSchema, "params"))

Esto aplica el middleware a la ruta ‘/’ que le pasan por parametro el id

De la documentación de Joi:

number
Generates a schema object that matches a number data type (as well as strings that can be converted to numbers).

Por si alguien también se percató que se está aceptando price como number o string.

Muy bien, ya puedo validar los datos!

Excelente el curso, todo muy claro y entendible.

Ahora si me quedo clarísimo como funciona el middleware, que bien que explica, cada detalle

products.route.js:

const express = require('express');
const ProductsService = require('../../services/product.service');
const validatorHandler = require('../../middlewares/validator.handler');
const {
  createProductSchema,
  updateProductSchema,
  getProductSchema,
  deleteProductSchema,
} = require('../../schemas/product.schema');

const router = express.Router();
const service = new ProductsService();

router.get('/', async (req, res) => {
  const products = await service.find();
  res.status(200).json(products);
});

router.get(
  '/:id',
  validatorHandler(getProductSchema, 'params'),
  async (req, res, next) => {
    try {
      const { id } = req.params;
      const product = await service.findOne(id);
      if (product) {
        res.status(200).json(product);
      } else {
        res.status(404).json({ message: 'Product not found' });
      }
    } catch (error) {
      next(error);
    }
  }
);

router.post(
  '/',
  validatorHandler(createProductSchema, 'body'),
  async (req, res) => {
    const body = req.body;
    const newProduct = await service.create(body);
    res.status(201).json({
      message: 'created',
      data: newProduct,
    });
  }
);

router.patch(
  '/:id',
  validatorHandler(getProductSchema, 'params'),
  validatorHandler(updateProductSchema, 'body'),
  async (req, res, next) => {
    try {
      const { id } = req.params;
      const body = req.body;
      const product = await service.update(id, body);
      res.status(200).json({
        message: 'updated',
        product,
      });
    } catch (error) {
      next(error);
    }
  }
);

router.delete(
  '/:id',
  validatorHandler(getProductSchema, 'params'),
  async (req, res) => {
    const { id } = req.params;
    const rta = await service.delete(id);
    res.status(200).json({
      message: 'deleted',
      rta,
    });
  }
);

module.exports = router;


Un curso increíble. Estoy entendiendo todo a detalle.

la verdad excelente, boom y joi de maravilla conjunto los middlewares es una hermosura utilizarlo 😄

Si quieren realizar validaciones mas complejas que las que trae Joi por defecto pueden usar regex, yo lo usé de la siguiente forma:

const Joi = require('joi');

const id = Joi.string().uuid();
const email = Joi.string().email();
const firstName = Joi
  .string()
  .min(2)
  .max(50)
  .regex(/^\w+(?:\s+\w+)*$/)
  .messages({
    "string.pattern.base": "First Name accepts alphabetic characters, numbers and spaces"
  });
const lastName = Joi
  .string()
  .min(2)
  .max(50)
  .regex(/^\w+(?:\s+\w+)*$/)
  .messages({
    "string.pattern.base": "Last Name accepts alphabetic characters, numbers and spaces"
  });
const photo = Joi.string().uri();

const getUserSchema = Joi.object({
  id: id.required()
});

const createUserSchema = Joi.object({
  email: email.required(),
  firstName: firstName.required(),
  lastName: lastName.required(),
  photo: photo
});

const updateUserSchema = Joi.object({
  firstName: firstName,
  lastName: lastName,
  photo: photo
});

module.exports = { getUserSchema, createUserSchema, updateUserSchema };