mongoose 8.19.4 → 9.0.0-rc0

package/lib/helpers/model/applyHooks.js

@@ -1,8 +1,5 @@
 'use strict';
 
-const symbols = require('../../schema/symbols');
-const promiseOrCallback = require('../promiseOrCallback');
-
 /*!
  * ignore
  */
@@ -15,10 +12,10 @@ module.exports = applyHooks;
 
 applyHooks.middlewareFunctions = [
   'deleteOne',
-  'save',
-  'validate',
   'remove',
+  'save',
   'updateOne',
+  'validate',
   'init'
 ];
 
@@ -47,15 +44,15 @@ function applyHooks(model, schema, options) {
     contextParameter: true
   };
   const objToDecorate = options.decorateDoc ? model : model.prototype;
-
   model.$appliedHooks = true;
   for (const key of Object.keys(schema.paths)) {
-    const type = schema.paths[key];
+    let type = schema.paths[key];
     let childModel = null;
-    if (type.$isSingleNested) {
-      childModel = type.caster;
-    } else if (type.$isMongooseDocumentArray) {
-      childModel = type.Constructor;
+
+    const result = findChildModel(type);
+    if (result) {
+      childModel = result.childModel;
+      type = result.type;
     } else {
       continue;
     }
@@ -64,7 +61,11 @@ function applyHooks(model, schema, options) {
       continue;
     }
 
-    applyHooks(childModel, type.schema, { ...options, isChildSchema: true });
+    applyHooks(childModel, type.schema, {
+      ...options,
+      decorateDoc: false,
+      isChildSchema: true
+    });
     if (childModel.discriminators != null) {
       const keys = Object.keys(childModel.discriminators);
       for (const key of keys) {
@@ -78,39 +79,10 @@ function applyHooks(model, schema, options) {
   // promises and make it so that `doc.save.toString()` provides meaningful
   // information.
 
-  const middleware = schema.s.hooks.
-    filter(hook => {
-      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
-        return !!hook['document'];
-      }
-      if (hook.name === 'remove' || hook.name === 'init') {
-        return hook['document'] == null || !!hook['document'];
-      }
-      if (hook.query != null || hook.document != null) {
-        return hook.document !== false;
-      }
-      return true;
-    }).
-    filter(hook => {
-      // If user has overwritten the method, don't apply built-in middleware
-      if (schema.methods[hook.name]) {
-        return !hook.fn[symbols.builtInMiddleware];
-      }
-
-      return true;
-    });
+  const middleware = schema._getDocumentMiddleware();
 
   model._middleware = middleware;
 
-  objToDecorate.$__originalValidate = objToDecorate.$__originalValidate || objToDecorate.$__validate;
-
-  const internalMethodsToWrap = options && options.isChildSchema ? ['save', 'validate', 'deleteOne'] : ['save', 'validate'];
-  for (const method of internalMethodsToWrap) {
-    const toWrap = method === 'validate' ? '$__originalValidate' : `$__${method}`;
-    const wrapped = middleware.
-      createWrapper(method, objToDecorate[toWrap], null, kareemOptions);
-    objToDecorate[`$__${method}`] = wrapped;
-  }
   objToDecorate.$__init = middleware.
     createWrapperSync('init', objToDecorate.$__init, null, kareemOptions);
 
@@ -134,17 +106,35 @@ function applyHooks(model, schema, options) {
       continue;
     }
     const originalMethod = objToDecorate[method];
-    objToDecorate[method] = function() {
-      const args = Array.prototype.slice.call(arguments);
-      const cb = args.slice(-1).pop();
-      const argsWithoutCallback = typeof cb === 'function' ?
-        args.slice(0, args.length - 1) : args;
-      return promiseOrCallback(cb, callback => {
-        return this[`$__${method}`].apply(this,
-          argsWithoutCallback.concat([callback]));
-      }, model.events);
-    };
-    objToDecorate[`$__${method}`] = middleware.
+    objToDecorate[`$__${method}`] = objToDecorate[method];
+    objToDecorate[method] = middleware.
       createWrapper(method, originalMethod, null, customMethodOptions);
   }
 }
+
+/**
+ * Check if there is an embedded schematype in the given schematype. Handles drilling down into primitive
+ * arrays and maps in case of array of array of subdocs or map of subdocs.
+ *
+ * @param {SchemaType} curType
+ * @returns {{ childModel: Model | typeof Subdocument, curType: SchemaType } | null}
+ */
+
+function findChildModel(curType) {
+  if (curType.$isSingleNested || curType.$isMongooseDocumentArray) {
+    return { childModel: curType.Constructor, type: curType };
+  }
+  if (curType.instance === 'Array') {
+    const embedded = curType.getEmbeddedSchemaType();
+    if (embedded) {
+      return findChildModel(embedded);
+    }
+  }
+  if (curType.instance === 'Map') {
+    const mapType = curType.getEmbeddedSchemaType();
+    if (mapType) {
+      return findChildModel(mapType);
+    }
+  }
+  return null;
+}

package/lib/helpers/model/applyMethods.js

@@ -60,8 +60,8 @@ module.exports = function applyMethods(model, schema) {
   model.$appliedMethods = true;
   for (const key of Object.keys(schema.paths)) {
     const type = schema.paths[key];
-    if (type.$isSingleNested && !type.caster.$appliedMethods) {
-      applyMethods(type.caster, type.schema);
+    if (type.$isSingleNested && !type.Constructor.$appliedMethods) {
+      applyMethods(type.Constructor, type.schema);
     }
     if (type.$isMongooseDocumentArray && !type.Constructor.$appliedMethods) {
       applyMethods(type.Constructor, type.schema);

package/lib/helpers/model/applyStaticHooks.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const promiseOrCallback = require('../promiseOrCallback');
 const { queryMiddlewareFunctions, aggregateMiddlewareFunctions, modelMiddlewareFunctions, documentMiddlewareFunctions } = require('../../constants');
 
 const middlewareFunctions = Array.from(
@@ -13,14 +12,6 @@ const middlewareFunctions = Array.from(
 );
 
 module.exports = function applyStaticHooks(model, hooks, statics) {
-  const kareemOptions = {
-    useErrorHandlers: true,
-    numCallbackParams: 1
-  };
-
-  model.$__insertMany = hooks.createWrapper('insertMany',
-    model.$__insertMany, model, kareemOptions);
-
   hooks = hooks.filter(hook => {
     // If the custom static overwrites an existing middleware, don't apply
     // middleware to it by default. This avoids a potential backwards breaking
@@ -36,45 +27,7 @@ module.exports = function applyStaticHooks(model, hooks, statics) {
     if (hooks.hasHooks(key)) {
       const original = model[key];
 
-      model[key] = function() {
-        const numArgs = arguments.length;
-        const lastArg = numArgs > 0 ? arguments[numArgs - 1] : null;
-        const cb = typeof lastArg === 'function' ? lastArg : null;
-        const args = Array.prototype.slice.
-          call(arguments, 0, cb == null ? numArgs : numArgs - 1);
-        // Special case: can't use `Kareem#wrap()` because it doesn't currently
-        // support wrapped functions that return a promise.
-        return promiseOrCallback(cb, callback => {
-          hooks.execPre(key, model, args, function(err) {
-            if (err != null) {
-              return callback(err);
-            }
-
-            let postCalled = 0;
-            const ret = original.apply(model, args.concat(post));
-            if (ret != null && typeof ret.then === 'function') {
-              ret.then(res => post(null, res), err => post(err));
-            }
-
-            function post(error, res) {
-              if (postCalled++ > 0) {
-                return;
-              }
-
-              if (error != null) {
-                return callback(error);
-              }
-
-              hooks.execPost(key, model, [res], function(error) {
-                if (error != null) {
-                  return callback(error);
-                }
-                callback(null, res);
-              });
-            }
-          });
-        }, model.events);
-      };
+      model[key] = hooks.createWrapper(key, original);
     }
   }
 };

package/lib/helpers/model/castBulkWrite.js

@@ -224,7 +224,7 @@ module.exports.castReplaceOne = async function castReplaceOne(originalModel, rep
   });
 
   // set `skipId`, otherwise we get "_id field cannot be changed"
-  const doc = new model(replaceOne['replacement'], strict, true);
+  const doc = new model(replaceOne['replacement'], strict, { skipId: true });
   if (model.schema.options.timestamps && getTimestampsOpt(replaceOne, options)) {
     doc.initializeTimestamps();
   }

package/lib/helpers/parallelLimit.js

@@ -6,50 +6,32 @@ module.exports = parallelLimit;
  * ignore
  */
 
-function parallelLimit(fns, limit, callback) {
-  let numInProgress = 0;
-  let numFinished = 0;
-  let error = null;
-
+async function parallelLimit(params, fn, limit) {
   if (limit <= 0) {
     throw new Error('Limit must be positive');
   }
 
-  if (fns.length === 0) {
-    return callback(null, []);
+  if (params.length === 0) {
+    return [];
   }
 
-  for (let i = 0; i < fns.length && i < limit; ++i) {
-    _start();
-  }
+  const results = [];
+  const executing = new Set();
 
-  function _start() {
-    fns[numFinished + numInProgress](_done(numFinished + numInProgress));
-    ++numInProgress;
-  }
+  for (let index = 0; index < params.length; index++) {
+    const param = params[index];
+    const p = fn(param, index);
+    results.push(p);
 
-  const results = [];
+    executing.add(p);
+
+    const clean = () => executing.delete(p);
+    p.then(clean).catch(clean);
 
-  function _done(index) {
-    return (err, res) => {
-      --numInProgress;
-      ++numFinished;
-
-      if (error != null) {
-        return;
-      }
-      if (err != null) {
-        error = err;
-        return callback(error);
-      }
-
-      results[index] = res;
-
-      if (numFinished === fns.length) {
-        return callback(null, results);
-      } else if (numFinished + numInProgress < fns.length) {
-        _start();
-      }
-    };
+    if (executing.size >= limit) {
+      await Promise.race(executing);
+    }
   }
+
+  return Promise.all(results);
 }

package/lib/helpers/pluralize.js

@@ -8,13 +8,13 @@ module.exports = pluralize;
 
 exports.pluralization = [
   [/human$/gi, 'humans'],
-  [/(m)an$/gi, '$1en'],
+  [/(m|wom)an$/gi, '$1en'],
   [/(pe)rson$/gi, '$1ople'],
   [/(child)$/gi, '$1ren'],
   [/^(ox)$/gi, '$1en'],
   [/(ax|test)is$/gi, '$1es'],
-  [/(octop|vir)us$/gi, '$1i'],
-  [/(alias|status)$/gi, '$1es'],
+  [/(octop|cact|foc|fung|nucle)us$/gi, '$1i'],
+  [/(alias|status|virus)$/gi, '$1es'],
   [/(bu)s$/gi, '$1ses'],
   [/(buffal|tomat|potat)o$/gi, '$1oes'],
   [/([ti])um$/gi, '$1a'],

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -78,14 +78,7 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
       continue;
     }
 
-    if (id?.constructor?.name === 'Binary' && id.sub_type === 4 && typeof id.toUUID === 'function') {
-      // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-      sid = String(id.toUUID());
-    } else if (id?.constructor?.name === 'Buffer' && id._subtype === 4 && typeof id.toUUID === 'function') {
-      sid = String(id.toUUID());
-    } else {
-      sid = String(id);
-    }
+    sid = String(id);
     doc = resultDocs[sid];
     // If user wants separate copies of same doc, use this option
     if (options.clone && doc != null) {

package/lib/helpers/populate/createPopulateQueryFilter.js

@@ -73,7 +73,7 @@ function _filterInvalidIds(ids, foreignSchemaType, skipInvalidIds) {
     try {
       foreignSchemaType.cast(id);
       return true;
-    } catch (err) {
+    } catch {
       return false;
     }
   });

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -219,7 +219,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
 
     const originalSchema = schema;
     if (schema && schema.instance === 'Array') {
-      schema = schema.caster;
+      schema = schema.embeddedSchemaType;
     }
     if (schema && schema.$isSchemaMap) {
       schema = schema.$__schemaType;
@@ -281,8 +281,8 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
 
         schemaForCurrentDoc = modelForCurrentDoc.schema._getSchema(options.path);
 
-        if (schemaForCurrentDoc && schemaForCurrentDoc.caster) {
-          schemaForCurrentDoc = schemaForCurrentDoc.caster;
+        if (schemaForCurrentDoc && schemaForCurrentDoc.embeddedSchemaType) {
+          schemaForCurrentDoc = schemaForCurrentDoc.embeddedSchemaType;
         }
       } else {
         schemaForCurrentDoc = schema;
@@ -418,7 +418,15 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
       justOne = options.justOne;
     }
 
-    modelNames = virtual._getModelNamesForPopulate(doc);
+    // Use the correct target doc/sub-doc for dynamic ref on nested schema. See gh-12363
+    if (_virtualRes.nestedSchemaPath && typeof virtual.options.ref === 'function') {
+      const subdocs = utils.getValue(_virtualRes.nestedSchemaPath, doc);
+      modelNames = Array.isArray(subdocs)
+        ? subdocs.flatMap(subdoc => virtual._getModelNamesForPopulate(subdoc))
+        : virtual._getModelNamesForPopulate(subdocs);
+    } else {
+      modelNames = virtual._getModelNamesForPopulate(doc);
+    }
     if (virtual.options.refPath) {
       justOne = !!virtual.options.justOne;
       data.isRefPath = true;
@@ -711,16 +719,16 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
     cur = cur + (cur.length === 0 ? '' : '.') + piece;
     const schematype = modelSchema.path(cur);
     if (schematype != null &&
-        schematype.$isMongooseArray &&
-        schematype.caster.discriminators != null &&
-        Object.keys(schematype.caster.discriminators).length !== 0) {
+        schematype.$isMongooseDocumentArray &&
+        schematype.Constructor.discriminators != null &&
+        Object.keys(schematype.Constructor.discriminators).length !== 0) {
       const subdocs = utils.getValue(cur, doc);
       const remnant = options.path.substring(cur.length + 1);
-      const discriminatorKey = schematype.caster.schema.options.discriminatorKey;
+      const discriminatorKey = schematype.Constructor.schema.options.discriminatorKey;
       modelNames = [];
       for (const subdoc of subdocs) {
         const discriminatorName = utils.getValue(discriminatorKey, subdoc);
-        const discriminator = schematype.caster.discriminators[discriminatorName];
+        const discriminator = schematype.Constructor.discriminators[discriminatorName];
         const discriminatorSchema = discriminator && discriminator.schema;
         if (discriminatorSchema == null) {
           continue;

package/lib/helpers/populate/getSchemaTypes.js

@@ -58,10 +58,10 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
         continue;
       }
 
-      if (foundschema.caster) {
+      if (foundschema.embeddedSchemaType) {
         // array of Mixed?
-        if (foundschema.caster instanceof Mixed) {
-          return foundschema.caster;
+        if (foundschema.embeddedSchemaType instanceof Mixed) {
+          return foundschema.embeddedSchemaType;
         }
 
         let schemas = null;
@@ -142,11 +142,11 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
           }
         } else if (p !== parts.length &&
             foundschema.$isMongooseArray &&
-            foundschema.casterConstructor.$isMongooseArray) {
+            foundschema.embeddedSchemaType.$isMongooseArray) {
           // Nested arrays. Drill down to the bottom of the nested array.
           let type = foundschema;
           while (type.$isMongooseArray && !type.$isMongooseDocumentArray) {
-            type = type.casterConstructor;
+            type = type.embeddedSchemaType;
           }
 
           const ret = search(

package/lib/helpers/query/cast$expr.js

@@ -146,7 +146,7 @@ function castNumberOperator(val) {
 
   try {
     return castNumber(val);
-  } catch (err) {
+  } catch {
     throw new CastError('Number', val);
   }
 }
@@ -174,7 +174,7 @@ function castIn(val, schema, strictQuery) {
   }
 
   return [
-    schematype.$isMongooseDocumentArray ? schematype.$embeddedSchemaType.cast(search) : schematype.caster.cast(search),
+    schematype.embeddedSchemaType.cast(search),
     path
   ];
 }
@@ -187,7 +187,7 @@ function castArithmetic(val) {
     }
     try {
       return castNumber(val);
-    } catch (err) {
+    } catch {
       throw new CastError('Number', val);
     }
   }
@@ -198,7 +198,7 @@ function castArithmetic(val) {
     }
     try {
       return castNumber(v);
-    } catch (err) {
+    } catch {
       throw new CastError('Number', v);
     }
   });
@@ -229,10 +229,8 @@ function castComparison(val, schema, strictQuery) {
           path = lhs[key].slice(1) + '.' + key;
           schematype = schema.path(lhs[key].slice(1));
           if (schematype != null) {
-            if (schematype.$isMongooseDocumentArray) {
-              schematype = schematype.$embeddedSchemaType;
-            } else if (schematype.$isMongooseArray) {
-              schematype = schematype.caster;
+            if (schematype.$isMongooseArray) {
+              schematype = schematype.embeddedSchemaType;
             }
           }
         }
@@ -250,13 +248,13 @@ function castComparison(val, schema, strictQuery) {
       if (is$literal) {
         try {
           val[1] = { $literal: caster(val[1].$literal) };
-        } catch (err) {
+        } catch {
           throw new CastError(caster.name.replace(/^cast/, ''), val[1], path + '.$literal');
         }
       } else {
         try {
           val[1] = caster(val[1]);
-        } catch (err) {
+        } catch {
           throw new CastError(caster.name.replace(/^cast/, ''), val[1], path);
         }
       }

package/lib/helpers/query/castFilterPath.js

@@ -22,7 +22,7 @@ module.exports = function castFilterPath(ctx, schematype, val) {
     const nested = val[$cond];
 
     if ($cond === '$not') {
-      if (nested && schematype && !schematype.caster) {
+      if (nested && schematype && !schematype.embeddedSchemaType && !schematype.Constructor) {
         const _keys = Object.keys(nested);
         if (_keys.length && isOperator(_keys[0])) {
           for (const key of Object.keys(nested)) {

package/lib/helpers/query/castUpdate.js

@@ -281,7 +281,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
         continue;
       }
 
-      if (schematype && schematype.caster && op in castOps) {
+      if (schematype && (schematype.embeddedSchemaType || schematype.Constructor) && op in castOps) {
         // embedded doc schema
         if ('$each' in val) {
           hasKeys = true;
@@ -428,7 +428,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
           if (obj[key] == null) {
             throw new CastError('String', obj[key], `${prefix}${key}.$rename`);
           }
-          const schematype = new SchemaString(`${prefix}${key}.$rename`);
+          const schematype = new SchemaString(`${prefix}${key}.$rename`, null, null, schema);
           obj[key] = schematype.castForQuery(null, obj[key], context);
           continue;
         }
@@ -449,9 +449,9 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
 
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
           if (schematype &&
-              schematype.caster &&
-              !schematype.caster.$isMongooseArray &&
-              !schematype.caster[schemaMixedSymbol]) {
+              schematype.embeddedSchemaType &&
+              !schematype.embeddedSchemaType.$isMongooseArray &&
+              !schematype.embeddedSchemaType[schemaMixedSymbol]) {
             obj[key] = { $each: obj[key] };
           }
         }
@@ -546,17 +546,16 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     if (op in numberOps) {
       try {
         return castNumber(val);
-      } catch (err) {
+      } catch {
         throw new CastError('number', val, path);
       }
     }
     return val;
   }
 
-  // console.log('CastUpdateVal', path, op, val, schema);
-
-  const cond = schema.caster && op in castOps &&
-      (utils.isObject(val) || Array.isArray(val));
+  const cond = schema.$isMongooseArray
+    && op in castOps
+    && (utils.isObject(val) || Array.isArray(val));
   if (cond && !overwriteOps[op]) {
     // Cast values for ops that add data to MongoDB.
     // Ensures embedded documents get ObjectIds etc.
@@ -564,7 +563,7 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     let cur = schema;
     while (cur.$isMongooseArray) {
       ++schemaArrayDepth;
-      cur = cur.caster;
+      cur = cur.embeddedSchemaType;
     }
     let arrayDepth = 0;
     let _val = val;
@@ -605,7 +604,7 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     }
     try {
       return castNumber(val);
-    } catch (error) {
+    } catch {
       throw new CastError('number', val, schema.path);
     }
   }
@@ -625,7 +624,10 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
   }
 
   if (overwriteOps[op]) {
-    const skipQueryCastForUpdate = val != null && schema.$isMongooseArray && schema.$fullPath != null && !schema.$fullPath.match(/\d+$/);
+    const skipQueryCastForUpdate = val != null
+      && schema.$isMongooseArray
+      && schema.$fullPath != null
+      && !schema.$fullPath.match(/\d+$/);
     const applySetters = schema[schemaMixedSymbol] != null;
     if (skipQueryCastForUpdate || applySetters) {
       return schema.applySetters(val, context);

package/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -82,7 +82,7 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
         continue;
       }
 
-      const discriminator = getDiscriminatorByValue(schematype.caster.discriminators, discriminatorKey);
+      const discriminator = getDiscriminatorByValue(schematype.Constructor.discriminators, discriminatorKey);
       const discriminatorSchema = discriminator && discriminator.schema;
       if (discriminatorSchema == null) {
         continue;

package/lib/helpers/schema/applyPlugins.js

@@ -33,7 +33,7 @@ module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
         applyPlugins(type.schema, plugins, options, cacheKey);
 
         // Recompile schema because plugins may have changed it, see gh-7572
-        type.caster.prototype.$__setSchema(type.schema);
+        type.Constructor.prototype.$__setSchema(type.schema);
       }
     }
   }

package/lib/helpers/schema/getIndexes.js

@@ -67,7 +67,7 @@ module.exports = function getIndexes(schema) {
         }
       }
 
-      const index = path._index || (path.caster && path.caster._index);
+      const index = path._index || (path.embeddedSchemaType && path.embeddedSchemaType._index);
 
       if (index !== false && index !== null && index !== undefined) {
         const field = {};
@@ -96,9 +96,6 @@ module.exports = function getIndexes(schema) {
         }
 
         delete options.type;
-        if (!('background' in options)) {
-          options.background = true;
-        }
         if (schema.options.autoIndex != null) {
           options._autoIndex = schema.options.autoIndex;
         }
@@ -126,9 +123,6 @@ module.exports = function getIndexes(schema) {
     } else {
       schema._indexes.forEach(function(index) {
         const options = index[1];
-        if (!('background' in options)) {
-          options.background = true;
-        }
         decorateDiscriminatorIndexOptions(schema, options);
       });
       indexes = indexes.concat(schema._indexes);

package/lib/helpers/timestamps/setupTimestamps.js

@@ -42,15 +42,13 @@ module.exports = function setupTimestamps(schema, timestamps) {
 
   schema.add(schemaAdditions);
 
-  schema.pre('save', function timestampsPreSave(next) {
+  schema.pre('save', function timestampsPreSave() {
     const timestampOption = get(this, '$__.saveOptions.timestamps');
     if (timestampOption === false) {
-      return next();
+      return;
     }
 
     setDocumentTimestamps(this, timestampOption, currentTime, createdAt, updatedAt);
-
-    next();
   });
 
   schema.methods.initializeTimestamps = function() {
@@ -88,7 +86,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
   schema.pre('updateOne', opts, _setTimestampsOnUpdate);
   schema.pre('updateMany', opts, _setTimestampsOnUpdate);
 
-  function _setTimestampsOnUpdate(next) {
+  function _setTimestampsOnUpdate() {
     const now = currentTime != null ?
       currentTime() :
       this.model.base.now();
@@ -105,6 +103,5 @@ module.exports = function setupTimestamps(schema, timestamps) {
       replaceOps.has(this.op)
     );
     applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);
-    next();
   }
 };