mongoose 8.19.4 → 8.20.0

package/lib/schema.js

@@ -1572,7 +1572,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   let name;
 
   if (utils.isPOJO(type) || type === 'mixed') {
-    return new MongooseTypes.Mixed(path, obj);
+    return new MongooseTypes.Mixed(path, obj, null, this);
   }
 
   if (Array.isArray(type) || type === Array || type === 'array' || type === MongooseTypes.Array) {
@@ -1595,7 +1595,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
             `${path}: new Schema(...)`);
         }
       }
-      return new MongooseTypes.DocumentArray(path, cast, obj);
+      return new MongooseTypes.DocumentArray(path, cast, obj, null, this);
     }
     if (cast &&
         cast[options.typeKey] &&
@@ -1612,14 +1612,14 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
             `${path}: new Schema(...)`);
         }
       }
-      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast);
+      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast, this);
     }
     if (typeof cast !== 'undefined') {
       if (Array.isArray(cast) || cast.type === Array || cast.type == 'Array') {
         if (cast && cast.type == 'Array') {
           cast.type = Array;
         }
-        return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj);
+        return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj, null, this);
       }
     }
 
@@ -1660,10 +1660,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
 
         const childSchema = new Schema(castFromTypeKey, childSchemaOptions);
         childSchema.$implicitlyCreated = true;
-        return new MongooseTypes.DocumentArray(path, childSchema, obj);
+        return new MongooseTypes.DocumentArray(path, childSchema, obj, null, this);
       } else {
         // Special case: empty object becomes mixed
-        return new MongooseTypes.Array(path, MongooseTypes.Mixed, obj);
+        return new MongooseTypes.Array(path, MongooseTypes.Mixed, obj, null, this);
       }
     }
 
@@ -1672,7 +1672,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
         ? cast[options.typeKey]
         : cast;
       if (Array.isArray(type)) {
-        return new MongooseTypes.Array(path, this.interpretAsType(path, type, options), obj);
+        return new MongooseTypes.Array(path, this.interpretAsType(path, type, options), obj, null, this);
       }
 
       name = typeof type === 'string'
@@ -1700,11 +1700,11 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       }
     }
 
-    return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options);
+    return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options, this);
   }
 
   if (type && type.instanceOfSchema) {
-    return new MongooseTypes.Subdocument(type, path, obj);
+    return new MongooseTypes.Subdocument(type, path, obj, this);
   }
 
   if (Buffer.isBuffer(type)) {
@@ -1743,53 +1743,11 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
   }
 
-  if (name === 'Union') {
-    obj.parentSchema = this;
-  }
-  const schemaType = new MongooseTypes[name](path, obj, options);
-
-  if (schemaType.$isSchemaMap) {
-    createMapNestedSchemaType(this, schemaType, path, obj, options);
-  }
+  const schemaType = new MongooseTypes[name](path, obj, options, this);
 
   return schemaType;
 };
 
-/*!
- * ignore
- */
-
-function createMapNestedSchemaType(schema, schemaType, path, obj, options) {
-  const mapPath = path + '.$*';
-  let _mapType = { type: {} };
-  if (utils.hasUserDefinedProperty(obj, 'of')) {
-    const isInlineSchema = utils.isPOJO(obj.of) &&
-      Object.keys(obj.of).length > 0 &&
-      !utils.hasUserDefinedProperty(obj.of, schema.options.typeKey);
-    if (isInlineSchema) {
-      _mapType = { [schema.options.typeKey]: new Schema(obj.of) };
-    } else if (utils.isPOJO(obj.of)) {
-      _mapType = Object.assign({}, obj.of);
-    } else {
-      _mapType = { [schema.options.typeKey]: obj.of };
-    }
-
-    if (_mapType[schema.options.typeKey] && _mapType[schema.options.typeKey].instanceOfSchema) {
-      const subdocumentSchema = _mapType[schema.options.typeKey];
-      subdocumentSchema.eachPath((subpath, type) => {
-        if (type.options.select === true || type.options.select === false) {
-          throw new MongooseError('Cannot use schema-level projections (`select: true` or `select: false`) within maps at path "' + path + '.' + subpath + '"');
-        }
-      });
-    }
-
-    if (utils.hasUserDefinedProperty(obj, 'ref')) {
-      _mapType.ref = obj.ref;
-    }
-  }
-  schemaType.$__schemaType = schema.interpretAsType(mapPath, _mapType, options);
-}
-
 /**
  * Iterates the schemas paths similar to Array#forEach.
  *

package/lib/schemaType.js

@@ -37,10 +37,11 @@ const setOptionsForDefaults = { _skipMarkModified: true };
  * @param {String} path
  * @param {SchemaTypeOptions} [options] See [SchemaTypeOptions docs](https://mongoosejs.com/docs/api/schematypeoptions.html)
  * @param {String} [instance]
+ * @param {Schema} [parentSchema]
  * @api public
  */
 
-function SchemaType(path, options, instance) {
+function SchemaType(path, options, instance, parentSchema) {
   this[schemaTypeSymbol] = true;
   this.path = path;
   this.instance = instance;
@@ -73,6 +74,7 @@ function SchemaType(path, options, instance) {
 
   const Options = this.OptionsConstructor || SchemaTypeOptions;
   this.options = new Options(options);
+  this.parentSchema = parentSchema;
   this._index = null;
 
   if (utils.hasUserDefinedProperty(this.options, 'immutable')) {
@@ -157,6 +159,30 @@ SchemaType.prototype.OptionsConstructor = SchemaTypeOptions;
 
 SchemaType.prototype.path;
 
+/**
+ * Returns a plain JavaScript object representing this SchemaType.
+ *
+ * Typically used by `JSON.stringify()` or when calling `.toJSON()` on a SchemaType instance.
+ * Omits certain internal properties such as `parentSchema` that can cause circular references.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({ name: String });
+ *     const schematype = schema.path('name');
+ *     console.log(schematype.toJSON());
+ *
+ * @function toJSON
+ * @memberOf SchemaType
+ * @instance
+ * @api public
+ */
+
+SchemaType.prototype.toJSON = function toJSON() {
+  const res = { ...this };
+  delete res.parentSchema;
+  return res;
+};
+
 /**
  * The validators that Mongoose should run to validate properties at this SchemaType's path.
  *
@@ -1751,7 +1777,7 @@ SchemaType.prototype.checkRequired = function(val) {
 
 SchemaType.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, options, this.instance);
+  const schematype = new this.constructor(this.path, options, this.instance, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) schematype.requiredValidator = this.requiredValidator;
   if (this.defaultValue !== undefined) schematype.defaultValue = this.defaultValue;

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

@@ -2,7 +2,6 @@
 
 const ArrayMethods = require('../../array/methods');
 const Document = require('../../../document');
-const castObjectId = require('../../../cast/objectid');
 const getDiscriminatorByValue = require('../../../helpers/discriminator/getDiscriminatorByValue');
 const internalToObjectOptions = require('../../../options').internalToObjectOptions;
 const utils = require('../../../utils');
@@ -121,23 +120,34 @@ const methods = {
    *
    * @return {EmbeddedDocument|null} the subdocument or null if not found.
    * @param {ObjectId|String|Number|Buffer} id
-   * @TODO cast to the _id based on schema for proper comparison
    * @method id
    * @api public
    * @memberOf MongooseDocumentArray
    */
 
   id(id) {
-    let casted;
-    let sid;
-    let _id;
+    if (id == null) {
+      return null;
+    }
+
+    const schemaType = this[arraySchemaSymbol];
+    let idSchemaType = null;
+
+    if (schemaType && schemaType.schema) {
+      idSchemaType = schemaType.schema.path('_id');
+    } else if (schemaType && schemaType.casterConstructor && schemaType.casterConstructor.schema) {
+      idSchemaType = schemaType.casterConstructor.schema.path('_id');
+    }
 
-    try {
-      casted = castObjectId(id).toString();
-    } catch (e) {
-      casted = null;
+    let castedId = null;
+    if (idSchemaType) {
+      try {
+        castedId = idSchemaType.cast(id);
+      } catch (_err) {}
     }
 
+    let _id;
+
     for (const val of this) {
       if (!val) {
         continue;
@@ -145,18 +155,20 @@ const methods = {
 
       _id = val.get('_id');
 
-      if (_id === null || typeof _id === 'undefined') {
+      if (_id == null) {
         continue;
       } else if (_id instanceof Document) {
-        sid || (sid = String(id));
-        if (sid == _id._id) {
+        _id = _id.get('_id');
+        if (castedId != null && utils.deepEqual(castedId, _id)) {
           return val;
-        }
-      } else if (!isBsonType(id, 'ObjectId') && !isBsonType(_id, 'ObjectId')) {
-        if (id == _id || utils.deepEqual(id, _id)) {
+        } else if (castedId == null && (id == _id || utils.deepEqual(id, _id))) {
+          // Backwards compat: compare user-specified param to _id using loose equality
           return val;
         }
-      } else if (casted == _id) {
+      } else if (castedId != null && utils.deepEqual(castedId, _id)) {
+        return val;
+      } else if (castedId == null && (_id == id || utils.deepEqual(id, _id))) {
+        // Backwards compat: compare user-specified param to _id using loose equality
         return val;
       }
     }

package/lib/types/map.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Mixed = require('../schema/mixed');
 const MongooseError = require('../error/mongooseError');
 const clone = require('../helpers/clone');
 const deepEqual = require('../utils').deepEqual;
@@ -41,7 +40,7 @@ class MongooseMap extends Map {
       this.$__pathRelativeToParent = null;
     }
 
-    this.$__schemaType = schemaType == null ? new Mixed(path) : schemaType;
+    this.$__schemaType = schemaType;
 
     this.$__runDeferred();
   }

package/package.json

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

package/types/document.d.ts

@@ -18,7 +18,7 @@ declare module 'mongoose' {
    * *  TQueryHelpers - Object with any helpers that should be mixed into the Query type
    * *  DocType - the type of the actual Document created
    */
-  class Document<T = unknown, TQueryHelpers = any, DocType = any, TVirtuals = Record<string, any>, TSchemaOptions = {}> {
+  class Document<T = Types.ObjectId, TQueryHelpers = any, DocType = any, TVirtuals = Record<string, any>, TSchemaOptions = {}> {
     constructor(doc?: any);
 
     /** This documents _id. */