mongoose 9.0.2 → 9.1.0

package/lib/types/arraySubdocument.js

@@ -73,7 +73,7 @@ for (const i in EventEmitter.prototype) {
 ArraySubdocument.prototype.$setIndex = function(index) {
   this.__index = index;
 
-  if (this.$__ != null && this.$__.validationError != null) {
+  if (this.$__?.validationError != null) {
     const keys = Object.keys(this.$__.validationError.errors);
     for (const key of keys) {
       this.invalidate(key, this.$__.validationError.errors[key]);
@@ -145,7 +145,7 @@ ArraySubdocument.prototype.$__fullPath = function(path, skipIndex) {
  */
 
 ArraySubdocument.prototype.$__pathRelativeToParent = function(path, skipIndex) {
-  if (this.__index == null || (!this.__parentArray || !this.__parentArray.$path)) {
+  if (this.__index == null || !this.__parentArray?.$path) {
     return null;
   }
   if (skipIndex) {
@@ -169,6 +169,16 @@ ArraySubdocument.prototype.$parent = function() {
   return this[documentArrayParent];
 };
 
+/*!
+ * Sets this sub-documents parent document.
+ *
+ * @api private
+ */
+
+ArraySubdocument.prototype.$__setParent = function $__setParent(parent) {
+  this[documentArrayParent] = parent;
+};
+
 /**
  * Returns this subdocument's parent array.
  *

package/lib/types/buffer.js

@@ -131,7 +131,7 @@ MongooseBuffer.mixin = {
   copy: function(target) {
     const ret = Buffer.prototype.copy.apply(this, arguments);
 
-    if (target && target.isMongooseBuffer) {
+    if (target?.isMongooseBuffer) {
       target._markModified();
     }
 

package/lib/types/documentArray/index.js

@@ -50,7 +50,7 @@ function MongooseDocumentArray(values, path, doc, schematype) {
   internals[arrayPathSymbol] = path;
   internals.__array = __array;
 
-  if (doc && doc.$__) {
+  if (doc?.$__) {
     internals[arrayParentSymbol] = doc;
     internals[arraySchemaSymbol] = doc.$__schema.path(path);
 
@@ -79,7 +79,7 @@ function MongooseDocumentArray(values, path, doc, schematype) {
       if (Object.hasOwn(DocumentArrayMethods, prop)) {
         return DocumentArrayMethods[prop];
       }
-      if (schematype && schematype.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
+      if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
       if (Object.hasOwn(ArrayMethods, prop)) {

package/lib/types/documentArray/methods/index.js

@@ -25,7 +25,7 @@ const methods = {
 
   toString() {
     return _baseToString.call(this.__array.map(subdoc => {
-      if (subdoc != null && subdoc.$__ != null) {
+      if (subdoc?.$__ != null) {
         return subdoc.toString();
       }
       return subdoc;
@@ -65,7 +65,7 @@ const methods = {
       value instanceof Constructor;
     if (isInstance ||
         // Hack re: #5001, see #5005
-        (value && value.constructor && value.constructor.baseCasterConstructor === Constructor)) {
+        value?.constructor?.baseCasterConstructor === Constructor) {
       if (!(value[documentArrayParent] && value.__parentArray)) {
         // value may have been created using array.create()
         value[documentArrayParent] = this[arrayParentSymbol];
@@ -75,7 +75,7 @@ const methods = {
       return value;
     }
 
-    if (value === undefined || value === null) {
+    if (value == null) {
       return null;
     }
 
@@ -133,9 +133,9 @@ const methods = {
     const schemaType = this[arraySchemaSymbol];
     let idSchemaType = null;
 
-    if (schemaType && schemaType.schema) {
+    if (schemaType?.schema) {
       idSchemaType = schemaType.schema.path('_id');
-    } else if (schemaType && schemaType.casterConstructor && schemaType.casterConstructor.schema) {
+    } else if (schemaType?.casterConstructor?.schema) {
       idSchemaType = schemaType.casterConstructor.schema.path('_id');
     }
 

package/lib/types/map.js

@@ -22,7 +22,7 @@ class MongooseMap extends Map {
       v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
     }
     super(v);
-    this.$__parent = doc != null && doc.$__ != null ? doc : null;
+    this.$__parent = doc?.$__ != null ? doc : null;
 
     // Calculate the full path from the root document
     // Priority: parent.$basePath (from subdoc) > options.path (from parent map/structure) > path (schema path)
@@ -50,7 +50,7 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    if (value != null && value.$isSingleNested) {
+    if (value?.$isSingleNested) {
       value.$basePath = this.$__path + '.' + key;
       // Store the path relative to parent subdoc for efficient markModified()
       if (this.$__pathRelativeToParent != null) {
@@ -129,7 +129,7 @@ class MongooseMap extends Map {
 
     let _fullPath;
     const parent = this.$__parent;
-    const populated = parent != null && parent.$__ && parent.$__.populated ?
+    const populated = parent?.$__?.populated ?
       parent.$populated(fullPath.call(this), true) || parent.$populated(this.$__path, true) :
       null;
     const priorVal = this.get(key);
@@ -177,7 +177,7 @@ class MongooseMap extends Map {
           options
         );
       } catch (error) {
-        if (this.$__parent != null && this.$__parent.$__ != null) {
+        if (this.$__parent?.$__ != null) {
           this.$__parent.invalidate(fullPath.call(this), error);
           return;
         }
@@ -189,7 +189,7 @@ class MongooseMap extends Map {
 
     // Set relative path on subdocuments to avoid string operations in markModified()
     // The path should be relative to the parent subdocument (if any), not just the key
-    if (value != null && value.$isSingleNested) {
+    if (value?.$isSingleNested) {
       if (this.$__pathRelativeToParent != null) {
         // Map's parent is a subdocument, store path relative to that subdoc (e.g., 'items.i2')
         value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
@@ -199,7 +199,7 @@ class MongooseMap extends Map {
       }
     }
 
-    if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
+    if (parent?.$__ != null && !deepEqual(value, priorVal)) {
       // Optimization: if parent is a subdocument, use precalculated relative path
       // to avoid building a full path just to strip the parent's prefix
       let pathToMark;
@@ -275,7 +275,7 @@ class MongooseMap extends Map {
   }
 
   toObject(options) {
-    if (options && options.flattenMaps) {
+    if (options?.flattenMaps) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {
@@ -308,7 +308,7 @@ class MongooseMap extends Map {
    */
 
   toJSON(options) {
-    if (typeof (options && options.flattenMaps) === 'boolean' ? options.flattenMaps : true) {
+    if (typeof options?.flattenMaps === 'boolean' ? options.flattenMaps : true) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {

package/lib/types/subdocument.js

@@ -23,10 +23,10 @@ function Subdocument(value, fields, parent, options) {
     }
     options = Object.assign(parentOptions, options);
   }
-  if (options != null && options.path != null) {
+  if (options?.path != null) {
     this.$basePath = options.path;
   }
-  if (options != null && options.pathRelativeToParent != null) {
+  if (options?.pathRelativeToParent != null) {
     this.$pathRelativeToParent = options.pathRelativeToParent;
   }
 
@@ -35,7 +35,7 @@ function Subdocument(value, fields, parent, options) {
   // subdocuments use relative paths (relative to the parent document) to track changes.
   // This avoids the subdocument's fields receiving the subdocument's path as options.path.
   let documentOptions = options;
-  if (options != null && options.path != null) {
+  if (options?.path != null) {
     documentOptions = Object.assign({}, options);
     delete documentOptions.path;
   }
@@ -356,6 +356,16 @@ Subdocument.prototype.parent = function() {
 
 Subdocument.prototype.$parent = Subdocument.prototype.parent;
 
+/*!
+ * Sets this sub-documents parent document.
+ *
+ * @api private
+ */
+
+Subdocument.prototype.$__setParent = function $__setParent(parent) {
+  this.$__parent = parent;
+};
+
 /**
  * ignore
  * @method $__removeFromParent
@@ -378,7 +388,7 @@ Subdocument.prototype.deleteOne = function deleteOne(options) {
   registerRemoveListener(this);
 
   // If removing entire doc, no need to remove subdoc
-  if (!options || !options.noop) {
+  if (!options?.noop) {
     this.$__removeFromParent();
 
     const owner = this.ownerDocument();
@@ -422,7 +432,7 @@ Subdocument.prototype.$toObject = function $toObject(options, json) {
 
   // If `$toObject()` was called recursively, respect the minimize option, including schematype level minimize.
   // If minimize is set, then we can minimize out the whole object.
-  if (Object.keys(ret).length === 0 && options?._calledWithOptions != null) {
+  if (utils.hasOwnKeys(ret) === false && options?._calledWithOptions != null) {
     const minimize = options._calledWithOptions?.minimize ?? this?.$__schemaTypeOptions?.minimize ?? options.minimize;
     if (minimize && !this.constructor.$__required) {
       return undefined;

package/lib/utils.js

@@ -436,10 +436,26 @@ exports.isNativeObject = function(arg) {
  * @param {Any} val
  */
 
-exports.isEmptyObject = function(val) {
-  return val != null &&
-    typeof val === 'object' &&
-    Object.keys(val).length === 0;
+exports.isEmptyObject = function isEmptyObject(val) {
+  if (val == null || typeof val !== 'object') {
+    return false;
+  }
+  return exports.hasOwnKeys(val) === false;
+};
+
+/**
+ * Determines if `obj` has any own keys. Assumes obj is already an object.
+ * Faster than Object.keys(obj).length > 0.
+ * @param {Object} obj
+ */
+
+exports.hasOwnKeys = function hasOwnKeys(obj) {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      return true;
+    }
+  }
+  return false;
 };
 
 /**
@@ -665,7 +681,7 @@ function getValueLookup(obj, part) {
     return obj;
   }
   let _from = obj?._doc || obj;
-  if (_from != null && _from.isMongooseArrayProxy) {
+  if (_from?.isMongooseArrayProxy) {
     _from = _from.__array;
   }
   return _from instanceof Map ?
@@ -720,7 +736,7 @@ exports.object.vals = function vals(o) {
  */
 
 exports.isNullOrUndefined = function(val) {
-  return val === null || val === undefined;
+  return val == null;
 };
 
 /*!
@@ -919,7 +935,7 @@ exports.mergeClone = function(to, fromObj) {
       });
     } else {
       let val = fromObj[key];
-      if (val != null && val.valueOf && !(val instanceof Date)) {
+      if (val?.valueOf && !(val instanceof Date)) {
         val = val.valueOf();
       }
       if (exports.isObject(val)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.0.2",
+  "version": "9.1.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -50,7 +50,7 @@
     "mkdirp": "^3.0.1",
     "mocha": "11.7.5",
     "moment": "2.30.1",
-    "mongodb-memory-server": "10.3.0",
+    "mongodb-memory-server": "11.0.0",
     "mongodb-runner": "^6.0.0",
     "mongodb-client-encryption": "~7.0",
     "ncp": "^2.0.0",

package/types/index.d.ts

@@ -177,7 +177,7 @@ declare module 'mongoose' {
     HydratedDocPathsType,
     any,
     TOverrides extends Record<string, never> ?
-      Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions> :
+      Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions> & AddDefaultId<HydratedDocPathsType, {}, TSchemaOptions> :
       IfAny<
         TOverrides,
         Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions>,
@@ -560,9 +560,14 @@ declare module 'mongoose' {
     pre<T = never>(method: MongooseDistinctDocumentMiddleware | MongooseDistinctDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: boolean }, fn: PreMiddlewareFunction<T>): this;
     // this = Union of Document and Query, could be called with any of them
     pre<T = THydratedDocumentType | Query<any, any>>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
       options: SchemaPreOptions & { document: true, query: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType | Query<any, any>>(
+      method: 'deleteOne' | RegExp,
+      options: SchemaPreOptions & { document: true, query: true },
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
@@ -570,9 +575,14 @@ declare module 'mongoose' {
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
+      options: SchemaPreOptions & { document: true },
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType>(
+      method: 'deleteOne' | RegExp,
       options: SchemaPreOptions & { document: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     pre<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: true, query: false }, fn: PreMiddlewareFunction<T>): this;
     // this = Query

package/types/middlewares.d.ts

@@ -38,6 +38,17 @@ declare module 'mongoose' {
     this: ThisType,
     opts?: Record<string, any>
   ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreDeleteOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    doc: ThisType,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreUpdateOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    doc: ThisType,
+    update?: Record<string, any>,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     opts: SaveOptions

package/types/models.d.ts

@@ -190,19 +190,27 @@ declare module 'mongoose' {
     mongodb.InsertOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
 
   export type ReplaceOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.ReplaceOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
+    Omit<mongodb.ReplaceOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.UpdateOneModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
+    Omit<mongodb.UpdateOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.UpdateManyModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
+    Omit<mongodb.UpdateManyModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type DeleteOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.DeleteOneModel<TSchema>;
+    Omit<mongodb.DeleteOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> };
 
   export type DeleteManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.DeleteManyModel<TSchema>;
+    Omit<mongodb.DeleteManyModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> };
 
   export type AnyBulkWriteOperation<TSchema extends mongodb.Document = mongodb.Document> =
     | { insertOne: InsertOneModel<TSchema> }
@@ -335,6 +343,8 @@ declare module 'mongoose' {
 
     /** Creates a new document or documents */
     create(): Promise<null>;
+    create(doc: Partial<TRawDocType>): Promise<THydratedDocumentType>;
+    create(docs: Array<Partial<TRawDocType>>): Promise<THydratedDocumentType[]>;
     create(docs: Array<DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>>, options: CreateOptions & { aggregateErrors: true }): Promise<(THydratedDocumentType | Error)[]>;
     create(docs: Array<DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>>, options?: CreateOptions): Promise<THydratedDocumentType[]>;
     create(doc: DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>): Promise<THydratedDocumentType>;

package/types/schemaoptions.d.ts

@@ -111,8 +111,10 @@ declare module 'mongoose' {
     /**
      * Optimistic concurrency is a strategy to ensure the document you're updating didn't change between when you
      * loaded it using find() or findOne(), and when you update it using save(). Set to `true` to enable
-     * optimistic concurrency. Set to string array to enable optimistic concurrency for only certain fields,
-     * or `{ exclude: string[] }` to define a list of fields to ignore for optimistic concurrency.
+     * optimistic concurrency for all fields. Set to a string array to enable optimistic concurrency only for
+     * the specified fields; note that this **replaces** the default array versioning behavior. Set to
+     * `{ exclude: string[] }` to enable optimistic concurrency for all fields except the specified ones;
+     * this also **replaces** the default array versioning.
      */
     optimisticConcurrency?: boolean | string[] | { exclude: string[] };
     /**