mongoose 7.3.4 → 7.4.1

package/lib/drivers/node-mongodb-native/connection.js

@@ -5,8 +5,13 @@
 'use strict';
 
 const MongooseConnection = require('../../connection');
+const MongooseError = require('../../error/index');
 const STATES = require('../../connectionstate');
+const mongodb = require('mongodb');
+const pkg = require('../../../package.json');
+const processConnectionOptions = require('../../helpers/processConnectionOptions');
 const setTimeout = require('../../helpers/timers').setTimeout;
+const utils = require('../../utils');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
@@ -121,6 +126,44 @@ NativeConnection.prototype.useDb = function(name, options) {
   return newConn;
 };
 
+/**
+ * Removes the database connection with the given name created with `useDb()`.
+ *
+ * Throws an error if the database connection was not found.
+ *
+ * #### Example:
+ *
+ *     // Connect to `initialdb` first
+ *     const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/initialdb').asPromise();
+ *
+ *     // Creates an un-cached connection to `mydb`
+ *     const db = conn.useDb('mydb');
+ *
+ *     // Closes `db`, and removes `db` from `conn.relatedDbs` and `conn.otherDbs`
+ *     await conn.removeDb('mydb');
+ *
+ * @method removeDb
+ * @memberOf Connection
+ * @param {String} name The database name
+ * @return {Connection} this
+ */
+
+NativeConnection.prototype.removeDb = function removeDb(name) {
+  const dbs = this.otherDbs.filter(db => db.name === name);
+  if (!dbs.length) {
+    throw new MongooseError(`No connections to database "${name}" found`);
+  }
+
+  for (const db of dbs) {
+    db._closeCalled = true;
+    db._destroyCalled = true;
+    db._readyState = STATES.disconnected;
+    db.$wasForceClosed = true;
+  }
+  delete this.relatedDbs[name];
+  this.otherDbs = this.otherDbs.filter(db => db.name !== name);
+};
+
 /**
  * Closes the connection
  *
@@ -154,6 +197,210 @@ NativeConnection.prototype.doClose = async function doClose(force) {
   return this;
 };
 
+/*!
+ * ignore
+ */
+
+NativeConnection.prototype.createClient = async function createClient(uri, options) {
+  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.');
+  }
+
+  if (this._destroyCalled) {
+    throw new MongooseError(
+      'Connection has been closed and destroyed, and cannot be used for re-opening the connection. ' +
+      'Please create a new connection with `mongoose.createConnection()` or `mongoose.connect()`.'
+    );
+  }
+
+  if (this.readyState === STATES.connecting || this.readyState === STATES.connected) {
+    if (this._connectionString !== uri) {
+      throw new MongooseError('Can\'t call `openUri()` on an active connection with ' +
+        'different connection strings. Make sure you aren\'t calling `mongoose.connect()` ' +
+        'multiple times. See: https://mongoosejs.com/docs/connections.html#multiple_connections');
+    }
+  }
+
+  options = processConnectionOptions(uri, options);
+
+  if (options) {
+
+    const autoIndex = options.config && options.config.autoIndex != null ?
+      options.config.autoIndex :
+      options.autoIndex;
+    if (autoIndex != null) {
+      this.config.autoIndex = autoIndex !== false;
+      delete options.config;
+      delete options.autoIndex;
+    }
+
+    if ('autoCreate' in options) {
+      this.config.autoCreate = !!options.autoCreate;
+      delete options.autoCreate;
+    }
+
+    if ('sanitizeFilter' in options) {
+      this.config.sanitizeFilter = options.sanitizeFilter;
+      delete options.sanitizeFilter;
+    }
+
+    // Backwards compat
+    if (options.user || options.pass) {
+      options.auth = options.auth || {};
+      options.auth.username = options.user;
+      options.auth.password = options.pass;
+
+      this.user = options.user;
+      this.pass = options.pass;
+    }
+    delete options.user;
+    delete options.pass;
+
+    if (options.bufferCommands != null) {
+      this.config.bufferCommands = options.bufferCommands;
+      delete options.bufferCommands;
+    }
+  } else {
+    options = {};
+  }
+
+  this._connectionOptions = options;
+  const dbName = options.dbName;
+  if (dbName != null) {
+    this.$dbName = dbName;
+  }
+  delete options.dbName;
+
+  if (!utils.hasUserDefinedProperty(options, 'driverInfo')) {
+    options.driverInfo = {
+      name: 'Mongoose',
+      version: pkg.version
+    };
+  }
+
+  this.readyState = STATES.connecting;
+  this._connectionString = uri;
+
+  let client;
+  try {
+    client = new mongodb.MongoClient(uri, options);
+  } catch (error) {
+    this.readyState = STATES.disconnected;
+    throw error;
+  }
+  this.client = client;
+
+  client.setMaxListeners(0);
+  await client.connect();
+
+  _setClient(this, client, options, dbName);
+
+  for (const db of this.otherDbs) {
+    _setClient(db, client, {}, db.name);
+  }
+  return this;
+};
+
+/*!
+ * ignore
+ */
+
+NativeConnection.prototype.setClient = function setClient(client) {
+  if (!(client instanceof mongodb.MongoClient)) {
+    throw new MongooseError('Must call `setClient()` with an instance of MongoClient');
+  }
+  if (this.readyState !== STATES.disconnected) {
+    throw new MongooseError('Cannot call `setClient()` on a connection that is already connected.');
+  }
+  if (client.topology == null) {
+    throw new MongooseError('Cannot call `setClient()` with a MongoClient that you have not called `connect()` on yet.');
+  }
+
+  this._connectionString = client.s.url;
+  _setClient(this, client, {}, client.s.options.dbName);
+
+  for (const model of Object.values(this.models)) {
+    // Errors handled internally, so safe to ignore error
+    model.init().catch(function $modelInitNoop() {});
+  }
+
+  return this;
+};
+
+/*!
+ * ignore
+ */
+
+function _setClient(conn, client, options, dbName) {
+  const db = dbName != null ? client.db(dbName) : client.db();
+  conn.db = db;
+  conn.client = client;
+  conn.host = client &&
+    client.s &&
+    client.s.options &&
+    client.s.options.hosts &&
+    client.s.options.hosts[0] &&
+    client.s.options.hosts[0].host || void 0;
+  conn.port = client &&
+    client.s &&
+    client.s.options &&
+    client.s.options.hosts &&
+    client.s.options.hosts[0] &&
+    client.s.options.hosts[0].port || void 0;
+  conn.name = dbName != null ? dbName : client && client.s && client.s.options && client.s.options.dbName || void 0;
+  conn._closeCalled = client._closeCalled;
+
+  const _handleReconnect = () => {
+    // If we aren't disconnected, we assume this reconnect is due to a
+    // socket timeout. If there's no activity on a socket for
+    // `socketTimeoutMS`, the driver will attempt to reconnect and emit
+    // this event.
+    if (conn.readyState !== STATES.connected) {
+      conn.readyState = STATES.connected;
+      conn.emit('reconnect');
+      conn.emit('reconnected');
+      conn.onOpen();
+    }
+  };
+
+  const type = client &&
+  client.topology &&
+  client.topology.description &&
+  client.topology.description.type || '';
+
+  if (type === 'Single') {
+    client.on('serverDescriptionChanged', ev => {
+      const newDescription = ev.newDescription;
+      if (newDescription.type === 'Unknown') {
+        conn.readyState = STATES.disconnected;
+      } else {
+        _handleReconnect();
+      }
+    });
+  } else if (type.startsWith('ReplicaSet')) {
+    client.on('topologyDescriptionChanged', ev => {
+      // Emit disconnected if we've lost connectivity to the primary
+      const description = ev.newDescription;
+      if (conn.readyState === STATES.connected && description.type !== 'ReplicaSetWithPrimary') {
+        // Implicitly emits 'disconnected'
+        conn.readyState = STATES.disconnected;
+      } else if (conn.readyState === STATES.disconnected && description.type === 'ReplicaSetWithPrimary') {
+        _handleReconnect();
+      }
+    });
+  }
+
+  conn.onOpen();
+
+  for (const i in conn.collections) {
+    if (utils.object.hasOwnProperty(conn.collections, i)) {
+      conn.collections[i].onOpen();
+    }
+  }
+}
+
 
 /*!
  * Module exports.

package/lib/error/cast.js

@@ -20,10 +20,9 @@ class CastError extends MongooseError {
   constructor(type, value, path, reason, schemaType) {
     // If no args, assume we'll `init()` later.
     if (arguments.length > 0) {
-      const stringValue = getStringValue(value);
       const valueType = getValueType(value);
       const messageFormat = getMessageFormat(schemaType);
-      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType, reason);
+      const msg = formatMessage(null, type, value, path, messageFormat, valueType, reason);
       super(msg);
       this.init(type, value, path, reason, schemaType);
     } else {
@@ -77,7 +76,7 @@ class CastError extends MongooseError {
    */
   setModel(model) {
     this.model = model;
-    this.message = formatMessage(model, this.kind, this.stringValue, this.path,
+    this.message = formatMessage(model, this.kind, this.value, this.path,
       this.messageFormat, this.valueType);
   }
 }
@@ -111,10 +110,8 @@ function getValueType(value) {
 }
 
 function getMessageFormat(schemaType) {
-  const messageFormat = schemaType &&
-  schemaType.options &&
-  schemaType.options.cast || null;
-  if (typeof messageFormat === 'string') {
+  const messageFormat = schemaType && schemaType._castErrorMessage || null;
+  if (typeof messageFormat === 'string' || typeof messageFormat === 'function') {
     return messageFormat;
   }
 }
@@ -123,8 +120,9 @@ function getMessageFormat(schemaType) {
  * ignore
  */
 
-function formatMessage(model, kind, stringValue, path, messageFormat, valueType, reason) {
-  if (messageFormat != null) {
+function formatMessage(model, kind, value, path, messageFormat, valueType, reason) {
+  if (typeof messageFormat === 'string') {
+    const stringValue = getStringValue(value);
     let ret = messageFormat.
       replace('{KIND}', kind).
       replace('{VALUE}', stringValue).
@@ -134,7 +132,10 @@ function formatMessage(model, kind, stringValue, path, messageFormat, valueType,
     }
 
     return ret;
+  } else if (typeof messageFormat === 'function') {
+    return messageFormat(value, path, model, kind);
   } else {
+    const stringValue = getStringValue(value);
     const valueTypeMsg = valueType ? ' (type ' + valueType + ')' : '';
     let ret = 'Cast to ' + kind + ' failed for value ' +
       stringValue + valueTypeMsg + ' at path "' + path + '"';

package/lib/error/messages.js

@@ -6,7 +6,7 @@
  *     const mongoose = require('mongoose');
  *     mongoose.Error.messages.String.enum  = "Your custom message for {PATH}.";
  *
- * As you might have noticed, error messages support basic templating
+ * Error messages support basic templating. Mongoose will replace the following strings with the corresponding value.
  *
  * - `{PATH}` is replaced with the invalid document path
  * - `{VALUE}` is replaced with the invalid value

package/lib/helpers/schema/applyWriteConcern.js

@@ -3,6 +3,9 @@
 const get = require('../get');
 
 module.exports = function applyWriteConcern(schema, options) {
+  if (options.writeConcern != null) {
+    return;
+  }
   const writeConcern = get(schema, 'options.writeConcern', {});
   if (Object.keys(writeConcern).length != 0) {
     options.writeConcern = {};

package/lib/helpers/schema/getPath.js

@@ -13,7 +13,6 @@ module.exports = function getPath(schema, path) {
   if (schematype != null) {
     return schematype;
   }
-
   const pieces = path.split('.');
   let cur = '';
   let isArray = false;

package/lib/helpers/schema/idGetter.js

@@ -12,8 +12,8 @@ module.exports = function addIdGetter(schema) {
   if (!autoIdGetter) {
     return schema;
   }
-
   schema.virtual('id').get(idGetter);
+  schema.virtual('id').set(idSetter);
 
   return schema;
 };
@@ -30,3 +30,14 @@ function idGetter() {
 
   return null;
 }
+
+/**
+ *
+ * @param {String} v the id to set
+ * @api private
+ */
+
+function idSetter(v) {
+  this._id = v;
+  return v;
+}

package/lib/model.js

@@ -320,7 +320,6 @@ Model.prototype.$__handleSave = function(options, callback) {
     _setIsNew(this, false);
     // Make it possible to retry the insert
     this.$__.inserting = true;
-
     return;
   }
 
@@ -479,7 +478,6 @@ function generateVersionError(doc, modifiedPaths) {
  *     newProduct === product; // true
  *
  * @param {Object} [options] options optional options
- * @param {Boolean} [options.ordered] saves the docs in series rather than parallel.
  * @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.session()).
  * @param {Object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
  * @param {Boolean} [options.validateBeforeSave] set to false to save without validating.
@@ -1372,6 +1370,14 @@ Model.createCollection = async function createCollection(options) {
     throw new MongooseError('Model.createCollection() no longer accepts a callback');
   }
 
+  const collectionOptions = this &&
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.collectionOptions;
+  if (collectionOptions != null) {
+    options = Object.assign({}, collectionOptions, options);
+  }
+
   const schemaCollation = this &&
     this.schema &&
     this.schema.options &&
@@ -2802,6 +2808,8 @@ Model.findByIdAndRemove = function(id, options) {
  *
  * @param {Array|Object} docs Documents to insert, as a spread or array
  * @param {Object} [options] Options passed down to `save()`. To specify `options`, `docs` **must** be an array, not a spread. See [Model.save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) for available options.
+ * @param {Boolean} [options.ordered] saves the docs in series rather than parallel.
+ * @param {Boolean} [options.aggregateErrors] Aggregate Errors instead of throwing the first one that occurs. Default: false
  * @return {Promise}
  * @api public
  */
@@ -2858,27 +2866,41 @@ Model.create = async function create(doc, options) {
     return Array.isArray(doc) ? [] : null;
   }
   let res = [];
+  const immediateError = typeof options.aggregateErrors === 'boolean' ? !options.aggregateErrors : true;
+
+  delete options.aggregateErrors; // dont pass on the option to "$save"
+
   if (options.ordered) {
     for (let i = 0; i < args.length; i++) {
-      const doc = args[i];
-      const Model = this.discriminators && doc[discriminatorKey] != null ?
-        this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
-        this;
-      if (Model == null) {
-        throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
+      try {
+        const doc = args[i];
+        const Model = this.discriminators && doc[discriminatorKey] != null ?
+          this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
+          this;
+        if (Model == null) {
+          throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
           `found for model "${this.modelName}"`);
-      }
-      let toSave = doc;
-      if (!(toSave instanceof Model)) {
-        toSave = new Model(toSave);
-      }
+        }
+        let toSave = doc;
+        if (!(toSave instanceof Model)) {
+          toSave = new Model(toSave);
+        }
 
-      await toSave.$save(options);
-      res.push(toSave);
+        await toSave.$save(options);
+        res.push(toSave);
+      } catch (err) {
+        if (!immediateError) {
+          res.push(err);
+        } else {
+          throw err;
+        }
+      }
     }
     return res;
   } else {
-    res = await Promise.all(args.map(async doc => {
+    // ".bind(Promise)" is required, otherwise results in "TypeError: Promise.allSettled called on non-object"
+    const promiseType = !immediateError ? Promise.allSettled.bind(Promise) : Promise.all.bind(Promise);
+    let p = promiseType(args.map(async doc => {
       const Model = this.discriminators && doc[discriminatorKey] != null ?
         this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
         this;
@@ -2896,6 +2918,13 @@ Model.create = async function create(doc, options) {
 
       return toSave;
     }));
+
+    // chain the mapper, only if "allSettled" is used
+    if (!immediateError) {
+      p = p.then(presult => presult.map(v => v.status === 'fulfilled' ? v.value : v.reason));
+    }
+
+    res = await p;
   }
 
 
@@ -3016,8 +3045,10 @@ Model.startSession = function() {
  *
  * #### Example:
  *
- *     const arr = [{ name: 'Star Wars' }, { name: 'The Empire Strikes Back' }];
- *     Movies.insertMany(arr, function(error, docs) {});
+ *     await Movies.insertMany([
+ *       { name: 'Star Wars' },
+ *       { name: 'The Empire Strikes Back' }
+ *     ]);
  *
  * @param {Array|Object|*} doc(s)
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)