6.9

.gitignore

@@ -20,7 +20,7 @@ coverage
 npm-debug.log
 data/
 .nyc_output/
-
+.env
 tools/31*
 
 # Visual Studio

lib/cast.js

@@ -64,11 +64,18 @@ module.exports = function cast(schema, obj, options, context) {
       if (!Array.isArray(val)) {
         throw new CastError('Array', val, path);
       }
-      for (let k = 0; k < val.length; ++k) {
+      for (let k = val.length - 1; k >= 0; k--) {
         if (val[k] == null || typeof val[k] !== 'object') {
           throw new CastError('Object', val[k], path + '.' + k);
         }
         val[k] = cast(schema, val[k], options, context);
+        if (Object.keys(val[k]).length === 0) {
+          val.splice(k, 1);
+        }
+      }
+
+      if (val.length === 0) {
+        delete obj[path];
       }
     } else if (path === '$where') {
       type = typeof val;

lib/schema.js

@@ -2251,6 +2251,32 @@ function _deletePath(schema, name) {
   delete branch[last];
 }
 
+/**
+ *
+ * @param {String|Array} path The virutal path(s) to remove.
+ * @returns {Schema} the Schema instance, or a mongoose error if the virtual does not exist.
+ * @api public
+ */
+
+Schema.prototype.removeVirtual = function(path) {
+  if (typeof path === 'string') {
+    path = [path];
+  }
+  if (Array.isArray(path)) {
+    for (const virtual of path) {
+      if (this.virtuals[virtual] == null) {
+        throw new MongooseError(`Attempting to remove virtual "${virtual}" that does not exist.`);
+      }
+    }
+
+    for (const virtual of path) {
+      delete this.paths[virtual];
+      delete this.virtuals[virtual];
+    }
+  }
+  return this;
+};
+
 /**
  * Loads an ES6 class into a schema. Maps [setters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set) + [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get), [static methods](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static),
  * and [instance methods](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Class_body_and_method_definitions)

package.json

@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^4.7.0",
     "kareem": "2.5.1",
-    "mongodb": "4.12.1",
+    "mongodb": "4.13.0",
     "mpath": "0.9.0",
     "mquery": "4.0.3",
     "ms": "2.1.3",

test/docs/cast.test.js

@@ -101,40 +101,58 @@ describe('Cast Tutorial', function() {
     await query.exec();
   });
 
-  it('strictQuery true', async function() {
-    mongoose.deleteModel('Character');
-    const schema = new mongoose.Schema({ name: String, age: Number }, {
-      strictQuery: true
+  describe('strictQuery', function() {
+    it('strictQuery true - simple object', async function() {
+      mongoose.deleteModel('Character');
+      const schema = new mongoose.Schema({ name: String, age: Number }, {
+        strictQuery: true
+      });
+      Character = mongoose.model('Character', schema);
+
+      const query = Character.findOne({ notInSchema: { $lt: 'not a number' } });
+
+      await query.exec();
+      query.getFilter(); // Empty object `{}`, Mongoose removes `notInSchema`
+      // acquit:ignore:start
+      assert.deepEqual(query.getFilter(), {});
+      // acquit:ignore:end
     });
-    Character = mongoose.model('Character', schema);
 
-    const query = Character.findOne({ notInSchema: { $lt: 'not a number' } });
+    it('strictQuery true - conditions', async function() {
+      mongoose.deleteModel('Character');
+      const schema = new mongoose.Schema({ name: String, age: Number }, {
+        strictQuery: true
+      });
+      Character = mongoose.model('Character', schema);
 
-    await query.exec();
-    query.getFilter(); // Empty object `{}`, Mongoose removes `notInSchema`
-    // acquit:ignore:start
-    assert.deepEqual(query.getFilter(), {});
-    // acquit:ignore:end
-  });
+      const query = Character.findOne({ $or: [{ notInSchema: { $lt: 'not a number' } }], $and: [{ name: 'abc' }, { age: { $gt: 18 } }, { notInSchema: { $lt: 'not a number' } }] });
 
-  it('strictQuery throw', async function() {
-    mongoose.deleteModel('Character');
-    const schema = new mongoose.Schema({ name: String, age: Number }, {
-      strictQuery: 'throw'
+      await query.exec();
+      query.getFilter(); // Empty object `{}`, Mongoose removes `notInSchema`
+      // acquit:ignore:start
+      assert.deepEqual(query.getFilter(), { $and: [{ name: 'abc' }, { age: { $gt: 18 } }] });
+      // acquit:ignore:end
     });
-    Character = mongoose.model('Character', schema);
 
-    const query = Character.findOne({ notInSchema: { $lt: 'not a number' } });
-
-    const err = await query.exec().then(() => null, err => err);
-    err.name; // 'StrictModeError'
-    // Path "notInSchema" is not in schema and strictQuery is 'throw'.
-    err.message;
-    // acquit:ignore:start
-    assert.equal(err.name, 'StrictModeError');
-    assert.equal(err.message, 'Path "notInSchema" is not in schema and ' +
-      'strictQuery is \'throw\'.');
-    // acquit:ignore:end
+    it('strictQuery throw', async function() {
+      mongoose.deleteModel('Character');
+      const schema = new mongoose.Schema({ name: String, age: Number }, {
+        strictQuery: 'throw'
+      });
+      Character = mongoose.model('Character', schema);
+
+      const query = Character.findOne({ notInSchema: { $lt: 'not a number' } });
+
+      const err = await query.exec().then(() => null, err => err);
+      err.name; // 'StrictModeError'
+      // Path "notInSchema" is not in schema and strictQuery is 'throw'.
+      err.message;
+      // acquit:ignore:start
+      assert.equal(err.name, 'StrictModeError');
+      assert.equal(err.message, 'Path "notInSchema" is not in schema and ' +
+        'strictQuery is \'throw\'.');
+      // acquit:ignore:end
+    });
   });
 
   it('implicit in', async function() {

test/schema.test.js

@@ -2910,4 +2910,63 @@ describe('schema', function() {
 
     assert.equal(schema._getSchema('child.testMap.foo.bar').instance, 'Mixed');
   });
+
+  it('should allow deleting a virtual path off the schema gh-8397', async function() {
+    const schema = new Schema({
+      name: String
+    }, {
+      virtuals: {
+        foo: {
+          get() {
+            return 42;
+          }
+        }
+      }
+    });
+    assert.ok(schema.virtuals.foo);
+    schema.removeVirtual('foo');
+    assert.ok(!schema.virtuals.foo);
+    const Test = db.model('gh-8397', schema);
+    const doc = new Test({ name: 'Test' });
+    assert.equal(doc.foo, undefined);
+  });
+
+  it('should allow deleting multiple virtuals gh-8397', async function() {
+    const schema = new Schema({
+      name: String
+    }, {
+      virtuals: {
+        foo: {
+          get() {
+            return 42;
+          }
+        },
+        bar: {
+          get() {
+            return 41;
+          }
+        }
+      }
+    });
+    assert.ok(schema.virtuals.foo);
+    assert.ok(schema.virtuals.bar);
+    schema.removeVirtual(['foo', 'bar']);
+    assert.ok(!schema.virtuals.foo);
+    assert.ok(!schema.virtuals.bar);
+    const Test = db.model('gh-8397', schema);
+    const doc = new Test({ name: 'Test' });
+    assert.equal(doc.foo, undefined);
+    assert.equal(doc.bar, undefined);
+  });
+
+  it('should throw an error if attempting to delete a virtual path that does not exist gh-8397', function() {
+    const schema = new Schema({
+      name: String
+    });
+    assert.ok(!schema.virtuals.foo);
+    assert.throws(() => {
+      schema.removeVirtual('foo');
+    }, { message: 'Attempting to remove virtual "foo" that does not exist.' });
+
+  });
 });

test/types/models.test.ts

@@ -466,7 +466,7 @@ function gh12100() {
   const TestModel = model('test', schema_with_string_id);
   const obj = new TestModel();
 
-  expectType<string>(obj._id);
+  expectType<string | null>(obj._id);
 })();
 
 (async function gh12094() {

test/types/queries.test.ts

@@ -411,7 +411,7 @@ async function gh12342_manual() {
 
 async function gh12342_auto() {
   interface Project {
-    name?: string, stars?: number
+    name?: string | null, stars?: number | null
   }
 
   const ProjectSchema = new Schema({