Mongoose Validation Error Message Handler

is responsilbe transfroming mongoose validation error into generic form.

Install

npm i mongoose-validation-error-message-handler

Usages

Example 1 simple

const mongoose = require('mongoose');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

const schema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
});

const model = mongoose.model('person', schema);

const object = new model({});
object.save(function (err, doc) {
  if (err) {
    const error = mongooseErrorHandler(err);
    console.log(error);
    /**
     * Error [MongooseValidatorError]: "name" is required
     * message: "name" is required
     * name: 'MongooseValidatorError',
     * path: 'name',
     * kind: 'required',
     * value: undefined
     */
  }
});

Example 2 custom messages

const mongoose = require('mongoose');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

const schema = new mongoose.Schema({
  name: {
    type: String,
  },
});

const model = mongoose.model('person', schema);

const object = new model({ name: {} });
object.save(function (err, doc) {
  if (err) {
    const error = mongooseErrorHandler(err, {
      messages: {
        string: '{path} must be a string'
      }
    });
    console.log(error);
    /**
     * Error [MongooseValidatorError]: name must be a string
     * message: name must be a string
     * name: 'MongooseValidatorError',
     * path: 'name',
     * kind: 'string',
     * value: {}
     */
  }
});

Example 3 paths origin message

const mongoose = require('mongoose');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

const schema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
});

const model = mongoose.model('person', schema);

const object = new model({});
object.save(function (err, doc) {
  if (err) {
    const error = mongooseErrorHandler(err, {
      paths: {
        name: { origin: true },
        nameX: { origin: true, kind: 'maxlength' },
      }
    });
    console.log(error);
    /**
     * person validation failed: name: Path `name` is required.
     */
  }
});

Example 4 paths custom messages

const mongoose = require('mongoose');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

const schema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
});

const model = mongoose.model('person', schema);

const object = new model({});
object.save(function (err, doc) {
  if (err) {
    const error = mongooseErrorHandler(err, {
      paths: {
        name: { message: 'name is required' },
        nameX: { message: 'name length must be less than or equal to {maxlength} characters long', kind: 'maxlength' },
      }
    });
    console.log(error);
    /**
     * Error [MongooseValidatorError]: name is required
     * name: 'MongooseValidatorError',
     * path: 'name',
     * kind: 'required',
     * value: undefined
     */
  }
});

Example 5 unique

You will need to install package mongoose-unique-validator first.

const mongoose = require('mongoose');
const uniqueValidator = require('mongoose-unique-validator');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

mongoose.Promise = Promise;
mongoose.connect('mongodb://localhost/example', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

mongoose.plugin(uniqueValidator);

const schema = new mongoose.Schema({
  name: {
    type: String,
    unique: true,
  },
});

const model = mongoose.model('person', schema);

const object = new model({ name: 'a' });
object.save(function (err, doc) {
  if (err) {
    const error = mongooseErrorHandler(err);
    console.log(error);
    /**
     * Error [MongooseValidatorError]: "name" already exists
     * name: 'MongooseValidatorError',
     * path: 'name',
     * kind: 'unique',
     * value: "a"
     */
  }
});

Example 6 server express

const express = require('express');
const mongoose = require('mongoose');
const mongooseErrorHandler = require('mongoose-validation-error-message-handler');

mongoose.Promise = Promise;
mongoose.connect('mongodb://localhost/example', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const schema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
});

const model = mongoose.model('person', schema);

const app = express();
app.use(express.json());

app.post('/', async (req, res, next) => {
  try {
    const object = await model.create(req.body);
    res.json(object);
  } catch (error) {
    next(error)
  }
});

// catch 404 and forward to error handler
app.use((req, res, next) => {
  const err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handler
app.use((err, req, res) => {
  let error = mongooseErrorHandler(err);
  if (error.name === 'MongooseValidatorError') {
    error.status = 400;
  }
  res.status(error.status || 500);
  res.json({ message: error.message });
});

app.listen(3000)

Options

messages

Kind	Properties	Message	SchemaTypeOptions
base	path, value	{path} is invalid
boolean	path, value	{path} must be a boolean	type
buffer	path, value	{path} must be a buffer	type
date	path, value	{path} must be a date	type
date.max	path, value, max	{path} must be less than or equal to {max}	max
date.min	path, value, min	{path} must be greater than or equal to {min}	min
enum	path, value, enumValues	{path} is invalid	enum
maxlength	path, value, maxlength	{path} length must be less than or equal to {maxlength} characters long	maxlength
minlength	path, value, minlength	{path} length must be at least {minlength} characters long	minlength
map	path, value	{path} must be a Map	type
number	path, value	{path} must be a number	type
number.max	path, value, max	{path} must be greater than or equal to {max}	max
number.min	path, value, min	{path} must be less than or equal to {min}	min
objectId	path, value	{path} must be a objectId	type
regexp	path, value, regexp	{path} format is invalid	match
required	path, value	{path} is required	required
string	path, value	{path} must be a string	type
unique	path, value	"{path}" already exists	unique
validate	path, value, enumValues	{path} is invalid	validate

paths

path: String

• original: Boolean,
• kind: String,
• message: String