Feature: Infer schema type automatically.

CHANGELOG.md

@@ -1,3 +1,13 @@
+6.2.8 / 2022-03-22
+==================
+ * fix(document): handle casting array of spread docs #11522
+ * fix(document): avoid setting nested properties on top-level document when initing with strict: false #11526
+ * fix(document): correctly handle deeply nested subdocuments when getting paths to validate #11501
+ * fix(types): avoid making TInstanceMethods any by default leading to `this = any` in middleware #11435
+ * fix(types): allow defining array default if using Types.Array<> in document interface #11391
+ * docs(migrating_to_6): describe breaking change in Mongoose 6 about default query populate model #11289
+ * docs(middleware): fix typo #11537 [x1489](https://github.com/x1489)
+
 6.2.7 / 2022-03-16
 ==================
  * perf(document): avoid running validation on every array element if there's no validators to run #11380

lib/document.js

@@ -2421,6 +2421,7 @@ Document.prototype.validate = function(pathsToValidate, options, callback) {
     }
 
     this.$__validate(pathsToValidate, options, (error) => {
+      this.$__.validating = null;
       this.$op = null;
       cb(error);
     });

lib/index.js

@@ -24,7 +24,6 @@ const legacyPluralize = require('./helpers/pluralize');
 const utils = require('./utils');
 const pkg = require('../package.json');
 const cast = require('./cast');
-const clearValidating = require('./plugins/clearValidating');
 const removeSubdocs = require('./plugins/removeSubdocs');
 const saveSubdocs = require('./plugins/saveSubdocs');
 const trackTransaction = require('./plugins/trackTransaction');
@@ -107,8 +106,7 @@ function Mongoose(options) {
       [validateBeforeSave, { deduplicate: true }],
       [shardingPlugin, { deduplicate: true }],
       [removeSubdocs, { deduplicate: true }],
-      [trackTransaction, { deduplicate: true }],
-      [clearValidating, { deduplicate: true }]
+      [trackTransaction, { deduplicate: true }]
     ]
   });
 }

lib/model.js

@@ -245,8 +245,7 @@ function _applyCustomWhere(doc, where) {
  */
 
 Model.prototype.$__handleSave = function(options, callback) {
-  const _this = this;
-  let saveOptions = {};
+  const saveOptions = {};
 
   applyWriteConcern(this.$__schema, options);
   if (typeof options.writeConcern !== 'undefined') {
@@ -274,14 +273,10 @@ Model.prototype.$__handleSave = function(options, callback) {
   if ('checkKeys' in options) {
     saveOptions.checkKeys = options.checkKeys;
   }
-  const session = this.$session();
   if (!saveOptions.hasOwnProperty('session')) {
-    saveOptions.session = session;
+    saveOptions.session = this.$session();
   }
 
-  if (Object.keys(saveOptions).length === 0) {
-    saveOptions = null;
-  }
   if (this.$isNew) {
     // send entire doc
     const obj = this.toObject(saveToObjectOptions);
@@ -298,74 +293,77 @@ Model.prototype.$__handleSave = function(options, callback) {
     }
 
     this.$__version(true, obj);
-    this[modelCollectionSymbol].insertOne(obj, saveOptions, function(err, ret) {
+    this[modelCollectionSymbol].insertOne(obj, saveOptions, (err, ret) => {
       if (err) {
-        _setIsNew(_this, true);
+        _setIsNew(this, true);
 
         callback(err, null);
         return;
       }
 
       callback(null, ret);
     });
+
     this.$__reset();
     _setIsNew(this, false);
     // Make it possible to retry the insert
     this.$__.inserting = true;
-  } else {
-    // Make sure we don't treat it as a new object on error,
-    // since it already exists
-    this.$__.inserting = false;
-
-    const delta = this.$__delta();
-    if (delta) {
-      if (delta instanceof MongooseError) {
-        callback(delta);
-        return;
-      }
 
-      const where = this.$__where(delta[0]);
-      if (where instanceof MongooseError) {
-        callback(where);
-        return;
-      }
+    return;
+  }
 
-      _applyCustomWhere(this, where);
-      this[modelCollectionSymbol].updateOne(where, delta[1], saveOptions, (err, ret) => {
-        if (err) {
-          this.$__undoReset();
+  // Make sure we don't treat it as a new object on error,
+  // since it already exists
+  this.$__.inserting = false;
 
-          callback(err);
-          return;
-        }
-        ret.$where = where;
-        callback(null, ret);
-      });
-    } else {
-      const optionsWithCustomValues = Object.assign({}, options, saveOptions);
-      const where = this.$__where();
-      if (this.$__schema.options.optimisticConcurrency) {
-        const key = this.$__schema.options.versionKey;
-        const val = this.$__getValue(key);
-        if (val != null) {
-          where[key] = val;
-        }
-      }
-      this.constructor.exists(where, optionsWithCustomValues)
-        .then(documentExists => {
-          const matchedCount = !documentExists ? 0 : 1;
-          callback(null, { $where: where, matchedCount });
-        })
-        .catch(callback);
+  const delta = this.$__delta();
+  if (delta) {
+    if (delta instanceof MongooseError) {
+      callback(delta);
       return;
     }
 
-    // store the modified paths before the document is reset
-    this.$__.modifiedPaths = this.modifiedPaths();
-    this.$__reset();
+    const where = this.$__where(delta[0]);
+    if (where instanceof MongooseError) {
+      callback(where);
+      return;
+    }
 
-    _setIsNew(this, false);
+    _applyCustomWhere(this, where);
+    this[modelCollectionSymbol].updateOne(where, delta[1], saveOptions, (err, ret) => {
+      if (err) {
+        this.$__undoReset();
+
+        callback(err);
+        return;
+      }
+      ret.$where = where;
+      callback(null, ret);
+    });
+  } else {
+    const optionsWithCustomValues = Object.assign({}, options, saveOptions);
+    const where = this.$__where();
+    if (this.$__schema.options.optimisticConcurrency) {
+      const key = this.$__schema.options.versionKey;
+      const val = this.$__getValue(key);
+      if (val != null) {
+        where[key] = val;
+      }
+    }
+    this.constructor.exists(where, optionsWithCustomValues)
+      .then(documentExists => {
+        const matchedCount = !documentExists ? 0 : 1;
+        callback(null, { $where: where, matchedCount });
+      })
+      .catch(callback);
+    return;
   }
+
+  // store the modified paths before the document is reset
+  this.$__.modifiedPaths = this.modifiedPaths();
+  this.$__reset();
+
+  _setIsNew(this, false);
 };
 
 /*!
@@ -374,8 +372,8 @@ Model.prototype.$__handleSave = function(options, callback) {
 
 Model.prototype.$__save = function(options, callback) {
   this.$__handleSave(options, (error, result) => {
-    const hooks = this.$__schema.s.hooks;
     if (error) {
+      const hooks = this.$__schema.s.hooks;
       return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
         callback(error, this);
       });
@@ -423,6 +421,7 @@ Model.prototype.$__save = function(options, callback) {
         this.$__undoReset();
         error = new DocumentNotFoundError(result.$where,
           this.constructor.modelName, numAffected, result);
+        const hooks = this.$__schema.s.hooks;
         return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
           callback(error, this);
         });
@@ -516,9 +515,9 @@ Model.prototype.save = function(options, fn) {
     this.$__.saveOptions = options;
 
     this.$__save(options, error => {
-      this.$__.saving = undefined;
-      delete this.$__.saveOptions;
-      delete this.$__.$versionError;
+      this.$__.saving = null;
+      this.$__.saveOptions = null;
+      this.$__.$versionError = null;
       this.$op = null;
 
       if (error) {

lib/options/SchemaDateOptions.js

@@ -48,6 +48,13 @@ Object.defineProperty(SchemaDateOptions.prototype, 'max', opts);
 /**
  * If set, Mongoose creates a TTL index on this path.
  *
+ * mongo TTL index `expireAfterSeconds` value will take 'expires' value expressed in seconds.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ "expireAt": { type: Date,  expires: 11 } });
+ *     // if 'expireAt' is set, then document expires at expireAt + 11 seconds
+ *
  * @api public
  * @property expires
  * @memberOf SchemaDateOptions
@@ -61,4 +68,4 @@ Object.defineProperty(SchemaDateOptions.prototype, 'expires', opts);
  * ignore
  */
 
-module.exports = SchemaDateOptions;
+module.exports = SchemaDateOptions;

lib/schema.js

@@ -106,9 +106,9 @@ function Schema(obj, options) {
   this.inherits = {};
   this.callQueue = [];
   this._indexes = [];
-  this.methods = {};
+  this.methods = (options && options.methods) || {};
   this.methodOptions = {};
-  this.statics = {};
+  this.statics = (options && options.statics) || {};
   this.tree = {};
   this.query = {};
   this.childSchemas = [];

package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.7",
+  "version": "6.2.8",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "bson": "^4.2.2",
-    "kareem": "2.3.4",
+    "kareem": "2.3.5",
     "mongodb": "4.3.1",
     "mpath": "0.8.4",
     "mquery": "4.0.2",

test/document.test.js

@@ -11198,4 +11198,12 @@ describe('document', function() {
 
     await doc.validate();
   });
+
+  it('should give an instance function back rather than undefined (m0_0a)', function M0_0aModelJS() {
+    const testSchema = new mongoose.Schema({}, { methods: { instanceFn() { return 'Returned from DocumentInstanceFn'; } } });
+    const TestModel = mongoose.model('TestModel', testSchema);
+    const TestDocument = new TestModel({});
+    assert.equal(TestDocument.instanceFn(), 'Returned from DocumentInstanceFn');
+  });
+
 });

test/model.test.js

@@ -8485,4 +8485,12 @@ function pick(obj, keys) {
     }
   }
   return newObj;
-}
+}
+
+describe('Check if statics functions that is supplied in schema option is availabe (m0_0a)', function() {
+  it('should give a static function back rather than undefined', function M0_0aModelJS() {
+    const testSchema = new mongoose.Schema({}, { statics: { staticFn() { return 'Returned from staticFn'; } } });
+    const TestModel = mongoose.model('TestModel', testSchema);
+    assert.equal(TestModel.staticFn(), 'Returned from staticFn');
+  });
+});

test/types/create.test.ts

@@ -3,7 +3,7 @@ import { Schema, model, Document, Types } from 'mongoose';
 const schema: Schema = new Schema({ name: { type: 'String' } });
 
 interface ITest extends Document {
-  _id?: Types.ObjectId;
+  _id?: Types.ObjectId | string;
   name?: string;
 }
 

test/types/document.test.ts

@@ -162,6 +162,12 @@ function gh11435() {
   const ItemSchema = new Schema<Item>({ name: String });
 
   ItemSchema.pre('validate', function preValidate() {
-    expectType<Model<unknown>>(this.model('Item1'));
+    expectType<Model<Item>>(this.model('Item1'));
+  });
+
+  const AutoTypedItemSchema = new Schema({ name: String });
+
+  AutoTypedItemSchema.pre('validate', function preValidate() {
+    expectType<Model<Item>>(this.model('Item1'));
   });
 }

test/types/middleware.test.ts

@@ -1,5 +1,5 @@
 import { Schema, model, Model, Document, SaveOptions, Query, Aggregate, HydratedDocument, PreSaveMiddlewareFunction } from 'mongoose';
-import { expectError, expectType } from 'tsd';
+import { expectError, expectAssignable, expectNotType } from 'tsd';
 
 interface ITest extends Document {
   name?: string;
@@ -81,6 +81,19 @@ const Test = model<ITest>('Test', schema);
 
 function gh11257(): void {
   schema.pre('save', { document: true }, function() {
-    expectType<HydratedDocument<ITest>>(this);
+    expectAssignable<HydratedDocument<ITest>>(this);
+  });
+}
+
+function gh11480(): void {
+  type IUserSchema = {
+    name: string;
+  }
+
+  const UserSchema = new Schema<IUserSchema>({ name: { type: String } });
+
+  UserSchema.pre('save', function(next) {
+    expectNotType<any>(this);
+    next();
   });
 }