mongoose 7.3.3 → 7.4.0

package/lib/schema/SubdocumentPath.js

@@ -165,22 +165,22 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
   let subdoc;
 
   // Only pull relevant selected paths and pull out the base path
-  const parentSelected = doc && doc.$__ && doc.$__.selected || {};
+  const parentSelected = doc && doc.$__ && doc.$__.selected;
   const path = this.path;
-  const selected = Object.keys(parentSelected).reduce((obj, key) => {
+  const selected = parentSelected == null ? null : Object.keys(parentSelected).reduce((obj, key) => {
     if (key.startsWith(path + '.')) {
       obj = obj || {};
       obj[key.substring(path.length + 1)] = parentSelected[key];
     }
     return obj;
   }, null);
-  options = Object.assign({}, options, { priorDoc: priorVal });
   if (init) {
     subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
     delete subdoc.$__.defaults;
     subdoc.$init(val);
     applyDefaults(subdoc, selected);
   } else {
+    options = Object.assign({}, options, { priorDoc: priorVal });
     if (Object.keys(val).length === 0) {
       return new Constructor({}, selected, doc, undefined, options);
     }
@@ -212,11 +212,15 @@ SubdocumentPath.prototype.castForQuery = function($conditional, val, context, op
     return val;
   }
 
+  const Constructor = getConstructor(this.caster, val);
+  if (val instanceof Constructor) {
+    return val;
+  }
+
   if (this.options.runSetters) {
     val = this._applySetters(val, context);
   }
 
-  const Constructor = getConstructor(this.caster, val);
   const overrideStrict = options != null && options.strict != null ?
     options.strict :
     void 0;
@@ -347,6 +351,8 @@ SubdocumentPath.defaultOptions = {};
 
 SubdocumentPath.set = SchemaType.set;
 
+SubdocumentPath.setters = [];
+
 /**
  * Attaches a getter for all SubdocumentPath instances
  *

package/lib/schema/array.js

@@ -170,6 +170,8 @@ SchemaArray.defaultOptions = {};
  */
 SchemaArray.set = SchemaType.set;
 
+SchemaArray.setters = [];
+
 /**
  * Attaches a getter for all Array instances
  *

package/lib/schema/bigint.js

@@ -62,6 +62,8 @@ SchemaBigInt._cast = castBigInt;
 
 SchemaBigInt.set = SchemaType.set;
 
+SchemaBigInt.setters = [];
+
 /**
  * Attaches a getter for all BigInt instances
  *

package/lib/schema/boolean.js

@@ -65,6 +65,8 @@ SchemaBoolean._cast = castBoolean;
 
 SchemaBoolean.set = SchemaType.set;
 
+SchemaBoolean.setters = [];
+
 /**
  * Attaches a getter for all Boolean instances
  *

package/lib/schema/buffer.js

@@ -70,6 +70,8 @@ SchemaBuffer._checkRequired = v => !!(v && v.length);
 
 SchemaBuffer.set = SchemaType.set;
 
+SchemaBuffer.setters = [];
+
 /**
  * Attaches a getter for all Buffer instances
  *

package/lib/schema/date.js

@@ -70,6 +70,8 @@ SchemaDate._cast = castDate;
 
 SchemaDate.set = SchemaType.set;
 
+SchemaDate.setters = [];
+
 /**
  * Attaches a getter for all Date instances
  *

package/lib/schema/decimal128.js

@@ -66,6 +66,8 @@ Decimal128._cast = castDecimal128;
 
 Decimal128.set = SchemaType.set;
 
+Decimal128.setters = [];
+
 /**
  * Attaches a getter for all Decimal128 instances
  *

package/lib/schema/documentarray.js

@@ -605,6 +605,8 @@ DocumentArrayPath.defaultOptions = {};
 
 DocumentArrayPath.set = SchemaType.set;
 
+DocumentArrayPath.setters = [];
+
 /**
  * Attaches a getter for all DocumentArrayPath instances
  *

package/lib/schema/mixed.js

@@ -94,6 +94,8 @@ Mixed.get = SchemaType.get;
 
 Mixed.set = SchemaType.set;
 
+Mixed.setters = [];
+
 /**
  * Casts `val` for Mixed.
  *

package/lib/schema/number.js

@@ -67,6 +67,8 @@ SchemaNumber.get = SchemaType.get;
 
 SchemaNumber.set = SchemaType.set;
 
+SchemaNumber.setters = [];
+
 /*!
  * ignore
  */

package/lib/schema/objectid.js

@@ -94,6 +94,8 @@ ObjectId.get = SchemaType.get;
 
 ObjectId.set = SchemaType.set;
 
+ObjectId.setters = [];
+
 /**
  * Adds an auto-generated ObjectId default if turnOn is true.
  * @param {Boolean} turnOn auto generated ObjectId defaults

package/lib/schema/string.js

@@ -143,6 +143,8 @@ SchemaString.get = SchemaType.get;
 
 SchemaString.set = SchemaType.set;
 
+SchemaString.setters = [];
+
 /*!
  * ignore
  */

package/lib/schema/uuid.js

@@ -194,6 +194,8 @@ SchemaUUID.get = SchemaType.get;
 
 SchemaUUID.set = SchemaType.set;
 
+SchemaUUID.setters = [];
+
 /**
  * Get/set the function used to cast arbitrary values to UUIDs.
  *

package/lib/schema.js

@@ -80,6 +80,7 @@ let id = 0;
  * - [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())
+ * - [collectionOptions]: object with options passed to [`createCollection()`](https://www.mongodb.com/docs/manual/reference/method/db.createCollection/) when calling `Model.createCollection()` or `autoCreate` set to true.
  *
  * #### Options for Nested Schemas:
  *
@@ -1585,9 +1586,6 @@ Schema.prototype.indexedPaths = function indexedPaths() {
  */
 
 Schema.prototype.pathType = function(path) {
-  // Convert to '.$' to check subpaths re: gh-6405
-  const cleanPath = _pathToPositionalSyntax(path);
-
   if (this.paths.hasOwnProperty(path)) {
     return 'real';
   }
@@ -1597,6 +1595,10 @@ Schema.prototype.pathType = function(path) {
   if (this.nested.hasOwnProperty(path)) {
     return 'nested';
   }
+
+  // Convert to '.$' to check subpaths re: gh-6405
+  const cleanPath = _pathToPositionalSyntax(path);
+
   if (this.subpaths.hasOwnProperty(cleanPath) || this.subpaths.hasOwnProperty(path)) {
     return 'real';
   }

package/lib/schematype.js

@@ -48,7 +48,9 @@ function SchemaType(path, options, instance) {
   this.getters = this.constructor.hasOwnProperty('getters') ?
     this.constructor.getters.slice() :
     [];
-  this.setters = [];
+  this.setters = this.constructor.hasOwnProperty('setters') ?
+    this.constructor.setters.slice() :
+    [];
 
   this.splitPath();
 
@@ -80,7 +82,11 @@ function SchemaType(path, options, instance) {
   const keys = Object.keys(this.options);
   for (const prop of keys) {
     if (prop === 'cast') {
-      this.castFunction(this.options[prop]);
+      if (Array.isArray(this.options[prop])) {
+        this.castFunction.apply(this, this.options[prop]);
+      } else {
+        this.castFunction(this.options[prop]);
+      }
       continue;
     }
     if (utils.hasUserDefinedProperty(this.options, prop) && typeof this[prop] === 'function') {
@@ -253,14 +259,24 @@ SchemaType.cast = function cast(caster) {
  * @api public
  */
 
-SchemaType.prototype.castFunction = function castFunction(caster) {
+SchemaType.prototype.castFunction = function castFunction(caster, message) {
   if (arguments.length === 0) {
     return this._castFunction;
   }
+
   if (caster === false) {
     caster = this.constructor._defaultCaster || (v => v);
   }
-  this._castFunction = caster;
+  if (typeof caster === 'string') {
+    this._castErrorMessage = caster;
+    return this._castFunction;
+  }
+  if (caster != null) {
+    this._castFunction = caster;
+  }
+  if (message != null) {
+    this._castErrorMessage = message;
+  }
 
   return this._castFunction;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.3.3",
+  "version": "7.4.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -19,9 +19,9 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "bson": "^5.3.0",
+    "bson": "^5.4.0",
     "kareem": "2.5.1",
-    "mongodb": "5.6.0",
+    "mongodb": "5.7.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",

package/types/augmentations.d.ts

@@ -0,0 +1,9 @@
+// this import is required so that types get merged instead of completely overwritten
+import 'bson';
+
+declare module 'bson' {
+  interface ObjectId {
+    /** Mongoose automatically adds a conveniency "_id" getter on the base ObjectId class */
+    _id: this;
+  }
+}

package/types/index.d.ts

@@ -22,6 +22,7 @@
 /// <reference path="./validation.d.ts" />
 /// <reference path="./inferschematype.d.ts" />
 /// <reference path="./virtuals.d.ts" />
+/// <reference path="./augmentations.d.ts" />
 
 declare class NativeDate extends global.Date { }
 

package/types/models.d.ts

@@ -123,7 +123,6 @@ declare module 'mongoose' {
     SessionOption {
     checkKeys?: boolean;
     j?: boolean;
-    ordered?: boolean;
     safe?: boolean | WriteConcern;
     timestamps?: boolean | QueryTimestampsConfig;
     validateBeforeSave?: boolean;
@@ -132,6 +131,11 @@ declare module 'mongoose' {
     wtimeout?: number;
   }
 
+  interface CreateOptions extends SaveOptions {
+    ordered?: boolean;
+    aggregateErrors?: boolean;
+  }
+
   interface RemoveOptions extends SessionOption, Omit<mongodb.DeleteOptions, 'session'> {}
 
   const Model: Model<any>;
@@ -217,7 +221,8 @@ declare module 'mongoose' {
     >;
 
     /** Creates a new document or documents */
-    create<DocContents = AnyKeys<TRawDocType>>(docs: Array<TRawDocType | DocContents>, options?: SaveOptions): Promise<THydratedDocumentType[]>;
+    create<DocContents = AnyKeys<TRawDocType>>(docs: Array<TRawDocType | DocContents>, options: CreateOptions & { aggregateErrors: true }): Promise<(THydratedDocumentType | Error)[]>;
+    create<DocContents = AnyKeys<TRawDocType>>(docs: Array<TRawDocType | DocContents>, options?: CreateOptions): Promise<THydratedDocumentType[]>;
     create<DocContents = AnyKeys<TRawDocType>>(doc: DocContents | TRawDocType): Promise<THydratedDocumentType>;
     create<DocContents = AnyKeys<TRawDocType>>(...docs: Array<TRawDocType | DocContents>): Promise<THydratedDocumentType[]>;
 

package/types/query.d.ts

@@ -691,7 +691,7 @@ declare module 'mongoose' {
     slice(val: number | Array<number>): this;
 
     /** Sets the sort order. If an object is passed, values allowed are `asc`, `desc`, `ascending`, `descending`, `1`, and `-1`. */
-    sort(arg?: string | { [key: string]: SortOrder | { $meta: 'textScore' } } | [string, SortOrder][] | undefined | null): this;
+    sort(arg?: string | { [key: string]: SortOrder | { $meta: any } } | [string, SortOrder][] | undefined | null): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {

package/types/schemaoptions.d.ts

@@ -49,6 +49,9 @@ declare module 'mongoose' {
     /** Sets a default collation for every query and aggregation. */
     collation?: mongodb.CollationOptions;
 
+    /** Arbitrary options passed to `createCollection()` */
+    collectionOptions?: mongodb.CreateCollectionOptions;
+
     /** The timeseries option to use when creating the model's collection. */
     timeseries?: mongodb.TimeSeriesCollectionOptions;
 

package/types/schematypes.d.ts

@@ -63,7 +63,11 @@ declare module 'mongoose' {
     validate?: SchemaValidator<T> | AnyArray<SchemaValidator<T>>;
 
     /** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
-    cast?: string;
+    cast?: string |
+    boolean |
+    ((value: any) => T) |
+    [(value: any) => T, string] |
+    [((value: any) => T) | null, (value: any, path: string, model: Model<any>, kind: string) => string];
 
     /**
      * If true, attach a required validator to this path, which ensures this path

package/types/types.d.ts

@@ -80,7 +80,6 @@ declare module 'mongoose' {
     }
 
     class ObjectId extends mongodb.ObjectId {
-      _id: this;
     }
 
     class Subdocument<IdType = any> extends Document<IdType> {

package/lib/helpers/path/flattenObjectWithDottedPaths.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const MongooseError = require('../../error/mongooseError');
-const isMongooseObject = require('../isMongooseObject');
-const setDottedPath = require('../path/setDottedPath');
-const util = require('util');
-
-/**
- * Given an object that may contain dotted paths, flatten the paths out.
- * For example: `flattenObjectWithDottedPaths({ a: { 'b.c': 42 } })` => `{ a: { b: { c: 42 } } }`
- */
-
-module.exports = function flattenObjectWithDottedPaths(obj) {
-  if (obj == null || typeof obj !== 'object' || Array.isArray(obj)) {
-    return;
-  }
-  // Avoid Mongoose docs, like docs and maps, because these may cause infinite recursion
-  if (isMongooseObject(obj)) {
-    return;
-  }
-  const keys = Object.keys(obj);
-  for (const key of keys) {
-    const val = obj[key];
-    if (key.indexOf('.') !== -1) {
-      try {
-        delete obj[key];
-        setDottedPath(obj, key, val);
-      } catch (err) {
-        if (!(err instanceof TypeError)) {
-          throw err;
-        }
-        throw new MongooseError(`Conflicting dotted paths when setting document path, key: "${key}", value: ${util.inspect(val)}`);
-      }
-      continue;
-    }
-
-    flattenObjectWithDottedPaths(obj[key]);
-  }
-};