mongoose 9.11.0 → 9.11.1

package/lib/cast.js

@@ -11,6 +11,7 @@ const cast$expr = require('./helpers/query/cast$expr');
 const castString = require('./cast/string');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
+const getDiscriminatorValueFromFilter = require('./helpers/discriminator/getDiscriminatorValueFromFilter');
 const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
 const isOperator = require('./helpers/query/isOperator');
 const util = require('util');
@@ -43,7 +44,8 @@ module.exports = function cast(schema, obj, options, context) {
   }
 
   if (schema?.discriminators != null && obj[schema.options.discriminatorKey] != null) {
-    schema = getSchemaDiscriminatorByValue(schema, obj[schema.options.discriminatorKey]) || schema;
+    const discriminatorValue = getDiscriminatorValueFromFilter(obj[schema.options.discriminatorKey]);
+    schema = getSchemaDiscriminatorByValue(schema, discriminatorValue) || schema;
   }
 
   const paths = Object.keys(obj);
@@ -134,18 +136,10 @@ module.exports = function cast(schema, obj, options, context) {
           if (_schematype?.schema?.discriminators != null &&
             discriminatorKey != null &&
             pathLastHalf !== discriminatorKey) {
-            const discriminatorVal = get(obj, pathFirstHalf + '.' + discriminatorKey);
+            const discriminatorVal = getDiscriminatorValueFromFilter(get(obj, pathFirstHalf + '.' + discriminatorKey));
             const discriminators = _schematype.schema.discriminators;
             if (typeof discriminatorVal === 'string' && discriminators[discriminatorVal] != null) {
-
               schematype = discriminators[discriminatorVal].path(pathLastHalf);
-            } else if (discriminatorVal != null &&
-              Object.keys(discriminatorVal).length === 1 &&
-              Array.isArray(discriminatorVal.$in) &&
-              discriminatorVal.$in.length === 1 &&
-              typeof discriminatorVal.$in[0] === 'string' &&
-              discriminators[discriminatorVal.$in[0]] != null) {
-              schematype = discriminators[discriminatorVal.$in[0]].path(pathLastHalf);
             }
           }
         }
@@ -329,15 +323,11 @@ module.exports = function cast(schema, obj, options, context) {
               if (nested && schematype?.schema != null) {
                 cast(schematype.schema, nested, options, context);
               } else if (nested && schematype?.$isMongooseArray) {
-                if (utils.isPOJO(nested) && nested.$not != null) {
-                  cast(schema, nested, options, context);
-                } else {
-                  val[$cond] = schematype.castForQuery(
-                    $cond,
-                    nested,
-                    context
-                  );
-                }
+                val[$cond] = schematype.castForQuery(
+                  $cond,
+                  nested,
+                  context
+                );
               }
             } else if ($cond === '$not') {
               if (nested && schematype) {

package/lib/cursor/queryCursor.js

@@ -170,6 +170,9 @@ QueryCursor.prototype.getDriverCursor = async function getDriverCursor() {
   if (this.cursor) {
     return this.cursor;
   }
+  if (this._error) {
+    throw this._error;
+  }
 
   await once(this, 'cursor');
   return this.cursor;
@@ -278,7 +281,7 @@ QueryCursor.prototype._destroy = function _destroy(_err, callback) {
 
   waitForCursor
     .then(() => {
-      this.cursor.close();
+      return this.cursor.close();
     })
     .then(() => {
       this._closed = true;

package/lib/document.js

@@ -63,6 +63,7 @@ const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const getDeepestSubdocumentForPath = require('./helpers/document/getDeepestSubdocumentForPath');
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
+const toObjectRecursive = require('./helpers/document/toObjectRecursive');
 
 let DocumentArray;
 let Embedded;
@@ -1253,9 +1254,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (pathType === 'nested' && val) {
     if (typeof val === 'object' && val != null) {
-      if (val.$__ != null) {
-        val = val.toObject(internalToObjectOptions);
-      }
+      val = toObjectRecursive(val, internalToObjectOptions);
       if (val == null) {
         this.invalidate(path, new MongooseError.CastError('Object', val, path));
         return this;
@@ -4265,9 +4264,11 @@ Document.prototype.$toObject = function(options, json) {
     ?? false;
 
   let ret;
-  if (hasOnlyPrimitiveValues && !options.flattenObjectIds) {
+  if (hasOnlyPrimitiveValues && !options.flattenObjectIds && !options.flattenDecimals) {
     // Fast path: if we don't have any nested objects or arrays, we only need a
-    // shallow clone.
+    // shallow clone. Skipped for `flattenObjectIds` and `flattenDecimals`, because
+    // `$__hasOnlyPrimitiveValues()` counts ObjectIds and Decimal128s as primitives
+    // and only the full `clone()` path converts them.
     ret = this.$__toObjectShallow(schemaFieldsOnly);
   } else if (schemaFieldsOnly) {
     ret = {};

package/lib/helpers/discriminator/getDiscriminatorValueFromFilter.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const isPOJO = require('../isPOJO');
+
+/**
+ * Returns the single discriminator value that a query filter condition selects,
+ * like `'Clicked'` for `'Clicked'`, `{ $eq: 'Clicked' }`, or `{ $in: ['Clicked'] }`.
+ * Returns the condition unchanged if it does not select exactly one value.
+ *
+ * @param {any} value the filter condition on the discriminator key
+ * @return {any}
+ * @api private
+ */
+
+module.exports = function getDiscriminatorValueFromFilter(value) {
+  if (!isPOJO(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return value;
+  }
+  if (keys[0] === '$eq') {
+    return value.$eq;
+  }
+  if (keys[0] === '$in' && Array.isArray(value.$in) && value.$in.length === 1) {
+    return value.$in[0];
+  }
+  return value;
+};

package/lib/helpers/document/toObjectRecursive.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const isPOJO = require('../isPOJO');
+
+/**
+ * Convert nested path documents underneath POJOs and arrays to POJOs without
+ * modifying the original value. Only clone containers that contain a nested
+ * path document. Preserve regular document children so casting can handle
+ * populated documents and subdocuments.
+ */
+
+module.exports = function toObjectRecursive(value, options) {
+  return _toObjectRecursive(value, options, true, new Set());
+};
+
+function _toObjectRecursive(value, options, isRoot, seen) {
+  if (value == null) {
+    return value;
+  }
+
+  if (value.$__ != null && typeof value.toObject === 'function') {
+    return isRoot || value.$__isNested ? value.toObject(options) : value;
+  }
+
+  if (!Array.isArray(value) && !isPOJO(value)) {
+    return value;
+  }
+
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+
+  let ret = value;
+  for (const key of Object.keys(value)) {
+    const converted = _toObjectRecursive(value[key], options, false, seen);
+    if (converted === value[key]) {
+      continue;
+    }
+
+    if (ret === value) {
+      ret = Array.isArray(value) ? Object.assign([], value) : { ...value };
+    }
+    ret[key] = converted;
+  }
+
+  seen.delete(value);
+  return ret;
+}

package/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -3,6 +3,7 @@
 const cleanPositionalOperators = require('../schema/cleanPositionalOperators');
 const get = require('../get');
 const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');
+const getDiscriminatorValueFromFilter = require('../discriminator/getDiscriminatorValueFromFilter');
 const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter');
 
 /**
@@ -46,16 +47,16 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
       let discriminatorKey = null;
 
       if (discriminatorValuePath in filter) {
-        discriminatorKey = filter[discriminatorValuePath];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[discriminatorValuePath]);
       }
       if (discriminatorFilterPath in filter) {
-        discriminatorKey = filter[discriminatorFilterPath];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[discriminatorFilterPath]);
       }
 
       const wrapperPath = subpath.replace(/\.\d+$/, '');
       if (schematype.$isMongooseDocumentArrayElement &&
           get(filter[wrapperPath], '$elemMatch.' + key) != null) {
-        discriminatorKey = filter[wrapperPath].$elemMatch[key];
+        discriminatorKey = getDiscriminatorValueFromFilter(filter[wrapperPath].$elemMatch[key]);
       }
 
       const discriminatorKeyUpdatePath = originalSubpath + '.' + key;

package/lib/helpers/update/castArrayFilters.js

@@ -92,7 +92,7 @@ function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilt
 
       if (schematype == null) {
         if (!strictQuery) {
-          return;
+          continue;
         }
         const filterPath = filterPathRelativeToBase == null ?
           baseFilterPath + '.0' :

package/lib/schema/array.js

@@ -611,6 +611,19 @@ function cast$elemMatch(val, context) {
   for (let i = 0; i < numKeys; ++i) {
     const key = keys[i];
     const value = val[key];
+    if (key === '$not') {
+      // `$not` wraps other operators, like `{ $not: { $gt: 5 } }` or
+      // `{ $not: { $elemMatch: ... } }`, so cast each wrapped operator.
+      // A RegExp is left as-is.
+      if (utils.isPOJO(value)) {
+        for (const notKey of Object.keys(value)) {
+          if (isOperator(notKey) && value[notKey] != null) {
+            value[notKey] = this.castForQuery(notKey, value[notKey], context);
+          }
+        }
+      }
+      continue;
+    }
     if (isOperator(key) && value != null) {
       val[key] = this.castForQuery(key, value, context);
     }

package/lib/schema/documentArray.js

@@ -484,10 +484,10 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
         }
 
         subdoc = new Constructor(null, value, initDocumentOptions, selected, i);
-        // Don't pass `path` to $init - it's only for this DocumentArray itself, not its element fields.
-        // Element subdocuments use relative paths internally for change tracking.
-        if (options.path != null) {
-          const { path, ...initOptions } = options;
+        // Don't pass `path` or `arrayPathIndex` to $init - they're only for this DocumentArray itself,
+        // not its element fields. Element subdocuments use relative paths internally for change tracking.
+        if (options.path != null || options.arrayPathIndex != null) {
+          const { path, arrayPathIndex, ...initOptions } = options;
           options = initOptions;
         }
         rawArray[i] = subdoc.$init(rawArray[i], options);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.11.0",
+  "version": "9.11.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/index.d.ts

@@ -738,7 +738,7 @@ declare module 'mongoose' {
     static ObjectId: typeof Schema.Types.ObjectId;
   }
 
-  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number | Schema.Types.Number;
+  export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number | Schema.Types.Number | 'int32' | 'Int32' | typeof Schema.Types.Int32 | Schema.Types.Int32;
   export type StringSchemaDefinition = typeof String | 'string' | 'String' | typeof Schema.Types.String | Schema.Types.String;
   export type BooleanSchemaDefinition = typeof Boolean | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean | Schema.Types.Boolean;
   export type DateSchemaDefinition = DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date | Schema.Types.Date;

package/types/models.d.ts

@@ -158,13 +158,19 @@ declare module 'mongoose' {
     MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    Omit<mongodb.UpdateOneModel<TSchema>, 'filter'> &
-    { filter: QueryFilter<TSchema> } &
+    Omit<mongodb.UpdateOneModel<TSchema>, 'filter' | 'update'> &
+    {
+      filter: QueryFilter<TSchema>;
+      update: UpdateQuery<TSchema> | UpdateWithAggregationPipeline;
+    } &
     MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    Omit<mongodb.UpdateManyModel<TSchema>, 'filter'> &
-    { filter: QueryFilter<TSchema> } &
+    Omit<mongodb.UpdateManyModel<TSchema>, 'filter' | 'update'> &
+    {
+      filter: QueryFilter<TSchema>;
+      update: UpdateQuery<TSchema> | UpdateWithAggregationPipeline;
+    } &
     MongooseBulkUpdatePerOperationOptions;
 
   export type DeleteOneModel<TSchema extends mongodb.Document = mongodb.Document> =