Control de roles

Yo diria que es un 403, no tiene permisos de acceso. 401 yo lo uso solo para si es sesion o no.

To create a role control, a middleware will be our best friend

First of all, let’s think about what we need, we need a middleware able to check what kind of users is authenticated, for this, let’s create a single function, which will receive a list of roles and return a middleware.

//@param roles array of roles that can access the route
function checkRole(roles) {

    return (req, res, next) => {
        const user = req.user;
        //Check if rol is allowed to access
        if (!roles.includes(user.role)) {
            next(boom.unauthorized("Unauthorized!You cannot do this, Admins have been notified "));
        } else {
            //If everything is right, go to next middleware
            next();
        }
    }
}

Finally just use it wherever you need to check role, por example:

router.post("/",
    passport.authenticate('jwt', { session: false }),
    checkRole(['admin', 'Captain']),
    validatorHandler(getOrderSchema, "body"),
    async(req, res, next) => {
        try {
            const body = req.body;
            res.status(201).json(await service.create(body));
        } catch (error) {
            next(error);
        }
    }
);

Recommendation

Acces Control NPM

Si estan usando insomia para hacer la pruebas de la API, pueden guardar el token del usuario al hacer login. Pega la siguiente linea, dentro del archivo de variables de entorno

{
	"TOKEN_ADMIN": "{% response 'body', 'req_1e7f7e044bd5407bbff202ad27392f6e', 'b64::JC50b2tlbg==::46b', no-history, 60 %}",
}

Nota: después de pegar la línea de código aparecerá un recuadro en rojo, no se asusten, deben configurar los parámetros según sus request disponible (esto se hace a traves de una ventana gráfica)

• Function to Perform: deber ser response (origen de la info que se desea guardar)
• Attribute: body ( que parte especifica del response contiene la info)
• Request: [Auth] POST Login Admin, este el nombre de mi request
• Filter: este es valor que deseamos guardar en la variable de entorno, en este caso es $.token
• Trigger behavior: acción a realizar una vez obtenida la info, en este caso No History, ya que solo queremos las info guardada en token

Se debe trabajar en la gestión de permisos y roles ya que no todos deben poder crear categorías o crear usuarios, únicamente un usuario administrador podría hacer eso.

Se crea un middleware que verifique que tipo de rol es, y lo que lo deje seguir o no.

En auth.handler.js se crea la función checkAdminRole la cual verificará si el rol del usuario es admin o customer, si es admin entonces pasa al siguiente middleware, de lo contrario lanza un error unauthorized.

function checkAdminRole(req, res, next) {
  const user = req.user;
  if (user.role === 'admin') {
    next();
  } else {
    next(boom.unauthorized());
  }
}

A la ruta se le agrega el middleware, la lógica es:

1. Autenticar, verificar el token y obtener los datos del user (*passport.authenticate)*.

2. Verificar el tipo de rol de user (checkAdminRole).

3. Validar los datos del body (validatorHandler).

4. Conectarse al servicio.

router.post(
  '/',
  passport.authenticate('jwt', { session: false }),
  checkAdminRole,
  validatorHandler(createCategorySchema, 'body'),
  async (req, res, next) => {
    try {
      const body = req.body;
      const newCategory = await service.create(body);
      res.status(201).json(newCategory);
    } catch (error) {
      next(error);
    }
  }
);

Cuando se desea escalar y tener más roles, la función checkAdminRole se vuelve poco mantenible, por ello creamos la función checkRoles que recibirá los roles que tendrán acceso a ese endpoint. Si en los roles se encuentra el rol del usuario, devolverá true y tendrá acceso al endpoint, de lo contrario devolverá false y arrojará error unauthorized.

En resumen, la función checkRoles recibe un array de roles, verifica que user.role se encuentre en ese array, y si todo bien procede al siguiente middleware.

function checkRoles(...roles) {
  return (req, res, next) => {
    const user = req.user;
    if (roles.includes(user.role)) {
      next();
    } else {
      next(boom.unauthorized());
    }
  };
}

Haciendo la implementación del middleware en la ruta queda de la siguiente manera, agregando los roles a los que tendrá acceso ese endpoint.

router.post(
  '/',
  passport.authenticate('jwt', { session: false }),
  checkRoles('admin', 'seller'),
  validatorHandler(createCategorySchema, 'body'),
  async (req, res, next) => {
    try {
      const body = req.body;
      const newCategory = await service.create(body);
      res.status(201).json(newCategory);
    } catch (error) {
      next(error);
    }
  }
);

Se recomienda utilizar la librería accesscontrol donde realmente y de forma explicita se gestionan permisos de una forma más profunda y avanzada.