Il posto migliore per gestire la convalida dei dati con mangusta ed express

Question

Forse non c'è una risposta definitiva qui ma vorrei sapere dove gestire la convalida dei dati quando si tratta di express.js e mangusta. Quale dei seguenti è la migliore pratica (Attualmente uso una combinazione e sta iniziando a sentire molto goffo):

1. Modello (mangusta)
2. Controller/Via (esprimono)

Alcuni post più vecchi che ho letto sono:

• this;
• this;
• and, this;

ma le risposte contrastanti aggiungono solo confusione. Forse semplicemente non è chiaro, nel qual caso è una soluzione migliore?

Answer 1

Quando si utilizza mangusta, spingere la maggior parte di della mia logica di convalida nel modello/schema di mangusta . È possibile utilizzare mongoose-validator che è solo un wrapper attorno a validatore di nodi per la convalida del modello semplice. Se è necessaria la convalida con altri modelli o una logica più complessa nella convalida, è possibile scrivere il proprio mandrino pre validare o post validare (see mongoose middleware).

Un ulteriore vantaggio che si ottiene quando si utilizza mangusta per convalidare il modello è che mangusta aggiunge una proprietà di errore al modello a cui è possibile accedere tramite model.errors[property]. Questa proprietà può essere utilizzata per i messaggi di errore di convalida sul Web o per un client di servizio.

Quando si scrive un software più complesso/molto complesso che lega la convalida al modello può diventare un problema. Ma mi occuperei di questo problema quando si presenterà. Poiché JavaScript ha funzioni di cittadini di prima classe, le tue funzioni di convalida possono ancora essere riutilizzate anche in queste situazioni complesse.

Answer 2

Il validatore mangusta è un ottimo posto per iniziare su un livello di modello, ma se è necessario disporre di convalida controller specifico, io uso il seguente codice in un file utils.js:

var async = require('async') 
exports.validator = function (reqProps, props, mongoEnt, next) { 
    var propsErr = []; 
    var mongoErr = {}; 

    async.parallel([function (cb) { 
     reqProps.forEach(function (rp) { 
      if (!props[rp])propsErr.push(rp); 
     }) 
     cb() 
    }, function (cb) { 
     if (mongoEnt != null) { 
      var test = new mongoEnt(props); 

      test.validate(function (err) { 
       mongoErr = err; 
       cb(); 
      }); 
     } else { 
      mongoErr = null; 
      cb(); 
     } 
    }], function (err, result) { 
     if (propsErr.length != 0) { 
       return next(new Error('The following props were not included: ' + propsErr)); 
     } else if(mongoErr != null) { 
       return next(new Error('The following prop was not included: ' +mongoErr.errors[Object.keys(mongoErr.errors).pop()].path)); 
     } else { 
      return next(null); 
     } 
    }) 
} 

Questo mi permette per entrambi convalidare usando il validatore di mangusta e controllare gli oggetti aggiuntivi che includo nella proprietà reqProps in una riga di codice. Anche se questo è solo il controllo delle proprietà richieste, è possibile estenderlo facilmente per il proprio schema di convalida.

Un esempio di utilizzo di questo codice:

var Person = mongoose.model('Person') 

exports.addUSCitizen = function(props, next){ 
    utils.validator(['ssn'], props, Person, function (err) { 
     if(err) return next(err); 
     //do something using props.ssn 
    }) 
}