mongoose 6.3.5 → 6.3.8

package/lgtm.yml

@@ -0,0 +1,12 @@
+path_classifiers:
+  src:
+    - lib
+  types:
+    - types
+  test:
+    - test
+  docs:
+    - docs
+queries:
+  - exclude: "*"
+  - include: lib

package/lib/connection.js

@@ -7,13 +7,13 @@
 const ChangeStream = require('./cursor/ChangeStream');
 const EventEmitter = require('events').EventEmitter;
 const Schema = require('./schema');
-const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
 const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
 const applyPlugins = require('./helpers/schema/applyPlugins');
+const driver = require('./driver');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const get = require('./helpers/get');
 const immediate = require('./helpers/immediate');
@@ -1026,6 +1026,7 @@ Connection.prototype.collection = function(name, options) {
   };
   options = Object.assign({}, defaultOptions, options ? utils.clone(options) : {});
   options.$wasForceClosed = this.$wasForceClosed;
+  const Collection = driver.get().Collection;
   if (!(name in this.collections)) {
     this.collections[name] = new Collection(name, this, options);
   }

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) {
@@ -3474,8 +3476,8 @@ Document.prototype.$toObject = function(options, json) {
   defaultOptions = utils.options(defaultOptions, clone(schemaOptions[path] || {}));
 
   // If options do not exist or is not an object, set it to empty object
-  options = utils.isPOJO(options) ? clone(options) : {};
-  options._calledWithOptions = options._calledWithOptions || clone(options);
+  options = utils.isPOJO(options) ? { ...options } : {};
+  options._calledWithOptions = options._calledWithOptions || { ...options };
 
   let _minimize;
   if (options._calledWithOptions.minimize != null) {
@@ -3499,7 +3501,7 @@ Document.prototype.$toObject = function(options, json) {
   // `clone()` will recursively call `$toObject()` on embedded docs, so we
   // need the original options the user passed in, plus `_isNested` and
   // `_parentOptions` for checking whether we need to depopulate.
-  const cloneOptions = Object.assign(utils.clone(options), {
+  const cloneOptions = Object.assign({}, options, {
     _isNested: true,
     json: json,
     minimize: _minimize,
@@ -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]);
@@ -4227,8 +4236,10 @@ Document.prototype.populate = function populate() {
  * @api public
  * @return {Array<Document>} array of populated documents. Empty array if there are no populated documents associated with this document.
  * @memberOf Document
+ * @method $getPopulatedDocs
  * @instance
  */
+
 Document.prototype.$getPopulatedDocs = function $getPopulatedDocs() {
   let keys = [];
   if (this.$__.populated != null) {

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -61,6 +61,8 @@ function applyTimestampsToChildren(now, update, schema) {
             if (createdAt != null) {
               subdoc[createdAt] = now;
             }
+
+            applyTimestampsToChildren(now, subdoc, $path.schema);
           });
         } else {
           if (updatedAt != null) {
@@ -69,6 +71,8 @@ function applyTimestampsToChildren(now, update, schema) {
           if (createdAt != null) {
             op[key][createdAt] = now;
           }
+
+          applyTimestampsToChildren(now, op[key], $path.schema);
         }
       }
     }

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

@@ -154,7 +154,7 @@ Mongoose.prototype.driver = driver;
  *     mongoose.set('debug', function(collectionName, methodName, ...methodArgs) {}); // use custom function to log collection methods + arguments
  *
  * Currently supported options are:
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+ * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
  * - 'cloneSchemas': false by default. Set to `true` to `clone()` all schemas before compiling into a model.
@@ -275,6 +275,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
 Mongoose.prototype.createConnection = function(uri, options, callback) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
+  const Connection = driver.get().getConnection();
   const conn = new Connection(_mongoose);
   if (typeof options === 'function') {
     callback = options;

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

@@ -124,7 +124,10 @@ function Query(conditions, options, model, collection) {
   }
 
   // inherit mquery
-  mquery.call(this, this.mongooseCollection, options);
+  mquery.call(this, null, options);
+  if (collection) {
+    this.collection(collection);
+  }
 
   if (conditions) {
     this.find(conditions);

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

@@ -69,6 +69,14 @@ class Map extends SchemaType {
   }
 }
 
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+Map.schemaName = 'Map';
+
 Map.prototype.OptionsConstructor = SchemaMapOptions;
 
 Map.defaultOptions = {};

package/lib/schema/objectid.js

@@ -9,6 +9,7 @@ const SchemaType = require('../schematype');
 const castObjectId = require('../cast/objectid');
 const getConstructorName = require('../helpers/getConstructorName');
 const oid = require('../types/objectid');
+const isBsonType = require('../helpers/isBsonType');
 const utils = require('../utils');
 
 const CastError = SchemaType.CastError;
@@ -113,7 +114,7 @@ ObjectId.prototype.auto = function(turnOn) {
  * ignore
  */
 
-ObjectId._checkRequired = v => v instanceof oid;
+ObjectId._checkRequired = v => isBsonType(v, 'ObjectID');
 
 /*!
  * ignore
@@ -161,7 +162,7 @@ ObjectId.cast = function cast(caster) {
  */
 
 ObjectId._defaultCaster = v => {
-  if (!(v instanceof oid)) {
+  if (!(isBsonType(v, 'ObjectID'))) {
     throw new Error(v + ' is not an instance of ObjectId');
   }
   return v;
@@ -221,7 +222,7 @@ ObjectId.prototype.checkRequired = function checkRequired(value, doc) {
  */
 
 ObjectId.prototype.cast = function(value, doc, init) {
-  if (!(value instanceof oid) && SchemaType._isRef(this, value, doc, init)) {
+  if (!(isBsonType(value, 'ObjectID')) && SchemaType._isRef(this, value, doc, init)) {
     // wait! we may need to cast this to a document
     if ((getConstructorName(value) || '').toLowerCase() === 'objectid') {
       return new oid(value.toHexString());

package/lib/schema.js

@@ -473,9 +473,39 @@ Schema.prototype.defaultOptions = function(options) {
   return options;
 };
 
+/**
+ * Inherit a Schema by applying a discriminator on an existing Schema.
+ *
+ *
+ * ####Example:
+ *
+ *     const options = { discriminatorKey: 'kind' };
+ *
+ *     const eventSchema = new mongoose.Schema({ time: Date }, options);
+ *     const Event = mongoose.model('Event', eventSchema);
+ *
+ *     // ClickedLinkEvent is a special type of Event that has
+ *     // a URL.
+ *     const ClickedLinkEvent = Event.discriminator('ClickedLink',
+ *     new mongoose.Schema({ url: String }, options));
+ *
+ *     // When you create a generic event, it can't have a URL field...
+ *     const genericEvent = new Event({ time: Date.now(), url: 'google.com' });
+ *     assert.ok(!genericEvent.url);
+ *     // But a ClickedLinkEvent can
+ *     const clickedEvent = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
+ *     assert.ok(clickedEvent.url);
+ *
+ * @param {String} name the name of the discriminator
+ * @param {Schema} schema the Schema of the discriminated Schema
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
 Schema.prototype.discriminator = function(name, schema) {
-  this._applyDiscriminators = {};
-  this._applyDiscriminators[name] = schema;
+  this._applyDiscriminators = Object.assign(this._applyDiscriminators || {}, { [name]: schema });
+
+  return this;
 };
 
 /**
@@ -1172,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.5",
+  "version": "6.3.8",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,10 +28,9 @@
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.10",
-    "@babel/preset-env": "7.17.10",
-    "@typescript-eslint/eslint-plugin": "5.21.0",
-    "@typescript-eslint/parser": "5.21.0",
+    "@babel/core": "7.18.2",
+    "@typescript-eslint/eslint-plugin": "5.27.0",
+    "@typescript-eslint/parser": "5.27.0",
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
@@ -41,31 +40,31 @@
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "buffer": "^5.6.0",
-    "cheerio": "1.0.0-rc.10",
+    "cheerio": "1.0.0-rc.11",
     "crypto-browserify": "3.12.0",
     "dox": "0.3.1",
-    "eslint": "8.14.0",
+    "eslint": "8.16.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "highlight.js": "11.5.1",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "4.0.14",
+    "marked": "4.0.16",
     "mkdirp": "^1.0.4",
     "mocha": "10.0.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.5.2",
+    "mongodb-memory-server": "8.6.0",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
     "serve-handler": "6.1.3",
-    "sinon": "13.0.2",
+    "sinon": "14.0.0",
     "stream-browserify": "3.0.0",
     "ts-benchmark": "^1.0.2",
     "tsd": "0.20.0",
-    "typescript": "4.6.4",
+    "typescript": "4.7.2",
     "uuid": "8.3.2",
-    "webpack": "5.72.0"
+    "webpack": "5.72.1"
   },
   "directories": {
     "lib": "./lib/mongoose"
@@ -97,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"
@@ -146,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/index.d.ts

@@ -120,6 +120,17 @@ declare module 'mongoose' {
     useProjection?: boolean;
   }
 
+  export type DiscriminatorModel<M, T> = T extends Model<infer T1, infer T2, infer T3, infer T4>
+    ?
+    M extends Model<infer M1, infer M2, infer M3, infer M4>
+      ? Model<Omit<M1, keyof T1> & T1, M2 | T2, M3 | T3, M4 | T4>
+      : M
+    : M;
+
+  export type DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, T> = T extends Schema<infer T1, infer T2, infer T3, infer T4, infer T5>
+    ? Schema<Omit<DocType, keyof T1> & T1, DiscriminatorModel<T2, M>, T3 | TInstanceMethods, T4 | TQueryHelpers, T5 | TVirtuals>
+    : Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals>;
+
   export class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = {}, TQueryHelpers = {}, TVirtuals = any> extends events.EventEmitter {
     /**
      * Create a new schema
@@ -142,6 +153,8 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
+    discriminator<T extends Schema = Schema>(name: string, schema: T): DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, T>;
+
     /** Returns a new schema that has the picked `paths` from this schema. */
     pick<T = this>(paths: string[], options?: SchemaOptions): T;
 
@@ -474,10 +487,10 @@ declare module 'mongoose' {
   type LeanTypeOrArray<T> = T extends unknown[] ? LeanArray<T> : LeanType<T>;
 
   export type LeanArray<T extends unknown[]> =
-  // By checking if it extends Types.Array we can get the original base type before collapsing down,
-  // rather than trying to manually remove the old types. This matches both Array and DocumentArray
+    // By checking if it extends Types.Array we can get the original base type before collapsing down,
+    // rather than trying to manually remove the old types. This matches both Array and DocumentArray
     T extends Types.Array<infer U> ? LeanTypeOrArray<U>[] :
-      // If it isn't a custom mongoose type we fall back to "do our best"
+    // If it isn't a custom mongoose type we fall back to "do our best"
       T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
 
   export type _LeanDocument<T> = {

package/types/query.d.ts

@@ -579,7 +579,7 @@ declare module 'mongoose' {
     snapshot(val?: boolean): 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 }): this;
+    sort(arg?: string | { [key: string]: SortOrder | { $meta: 'textScore' } } | undefined | null): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {

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.
@@ -126,7 +135,7 @@ declare module 'mongoose' {
     transform?: (this: any, val: T) => any;
 
     /** defines a custom getter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
-    get?: (value: any, doc?: this) => T;
+    get?: (value: any, doc?: this) => T | undefined;
 
     /** defines a custom setter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
     set?: (value: any, priorVal?: T, doc?: this) => any;
@@ -271,7 +280,7 @@ declare module 'mongoose' {
     namespace Types {
       class Array extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Array';
 
         static options: { castNonArrays: boolean; };
 
@@ -290,7 +299,7 @@ declare module 'mongoose' {
 
       class Boolean extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Boolean';
 
         /** Configure which values get casted to `true`. */
         static convertToTrue: Set<any>;
@@ -301,7 +310,7 @@ declare module 'mongoose' {
 
       class Buffer extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Buffer';
 
         /**
          * Sets the default [subtype](https://studio3t.com/whats-new/best-practices-uuid-mongodb/)
@@ -312,7 +321,7 @@ declare module 'mongoose' {
 
       class Date extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Date';
 
         /** Declares a TTL index (rounded to the nearest second) for _Date_ types only. */
         expires(when: number | string): this;
@@ -326,12 +335,12 @@ declare module 'mongoose' {
 
       class Decimal128 extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Decimal128';
       }
 
       class DocumentArray extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'DocumentArray';
 
         static options: { castNonArrays: boolean; };
 
@@ -347,17 +356,17 @@ declare module 'mongoose' {
 
       class Map extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Map';
       }
 
       class Mixed extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Mixed';
       }
 
       class Number extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Number';
 
         /** Sets a enum validator */
         enum(vals: number[]): this;
@@ -371,7 +380,7 @@ declare module 'mongoose' {
 
       class ObjectId extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'ObjectId';
 
         /** Adds an auto-generated ObjectId default if turnOn is true. */
         auto(turnOn: boolean): this;
@@ -390,7 +399,7 @@ declare module 'mongoose' {
 
       class String extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'String';
 
         /** Adds an enum validator */
         enum(vals: string[] | any): this;

package/.lgtm.yml

@@ -1,3 +0,0 @@
-path_classifiers:
-  test:
-    - lib