mongoose 5.2.6 → 5.2.7

package/.travis.yml

@@ -16,6 +16,6 @@ before_script:
   - ./mongodb-linux-x86_64-3.6.4/bin/mongod --fork --nopreallocj --dbpath ./data/db/27017 --syslog --port 27017
 script:
   - npm test
-  - npm run lint
+  - node tools/checkNodeVersion.js "4.x || 5.x" || npm run lint
 notifications:
   email: false

package/History.md

@@ -1,3 +1,20 @@
+5.2.7 / 2018-08-06
+==================
+ * fix(model): check `expireAfterSeconds` option when diffing indexes in syncIndexes() #6820 #6819 [christopherhex](https://github.com/christopherhex)
+ * chore: fix some common test flakes in travis #6816 [Fonger](https://github.com/Fonger)
+ * chore: bump eslint and webpack to avoid bad versions of eslint-scope #6814
+ * test(model): add delay to session tests to improve pass rate #6811 [Fonger](https://github.com/Fonger)
+ * fix(model): support options in `deleteMany` #6810 [Fonger](https://github.com/Fonger)
+ * fix(query): don't use $each when pushing an array into an array #6809 [lineus](https://github.com/lineus)
+ * chore: bump mquery so eslint isn't a prod dependency #6800
+ * fix(populate): correctly get schema type when calling `populate()` on already populated path #6798
+ * fix(populate): propagate readConcern options in populate from parent query #6792 #6785 [Fonger](https://github.com/Fonger)
+ * docs(connection): add description of useNewUrlParser option #6789
+ * fix(query): make select('+path') a no-op if no select prop in schema #6785
+ * docs(schematype+validation): document using function syntax for custom validator message #6772
+ * fix(update): throw CastError if updating with `$inc: null` #6770
+ * fix(connection): throw helpful error when calling `createConnection(undefined)` #6763
+
 5.2.6 / 2018-07-30
 ==================
  * fix(document): don't double-call deeply nested custom getters when using `get()` #6779 #6637

package/lib/cast/number.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const CastError = require('../error/cast');
+
+/*!
+ * Given a value, cast it to a number, or throw a `CastError` if the value
+ * cannot be casted. `null` and `undefined` are considered valid.
+ *
+ * @param {Any} value
+ * @param {String} [path] optional the path to set on the CastError
+ * @return {Boolean|null|undefined}
+ * @throws {CastError} if `value` is not one of the allowed values
+ * @api private
+ */
+
+module.exports = function castNumber(val, path) {
+  if (isNaN(val)) {
+    throw new CastError('number', val, path);
+  }
+
+  if (val == null) {
+    return val;
+  }
+  if (val === '') {
+    return null;
+  }
+
+  if (typeof val === 'string' || typeof val === 'boolean') {
+    val = Number(val);
+  }
+
+  if (isNaN(val)) {
+    throw new CastError('number', val, path);
+  }
+  if (val instanceof Number) {
+    return val;
+  }
+  if (typeof val === 'number') {
+    return val;
+  }
+  if (!Array.isArray(val) && typeof val.valueOf === 'function') {
+    return Number(val.valueOf());
+  }
+  if (val.toString && !Array.isArray(val) && val.toString() == Number(val)) {
+    return new Number(val);
+  }
+
+  throw new CastError('number', val, path);
+};

package/lib/connection.js

@@ -420,6 +420,12 @@ Connection.prototype.openUri = function(uri, options, callback) {
       'http://mongoosejs.com/docs/connections.html for supported connection syntax');
   }
 
+  if (typeof uri !== 'string') {
+    throw new MongooseError('The `uri` parameter to `openUri()` must be a ' +
+      `string, got "${typeof uri}". Make sure the first parameter to ` +
+      '`mongoose.connect()` or `mongoose.createConnection()` is a string.');
+  }
+
   const Promise = PromiseProvider.get();
   const _this = this;
 

package/lib/helpers/populate/getSchemaTypes.js

@@ -4,8 +4,9 @@
  * ignore
  */
 
-var Mixed = require('../../schema/mixed');
-var mpath = require('mpath');
+const Mixed = require('../../schema/mixed');
+const get = require('lodash.get');
+const mpath = require('mpath');
 
 /*!
  * @param {Schema} schema
@@ -28,79 +29,96 @@ module.exports = function getSchemaTypes(schema, doc, path) {
     while (p--) {
       trypath = parts.slice(0, p).join('.');
       foundschema = schema.path(trypath);
-      if (foundschema) {
-        if (foundschema.caster) {
-          // array of Mixed?
-          if (foundschema.caster instanceof Mixed) {
-            return foundschema.caster;
-          }
 
-          let schemas = null;
-          if (doc != null && foundschema.schema != null && foundschema.schema.discriminators != null) {
-            const discriminators = foundschema.schema.discriminators;
-            const discriminatorKeyPath = trypath + '.' +
-              foundschema.schema.options.discriminatorKey;
-            const keys = mpath.get(discriminatorKeyPath, subdoc) || [];
-            schemas = Object.keys(discriminators).
-              reduce(function(cur, discriminator) {
-                if (keys.indexOf(discriminator) !== -1) {
-                  cur.push(discriminators[discriminator]);
-                }
-                return cur;
-              }, []);
-          }
+      if (foundschema == null) {
+        continue;
+      }
 
-          // Now that we found the array, we need to check if there
-          // are remaining document paths to look up for casting.
-          // Also we need to handle array.$.path since schema.path
-          // doesn't work for that.
-          // If there is no foundschema.schema we are dealing with
-          // a path like array.$
-          if (p !== parts.length && foundschema.schema) {
-            let ret;
-            if (parts[p] === '$') {
-              if (p + 1 === parts.length) {
-                // comments.$
-                return foundschema;
-              }
-              // comments.$.comments.$.title
-              ret = search(parts.slice(p + 1), schema, mpath.get(trypath, subdoc));
-              if (ret) {
-                ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                  !foundschema.schema.$isSingleNested;
-              }
-              return ret;
-            }
+      if (foundschema.caster) {
+        // array of Mixed?
+        if (foundschema.caster instanceof Mixed) {
+          return foundschema.caster;
+        }
 
-            if (schemas != null && schemas.length > 0) {
-              ret = [];
-              for (var i = 0; i < schemas.length; ++i) {
-                let _ret = search(parts.slice(p), schemas[i], mpath.get(trypath, subdoc));
-                if (_ret != null) {
-                  _ret.$isUnderneathDocArray = _ret.$isUnderneathDocArray ||
-                    !foundschema.schema.$isSingleNested;
-                  if (_ret.$isUnderneathDocArray) {
-                    ret.$isUnderneathDocArray = true;
-                  }
-                  ret.push(_ret);
-                }
+        let schemas = null;
+        if (doc != null && foundschema.schema != null && foundschema.schema.discriminators != null) {
+          const discriminators = foundschema.schema.discriminators;
+          const discriminatorKeyPath = trypath + '.' +
+            foundschema.schema.options.discriminatorKey;
+          const keys = mpath.get(discriminatorKeyPath, subdoc) || [];
+          schemas = Object.keys(discriminators).
+            reduce(function(cur, discriminator) {
+              if (keys.indexOf(discriminator) !== -1) {
+                cur.push(discriminators[discriminator]);
               }
-              return ret;
-            } else {
-              ret = search(parts.slice(p), foundschema.schema, mpath.get(trypath, subdoc));
+              return cur;
+            }, []);
+        }
+
+        // Now that we found the array, we need to check if there
+        // are remaining document paths to look up for casting.
+        // Also we need to handle array.$.path since schema.path
+        // doesn't work for that.
+        // If there is no foundschema.schema we are dealing with
+        // a path like array.$
+        if (p !== parts.length && foundschema.schema) {
+          let ret;
+          if (parts[p] === '$') {
+            if (p + 1 === parts.length) {
+              // comments.$
+              return foundschema;
+            }
+            // comments.$.comments.$.title
+            ret = search(parts.slice(p + 1), schema, mpath.get(trypath, subdoc));
+            if (ret) {
+              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+                !foundschema.schema.$isSingleNested;
+            }
+            return ret;
+          }
 
-              if (ret) {
-                ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+          if (schemas != null && schemas.length > 0) {
+            ret = [];
+            for (var i = 0; i < schemas.length; ++i) {
+              let _ret = search(parts.slice(p), schemas[i], mpath.get(trypath, subdoc));
+              if (_ret != null) {
+                _ret.$isUnderneathDocArray = _ret.$isUnderneathDocArray ||
                   !foundschema.schema.$isSingleNested;
+                if (_ret.$isUnderneathDocArray) {
+                  ret.$isUnderneathDocArray = true;
+                }
+                ret.push(_ret);
               }
+            }
+            return ret;
+          } else {
+            ret = search(parts.slice(p), foundschema.schema, mpath.get(trypath, subdoc));
 
-              return ret;
+            if (ret) {
+              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+                !foundschema.schema.$isSingleNested;
             }
+
+            return ret;
           }
         }
+      }
+
+      if (doc.$__ && doc.populated(trypath)) {
+        const schema = get(doc.$__.populated[trypath], 'options.model.schema');
+        if (schema != null) {
+          const ret = search(parts.slice(p), schema, mpath.get(trypath, subdoc));
+
+          if (ret) {
+            ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+              !schema.$isSingleNested;
+          }
 
-        return foundschema;
+          return ret;
+        }
       }
+
+      return foundschema;
     }
   }
 

package/lib/helpers/query/castUpdate.js

@@ -1,7 +1,9 @@
 'use strict';
 
+const CastError = require('../../error/cast');
 const StrictModeError = require('../../error/strict');
 const ValidationError = require('../../error/validation');
+const castNumber = require('../../cast/number');
 const getEmbeddedDiscriminatorPath = require('./getEmbeddedDiscriminatorPath');
 const utils = require('../../utils');
 
@@ -136,7 +138,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
           hasKeys = true;
           try {
             obj[key] = {
-              $each: castUpdateVal(schematype, val.$each, op, context)
+              $each: castUpdateVal(schematype, val.$each, op, context, prefix + key)
             };
           } catch (error) {
             aggregatedError = _handleCastError(error, context, key, aggregatedError);
@@ -155,7 +157,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
           }
         } else {
           try {
-            obj[key] = castUpdateVal(schematype, val, op, context);
+            obj[key] = castUpdateVal(schematype, val, op, context, prefix + key);
           } catch (error) {
             aggregatedError = _handleCastError(error, context, key, aggregatedError);
           }
@@ -170,7 +172,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
       } else if ((op === '$currentDate') || (op in castOps && schematype)) {
         // $currentDate can take an object
         try {
-          obj[key] = castUpdateVal(schematype, val, op, context);
+          obj[key] = castUpdateVal(schematype, val, op, context, prefix + key);
         } catch (error) {
           aggregatedError = _handleCastError(error, context, key, aggregatedError);
         }
@@ -249,13 +251,15 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
         }
 
         try {
-          obj[key] = castUpdateVal(schematype, val, op, key, context);
+          obj[key] = castUpdateVal(schematype, val, op, key, context, prefix + key);
         } catch (error) {
           aggregatedError = _handleCastError(error, context, key, aggregatedError);
         }
 
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
-          obj[key] = { $each: obj[key] };
+          if (schematype.caster && !schematype.caster.$isMongooseArray) {
+            obj[key] = { $each: obj[key] };
+          }
         }
 
         if (options.omitUndefined && obj[key] === void 0) {
@@ -295,10 +299,17 @@ function _handleCastError(error, query, key, aggregatedError) {
 
 var numberOps = {
   $pop: 1,
-  $unset: 1,
   $inc: 1
 };
 
+/*!
+ * These ops require no casting because the RHS doesn't do anything.
+ */
+
+const noCastOps = {
+  $unset: 1
+};
+
 /*!
  * These operators require casting docs
  * to real Documents for Update operations.
@@ -331,12 +342,12 @@ var overwriteOps = {
  * @api private
  */
 
-function castUpdateVal(schema, val, op, $conditional, context) {
+function castUpdateVal(schema, val, op, $conditional, context, path) {
   if (!schema) {
     // non-existing schema path
-    return op in numberOps
-      ? Number(val)
-      : val;
+    return op in numberOps ?
+      castNumber(val, path) :
+      val;
   }
 
   var cond = schema.caster && op in castOps &&
@@ -357,11 +368,22 @@ function castUpdateVal(schema, val, op, $conditional, context) {
     return schema.cast(val);
   }
 
+  if (op in noCastOps) {
+    return val;
+  }
   if (op in numberOps) {
+    // Null and undefined not allowed for $pop, $inc
+    if (val == null) {
+      throw new CastError('number', val, schema.path);
+    }
     if (op === '$inc') {
-      return schema.castForQueryWrapper({ val: val, context: context });
+      // Support `$inc` with long, int32, etc. (gh-4283)
+      return schema.castForQueryWrapper({
+        val: val,
+        context: context
+      });
     }
-    return Number(val);
+    return castNumber(val, schema.path);
   }
   if (op === '$currentDate') {
     if (typeof val === 'object') {

package/lib/model.js

@@ -1044,7 +1044,7 @@ Model.syncIndexes = function syncIndexes(options, callback) {
             utils.clone(schemaIndex[1]));
 
           // If these options are different, need to rebuild the index
-          const optionKeys = ['unique', 'partialFilterExpression', 'sparse'];
+          const optionKeys = ['unique', 'partialFilterExpression', 'sparse', 'expireAfterSeconds'];
           const indexCopy = Object.assign({}, index);
           for (const key of optionKeys) {
             if (!(key in options) && !(key in indexCopy)) {
@@ -1480,19 +1480,26 @@ Model.deleteOne = function deleteOne(conditions, callback) {
  * Like `Model.remove()`, this function does **not** trigger `pre('remove')` or `post('remove')` hooks.
  *
  * @param {Object} conditions
+ * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Function} [callback]
  * @return {Query}
  * @api public
  */
 
-Model.deleteMany = function deleteMany(conditions, callback) {
+Model.deleteMany = function deleteMany(conditions, options, callback) {
   if (typeof conditions === 'function') {
     callback = conditions;
     conditions = {};
+    options = null;
+  }
+  else if (typeof options === 'function') {
+    callback = options;
+    options = null;
   }
 
   // get the mongodb collection object
   var mq = new this.Query(conditions, {}, this, this.collection);
+  mq.setOptions(options);
 
   if (callback) {
     callback = this.$wrapCallback(callback);
@@ -2503,10 +2510,17 @@ Model.create = function create(doc, options, callback) {
  * This function does **not** trigger any middleware. In particular, it
  * does **not** trigger aggregate middleware.
  *
+ * The ChangeStream object is an event emitter that emits the following events:
+ *
+ * - 'change': A change occurred, see below example
+ * - 'error': An unrecoverable error occurred. In particular, change streams currently error out if they lose connection to the replica set primary. Follow [this GitHub issue](https://github.com/Automattic/mongoose/issues/6799) for updates.
+ * - 'end': Emitted if the underlying stream is closed
+ * - 'close': Emitted if the underlying stream is closed
+ *
  * ####Example:
  *
  *     const doc = await Person.create({ name: 'Ned Stark' });
- *     Person.watch().on('change', change => console.log(change));
+ *     const changeStream = Person.watch().on('change', change => console.log(change));
  *     // Will print from the above `console.log()`:
  *     // { _id: { _data: ... },
  *     //   operationType: 'delete',
@@ -3872,10 +3886,10 @@ function getModelsMapForPopulate(model, docs, options) {
   let discriminatorKey;
   let modelForFindSchema;
 
-  var originalModel = options.model;
-  var isVirtual = false;
-  var isRefPathArray = false;
-  var modelSchema = model.schema;
+  let originalModel = options.model;
+  let isVirtual = false;
+  let isRefPathArray = false;
+  const modelSchema = model.schema;
 
   for (i = 0; i < len; i++) {
     doc = docs[i];

package/lib/query.js

@@ -844,13 +844,20 @@ Query.prototype.mod = function() {
  *     // exclude c and d, include other fields
  *     query.select('-c -d');
  *
+ *     // Use `+` to override schema-level `select: false` without making the
+ *     // projection inclusive.
+ *     const schema = new Schema({
+ *       foo: { type: String, select: false },
+ *       bar: String
+ *     });
+ *     // ...
+ *     query.select('+foo'); // Override foo's `select: false` without excluding `bar`
+ *
  *     // or you may use object notation, useful when
  *     // you have keys already prefixed with a "-"
  *     query.select({ a: 1, b: 1 });
  *     query.select({ c: 0, d: 0 });
  *
- *     // force inclusion of field excluded at schema level
- *     query.select('+path')
  *
  * @method select
  * @memberOf Query
@@ -3736,11 +3743,17 @@ Query.prototype.populate = function() {
 
   const res = utils.populate.apply(null, arguments);
 
-  // Propagate readPreference and lean from parent query, unless one already
-  // specified
+  // Propagate readConcern and readPreference and lean from parent query,
+  // unless one already specified
   if (this.options != null) {
+    const readConcern = this.options.readConcern;
     const readPref = this.options.readPreference;
+
     for (let i = 0; i < res.length; ++i) {
+      if (readConcern != null && get(res[i], 'options.readConcern') == null) {
+        res[i].options = res[i].options || {};
+        res[i].options.readConcern = readConcern;
+      }
       if (readPref != null && get(res[i], 'options.readPreference') == null) {
         res[i].options = res[i].options || {};
         res[i].options.readPreference = readPref;

package/lib/queryhelpers.js

@@ -188,10 +188,16 @@ exports.applyPaths = function applyPaths(fields, schema) {
   let stack = [];
 
   let analyzePath = function(path, type) {
+    var plusPath = '+' + path;
+    var hasPlusPath = fields && plusPath in fields;
+    if (hasPlusPath) {
+      // forced inclusion
+      delete fields[plusPath];
+    }
+
     if (typeof type.selected !== 'boolean') return;
 
-    var plusPath = '+' + path;
-    if (fields && plusPath in fields) {
+    if (hasPlusPath) {
       // forced inclusion
       delete fields[plusPath];
 

package/lib/schema/number.js

@@ -1,13 +1,17 @@
+'use strict';
+
 /*!
  * Module requirements.
  */
 
-var SchemaType = require('../schematype');
-var CastError = SchemaType.CastError;
-var handleBitwiseOperator = require('./operators/bitwise');
-var MongooseError = require('../error');
-var utils = require('../utils');
-var Document;
+const MongooseError = require('../error');
+const SchemaType = require('../schematype');
+const castNumber = require('../cast/number');
+const handleBitwiseOperator = require('./operators/bitwise');
+const utils = require('../utils');
+
+const CastError = SchemaType.CastError;
+let Document;
 
 /**
  * Number SchemaType constructor.
@@ -207,31 +211,7 @@ SchemaNumber.prototype.cast = function(value, doc, init) {
     value._id : // documents
     value;
 
-  if (!isNaN(val)) {
-    if (val === null) {
-      return val;
-    }
-    if (val === '') {
-      return null;
-    }
-    if (typeof val === 'string' || typeof val === 'boolean') {
-      val = Number(val);
-    }
-    if (val instanceof Number) {
-      return val;
-    }
-    if (typeof val === 'number') {
-      return val;
-    }
-    if (!Array.isArray(val) && typeof val.valueOf === 'function') {
-      return Number(val.valueOf());
-    }
-    if (val.toString && !Array.isArray(val) && val.toString() == Number(val)) {
-      return new Number(val);
-    }
-  }
-
-  throw new CastError('number', value, this.path);
+  return castNumber(val, this.path);
 };
 
 /*!

package/lib/schematype.js

@@ -414,7 +414,9 @@ SchemaType.prototype.get = function(fn) {
 /**
  * Adds validator(s) for this document path.
  *
- * Validators always receive the value to validate as their first argument and must return `Boolean`. Returning `false` means validation failed.
+ * Validators always receive the value to validate as their first argument and
+ * must return `Boolean`. Returning `false` or throwing an error means
+ * validation failed.
  *
  * The error message argument is optional. If not passed, the [default generic error message template](#error_messages_MongooseError-messages) will be used.
  *
@@ -446,24 +448,35 @@ SchemaType.prototype.get = function(fn) {
  *
  * ####Error message templates:
  *
- * From the examples above, you may have noticed that error messages support basic templating. There are a few other template keywords besides `{PATH}` and `{VALUE}` too. To find out more, details are available [here](#error_messages_MongooseError.messages)
+ * From the examples above, you may have noticed that error messages support
+ * basic templating. There are a few other template keywords besides `{PATH}`
+ * and `{VALUE}` too. To find out more, details are available
+ * [here](#error_messages_MongooseError.messages).
  *
- * ####Asynchronous validation:
+ * If Mongoose's built-in error message templating isn't enough, Mongoose
+ * supports setting the `message` property to a function.
  *
- * Passing a validator function that receives two arguments tells mongoose that the validator is an asynchronous validator. The first argument passed to the validator function is the value being validated. The second argument is a callback function that must called when you finish validating the value and passed either `true` or `false` to communicate either success or failure respectively.
+ *     schema.path('name').validate({
+ *       validator: v => v.length > 5,
+ *       // `errors['name']` will be "name must have length > 5, got 'foo'"
+ *       message: props => `${props.path} must have length > 5, got '${props.value}'`
+ *     });
+ *
+ * To bypass Mongoose's error messages and just copy the error message that
+ * the validator throws, do this:
  *
  *     schema.path('name').validate({
- *       isAsync: true,
- *       validator: function (value, respond) {
- *         doStuff(value, function () {
- *           ...
- *           respond(false); // validation failed
- *         });
- *       },
- *       message: 'Custom error message!' // Optional
+ *       validator: () => { throw new Error('Oops!'); },
+ *       // `errors['name']` will be "Oops!"
+ *       message: props => props.reason.message
  *     });
  *
- *     // Can also return a promise
+ * ####Asynchronous validation:
+ *
+ * Mongoose supports validators that return a promise. A validator that returns
+ * a promise is called an _async validator_. Async validators run in
+ * parallel, and `validate()` will wait until all async validators have settled.
+ *
  *     schema.path('name').validate({
  *       validator: function (value) {
  *         return new Promise(function (resolve, reject) {
@@ -485,13 +498,14 @@ SchemaType.prototype.get = function(fn) {
  *     var dvd = new Product(..);
  *     dvd.save(); // emits error on the `conn` above
  *
- * If you desire handling these errors at the Model level, attach an `error` listener to your Model and the event will instead be emitted there.
+ * If you want to handle these errors at the Model level, add an `error`
+ * listener to your Model as shown below.
  *
  *     // registering an error listener on the Model lets us handle errors more locally
  *     Product.on('error', handleError);
  *
  * @param {RegExp|Function|Object} obj validator
- * @param {String} [errorMsg] optional error message
+ * @param {String|Function} [errorMsg] optional error message. If function, should return the error message as a string
  * @param {String} [type] optional validator type
  * @return {SchemaType} this
  * @api public
@@ -836,7 +850,7 @@ SchemaType.prototype.doValidate = function(value, fn, scope) {
         asyncValidate(validator, scope, value, validatorProperties, validate);
       } else {
         try {
-          ok = validator.call(scope, value);
+          ok = validator.call(scope, value, validatorProperties);
         } catch (error) {
           ok = false;
           validatorProperties.reason = error;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.2.6",
+  "version": "5.2.7",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -27,7 +27,7 @@
     "mongodb-core": "3.1.0",
     "mongoose-legacy-pluralize": "1.0.2",
     "mpath": "0.4.1",
-    "mquery": "3.1.1",
+    "mquery": "3.1.2",
     "ms": "2.0.0",
     "regexp-clone": "0.0.1",
     "sliced": "1.0.1"
@@ -41,7 +41,7 @@
     "bluebird": "3.5.0",
     "co": "4.6.0",
     "dox": "0.3.1",
-    "eslint": "4.14.0",
+    "eslint": "5.3.0",
     "highlight.js": "9.1.0",
     "jade": "1.11.0",
     "lodash": "4.17.5",
@@ -58,14 +58,13 @@
     "tbd": "0.6.4",
     "uuid": "2.0.3",
     "uuid-parse": "1.0.0",
-    "webpack": "4.12.0",
+    "webpack": "4.16.4",
     "validator": "5.4.0"
   },
   "directories": {
     "lib": "./lib/mongoose"
   },
   "scripts": {
-    "fix-lint": "eslint . --fix",
     "lint": "eslint . --quiet",
     "release": "git pull && git push origin master --tags && npm publish",
     "release-legacy": "git pull origin 4.x && git push origin 4.x --tags && npm publish --tag legacy",

package/tools/checkNodeVersion.js

@@ -0,0 +1,7 @@
+const version = process.version;
+const semver = require('semver');
+
+// Gnarly but this helps us avoid running eslint on node v4.
+if (!semver.satisfies(version, process.argv[2])) {
+  throw new Error(`${version} does not satisfy "${process.argv[2]}"`);
+}