mongoose 6.3.3 → 6.3.6

package/lgtm.yml

@@ -0,0 +1,12 @@
+path_classifiers:
+  src:
+    - lib
+  types:
+    - types
+  test:
+    - test
+  docs:
+    - docs
+queries:
+  - exclude: "*"
+  - include: lib

package/lib/cast/objectid.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const isBsonType = require('../helpers/isBsonType');
 const ObjectId = require('../driver').get().ObjectId;
 
 module.exports = function castObjectId(value) {
@@ -7,12 +8,12 @@ module.exports = function castObjectId(value) {
     return value;
   }
 
-  if (value instanceof ObjectId) {
+  if (isBsonType(value, 'ObjectID')) {
     return value;
   }
 
   if (value._id) {
-    if (value._id instanceof ObjectId) {
+    if (isBsonType(value._id, 'ObjectID')) {
       return value._id;
     }
     if (value._id.toString instanceof Function) {

package/lib/connection.js

@@ -7,13 +7,13 @@
 const ChangeStream = require('./cursor/ChangeStream');
 const EventEmitter = require('events').EventEmitter;
 const Schema = require('./schema');
-const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
 const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
 const applyPlugins = require('./helpers/schema/applyPlugins');
+const driver = require('./driver');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const get = require('./helpers/get');
 const immediate = require('./helpers/immediate');
@@ -548,7 +548,7 @@ Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
   // If `dropDatabase()` is called, this model's collection will not be
   // init-ed. It is sufficiently common to call `dropDatabase()` after
   // `mongoose.connect()` but before creating models that we want to
-  // support this. See gh-6967
+  // support this. See gh-6796
   for (const name of Object.keys(this.models)) {
     delete this.models[name].$init;
   }
@@ -1026,6 +1026,7 @@ Connection.prototype.collection = function(name, options) {
   };
   options = Object.assign({}, defaultOptions, options ? utils.clone(options) : {});
   options.$wasForceClosed = this.$wasForceClosed;
+  const Collection = driver.get().Collection;
   if (!(name in this.collections)) {
     this.collections[name] = new Collection(name, this, options);
   }

package/lib/document.js

@@ -1323,6 +1323,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (!schema) {
     this.$__set(pathToMark, path, options, constructing, parts, schema, val, priorVal);
+
+    if (pathType === 'nested' && val == null) {
+      cleanModifiedSubpaths(this, path);
+    }
     return this;
   }
 
@@ -1374,7 +1378,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     })();
 
     let didPopulate = false;
-    if (refMatches && val instanceof Document) {
+    if (refMatches && val instanceof Document && (!val.$__.wasPopulated || utils.deepEqual(val.$__.wasPopulated.value, val._id))) {
       const unpopulatedValue = (schema && schema.$isSingleNested) ? schema.cast(val, this) : val._id;
       this.$populated(path, unpopulatedValue, { [populateModelSymbol]: val.constructor });
       val.$__.wasPopulated = { value: unpopulatedValue };
@@ -3460,9 +3464,9 @@ Document.prototype.$toObject = function(options, json) {
 
   const path = json ? 'toJSON' : 'toObject';
   const baseOptions = this.constructor &&
-  this.constructor.base &&
-  this.constructor.base.options &&
-  get(this.constructor.base.options, path) || {};
+    this.constructor.base &&
+    this.constructor.base.options &&
+    get(this.constructor.base.options, path) || {};
   const schemaOptions = this.$__schema && this.$__schema.options || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
@@ -3470,8 +3474,8 @@ Document.prototype.$toObject = function(options, json) {
   defaultOptions = utils.options(defaultOptions, clone(schemaOptions[path] || {}));
 
   // If options do not exist or is not an object, set it to empty object
-  options = utils.isPOJO(options) ? clone(options) : {};
-  options._calledWithOptions = options._calledWithOptions || clone(options);
+  options = utils.isPOJO(options) ? { ...options } : {};
+  options._calledWithOptions = options._calledWithOptions || { ...options };
 
   let _minimize;
   if (options._calledWithOptions.minimize != null) {
@@ -3495,11 +3499,12 @@ Document.prototype.$toObject = function(options, json) {
   // `clone()` will recursively call `$toObject()` on embedded docs, so we
   // need the original options the user passed in, plus `_isNested` and
   // `_parentOptions` for checking whether we need to depopulate.
-  const cloneOptions = Object.assign(utils.clone(options), {
+  const cloneOptions = Object.assign({}, options, {
     _isNested: true,
     json: json,
     minimize: _minimize,
-    flattenMaps: flattenMaps
+    flattenMaps: flattenMaps,
+    _seen: (options && options._seen) || new Map()
   });
 
   if (utils.hasUserDefinedProperty(options, 'getters')) {
@@ -4222,8 +4227,10 @@ Document.prototype.populate = function populate() {
  * @api public
  * @return {Array<Document>} array of populated documents. Empty array if there are no populated documents associated with this document.
  * @memberOf Document
+ * @method $getPopulatedDocs
  * @instance
  */
+
 Document.prototype.$getPopulatedDocs = function $getPopulatedDocs() {
   let keys = [];
   if (this.$__.populated != null) {

package/lib/error/index.js

@@ -5,11 +5,11 @@
  * Mongoose-specific errors.
  *
  * #### Example:
- *     const Model = mongoose.model('Test', new Schema({ answer: Number }));
+ *     const Model = mongoose.model('Test', new mongoose.Schema({ answer: Number }));
  *     const doc = new Model({ answer: 'not a number' });
  *     const err = doc.validateSync();
  *
- *     err instanceof mongoose.Error; // true
+ *     err instanceof mongoose.Error.ValidationError; // true
  *
  * @constructor Error
  * @param {String} msg Error message

package/lib/helpers/clone.js

@@ -77,7 +77,7 @@ function clone(obj, options, isArrayChild) {
     }
   }
 
-  if (obj instanceof ObjectId) {
+  if (isBsonType(obj, 'ObjectID')) {
     return new ObjectId(obj.id);
   }
 
@@ -118,9 +118,16 @@ module.exports = clone;
 
 function cloneObject(obj, options, isArrayChild) {
   const minimize = options && options.minimize;
+  const omitUndefined = options && options.omitUndefined;
+  const seen = options && options._seen;
   const ret = {};
   let hasKeys;
 
+  if (seen && seen.has(obj)) {
+    return seen.get(obj);
+  } else if (seen) {
+    seen.set(obj, ret);
+  }
   if (trustedSymbol in obj) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
@@ -138,7 +145,7 @@ function cloneObject(obj, options, isArrayChild) {
     // Don't pass `isArrayChild` down
     const val = clone(obj[key], options, false);
 
-    if (minimize === false && typeof val === 'undefined') {
+    if ((minimize === false || omitUndefined) && typeof val === 'undefined') {
       delete ret[key];
     } else if (minimize !== true || (typeof val !== 'undefined')) {
       hasKeys || (hasKeys = true);

package/lib/helpers/common.js

@@ -5,8 +5,7 @@
  */
 
 const Binary = require('../driver').get().Binary;
-const Decimal128 = require('../types/decimal128');
-const ObjectId = require('../types/objectid');
+const isBsonType = require('./isBsonType');
 const isMongooseObject = require('./isMongooseObject');
 
 exports.flatten = flatten;
@@ -99,9 +98,9 @@ function shouldFlatten(val) {
   return val &&
     typeof val === 'object' &&
     !(val instanceof Date) &&
-    !(val instanceof ObjectId) &&
+    !isBsonType(val, 'ObjectID') &&
     (!Array.isArray(val) || val.length !== 0) &&
     !(val instanceof Buffer) &&
-    !(val instanceof Decimal128) &&
+    !isBsonType(val, 'Decimal128') &&
     !(val instanceof Binary);
 }

package/lib/helpers/discriminator/areDiscriminatorValuesEqual.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const ObjectId = require('../../types/objectid');
+const isBsonType = require('../isBsonType');
 
 module.exports = function areDiscriminatorValuesEqual(a, b) {
   if (typeof a === 'string' && typeof b === 'string') {
@@ -9,7 +9,7 @@ module.exports = function areDiscriminatorValuesEqual(a, b) {
   if (typeof a === 'number' && typeof b === 'number') {
     return a === b;
   }
-  if (a instanceof ObjectId && b instanceof ObjectId) {
+  if (isBsonType(a, 'ObjectID') && isBsonType(b, 'ObjectID')) {
     return a.toString() === b.toString();
   }
   return false;

package/lib/helpers/isBsonType.js

@@ -1,13 +1,15 @@
 'use strict';
 
-const get = require('./get');
-
 /*!
  * Get the bson type, if it exists
  */
 
 function isBsonType(obj, typename) {
-  return get(obj, '_bsontype', void 0) === typename;
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    obj._bsontype === typename
+  );
 }
 
 module.exports = isBsonType;

package/lib/helpers/path/setDottedPath.js

@@ -1,14 +1,25 @@
 'use strict';
 
+const specialProperties = require('../specialProperties');
+
+
 module.exports = function setDottedPath(obj, path, val) {
   if (path.indexOf('.') === -1) {
+    if (specialProperties.has(path)) {
+      return;
+    }
+
     obj[path] = val;
     return;
   }
   const parts = path.split('.');
+
   const last = parts.pop();
   let cur = obj;
   for (const part of parts) {
+    if (specialProperties.has(part)) {
+      continue;
+    }
     if (cur[part] == null) {
       cur[part] = {};
     }
@@ -16,5 +27,7 @@ module.exports = function setDottedPath(obj, path, val) {
     cur = cur[part];
   }
 
-  cur[last] = val;
+  if (!specialProperties.has(last)) {
+    cur[last] = val;
+  }
 };

package/lib/helpers/topology/isAtlas.js

@@ -8,6 +8,19 @@ module.exports = function isAtlas(topologyDescription) {
   }
 
   const hostnames = Array.from(topologyDescription.servers.keys());
-  return hostnames.length > 0 &&
-    hostnames.every(host => host.endsWith('.mongodb.net:27017'));
+
+  if (hostnames.length === 0) {
+    return false;
+  }
+
+  for (let i = 0, il = hostnames.length; i < il; ++i) {
+    const url = new URL(hostnames[i]);
+    if (
+      url.hostname.endsWith('.mongodb.net') === false ||
+      url.port !== '27017'
+    ) {
+      return false;
+    }
+  }
+  return true;
 };

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -61,6 +61,8 @@ function applyTimestampsToChildren(now, update, schema) {
             if (createdAt != null) {
               subdoc[createdAt] = now;
             }
+
+            applyTimestampsToChildren(now, subdoc, $path.schema);
           });
         } else {
           if (updatedAt != null) {
@@ -69,6 +71,8 @@ function applyTimestampsToChildren(now, update, schema) {
           if (createdAt != null) {
             op[key][createdAt] = now;
           }
+
+          applyTimestampsToChildren(now, op[key], $path.schema);
         }
       }
     }

package/lib/index.js

@@ -34,6 +34,7 @@ const PromiseProvider = require('./promise_provider');
 const shardingPlugin = require('./plugins/sharding');
 const trusted = require('./helpers/query/trusted').trusted;
 const sanitizeFilter = require('./helpers/query/sanitizeFilter');
+const isBsonType = require('./helpers/isBsonType');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -153,7 +154,7 @@ Mongoose.prototype.driver = driver;
  *     mongoose.set('debug', function(collectionName, methodName, ...methodArgs) {}); // use custom function to log collection methods + arguments
  *
  * Currently supported options are:
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+ * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
  * - 'cloneSchemas': false by default. Set to `true` to `clone()` all schemas before compiling into a model.
@@ -274,6 +275,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
 Mongoose.prototype.createConnection = function(uri, options, callback) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
+  const Connection = driver.get().getConnection();
   const conn = new Connection(_mongoose);
   if (typeof options === 'function') {
     callback = options;
@@ -995,8 +997,7 @@ Mongoose.prototype.isValidObjectId = function(v) {
  */
 
 Mongoose.prototype.isObjectIdOrHexString = function(v) {
-  const _mongoose = this instanceof Mongoose ? this : mongoose;
-  return v instanceof _mongoose.Types.ObjectId || (typeof v === 'string' && objectIdHexRegexp.test(v));
+  return isBsonType(v, 'ObjectID') || (typeof v === 'string' && objectIdHexRegexp.test(v));
 };
 
 /**

package/lib/model.js

@@ -768,6 +768,7 @@ Model.prototype.$__delta = function() {
         transform: false,
         virtuals: false,
         getters: false,
+        omitUndefined: true,
         _isNested: true
       });
       operand(this, where, delta, data, value);
@@ -1488,61 +1489,68 @@ Model.syncIndexes = function syncIndexes(options, callback) {
  * the result of this function would be the result of
  * Model.syncIndexes().
  *
- * @param {Object} options not used at all.
+ * @param {Object} [options]
  * @param {Function} callback optional callback
- * @returns {Promise} which containts an object, {toDrop, toCreate}, which
- * are indexes that would be dropped in mongodb and indexes that would be created in mongodb.
+ * @returns {Promise} which contains an object, {toDrop, toCreate}, which
+ * are indexes that would be dropped in MongoDB and indexes that would be created in MongoDB.
  */
 
 Model.diffIndexes = function diffIndexes(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = null;
+  }
   const toDrop = [];
   const toCreate = [];
   callback = this.$handleCallbackError(callback);
   return this.db.base._promiseOrCallback(callback, cb => {
     cb = this.$wrapCallback(cb);
-    this.listIndexes((err, indexes) => {
-      if (indexes === undefined) {
-        indexes = [];
+    this.listIndexes((err, dbIndexes) => {
+      if (dbIndexes === undefined) {
+        dbIndexes = [];
       }
-      const schemaIndexes = this.schema.indexes();
-      // Iterate through the indexes created in mongodb and
-      // compare against the indexes in the schema.
-      for (const index of indexes) {
+      dbIndexes = getRelatedDBIndexes(this, dbIndexes);
+      const schemaIndexes = getRelatedSchemaIndexes(this, this.schema.indexes());
+
+      for (const dbIndex of dbIndexes) {
         let found = false;
         // Never try to drop `_id` index, MongoDB server doesn't allow it
-        if (isDefaultIdIndex(index)) {
+        if (isDefaultIdIndex(dbIndex)) {
           continue;
         }
 
-        for (const schemaIndex of schemaIndexes) {
-          const key = schemaIndex[0];
-          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
-          if (isIndexEqual(key, options, index)) {
+        for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
+          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndexOptions));
+          applySchemaCollation(schemaIndexKeysObject, options, this.schema.options);
+
+          if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
             found = true;
           }
         }
 
         if (!found) {
-          toDrop.push(index.name);
+          toDrop.push(dbIndex.name);
         }
       }
       // Iterate through the indexes created on the schema and
       // compare against the indexes in mongodb.
-      for (const schemaIndex of schemaIndexes) {
-        let found = false;
-        const key = schemaIndex[0];
-        const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
-        for (const index of indexes) {
-          if (isDefaultIdIndex(index)) {
-            continue;
+      if (!options || options.toCreate !== false) {
+        for (const schemaIndex of schemaIndexes) {
+          let found = false;
+          const key = schemaIndex[0];
+          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndex[1]));
+          for (const index of dbIndexes) {
+            if (isDefaultIdIndex(index)) {
+              continue;
+            }
+            if (isIndexEqual(key, options, index)) {
+              found = true;
+            }
           }
-          if (isIndexEqual(key, options, index)) {
-            found = true;
+          if (!found) {
+            toCreate.push(key);
           }
         }
-        if (!found) {
-          toCreate.push(key);
-        }
       }
       cb(null, { toDrop, toCreate });
     });
@@ -1568,36 +1576,12 @@ Model.cleanIndexes = function cleanIndexes(callback) {
   return this.db.base._promiseOrCallback(callback, cb => {
     const collection = this.$__collection;
 
-    this.listIndexes((err, dbIndexes) => {
+    this.diffIndexes({ toCreate: false }, (err, res) => {
       if (err != null) {
         return cb(err);
       }
 
-      dbIndexes = getRelatedDBIndexes(this, dbIndexes);
-      const schemaIndexes = getRelatedSchemaIndexes(this, this.schema.indexes());
-
-      const toDrop = [];
-
-      for (const dbIndex of dbIndexes) {
-        let found = false;
-        // Never try to drop `_id` index, MongoDB server doesn't allow it
-        if (isDefaultIdIndex(dbIndex)) {
-          continue;
-        }
-
-        for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
-          const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndexOptions));
-          applySchemaCollation(schemaIndexKeysObject, options, this.schema.options);
-
-          if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
-            found = true;
-          }
-        }
-
-        if (!found) {
-          toDrop.push(dbIndex.name);
-        }
-      }
+      const toDrop = res.toDrop;
 
       if (toDrop.length === 0) {
         return cb(null, []);

package/lib/query.js

@@ -124,7 +124,10 @@ function Query(conditions, options, model, collection) {
   }
 
   // inherit mquery
-  mquery.call(this, this.mongooseCollection, options);
+  mquery.call(this, null, options);
+  if (collection) {
+    this.collection(collection);
+  }
 
   if (conditions) {
     this.find(conditions);

package/lib/queryhelpers.js

@@ -226,7 +226,9 @@ exports.applyPaths = function applyPaths(fields, schema) {
     const addedPaths = [];
     schema.eachPath(function(path, type) {
       if (prefix) path = prefix + '.' + path;
-
+      if (type.$isSchemaMap || path.endsWith('.$*')) {
+        return;
+      }
       let addedPath = analyzePath(path, type);
       // arrays
       if (addedPath == null && !Array.isArray(type) && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
@@ -248,7 +250,6 @@ exports.applyPaths = function applyPaths(fields, schema) {
         }
       }
     });
-
     stack.pop();
     return addedPaths;
   }

package/lib/schema/decimal128.js

@@ -6,9 +6,9 @@
 
 const SchemaType = require('../schematype');
 const CastError = SchemaType.CastError;
-const Decimal128Type = require('../types/decimal128');
 const castDecimal128 = require('../cast/decimal128');
 const utils = require('../utils');
+const isBsonType = require('../helpers/isBsonType');
 
 /**
  * Decimal128 SchemaType constructor.
@@ -105,7 +105,7 @@ Decimal128.cast = function cast(caster) {
  */
 
 Decimal128._defaultCaster = v => {
-  if (v != null && !(v instanceof Decimal128Type)) {
+  if (v != null && !isBsonType(v, 'Decimal128')) {
     throw new Error();
   }
   return v;
@@ -115,7 +115,7 @@ Decimal128._defaultCaster = v => {
  * ignore
  */
 
-Decimal128._checkRequired = v => v instanceof Decimal128Type;
+Decimal128._checkRequired = v => isBsonType(v, 'Decimal128');
 
 /**
  * Override the function the required validator uses to check whether a string
@@ -164,7 +164,7 @@ Decimal128.prototype.checkRequired = function checkRequired(value, doc) {
 
 Decimal128.prototype.cast = function(value, doc, init) {
   if (SchemaType._isRef(this, value, doc, init)) {
-    if (value instanceof Decimal128Type) {
+    if (isBsonType(value, 'Decimal128')) {
       return value;
     }
 

package/lib/schema/map.js

@@ -69,6 +69,14 @@ class Map extends SchemaType {
   }
 }
 
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+Map.schemaName = 'Map';
+
 Map.prototype.OptionsConstructor = SchemaMapOptions;
 
 Map.defaultOptions = {};

package/lib/schema/objectid.js

@@ -9,6 +9,7 @@ const SchemaType = require('../schematype');
 const castObjectId = require('../cast/objectid');
 const getConstructorName = require('../helpers/getConstructorName');
 const oid = require('../types/objectid');
+const isBsonType = require('../helpers/isBsonType');
 const utils = require('../utils');
 
 const CastError = SchemaType.CastError;
@@ -113,7 +114,7 @@ ObjectId.prototype.auto = function(turnOn) {
  * ignore
  */
 
-ObjectId._checkRequired = v => v instanceof oid;
+ObjectId._checkRequired = v => isBsonType(v, 'ObjectID');
 
 /*!
  * ignore
@@ -161,7 +162,7 @@ ObjectId.cast = function cast(caster) {
  */
 
 ObjectId._defaultCaster = v => {
-  if (!(v instanceof oid)) {
+  if (!(isBsonType(v, 'ObjectID'))) {
     throw new Error(v + ' is not an instance of ObjectId');
   }
   return v;
@@ -221,7 +222,7 @@ ObjectId.prototype.checkRequired = function checkRequired(value, doc) {
  */
 
 ObjectId.prototype.cast = function(value, doc, init) {
-  if (!(value instanceof oid) && SchemaType._isRef(this, value, doc, init)) {
+  if (!(isBsonType(value, 'ObjectID')) && SchemaType._isRef(this, value, doc, init)) {
     // wait! we may need to cast this to a document
     if ((getConstructorName(value) || '').toLowerCase() === 'objectid') {
       return new oid(value.toHexString());

package/lib/schema/string.js

@@ -4,12 +4,12 @@
  * Module dependencies.
  */
 
-const { BSONRegExp } = require('bson');
 const SchemaType = require('../schematype');
 const MongooseError = require('../error/index');
 const SchemaStringOptions = require('../options/SchemaStringOptions');
 const castString = require('../cast/string');
 const utils = require('../utils');
+const isBsonType = require('../helpers/isBsonType');
 
 const CastError = SchemaType.CastError;
 
@@ -677,7 +677,7 @@ SchemaString.prototype.castForQuery = function($conditional, val) {
     return handler.call(this, val);
   }
   val = $conditional;
-  if (Object.prototype.toString.call(val) === '[object RegExp]' || val instanceof BSONRegExp) {
+  if (Object.prototype.toString.call(val) === '[object RegExp]' || isBsonType(val, 'BSONRegExp')) {
     return val;
   }