6.0.14 / 2021-11-29

* fix(document): catch errors in required functions #10968

* fix(connection): clone schema when passing a schema from a different copy of Mongoose to `Connection#model()` #10904

* fix(populate): set empty array [] on virtual populate with no result #10992

* fix(query): handle orFail() with replaceOne() #10963

* fix(populate): use Model by default when using Model.populate() on a POJO #10978

* fix(document): throw VersionError if saving a document with version bump and document isn't found #10974

* fix(index.d.ts): make populate type param optional #10989 [mohd-akram](https://github.com/mohd-akram)

* docs(migrating_to_6): add a note about minimize and toObject() behavior change in v5.10.5 #10827

* docs: remove duplicate `path` in docs #11020 [ItWorksOnMyMachine](https://github.com/ItWorksOnMyMachine)

* docs: fix typo in populate docs #11015 [gavi-shandler](https://github.com/gavi-shandler)

* docs: fix typo in model.js #10982 [eltociear](https://github.com/eltociear)

* [`toObject()` and `toJSON()` Use Nested Schema `minimize`](#toobject-and-tojson-use-nested-schema-minimize)

<h3 id="toobject-and-tojson-use-nested-schema-minimize"><a href="#toobject-and-tojson-use-nested-schema-minimize">`toObject()` and `toJSON()` Use Nested Schema `minimize`</a></h3>

This change was technically released with 5.10.5, but [caused issues for users migrating from 5.9.x to 6.x](https://github.com/Automattic/mongoose/issues/10827).

In Mongoose `< 5.10.5`, `toObject()` and `toJSON()` would use the top-level schema's `minimize` option by default.

const child = new Schema({ thing: Schema.Types.Mixed });

const parent = new Schema({ child }, { minimize: false });

const Parent = model('Parent', parent);

const p = new Parent({ child: { thing: {} } });

console.log(p.toObject());

As a workaround, you can either explicitly pass `minimize` to `toObject()` or `toJSON()`:

console.log(p.toObject({ minimize: false }));

Or define the `child` schema inline (Mongoose 6 only) to inherit the parent's `minimize` option.

const parent = new Schema({

// Implicitly creates a new schema with the top-level schema's `minimize` option.

child: { type: { thing: Schema.Types.Mixed } }

}, { minimize: false });

// Works, foreign field `author` is selected

populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;

populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;

populate<Paths = {}>(path: string, names: string): Promise<this & Paths>;

populate<Paths = {}>(path: string, names: string, callback: Callback<this & Paths>): void;

class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any> extends events.EventEmitter {

populate<Paths = {}>(path: string | any, select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<ResultType & Paths, DocType, THelpers, RawDocType>;

populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<ResultType & Paths, DocType, THelpers, RawDocType>;

<a rel="sponsored" href="https://casino.guide/crypto-casinos/">

<img class="sponsor" src="https://casino.guide/wp-content/themes/casinoguide/assets/lotti/en/default/images/img_0.png" style="height: 100px">

</a>

try {

doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);

} catch (err) {

doc.invalidate(path, err);

}

if (Array.isArray(valueToSet)) {

valueToSet = valueToSet.map(v => v == null ? void 0 : v);

}

// `Model.populate()` on a POJO with no known local model. Default to using the `Model`

if (options._localModel == null) {

modelNames = [model.modelName];

} else {

return { modelNames: modelNames, justOne: justOne, isRefPath: isRefPath, refPath: refPath };

}

this.constructor.exists(where, optionsWithCustomValues).

then((documentExists) => {

const matchedCount = 0;

return callback(null, { $where: where, matchedCount });

const matchedCount = 1;

callback(null, { $where: where, matchedCount });

}).

catch(callback);

if (result != null) {

"version": "6.0.14",

const VersionError = mongoose.Error.VersionError;

it('saving a document when version bump required, throws a VersionError when document is not found (gh-10974)', async function() {

const personSchema = new Schema({ tags: [String] });

const Person = db.model('Person', personSchema);

const person = await Person.create({ tags: ['tag1', 'tag2'] });

await Person.deleteOne({ _id: person._id });

person.tags.splice(0, 1);

const err = await person.save().then(() => null, err => err);

assert.ok(err instanceof VersionError);

assert.equal(err.message, `No matching document found for id "${person._id}" version 0 modifiedPaths "tags"`);

});

it('catches errors in `required` functions (gh-10968)', async function() {

const TestSchema = new Schema({

url: {

type: String,

required: function() {

throw new Error('oops!');

}

}

});

const Test = db.model('Test', TestSchema);

const err = await Test.create({}).then(() => null, err => err);

assert.ok(err);

assert.equal(err.errors['url'].message, 'oops!');

});

it('sets empty array if lean with justOne = false and no results (gh-10992)', async function() {

const PersonSchema = new mongoose.Schema({

name: String,

band: String

});

const BandSchema = new mongoose.Schema({

name: String

});

BandSchema.virtual('members', {

ref: 'Person',

localField: 'name',

foreignField: 'band',

justOne: false

});

db.model('Person', PersonSchema);

const Band = db.model('Test', BandSchema);

await Band.create({ name: 'Guns N\' Roses' });

const res = await Band.find().populate('members').lean();

assert.equal(res.length, 1);

assert.equal(res[0].name, 'Guns N\' Roses');

assert.deepStrictEqual(res[0].members, []);

});

it('uses `Model` by default when doing `Model.populate()` on a POJO (gh-10978)', async function() {

const UserSchema = new Schema({

name: { type: String, default: '' }

});

const TestSchema = new Schema({

users: [{ user: { type: 'ObjectId', ref: 'User' } }]

});

const User = db.model('User', UserSchema);

const Test = db.model('Test', TestSchema);

const users = await User.create([{ name: 'user-name' }, { name: 'user-name-2' }]);

await Test.create([{ users: [{ user: users[0]._id }, { user: users[1]._id }] }]);

const found = await Test.aggregate([

{

$project: {

users: '$users'

}

},

{ $unwind: '$users' },

{ $sort: { 'users.name': 1 } }

]);

const _users = found.reduce((users, cur) => [...users, cur.users], []);

await User.populate(_users, { path: 'user' });

assert.equal(_users.length, 2);

assert.equal(_users[0].user.name, 'user-name');

assert.equal(_users[1].user.name, 'user-name-2');

});