mongoose 9.10.4 → 9.11.1

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/query.js

@@ -2563,6 +2563,35 @@ Query.prototype.find = function(conditions) {
   return this;
 };
 
+/**
+ * Executes the query as a `find()` and also runs a `countDocuments()` query
+ * on the same filter, returning `[documents, count]`. The count ignores
+ * `skip` and `limit` so that it returns the total number of matching documents.
+ *
+ * #### Example:
+ *
+ *     const query = Adventure.find({ type: 'animal' }).sort({ name: 1 }).limit(10);
+ *     const [adventures, total] = await query.findAndCount();
+ *
+ * @return {Promise<Array>} a promise that resolves to `[documents, total]`
+ * @api public
+ */
+
+Query.prototype.findAndCount = async function findAndCount() {
+  if (this.options.sort == null) {
+    throw new MongooseError('Query.prototype.findAndCount() requires sort. Use `sort()` to set a sort order before calling `findAndCount()`.');
+  }
+  if (this.options.limit == null) {
+    throw new MongooseError('Query.prototype.findAndCount() requires limit. Use `limit()` to set a limit before calling `findAndCount()`.');
+  }
+
+  this.op = 'find';
+
+  const countQuery = this.clone().countDocuments().skip(0).limit(null);
+
+  return Promise.all([this.exec(), countQuery.exec()]);
+};
+
 /**
  * Merges another Query or conditions object into this one.
  *

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

@@ -65,7 +65,6 @@ function SchemaDocumentArray(key, schema, options, schemaOptions, parentSchema)
     $parentSchemaType,
     Constructor
   });
-
   SchemaArray.call(this, key, embeddedSchemaType, options, null, parentSchema);
 
   this.schema = schema;
@@ -234,8 +233,16 @@ SchemaDocumentArray.prototype.doValidate = async function doValidate(array, scop
   // lazy load
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentArray'));
 
-  await SchemaType.prototype.doValidate.call(this, array, scope);
+  let schemaTypeError;
+  try {
+    await SchemaType.prototype.doValidate.call(this, array, scope);
+  } catch (err) {
+    schemaTypeError = err;
+  }
   if (options?.updateValidator) {
+    if (schemaTypeError != null) {
+      throw schemaTypeError;
+    }
     return;
   }
   if (!utils.isMongooseDocumentArray(array)) {
@@ -258,14 +265,29 @@ SchemaDocumentArray.prototype.doValidate = async function doValidate(array, scop
       doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
-    if (options?.validateModifiedOnly && !doc.$isModified()) {
+    if (options?.validateModifiedOnly && !doc.$isNew && !doc.$isModified()) {
       continue;
     }
 
-    promises.push(doc.validate(null, options));
+    const subdocOptions = doc.$isNew && options?.validateModifiedOnly ?
+      { ...options, validateModifiedOnly: false } :
+      options;
+    promises.push(doc.validate(null, subdocOptions));
   }
 
-  await Promise.all(promises);
+  let subdocumentError;
+  try {
+    await Promise.all(promises);
+  } catch (err) {
+    subdocumentError = err;
+  }
+
+  if (schemaTypeError != null) {
+    throw schemaTypeError;
+  }
+  if (subdocumentError != null) {
+    throw subdocumentError;
+  }
 };
 
 /**
@@ -281,15 +303,11 @@ SchemaDocumentArray.prototype.doValidate = async function doValidate(array, scop
 
 SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
   const schemaTypeError = SchemaType.prototype.doValidateSync.call(this, array, scope);
-  if (schemaTypeError != null) {
-    return schemaTypeError;
-  }
-
   const count = array?.length;
-  let resultError = null;
+  let resultError = schemaTypeError;
 
   if (!count) {
-    return;
+    return resultError;
   }
 
   // handle sparse arrays, do not use array.forEach which does not
@@ -310,11 +328,14 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
       doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
-    if (options?.validateModifiedOnly && !doc.$isModified()) {
+    if (options?.validateModifiedOnly && !doc.$isNew && !doc.$isModified()) {
       continue;
     }
 
-    const subdocValidateError = doc.$__validateSync(options);
+    const subdocOptions = doc.$isNew && options?.validateModifiedOnly ?
+      { ...options, validateModifiedOnly: false } :
+      options;
+    const subdocValidateError = doc.$__validateSync(subdocOptions);
 
     if (subdocValidateError && resultError == null) {
       resultError = subdocValidateError;
@@ -463,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/lib/schema/documentArrayElement.js

@@ -108,9 +108,41 @@ SchemaDocumentArrayElement.prototype.doValidate = async function doValidate(valu
     value = new Constructor(value, scope, null, null, options?.index ?? null);
   }
 
+  // The parent document array validates each of its subdocuments, so when it
+  // already did, this element's own validators are all that is left to run.
+  if (options?.skipSubdocumentValidation) {
+    if (options.skipSchemaValidators) {
+      return;
+    }
+    return SchemaType.prototype.doValidate.call(this, value, scope, options);
+  }
+
   return SchemaSubdocument.prototype.doValidate.call(this, value, scope, options);
 };
 
+/**
+ * Synchronous validation on this individual array element
+ *
+ * @api private
+ */
+
+SchemaDocumentArrayElement.prototype.doValidateSync = function doValidateSync(value, scope, options) {
+  const Constructor = getConstructor(this.Constructor, value);
+
+  if (value && !(value instanceof Constructor)) {
+    value = new Constructor(value, scope, null, null, options?.index ?? null);
+  }
+
+  if (options?.skipSubdocumentValidation) {
+    if (options.skipSchemaValidators) {
+      return;
+    }
+    return SchemaType.prototype.doValidateSync.call(this, value, scope, options);
+  }
+
+  return SchemaSubdocument.prototype.doValidateSync.call(this, value, scope, options);
+};
+
 /**
  * Clone the current SchemaType
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.10.4",
+  "version": "9.11.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -22,7 +22,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "kareem": "3.4.0",
-    "mongodb": "~7.6",
+    "mongodb": "~7.7",
     "mpath": "0.9.0",
     "mquery": "6.0.0",
     "ms": "2.1.3",

package/tstyche.matrix.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://tstyche.org/schemas/config.json",
+  "checkDeclarationFiles": false,
+  "checkSuppressedErrors": false,
+  "testFileMatch": [
+    "test/types/*.test.*",
+    "test/types/**/*.test.*"
+  ]
+}

package/types/connection.d.ts

@@ -203,7 +203,7 @@ declare module 'mongoose' {
           ObtainSchemaGeneric<TSchema, 'TSchemaOptions'>
         >,
       TSchema,
-      ObtainSchemaGeneric<TSchema, 'TLeanResultType'>
+      Default__v<Require_id<ObtainSchemaGeneric<TSchema, 'TLeanResultType'>>>
     > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
     model<T, U, TQueryHelpers = {}>(
       name: string,

package/types/document.d.ts

@@ -141,7 +141,9 @@ declare module 'mongoose' {
       this,
       TQueryHelpers,
       DocType,
-      'deleteOne'
+      'deleteOne',
+      Record<string, never>,
+      Default__v<Require_id<DocType>>
     >;
 
     /**

package/types/index.d.ts

@@ -104,7 +104,7 @@ declare module 'mongoose' {
         ObtainSchemaGeneric<TSchema, 'TSchemaOptions'>
       >,
     TSchema,
-    ObtainSchemaGeneric<TSchema, 'TLeanResultType'>
+    Default__v<Require_id<ObtainSchemaGeneric<TSchema, 'TLeanResultType'>>>
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
@@ -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;