code version 1.1.0

Author: AnechaS

.eslintrc.json

@@ -0,0 +1,35 @@
+{
+  "root": true,
+  "env": {
+    "commonjs": true,
+    "es6": true,
+    "node": true,
+    "jest": true
+  },
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "modules": true,
+      "experimentalObjectRestSpread": true
+    }
+  },
+  "rules": {
+    "indent": ["error", 2, { "SwitchCase": 1 }],
+    "semi": ["error", "always"],
+    "quotes": ["error", "single", { "avoidEscape": true }],
+    "no-var": "error",
+    "no-unused-vars": ["error", { "argsIgnorePattern": "next" }],
+    "no-console": ["error"],
+    "func-style": ["error", "declaration", { "allowArrowFunctions": true }],
+    "object-curly-spacing": ["error", "always"],
+    "comma-spacing": ["error", { "before": false, "after": true }],
+    "key-spacing": ["error", { "beforeColon": false }],
+    "no-constant-condition": ["error", { "checkLoops": false }],
+    "quote-props": ["error", "as-needed"],
+    "no-prototype-builtins": [0],
+    "require-atomic-updates": [0]
+  },
+  "ignorePatterns": ["example"]
+}

.gitignore

@@ -1,2 +1 @@
-globalConfig.json
 node_modules

README.md

@@ -1,16 +1,269 @@
 # Mongoose Validation Failed Handler
 
-## Usage
+## Install
 
-```javascripts
+```bash
+npm i mongoose-validation-error-message-handler
+```
+
+## Usages
+
+### Example 1 simple
+
+```javascript
+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({ name: 'a' });
+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: 'unique',
+     * value: "a"
+     */
+  }
+});
+```
+
+### Example 2 custom messages
+
+```javascript
+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
+
+```javascript
+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, {
+      path: {
+        name: { origin: true },
+        nameX: { origin: true, kind: 'maxlength' },
+      }
+    });
+    console.log(error);
+    /**
+     * person validation failed: name: Path `name` is required.
+     */
+  }
+});
+```
+
+### Example 4 paths custom messages
+
+```javascript
+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, {
+      path: {
+        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.
+
+```javascript
+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" is already exists
+     * name: 'MongooseValidatorError',
+     * path: 'name',
+     * kind: 'unique',
+     * value: "a"
+     */
+  }
+});
+```
+
+### Example 6 server express
+
+```javascript
+const express = require('express');
+const mongoose = require('mongoose');
 const mongooseErrorHandler = require('mongoose-validation-error-message-handler');
 
-const error = mongooseErrorHandler(mongoose.Error.ValidationError, {
-    messages: {
-      [kind]: String
-    },
-    paths: {
-      [path]: Object
-    }
+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 convertedError = mongooseErrorHandler(err);
+  res.status(convertedError.status || 500);
+  res.json({ message: convertedError.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 | email '[email protected]' already exists. | unique |
+| validate | `path`, `value`, `enumValues` | {path} is invalid | validate |
+
+### paths
+
+`path`: String
+- `original`: Boolean, 
+- `kind`: String, 
+- `message`: String

example/custom-messages.js

@@ -0,0 +1,48 @@
+const mongoose = require('mongoose');
+const mongooseErrorHandler = require('../');
+
+const schema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+  },
+});
+
+const model = mongoose.model('person', schema);
+
+const messages = {
+  base: '{path} is invalid',
+  required: '{path} is required',
+  enum: '{path} is invalid',
+  validate: '{path} is invalid',
+  unique: '{path} is already exists',
+  boolean: '{path} must be a boolean',
+  buffer: '{path} must be a buffer',
+  objectId: '{path} must be a objectId',
+  map: '{path} must be a Map',
+  string: '{path} must be a string',
+  maxlength: '{path} length must be less than or equal to {maxlength} characters long',
+  minlength: '{path} length must be at least {minlength} characters long',
+  regexp: '{path} format is invalid',
+  number: '{path} must be a number',
+  'number.max': '{path} must be greater than or equal to {max}',
+  'number.min': '{path} must be less than or equal to {min}',
+  date: '{path} must be a date',
+  'date.max': '{path} must be less than or equal to {max}',
+  'date.min': '{path} must be greater than or equal to {min}',
+}
+
+const object = new model({});
+object.save(function (err, doc) {
+  if (err) {
+    const error = mongooseErrorHandler(err, { messages });
+    console.log(error);
+    /**
+     * Error [MongooseValidatorError]: name is required
+     * name: 'MongooseValidatorError',
+     * path: 'name',
+     * kind: 'required',
+     * value: undefined
+     */
+  }
+});