mongoose 6.2.7 → 6.2.8

package/lib/browserDocument.js

@@ -17,6 +17,7 @@ const isObject = require('./helpers/isObject');
  * Document constructor.
  *
  * @param {Object} obj the values to set
+ * @param {Object} schema
  * @param {Object} [fields] optional object containing the fields which were selected in the query returning this document and any populated paths data
  * @param {Boolean} [skipId] bool, should we auto create an ObjectId _id
  * @inherits NodeJS EventEmitter https://nodejs.org/api/events.html#events_class_events_eventemitter

package/lib/cursor/AggregationCursor.js

@@ -26,7 +26,6 @@ const util = require('util');
  * Use [`Aggregate#cursor()`](/docs/api.html#aggregate_Aggregate-cursor) instead.
  *
  * @param {Aggregate} agg
- * @param {Object} options
  * @inherits Readable
  * @event `cursor`: Emitted when the cursor is created
  * @event `error`: Emitted when an error occurred

package/lib/document.js

@@ -801,7 +801,7 @@ function init(self, obj, doc, opts, prefix) {
       init(self, obj[i], doc[i], opts, path + '.');
     } else if (!schemaType) {
       doc[i] = obj[i];
-      if (!strict) {
+      if (!strict && !prefix) {
         self[i] = obj[i];
       }
     } else {
@@ -2472,7 +2472,6 @@ function _getPathsToValidate(doc) {
     return true;
   }));
 
-
   Object.keys(doc.$__.activePaths.states.init).forEach(addToPaths);
   Object.keys(doc.$__.activePaths.states.modify).forEach(addToPaths);
   Object.keys(doc.$__.activePaths.states.default).forEach(addToPaths);
@@ -2484,18 +2483,23 @@ function _getPathsToValidate(doc) {
     if (subdoc.$basePath) {
       // Remove child paths for now, because we'll be validating the whole
       // subdoc
+      if (!subdoc.$__.fullPath) {
+        subdoc.ownerDocument();
+      }
+      const fullPathToSubdoc = subdoc.$__.fullPath;
+
       for (const p of paths) {
-        if (p === null || p.startsWith(subdoc.$basePath + '.')) {
+        if (p === null || p.startsWith(fullPathToSubdoc + '.')) {
           paths.delete(p);
         }
       }
 
-      if (doc.$isModified(subdoc.$basePath, modifiedPaths) &&
-            !doc.isDirectModified(subdoc.$basePath) &&
-            !doc.$isDefault(subdoc.$basePath)) {
-        paths.add(subdoc.$basePath);
+      if (doc.$isModified(fullPathToSubdoc, modifiedPaths) &&
+            !doc.isDirectModified(fullPathToSubdoc) &&
+            !doc.$isDefault(fullPathToSubdoc)) {
+        paths.add(fullPathToSubdoc);
 
-        skipSchemaValidators[subdoc.$basePath] = true;
+        skipSchemaValidators[fullPathToSubdoc] = true;
       }
     }
   }
@@ -2658,6 +2662,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   } else if (pathsToSkip) {
     paths = _handlePathsToSkip(paths, pathsToSkip);
   }
+
   if (paths.length === 0) {
     return immediate(function() {
       const error = _complete();

package/lib/helpers/document/handleSpreadDoc.js

@@ -2,14 +2,32 @@
 
 const utils = require('../../utils');
 
+const keysToSkip = new Set(['__index', '__parentArray', '_doc']);
+
 /**
  * Using spread operator on a Mongoose document gives you a
  * POJO that has a tendency to cause infinite recursion. So
  * we use this function on `set()` to prevent that.
  */
 
-module.exports = function handleSpreadDoc(v) {
+module.exports = function handleSpreadDoc(v, includeExtraKeys) {
   if (utils.isPOJO(v) && v.$__ != null && v._doc != null) {
+    if (includeExtraKeys) {
+      const extraKeys = {};
+      for (const key of Object.keys(v)) {
+        if (typeof key === 'symbol') {
+          continue;
+        }
+        if (key[0] === '$') {
+          continue;
+        }
+        if (keysToSkip.has(key)) {
+          continue;
+        }
+        extraKeys[key] = v[key];
+      }
+      return { ...v._doc, ...extraKeys };
+    }
     return v._doc;
   }
 

package/lib/helpers/query/castFilterPath.js

@@ -41,7 +41,6 @@ module.exports = function castFilterPath(query, schematype, val) {
         }
         continue;
       }
-      // cast(schematype.caster ? schematype.caster.schema : schema, nested, options, context);
     } else {
       val[$cond] = schematype.castForQueryWrapper({
         $conditional: $cond,

package/lib/model.js

@@ -1885,7 +1885,7 @@ Model.discriminators;
  * ####Note:
  * Only translate arguments of object type anything else is returned raw
  *
- * @param {Object} raw fields/conditions that may contain aliased keys
+ * @param {Object} fields fields/conditions that may contain aliased keys
  * @return {Object} the translated 'pure' fields/conditions
  */
 Model.translateAliases = function translateAliases(fields) {

package/lib/schema/SubdocumentPath.js

@@ -26,7 +26,7 @@ module.exports = SubdocumentPath;
  * Single nested subdocument SchemaType constructor.
  *
  * @param {Schema} schema
- * @param {String} key
+ * @param {String} path
  * @param {Object} options
  * @inherits SchemaType
  * @api public
@@ -243,6 +243,9 @@ SubdocumentPath.prototype.doValidate = function(value, fn, scope, options) {
   }
 
   if (options && options.skipSchemaValidators) {
+    if (!value) {
+      return fn(null);
+    }
     return value.validate(fn);
   }
 

package/lib/schema/array.js

@@ -32,6 +32,7 @@ const emptyOpts = Object.freeze({});
  * @param {String} key
  * @param {SchemaType} cast
  * @param {Object} options
+ * @param {Object} schemaOptions
  * @inherits SchemaType
  * @api public
  */

package/lib/schema/documentarray.js

@@ -12,6 +12,7 @@ const SchemaDocumentArrayOptions =
 const SchemaType = require('../schematype');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
+const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
 const util = require('util');
 const utils = require('../utils');
 const getConstructor = require('../helpers/discriminator/getConstructor');
@@ -29,6 +30,7 @@ let Subdocument;
  * @param {String} key
  * @param {Schema} schema
  * @param {Object} options
+ * @param {Object} schemaOptions
  * @inherits SchemaArray
  * @api public
  */
@@ -427,13 +429,18 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     const Constructor = getConstructor(this.casterConstructor, rawArray[i]);
 
     // Check if the document has a different schema (re gh-3701)
-    if (rawArray[i].$__ && !(rawArray[i] instanceof Constructor)) {
-      rawArray[i] = rawArray[i].toObject({
-        transform: false,
-        // Special case: if different model, but same schema, apply virtuals
-        // re: gh-7898
-        virtuals: rawArray[i].schema === Constructor.schema
-      });
+    if (rawArray[i].$__ != null && !(rawArray[i] instanceof Constructor)) {
+      const spreadDoc = handleSpreadDoc(rawArray[i], true);
+      if (rawArray[i] !== spreadDoc) {
+        rawArray[i] = spreadDoc;
+      } else {
+        rawArray[i] = rawArray[i].toObject({
+          transform: false,
+          // Special case: if different model, but same schema, apply virtuals
+          // re: gh-7898
+          virtuals: rawArray[i].schema === Constructor.schema
+        });
+      }
     }
 
     if (rawArray[i] instanceof Subdocument) {

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

@@ -445,6 +445,7 @@ const methods = {
    * Return whether or not the `obj` is included in the array.
    *
    * @param {Object} obj the item to check
+   * @param {Number} fromIndex
    * @return {Boolean}
    * @api public
    * @method includes
@@ -460,6 +461,7 @@ const methods = {
    * Return the index of `obj` or `-1` if not found.
    *
    * @param {Object} obj the item to look for
+   * @param {Number} fromIndex
    * @return {Number}
    * @api public
    * @method indexOf

package/lib/virtualtype.js

@@ -24,6 +24,7 @@ const utils = require('./utils');
  * @param {Number} [options.skip=null] add a default `skip` to the `populate()` query
  * @param {Number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results because it only executes a single query for every document being populated. If you set `perDocumentLimit`, Mongoose will ensure correct `limit` per document by executing a separate query for each document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })` will execute 2 additional queries if `.find()` returns 2 documents.
  * @param {Object} [options.options=null] Additional options like `limit` and `lean`.
+ * @param {string} name
  * @api public
  */
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.7",
+  "version": "6.2.8",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -35,6 +35,7 @@
     "acquit": "1.x",
     "acquit-ignore": "0.2.x",
     "acquit-require": "0.1.x",
+    "axios": "0.26.1",
     "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
@@ -116,4 +117,4 @@
       "target": "ES2017"
     }
   }
-}
+}

package/types/document.d.ts

@@ -169,6 +169,9 @@ declare module 'mongoose' {
     /** The name of the model */
     modelName: string;
 
+    /** Returns the model with the given name on this document's associated connection. */
+    model<ModelType = Model<unknown>>(name: string): ModelType;
+
     /**
      * Overwrite all values in this document with the values of `obj`, except
      * for immutable properties. Behaves similarly to `set()`, except for it

package/types/index.d.ts

@@ -709,6 +709,8 @@ declare module 'mongoose' {
     model?: string | Model<any>;
     /** optional query options like sort, limit, etc */
     options?: any;
+    /** optional boolean, set to `false` to allow populating paths that aren't in the schema */
+    strictPopulate?: boolean;
     /** deep populate */
     populate?: string | PopulateOptions | (string | PopulateOptions)[];
     /**
@@ -757,7 +759,7 @@ declare module 'mongoose' {
   export type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
   export type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
 
-  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any, TQueryHelpers = any> extends events.EventEmitter {
+  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = {}, TQueryHelpers = {}> extends events.EventEmitter {
     /**
      * Create a new schema
      */
@@ -811,7 +813,7 @@ declare module 'mongoose' {
     method(obj: Partial<TInstanceMethods>): this;
 
     /** Object of currently defined methods on this schema. */
-    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] };
+    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] } & AnyObject;
 
     /** The original object passed to the schema constructor */
     obj: SchemaDefinition<SchemaDefinitionType<DocType>>;
@@ -933,6 +935,8 @@ declare module 'mongoose' {
   type AnyArray<T> = T[] | ReadonlyArray<T>;
   type SchemaValidator<T> = RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T> | ValidateOpts<T>[];
 
+  type ExtractMongooseArray<T> = T extends Types.Array<any> ? AnyArray<Unpacked<T>> : T;
+
   export class SchemaTypeOptions<T> {
     type?:
       T extends string ? StringSchemaDefinition :
@@ -970,7 +974,7 @@ declare module 'mongoose' {
      * The default value for this path. If a function, Mongoose executes the function
      * and uses the return value as the default.
      */
-    default?: T | ((this: any, doc: any) => Partial<T>);
+    default?: ExtractMongooseArray<T> | ((this: any, doc: any) => Partial<ExtractMongooseArray<T>>);
 
     /**
      * The model that `populate()` should use if populating this path.