Tworzenie oprogramowania pośredniczącego Expressjs, które akceptuje parametry

110

Próbuję utworzyć oprogramowanie pośredniczące, które może akceptować parametry. Jak można to zrobić?

przykład

app.get('/hasToBeAdmin', HasRole('Admin'), function(req,res){

})

HasRole = function(role, req, res, next){
   if(role != user.role){
      res.redirect('/NotInRole);
   }

   next();
}

node.js express

— Vartan Arabyan
źródło

43

Ha, zadałeś moje dokładne pytanie dotyczące mojego dokładnego scenariusza, ale 6 lat wcześniej. SO jest niesamowity.

— aero

6

@aero dokładnie to samo, czego szukałem: D

— Jeson Dias

4

@aero 7 lat później szukam dokładnie tego samego: D

— jean d'arme

4

@aero 7+ lat później szukam dokładnie tego samego!

— sidd

4

@aero 8 ~ lat później szukam dokładnie tego samego! \ o /

— Ítalo Sousa

167

function HasRole(role) {
  return function(req, res, next) {
    if (role !== req.user.role) res.redirect(...);
    else next();
  }
}

Chcę się również upewnić, że nie wykonuję wielu kopii tej samej funkcji:

function HasRole(role) {
  return HasRole[role] || (HasRole[role] = function(req, res, next) {
    if (role !== req.user.role) res.redirect(...);
    else next();
  })
}

— Jonathan Ong
źródło

9

Druga metoda buforuje parametry, które mogą być pożądane lub nie.

— Pier-Luc Gendreau

1

@Jonathan Ong, czy możesz wyjaśnić drugą definicję funkcji. Co tam się dzieje? Nie rozumiem następującego zwrotu linii HasRole [rola] || (HasRole [role] = function (req, res, next) {

— Rafay Hassan,

1

@JonathanOng Czy mógłbyś trochę dokładniej wyjaśnić drugi przykład tym, którzy nie znają węzła tak dobrze? (w tym mnie). Kiedy można uzyskać wiele kopii tej samej funkcji i kiedy może to powodować problemy? Dzięki.

— Dave

bez buforowania app.get('/a', hasRole('admin'))i app.get('/b', hasRole('admin'))utworzy nowe zamknięcie dla każdego hasRole. realistycznie nie ma to większego znaczenia, chyba że masz naprawdę dużą aplikację. po prostu domyślnie koduję w ten sposób.

— Jonathan Ong

14

app.get('/hasToBeAdmin', (req, res, next) => {
  hasRole(req, res, next, 'admin');
}, (req,res) => { 
    // regular route 
});

const hasRole = (req, res, next, role) => {
   if(role != user.role){
      res.redirect('/NotInRole');
   }
   next();
};

— chovy
źródło

Dobry i prosty pomysł. Oprogramowanie pośredniczące to naprawdę zwykła funkcja. Dlaczego nie przekazać mu innych wartości. W pierwszej funkcji proszę uwzględnić req, res i next.

— zevero

1

Chociaż kod często mówi sam za siebie, dobrze jest dodać do kodu wyjaśnienia. Pojawiło się to w kolejce recenzji, tak jak zwykle odpowiedzi zawierające tylko kod.

— Will

Myślałem o tym podejściu przed wizytą w SO, ale pomyślałem: „Meh, z pewnością jest lepszy sposób”. Po wizycie widzę, że to naprawdę najprostszy, najbardziej skuteczny sposób.

— Fusseldieb

4

Alternatywnie, jeśli nie masz zbyt wielu przypadków lub jeśli rola NIE jest ciągiem znaków:

function HasRole(role) {
  return function (req, res, next) {
    if (role !== req.user.role) res.redirect(/* ... */);
    else next();
  }
}

var middlware_hasRoleAdmin = HasRole('admin'); // define router only once

app.get('/hasToBeAdmin', middlware_hasRoleAdmin, function (req, res) {

})

— zevero
źródło

eleganckie rozwiązanie

— Leos Literak

2

Jeśli masz różne poziomy uprawnień, możesz je uporządkować w ten sposób:

const LEVELS = Object.freeze({
  basic: 1,
  pro: 2,
  admin: 3
});

/**
 *  Check if user has the required permission level
 */
module.exports = (role) => {
  return (req, res, next) => {
    if (LEVELS[req.user.role] < LEVELS[role]) return res.status(401).end();
    return next();
  }
}

— asdf
źródło

0

Używam tego rozwiązania. Otrzymuję token jwt w body req i stamtąd otrzymuję informacje o roli

//roleMiddleware.js

const checkRole = role => {
    
    return (req, res, next) => {
        if (req.role == role) {
            console.log(`${role} role granted`)
            next()
        } else {
            res.status(401).send({ result: 'error', message: `No ${role} permission granted` })
        }
    }
}

module.exports = { checkRole }

Najpierw używam oprogramowania pośredniego uwierzytelniania, aby wiedzieć, czy jest prawidłowym użytkownikiem, a następnie oprogramowania pośredniczącego roli, aby wiedzieć, czy użytkownik ma dostęp do trasy interfejsu API

// router.js

router.post('/v1/something-protected', requireAuth, checkRole('commercial'), (req, res) => {
    // do what you want...
})

Mam nadzieję, że będę przydatny

— jarraga
źródło