mongoose 6.3.6 → 6.3.9

package/lib/connection.js

@@ -9,6 +9,7 @@ const EventEmitter = require('events').EventEmitter;
 const Schema = require('./schema');
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
+const DisconnectedError = require('./error/disconnected');
 const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
@@ -565,8 +566,7 @@ function _wrapConnHelper(fn) {
     const argsWithoutCb = typeof cb === 'function' ?
       Array.prototype.slice.call(arguments, 0, arguments.length - 1) :
       Array.prototype.slice.call(arguments);
-    const disconnectedError = new MongooseError('Connection ' + this.id +
-      ' was disconnected when calling `' + fn.name + '`');
+    const disconnectedError = new DisconnectedError(this.id, fn.name);
 
     return promiseOrCallback(cb, cb => {
       immediate(() => {
@@ -1260,8 +1260,7 @@ Connection.prototype.deleteModel = function(name) {
  */
 
 Connection.prototype.watch = function(pipeline, options) {
-  const disconnectedError = new MongooseError('Connection ' + this.id +
-    ' was disconnected when calling `watch()`');
+  const disconnectedError = new DisconnectedError(this.id, 'watch');
 
   const changeStreamThunk = cb => {
     immediate(() => {

package/lib/document.js

@@ -136,7 +136,6 @@ function Document(obj, fields, skipId, options) {
   // excluded fields
   if (utils.isPOJO(fields)) {
     exclude = isExclusive(fields);
-
     this.$__.fields = fields;
     this.$__.exclude = exclude;
   }
@@ -641,7 +640,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 +1048,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 +1058,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 +1089,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 +1567,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) {
@@ -3386,7 +3388,7 @@ Document.prototype.$getAllSubdocs = function() {
       }, seed);
     } else if (val && !Array.isArray(val) && val.$isSingleNested) {
       seed = Object.keys(val._doc).reduce(function(seed, path) {
-        return docReducer(val._doc, seed, path);
+        return docReducer(val, seed, path);
       }, seed);
       seed.push(val);
     } else if (val && utils.isMongooseDocumentArray(val)) {
@@ -3929,12 +3931,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/error/disconnected.js

@@ -16,10 +16,9 @@ class DisconnectedError extends MongooseError {
   /**
    * @param {String} connectionString
    */
-  constructor(connectionString) {
-    super('Ran out of retries trying to reconnect to "' +
-      connectionString + '". Try setting `server.reconnectTries` and ' +
-      '`server.reconnectInterval` to something higher.');
+  constructor(id, fnName) {
+    super('Connection ' + id +
+    ' was disconnected when calling `' + fnName + '()`');
   }
 }
 

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/index.js

@@ -260,8 +260,6 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
- * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
- * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
  * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @param {Number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {Number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
@@ -323,8 +321,6 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  * @param {Number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
  * @param {Number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
- * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
- * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
  * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.

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);

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.3.6",
+  "version": "6.3.9",
   "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/aggregate.d.ts

@@ -1,6 +1,9 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
+  /** Extract generic type from Aggregate class */
+  type AggregateExtract<P> = P extends Aggregate<infer T> ? T : never;
+
   interface AggregateOptions extends
     SessionOption {
     /**

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/index.d.ts

@@ -211,14 +211,14 @@ declare module 'mongoose' {
     plugin(fn: (schema: Schema<DocType>, opts?: any) => void, opts?: any): this;
 
     /** Defines a post hook for the model. */
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T>): this;
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<any>>): this;
-    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<any>>): this;
-    post<T = M>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T>): this;
-    post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PostMiddlewareFunction<T, T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
+    post<T = M>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T, T>): this;
+    post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
 
     post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
     post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;

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 {