Le meilleur moyen de vérifier la mangouste erreur de validation

Techniquement, vous devez d'abord vérifier l'erreur de nom parce que pas toutes les erreurs sont traitées de la même manière. Ensuite, en fonction de l'erreur de nom, vous devez vérifier des propriétés particulières, comme les erreurs de la propriété qui vient avec une ValidationError.

Également vous mettre le nom du champ dans le type d'erreur et c'est redondant, il est préférable d'utiliser le même type d'erreur car dans la vérification des erreurs de procédure vous permettra d'obtenir le nom du champ également.

De sorte que votre code peut être quelque chose comme:

User.schema.path('email').validate(function(value, respond) {
  User.findOne({email: value}, function(err, user) {
    if(err) throw err;
    if(user) return respond(false);
    respond(true);
  });
}, 'exists');

User.schema.path('username').validate(function(value, respond) {
  User.findOne({username: value}, function(err, user) {
    if(err) throw err;
    if(user) return respond(false);
    respond(true);
  });
}, 'exists');

Et puis, la vérification des erreurs de procédure:

if (err) {
  switch (err.name) {
    case 'ValidationError':
      for (field in err.errors) {
        switch (err.errors[field].type) {
          case 'exists':
            ...
            break;
          case 'invalid':
            ...
            break;
          ...
        }
      }
      break;
    default:
      ...
  }
}

Si vous voulez raccourcir, vous avez différentes options. Si vous avez seulement un type de validation, vous pouvez le faire comme ceci:

if (err) {
  if (err.name == 'ValidationError') {
    for (field in err.errors) {
      ...
    }
  } else {
    //A general error (db, crypto, etc…)
    ...
  }
}

L'expression minimale de l'erreur, vérifiez la procédure serait semblable à ce que vous avez écrit dans votre post:

if (err) {
  for (field in err.errors) {
    ...
  }
}

Cela fonctionne parce que si des erreurs n'est pas défini, il va simplement ignorer le pour. Mais vous êtes ignorant tous les autres types d'erreur ici.

Je pense aussi que ces erreurs mises en page sont un peu la pagaille, mais ne vous attendez pas pour que cela change dans un avenir proche.

- Je utiliser AngularJS, donc ngRepeat affiche mes erreurs de validation sur le formulaire web. Tout ce que je dois faire est de retourner un tableau de messages d'erreur.

Parfois Mangouste lèvera une erreur qui n'est PAS une erreur de validation, et dans ce cas, l'err.les erreurs de l'objet ne seront pas présents. I journal l'erreur d'exécution. J'utilise toujours le même endroit sur le formulaire web pour afficher l'exécution d'erreur à l'utilisateur.

var makeMongooseErrorMsgArray = function(err){
    var msgArray = [];
    if (err.errors) { //validation errors
        $.each(err.errors, function (key, val) {
            msgArray.push(val.message);
        });
    } else if (err.message){ //should be execution error without err.errors
        errLogr.log(err); //log execution errors
        msgArray.push(err.message);
    } else {
        msgArray.push('Unknown error');
    }
    return msgArray;
}

Par la lecture de toutes ces réponses, je considère que c'est le meilleur pour créer la fonction d'utilité et la réutilisation en tant que tel:

C'est la fonction qui gère ValidationError par l'envoi de la réponse souhaitée pour le client avec les messages de validation, et éventuellement console.log pour afficher les messages dans la console.

function handleValidationError(err, res, consoleLog = false){
  const messages = []
  for (let field in err.errors) {
    messages.push(err.errors[field].message)
    consoleLog && console.log(err.errors[field].message)
  }
  res.status(422).json({ messages })
}

Ensuite au contrôleur où nous voulons gérer l'erreur, nous vérifions si err.name est ValidationError, et, dans l'affirmative, nous utilisons la fonction d'utilité à partir de ci-dessus.

user.save((err) => {
  if (err) {
    if (err.name === 'ValidationError') return handleValidationError(err, res) //here
    return res.status(500).json({ message: 'Error while creating new user' })
  }
  return res.status(201).json({ message: 'User created' })
})

Puis client d'obtenir la validation des erreurs de réponse en tant que telle:

curl\
-H 'Content-Type: application/json'\
-d '{"email": "foo", "password": "barbaz"}'\
http://localhost:3000/user/new

De sortie:

{"messages":["Email validation failure"]}

Ici mon unique moyen de gérer la mangouste erreur de validation

Le code est toujours en cours, une fois prêt, je vais le mettre à jour, ou vous pouvez contribuer étend mon code.

let message = "";
let title = "Validation Error";
let code = 400;
let requiredFields = [];
for (let field in err.errors) {
    let subMsg = ""
    if (err.errors[field].kind === "required") {
        requiredFields.push(field)
    }
}
if (requiredFields.length > 0) {
    message = "Following fields are required: " + requiredFields.join(", ");
} else {
    message = "Unknown";
}
res.status(code).json({
    status: code,
    message: message,
    title: title
});