mongoose 6.3.6 → 6.3.7

package/lib/document.js

@@ -79,7 +79,6 @@ function Document(obj, fields, skipId, options) {
     options = skipId;
     skipId = options.skipId;
   }
-  options = Object.assign({}, options);
 
   // Support `browserDocument.js` syntax
   if (this.$__schema == null) {
@@ -93,9 +92,9 @@ function Document(obj, fields, skipId, options) {
   }
 
   this.$__ = new InternalCache();
-  this.$isNew = 'isNew' in options ? options.isNew : true;
+  this.$isNew = options && options.isNew != null ? options.isNew : true;
 
-  if (options.priorDoc != null) {
+  if (options && options.priorDoc != null) {
     this.$__.priorDoc = options.priorDoc;
   }
 
@@ -108,18 +107,20 @@ function Document(obj, fields, skipId, options) {
   }
 
   let defaults = true;
-  if (options.defaults !== undefined) {
+  if (options && options.defaults !== undefined) {
     this.$__.defaults = options.defaults;
     defaults = options.defaults;
   }
 
   const schema = this.$__schema;
 
+  let strict;
   if (typeof fields === 'boolean' || fields === 'throw') {
     this.$__.strictMode = fields;
+    strict = fields;
     fields = undefined;
   } else {
-    this.$__.strictMode = schema.options.strict;
+    strict = schema.options.strict;
     if (fields != null) {
       this.$__.selected = fields;
     }
@@ -136,7 +137,6 @@ function Document(obj, fields, skipId, options) {
   // excluded fields
   if (utils.isPOJO(fields)) {
     exclude = isExclusive(fields);
-
     this.$__.fields = fields;
     this.$__.exclude = exclude;
   }
@@ -170,15 +170,15 @@ function Document(obj, fields, skipId, options) {
   // Function defaults get applied **after** setting initial values so they
   // see the full doc rather than an empty one, unless they opt out.
   // Re: gh-3781, gh-6155
-  if (options.willInit && defaults) {
+  if (options && options.willInit && defaults) {
     if (options.skipDefaults) {
       this.$__.skipDefaults = options.skipDefaults;
     }
   } else if (defaults) {
-    $__applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults);
+    $__applyDefaults(this, fields, exclude, hasIncludedChildren, false, options && options.skipDefaults);
   }
 
-  if (!this.$__.strictMode && obj) {
+  if (!strict && obj) {
     const _this = this;
     const keys = Object.keys(this._doc);
 
@@ -641,7 +641,11 @@ Document.prototype.$__buildDoc = function(obj, fields, skipId, exclude, hasInclu
     for (let i = 0; i < len; ++i) {
       const piece = path[i];
 
-      curPath += (!curPath.length ? '' : '.') + piece;
+      if (!curPath.length) {
+        curPath = piece;
+      } else {
+        curPath += '.' + piece;
+      }
 
       // support excluding intermediary levels
       if (exclude === true) {
@@ -1045,8 +1049,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     type = undefined;
   }
 
-  options = options || {};
-  const merge = options.merge;
+  const merge = options && options.merge;
   const adhoc = type && type !== true;
   const constructing = type === true;
   let adhocs;
@@ -1056,7 +1059,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
   let key;
   let prefix;
 
-  const strict = 'strict' in options
+  const strict = options && 'strict' in options
     ? options.strict
     : this.$__.strictMode;
 
@@ -1087,7 +1090,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
     // `_skipMinimizeTopLevel` is because we may have deleted the top-level
     // nested key to ensure key order.
-    const _skipMinimizeTopLevel = options._skipMinimizeTopLevel || false;
+    const _skipMinimizeTopLevel = options && options._skipMinimizeTopLevel || false;
     if (len === 0 && _skipMinimizeTopLevel) {
       delete options._skipMinimizeTopLevel;
       if (val) {
@@ -1565,7 +1568,7 @@ Document.prototype.set = Document.prototype.$set;
  */
 
 Document.prototype.$__shouldModify = function(pathToMark, path, options, constructing, parts, schema, val, priorVal) {
-  if (options._skipMarkModified) {
+  if (options && options._skipMarkModified) {
     return false;
   }
   if (this.$isNew) {
@@ -3929,12 +3932,19 @@ function applySchemaTypeTransforms(self, json) {
     const schematype = schema.paths[path];
     if (typeof schematype.options.transform === 'function') {
       const val = self.$get(path);
+      if (val === undefined) {
+        continue;
+      }
       const transformedValue = schematype.options.transform.call(self, val);
       throwErrorIfPromise(path, transformedValue);
       utils.setValue(path, transformedValue, json);
     } else if (schematype.$embeddedSchemaType != null &&
         typeof schematype.$embeddedSchemaType.options.transform === 'function') {
-      const vals = [].concat(self.$get(path));
+      const val = self.$get(path);
+      if (val === undefined) {
+        continue;
+      }
+      const vals = [].concat(val);
       const transform = schematype.$embeddedSchemaType.options.transform;
       for (let i = 0; i < vals.length; ++i) {
         const transformedValue = transform.call(self, vals[i]);

package/lib/helpers/schematype/handleImmutable.js

@@ -40,7 +40,8 @@ function createImmutableSetter(path, immutable) {
     const _value = this.$__.priorDoc != null ?
       this.$__.priorDoc.$__getValue(path) :
       this.$__getValue(path);
-    if (this.$__.strictMode === 'throw' && v !== _value) {
+    const strict = this.$__.strictMode == null ? this.$__schema.options.strict : this.$__.strictMode;
+    if (strict === 'throw' && v !== _value) {
       throw new StrictModeError(path, 'Path `' + path + '` is immutable ' +
         'and strict mode is set to throw.', true);
     }

package/lib/helpers/update/castArrayFilters.js

@@ -15,6 +15,9 @@ module.exports = function castArrayFilters(query) {
   if (query._mongooseOptions.strict != null) {
     strictQuery = query._mongooseOptions.strict;
   }
+  if (query.model && query.model.base.options.strictQuery != null) {
+    strictQuery = query.model.base.options.strictQuery;
+  }
   if (schema._userProvidedOptions.strictQuery != null) {
     strictQuery = schema._userProvidedOptions.strictQuery;
   }

package/lib/options/SchemaTypeOptions.js

@@ -119,6 +119,19 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'default', opts);
 
 Object.defineProperty(SchemaTypeOptions.prototype, 'ref', opts);
 
+/**
+ * The path in the document that `populate()` should use to find the model
+ * to use.
+ *
+ * @api public
+ * @property ref
+ * @memberOf SchemaTypeOptions
+ * @type Function|String
+ * @instance
+ */
+
+Object.defineProperty(SchemaTypeOptions.prototype, 'refPath', opts);
+
 /**
  * Whether to include or exclude this path by default when loading documents
  * using `find()`, `findOne()`, etc.

package/lib/schema/SubdocumentPath.js

@@ -33,6 +33,13 @@ module.exports = SubdocumentPath;
  */
 
 function SubdocumentPath(schema, path, options) {
+  const schemaTypeIdOption = SubdocumentPath.defaultOptions &&
+    SubdocumentPath.defaultOptions._id;
+  if (schemaTypeIdOption != null) {
+    options = options || {};
+    options._id = schemaTypeIdOption;
+  }
+
   schema = handleIdOption(schema, options);
 
   this.caster = _createConstructor(schema);
@@ -160,7 +167,7 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
     }
     return obj;
   }, null);
-  options = Object.assign({}, options, { priorDoc: priorVal });
+  options = priorVal != null ? Object.assign({}, options, { priorDoc: priorVal }) : options;
   if (init) {
     subdoc = new Constructor(void 0, selected, doc);
     subdoc.$init(val);

package/lib/schema/documentarray.js

@@ -391,8 +391,6 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
   let selected;
   let subdoc;
 
-  options = options || {};
-
   if (!Array.isArray(value)) {
     if (!init && !DocumentArrayPath.options.castNonArrays) {
       throw new CastError('DocumentArray', value, this.path, null, this);
@@ -407,7 +405,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
 
   // We need to create a new array, otherwise change tracking will
   // update the old doc (gh-4449)
-  if (!options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
+  if (!options || !options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
     value = new MongooseDocumentArray(value, this.path, doc);
   }
 
@@ -415,7 +413,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     value[arrayAtomicsSymbol] = prev[arrayAtomicsSymbol] || {};
   }
 
-  if (options.arrayPathIndex != null) {
+  if (options && options.arrayPathIndex != null) {
     value[arrayPathSymbol] = this.path + '.' + options.arrayPathIndex;
   }
 

package/lib/schema.js

@@ -1202,6 +1202,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   }
 
   if (type && type.instanceOfSchema) {
+
     return new MongooseTypes.Subdocument(type, path, obj);
   }
 

package/lib/schematype.js

@@ -1181,6 +1181,7 @@ SchemaType.prototype._castNullish = function _castNullish(v) {
 
 SchemaType.prototype.applySetters = function(value, scope, init, priorVal, options) {
   let v = this._applySetters(value, scope, init, priorVal, options);
+
   if (v == null) {
     return this._castNullish(v);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.3.6",
+  "version": "6.3.7",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -96,7 +96,7 @@
     "test": "mocha --exit ./test/*.test.js",
     "test-rs": "START_REPLICA_SET=1 mocha --timeout 30000 --exit ./test/*.test.js",
     "test-tsd": "node ./test/types/check-types-filename && tsd",
-    "tdd": "mocha ./test/*.test.js ./test/typescript/main.test.js --inspect --watch --recursive --watch-files ./**/*.js",
+    "tdd": "mocha ./test/*.test.js --inspect --watch --recursive --watch-files ./**/*.{js,ts}",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
     "ts-benchmark": "ts-benchmark -p ./benchmarks/typescript/simple -f 17 18 29 32",
     "ts-benchmark-watch": "ts-benchmark -p ./benchmarks/typescript/simple -w ./types -i -s -f 17 18 29 32 -b master"
@@ -145,4 +145,4 @@
       "target": "ES2017"
     }
   }
-}
+}

package/types/helpers.d.ts

@@ -20,14 +20,13 @@ declare module 'mongoose' {
    * of an ObjectId.
    */
   function isObjectIdOrHexString(v: mongodb.ObjectId): true;
-  function isObjectIdOrHexString(v: string): boolean;
+  function isObjectIdOrHexString(v: mongodb.ObjectId | string): boolean;
   function isObjectIdOrHexString(v: any): false;
 
   /**
    * Returns true if Mongoose can cast the given value to an ObjectId, or
    * false otherwise.
    */
-  function isValidObjectId(v: mongodb.ObjectId): true;
-  function isValidObjectId(v: Types.ObjectId): true;
+  function isValidObjectId(v: mongodb.ObjectId | Types.ObjectId): true;
   function isValidObjectId(v: any): boolean;
-}
+}

package/types/models.d.ts

@@ -1,9 +1,9 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  export interface AcceptsDiscriminator<B> {
+  export interface AcceptsDiscriminator {
     /** Adds a discriminator type. */
-    discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
+    discriminator<D>(name: string | number, schema: Schema, value?: string | number | ObjectId): Model<D>;
     discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId): U;
   }
 
@@ -116,7 +116,7 @@ declare module 'mongoose' {
   const Model: Model<any>;
   interface Model<T, TQueryHelpers = {}, TMethodsAndOverrides = {}, TVirtuals = {}> extends
     NodeJS.EventEmitter,
-    AcceptsDiscriminator<T>,
+    AcceptsDiscriminator,
     IndexManager,
     SessionStarter {
     new <DocType = AnyKeys<T> & AnyObject>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethodsAndOverrides, TVirtuals>;
@@ -416,4 +416,4 @@ declare module 'mongoose' {
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(obj: object): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
   }
-}
+}

package/types/schematypes.d.ts

@@ -37,6 +37,8 @@ declare module 'mongoose' {
   /** The various Mongoose SchemaTypes. */
   const SchemaTypes: typeof Schema.Types;
 
+  type DefaultType<T> = T extends Schema.Types.Mixed ? any : Partial<ExtractMongooseArray<T>>;
+
   class SchemaTypeOptions<T> {
     type?:
     T extends string ? StringSchemaDefinition :
@@ -74,13 +76,20 @@ 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 extends Schema.Types.Mixed ? ({} | ((this: any, doc: any) => any)) : (ExtractMongooseArray<T> | ((this: any, doc: any) => Partial<ExtractMongooseArray<T>>));
+    default?: DefaultType<T> | ((this: any, doc: any) => DefaultType<T>) | null;
 
     /**
      * The model that `populate()` should use if populating this path.
      */
     ref?: string | Model<any> | ((this: any, doc: any) => string | Model<any>);
 
+    /**
+     * The path in the document that `populate()` should use to find the model
+     * to use.
+     */
+
+    refPath?: string | ((this: any, doc: any) => string);
+
     /**
      * Whether to include or exclude this path by default when loading documents
      * using `find()`, `findOne()`, etc.
@@ -269,17 +278,17 @@ declare module 'mongoose' {
 
   namespace Schema {
     namespace Types {
-      class Array<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
+      class Array extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'Array';
 
         static options: { castNonArrays: boolean; };
 
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
-        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
+        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
 
         /** The schematype embedded in this array */
-        caster?: SchemaType<B>;
+        caster?: SchemaType;
 
         /**
          * Adds an enum validator if this is an array of strings or numbers. Equivalent to
@@ -329,17 +338,17 @@ declare module 'mongoose' {
         static schemaName: 'Decimal128';
       }
 
-      class DocumentArray<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
+      class DocumentArray extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'DocumentArray';
 
         static options: { castNonArrays: boolean; };
 
-        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
+        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
 
         /** The schema used for documents in this array */
-        schema: Schema<B>;
+        schema: Schema;
 
         /** The constructor used for subdocuments in this array */
         caster?: typeof Types.Subdocument;
@@ -377,15 +386,15 @@ declare module 'mongoose' {
         auto(turnOn: boolean): this;
       }
 
-      class Subdocument<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
+      class Subdocument extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: string;
 
         /** The document's schema */
-        schema: Schema<B>;
+        schema: Schema;
 
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
-        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
+        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
       }
 
       class String extends SchemaType {