mongoose 7.1.0 → 7.1.2

package/lib/schema/DocumentArrayElement.js

@@ -0,0 +1,100 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('../error/mongooseError');
+const SchemaType = require('../schematype');
+const SubdocumentPath = require('./SubdocumentPath');
+const getConstructor = require('../helpers/discriminator/getConstructor');
+
+/**
+ * DocumentArrayElement SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api public
+ */
+
+function DocumentArrayElement(path, options) {
+  this.$parentSchemaType = options && options.$parentSchemaType;
+  if (!this.$parentSchemaType) {
+    throw new MongooseError('Cannot create DocumentArrayElement schematype without a parent');
+  }
+  delete options.$parentSchemaType;
+
+  SchemaType.call(this, path, options, 'DocumentArrayElement');
+
+  this.$isMongooseDocumentArrayElement = true;
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+DocumentArrayElement.schemaName = 'DocumentArrayElement';
+
+DocumentArrayElement.defaultOptions = {};
+
+/*!
+ * Inherits from SchemaType.
+ */
+DocumentArrayElement.prototype = Object.create(SchemaType.prototype);
+DocumentArrayElement.prototype.constructor = DocumentArrayElement;
+
+/**
+ * Casts `val` for DocumentArrayElement.
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+DocumentArrayElement.prototype.cast = function(...args) {
+  return this.$parentSchemaType.cast(...args)[0];
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $cond
+ * @param {any} [val]
+ * @api private
+ */
+
+DocumentArrayElement.prototype.doValidate = function(value, fn, scope, options) {
+  const Constructor = getConstructor(this.caster, value);
+
+  if (value && !(value instanceof Constructor)) {
+    value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
+  }
+
+  return SubdocumentPath.prototype.doValidate.call(this, value, fn, scope, options);
+};
+
+/**
+ * Clone the current SchemaType
+ *
+ * @return {DocumentArrayElement} The cloned instance
+ * @api private
+ */
+
+DocumentArrayElement.prototype.clone = function() {
+  this.options.$parentSchemaType = this.$parentSchemaType;
+  const ret = SchemaType.prototype.clone.apply(this, arguments);
+  delete this.options.$parentSchemaType;
+
+  ret.caster = this.caster;
+  ret.schema = this.schema;
+
+  return ret;
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = DocumentArrayElement;

package/lib/schema/SubdocumentPath.js

@@ -84,6 +84,7 @@ function _createConstructor(schema, baseClass) {
   _embedded.prototype = Object.create(proto);
   _embedded.prototype.$__setSchema(schema);
   _embedded.prototype.constructor = _embedded;
+  _embedded.base = schema.base;
   _embedded.schema = schema;
   _embedded.$isSingleNested = true;
   _embedded.events = new EventEmitter();

package/lib/schema/documentarray.js

@@ -6,11 +6,11 @@
 
 const ArrayType = require('./array');
 const CastError = require('../error/cast');
+const DocumentArrayElement = require('./DocumentArrayElement');
 const EventEmitter = require('events').EventEmitter;
 const SchemaDocumentArrayOptions =
   require('../options/SchemaDocumentArrayOptions');
 const SchemaType = require('../schematype');
-const SubdocumentPath = require('./SubdocumentPath');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
@@ -74,25 +74,14 @@ function DocumentArrayPath(key, schema, options, schemaOptions) {
     });
   }
 
-  const parentSchemaType = this;
-  this.$embeddedSchemaType = new SchemaType(key + '.$', {
+  const $parentSchemaType = this;
+  this.$embeddedSchemaType = new DocumentArrayElement(key + '.$', {
     required: this &&
       this.schemaOptions &&
-      this.schemaOptions.required || false
+      this.schemaOptions.required || false,
+    $parentSchemaType
   });
-  this.$embeddedSchemaType.cast = function(value, doc, init) {
-    return parentSchemaType.cast(value, doc, init)[0];
-  };
-  this.$embeddedSchemaType.doValidate = function(value, fn, scope, options) {
-    const Constructor = getConstructor(this.caster, value);
-
-    if (value && !(value instanceof Constructor)) {
-      value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
-    }
 
-    return SubdocumentPath.prototype.doValidate.call(this, value, fn, scope, options);
-  };
-  this.$embeddedSchemaType.$isMongooseDocumentArrayElement = true;
   this.$embeddedSchemaType.caster = this.Constructor;
   this.$embeddedSchemaType.schema = this.schema;
 }

package/lib/schema/string.js

@@ -202,6 +202,7 @@ SchemaString.checkRequired = SchemaType.checkRequired;
  * @param {...String|Object} [args] enumeration values
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
+ * @see Enums in JavaScript https://masteringjs.io/tutorials/fundamentals/enum
  * @api public
  */
 

package/lib/schema.js

@@ -78,6 +78,7 @@ let id = 0;
  * - [skipVersioning](https://mongoosejs.com/docs/guide.html#skipVersioning): object - paths to exclude from versioning
  * - [timestamps](https://mongoosejs.com/docs/guide.html#timestamps): object or boolean - defaults to `false`. If true, Mongoose adds `createdAt` and `updatedAt` properties to your schema and manages those properties for you.
  * - [pluginTags](https://mongoosejs.com/docs/guide.html#pluginTags): array of strings - defaults to `undefined`. If set and plugin called with `tags` option, will only apply that plugin to schemas with a matching tag.
+ * - [virtuals](https://mongoosejs.com/docs/tutorials/virtuals.html#virtuals-via-schema-options): object - virtuals to define, alias for [`.virtual`](https://mongoosejs.com/docs/api/schema.html#Schema.prototype.virtual())
  *
  * #### Options for Nested Schemas:
  *
@@ -739,6 +740,10 @@ Schema.prototype.add = function add(obj, prefix) {
         if (this._userProvidedOptions.typeKey) {
           childSchemaOptions.typeKey = this._userProvidedOptions.typeKey;
         }
+        // propagate 'strict' option to child schema
+        if (this._userProvidedOptions.strict != null) {
+          childSchemaOptions.strict = this._userProvidedOptions.strict;
+        }
 
         const _schema = new Schema(_typeDef, childSchemaOptions);
         _schema.$implicitlyCreated = true;
@@ -2059,9 +2064,31 @@ Schema.prototype.set = function(key, value, tags) {
       break;
   }
 
+  // Propagate `strict` and `strictQuery` changes down to implicitly created schemas
+  if (key === 'strict') {
+    _propagateOptionsToImplicitlyCreatedSchemas(this, { strict: value });
+  }
+  if (key === 'strictQuery') {
+    _propagateOptionsToImplicitlyCreatedSchemas(this, { strictQuery: value });
+  }
+
   return this;
 };
 
+/*!
+ * Recursively set options on implicitly created schemas
+ */
+
+function _propagateOptionsToImplicitlyCreatedSchemas(baseSchema, options) {
+  for (const { schema } of baseSchema.childSchemas) {
+    if (!schema.$implicitlyCreated) {
+      continue;
+    }
+    Object.assign(schema.options, options);
+    _propagateOptionsToImplicitlyCreatedSchemas(schema, options);
+  }
+}
+
 /**
  * Gets a schema option.
  *

package/lib/types/map.js

@@ -96,9 +96,10 @@ class MongooseMap extends Map {
       return;
     }
 
-    const fullPath = this.$__path + '.' + key;
-    const populated = this.$__parent != null && this.$__parent.$__ ?
-      this.$__parent.$populated(fullPath, true) || this.$__parent.$populated(this.$__path, true) :
+    let _fullPath;
+    const parent = this.$__parent;
+    const populated = parent != null && parent.$__ && parent.$__.populated ?
+      parent.$populated(fullPath.call(this), true) || parent.$populated(this.$__path, true) :
       null;
     const priorVal = this.get(key);
 
@@ -127,11 +128,19 @@ class MongooseMap extends Map {
       }
     } else {
       try {
-        value = this.$__schemaType.
-          applySetters(value, this.$__parent, false, this.get(key), { path: fullPath });
+        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested ?
+          { path: fullPath.call(this) } :
+          null;
+        value = this.$__schemaType.applySetters(
+          value,
+          this.$__parent,
+          false,
+          this.get(key),
+          options
+        );
       } catch (error) {
         if (this.$__parent != null && this.$__parent.$__ != null) {
-          this.$__parent.invalidate(fullPath, error);
+          this.$__parent.invalidate(fullPath.call(this), error);
           return;
         }
         throw error;
@@ -140,13 +149,18 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    if (value != null && value.$isSingleNested) {
-      value.$basePath = this.$__path + '.' + key;
+    if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
+      parent.markModified(fullPath.call(this));
     }
 
-    const parent = this.$__parent;
-    if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
-      parent.markModified(this.$__path + '.' + key);
+    // Delay calculating full path unless absolutely necessary, because string
+    // concatenation is a bottleneck re: #13171
+    function fullPath() {
+      if (_fullPath) {
+        return _fullPath;
+      }
+      _fullPath = this.$__path + '.' + key;
+      return _fullPath;
     }
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.1.0",
+  "version": "7.1.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,10 +28,10 @@
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/preset-env": "7.21.4",
-    "@typescript-eslint/eslint-plugin": "5.57.0",
-    "@typescript-eslint/parser": "5.57.0",
+    "@babel/core": "7.21.8",
+    "@babel/preset-env": "7.21.5",
+    "@typescript-eslint/eslint-plugin": "5.59.2",
+    "@typescript-eslint/parser": "5.59.2",
     "acquit": "1.3.0",
     "acquit-ignore": "0.2.1",
     "acquit-require": "0.1.1",
@@ -39,34 +39,35 @@
     "axios": "1.1.3",
     "babel-loader": "8.2.5",
     "benchmark": "2.1.4",
+    "bluebird": "3.7.2",
     "broken-link-checker": "^0.7.8",
     "buffer": "^5.6.0",
     "cheerio": "1.0.0-rc.12",
     "crypto-browserify": "3.12.0",
     "dotenv": "16.0.3",
     "dox": "1.0.0",
-    "eslint": "8.37.0",
+    "eslint": "8.39.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
-    "highlight.js": "11.7.0",
+    "highlight.js": "11.8.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "marked": "4.3.0",
     "mkdirp": "^2.1.3",
     "mocha": "10.2.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.12.1",
+    "mongodb-memory-server": "8.12.2",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
-    "sinon": "15.0.3",
+    "sinon": "15.0.4",
     "stream-browserify": "3.0.0",
     "tsd": "0.25.0",
-    "typescript": "5.0.3",
+    "typescript": "5.0.4",
     "uuid": "9.0.0",
-    "webpack": "5.77.0",
+    "webpack": "5.81.0",
     "fs-extra": "~11.1.1"
   },
   "directories": {
@@ -79,6 +80,7 @@
     "docs:clean:6x": "rimraf index.html && rimraf -rf ./docs/6.x && rimraf -rf ./docs/source/_docs && rimraf -rf ./tmp",
     "docs:copy:tmp": "mkdirp ./tmp/docs/css && mkdirp ./tmp/docs/js && mkdirp ./tmp/docs/images && mkdirp ./tmp/docs/tutorials && mkdirp ./tmp/docs/typescript && mkdirp ./tmp/docs/api && ncp ./docs/css ./tmp/docs/css --filter=.css$ && ncp ./docs/js ./tmp/docs/js --filter=.js$ && ncp ./docs/images ./tmp/docs/images && ncp ./docs/tutorials ./tmp/docs/tutorials && ncp ./docs/typescript ./tmp/docs/typescript && ncp ./docs/api ./tmp/docs/api && cp index.html ./tmp && cp docs/*.html ./tmp/docs/",
     "docs:copy:tmp:5x": "rimraf ./docs/5.x && ncp ./tmp ./docs/5.x",
+    "docs:move:6x:tmp": "mv ./docs/6.x ./tmp",
     "docs:copy:tmp:6x": "rimraf ./docs/6.x && ncp ./tmp ./docs/6.x",
     "docs:checkout:gh-pages": "git checkout gh-pages",
     "docs:checkout:5x": "git checkout 5.x",
@@ -93,7 +95,7 @@
     "docs:view": "node ./scripts/static.js",
     "docs:prepare:publish:stable": "npm run docs:checkout:gh-pages && npm run docs:merge:stable && npm run docs:clean:stable && npm run docs:generate && npm run docs:generate:search",
     "docs:prepare:publish:5x": "npm run docs:checkout:5x && npm run docs:merge:5x && npm run docs:clean:stable && npm run docs:generate && npm run docs:copy:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:5x",
-    "docs:prepare:publish:6x": "npm run docs:checkout:6x && npm run docs:merge:6x && npm run docs:clean:stable && npm run docs:generate && npm run docs:copy:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:6x",
+    "docs:prepare:publish:6x": "npm run docs:checkout:6x && npm run docs:merge:6x && npm run docs:clean:stable && env DOCS_DEPLOY=true npm run docs:generate && npm run docs:move:6x:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:6x",
     "docs:check-links": "blc http://127.0.0.1:8089 -ro",
     "lint": "eslint .",
     "lint-js": "eslint . --ext .js",

package/types/document.d.ts

@@ -90,9 +90,9 @@ declare module 'mongoose' {
     $session(session?: ClientSession | null): ClientSession | null;
 
     /** Alias for `set()`, used internally to avoid conflicts */
-    $set(path: string, val: any, type: any, options?: DocumentSetOptions): this;
-    $set(path: string, val: any, options?: DocumentSetOptions): this;
-    $set(value: any): this;
+    $set(path: string | Record<string, any>, val: any, type: any, options?: DocumentSetOptions): this;
+    $set(path: string | Record<string, any>, val: any, options?: DocumentSetOptions): this;
+    $set(value: string | Record<string, any>): this;
 
     /** Set this property to add additional query filters when Mongoose saves this document and `isNew` is false. */
     $where: Record<string, unknown>;
@@ -107,7 +107,7 @@ declare module 'mongoose' {
     db: Connection;
 
     /** Removes this document from the db. */
-    deleteOne(options?: QueryOptions): QueryWithHelpers<any, this, TQueryHelpers>;
+    deleteOne(options?: QueryOptions): Promise<this>;
 
     /**
      * Takes a populated field and returns it to its unpopulated state. If called with
@@ -216,9 +216,9 @@ declare module 'mongoose' {
     schema: Schema;
 
     /** Sets the value of a path, or many paths. */
-    set(path: string, val: any, type: any, options?: any): this;
-    set(path: string, val: any, options?: any): this;
-    set(value: any): this;
+    set(path: string | Record<string, any>, val: any, type: any, options?: DocumentSetOptions): this;
+    set(path: string | Record<string, any>, val: any, options?: DocumentSetOptions): this;
+    set(value: string | Record<string, any>): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
     toJSON<T = Require_id<DocType>>(options?: ToObjectOptions & { flattenMaps?: true }): FlattenMaps<T>;

package/types/index.d.ts

@@ -594,11 +594,18 @@ declare module 'mongoose' {
   export type UpdateQuery<T> = _UpdateQuery<T> & AnyObject;
 
   export type FlattenMaps<T> = {
-    [K in keyof T]: T[K] extends Map<any, infer V>
-      ? Record<string, V> : T[K] extends TreatAsPrimitives
-        ? T[K] : FlattenMaps<T[K]>;
+    [K in keyof T]: FlattenProperty<T[K]>;
   };
 
+  /**
+   * Separate type is needed for properties of union type (for example, Types.DocumentArray | undefined) to apply conditional check to each member of it
+   * https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+   */
+  type FlattenProperty<T> = T extends Map<any, infer V>
+    ? Record<string, V> : T extends TreatAsPrimitives
+      ? T : T extends Types.DocumentArray<infer ItemType>
+        ? Types.DocumentArray<FlattenMaps<ItemType>> : FlattenMaps<T>;
+
   export type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
   export type TreatAsPrimitives = actualPrimitives | NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId | Buffer | Function;