You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4793 lines
168 KiB
JavaScript
4793 lines
168 KiB
JavaScript
11 months ago
|
'use strict';
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Module dependencies.
|
||
|
|
*/
|
||
|
|
|
||
|
|
const Aggregate = require('./aggregate');
|
||
|
|
const ChangeStream = require('./cursor/changeStream');
|
||
|
|
const Document = require('./document');
|
||
|
|
const DocumentNotFoundError = require('./error/notFound');
|
||
|
|
const DivergentArrayError = require('./error/divergentArray');
|
||
|
|
const EventEmitter = require('events').EventEmitter;
|
||
|
|
const Kareem = require('kareem');
|
||
|
|
const MongooseBuffer = require('./types/buffer');
|
||
|
|
const MongooseError = require('./error/index');
|
||
|
|
const OverwriteModelError = require('./error/overwriteModel');
|
||
|
|
const Query = require('./query');
|
||
|
|
const SaveOptions = require('./options/saveOptions');
|
||
|
|
const Schema = require('./schema');
|
||
|
|
const ValidationError = require('./error/validation');
|
||
|
|
const VersionError = require('./error/version');
|
||
|
|
const ParallelSaveError = require('./error/parallelSave');
|
||
|
|
const applyDefaultsHelper = require('./helpers/document/applyDefaults');
|
||
|
|
const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
|
||
|
|
const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
|
||
|
|
const applyHooks = require('./helpers/model/applyHooks');
|
||
|
|
const applyMethods = require('./helpers/model/applyMethods');
|
||
|
|
const applyProjection = require('./helpers/projection/applyProjection');
|
||
|
|
const applySchemaCollation = require('./helpers/indexes/applySchemaCollation');
|
||
|
|
const applyStaticHooks = require('./helpers/model/applyStaticHooks');
|
||
|
|
const applyStatics = require('./helpers/model/applyStatics');
|
||
|
|
const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
|
||
|
|
const assignVals = require('./helpers/populate/assignVals');
|
||
|
|
const castBulkWrite = require('./helpers/model/castBulkWrite');
|
||
|
|
const clone = require('./helpers/clone');
|
||
|
|
const createPopulateQueryFilter = require('./helpers/populate/createPopulateQueryFilter');
|
||
|
|
const decorateUpdateWithVersionKey = require('./helpers/update/decorateUpdateWithVersionKey');
|
||
|
|
const getDefaultBulkwriteResult = require('./helpers/getDefaultBulkwriteResult');
|
||
|
|
const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
|
||
|
|
const discriminator = require('./helpers/model/discriminator');
|
||
|
|
const firstKey = require('./helpers/firstKey');
|
||
|
|
const each = require('./helpers/each');
|
||
|
|
const get = require('./helpers/get');
|
||
|
|
const getConstructorName = require('./helpers/getConstructorName');
|
||
|
|
const getDiscriminatorByValue = require('./helpers/discriminator/getDiscriminatorByValue');
|
||
|
|
const getModelsMapForPopulate = require('./helpers/populate/getModelsMapForPopulate');
|
||
|
|
const immediate = require('./helpers/immediate');
|
||
|
|
const internalToObjectOptions = require('./options').internalToObjectOptions;
|
||
|
|
const isDefaultIdIndex = require('./helpers/indexes/isDefaultIdIndex');
|
||
|
|
const isIndexEqual = require('./helpers/indexes/isIndexEqual');
|
||
|
|
const {
|
||
|
|
getRelatedDBIndexes,
|
||
|
|
getRelatedSchemaIndexes
|
||
|
|
} = require('./helpers/indexes/getRelatedIndexes');
|
||
|
|
const isPathExcluded = require('./helpers/projection/isPathExcluded');
|
||
|
|
const decorateDiscriminatorIndexOptions = require('./helpers/indexes/decorateDiscriminatorIndexOptions');
|
||
|
|
const isPathSelectedInclusive = require('./helpers/projection/isPathSelectedInclusive');
|
||
|
|
const leanPopulateMap = require('./helpers/populate/leanPopulateMap');
|
||
|
|
const parallelLimit = require('./helpers/parallelLimit');
|
||
|
|
const parentPaths = require('./helpers/path/parentPaths');
|
||
|
|
const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
|
||
|
|
const pushNestedArrayPaths = require('./helpers/model/pushNestedArrayPaths');
|
||
|
|
const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
|
||
|
|
const setDottedPath = require('./helpers/path/setDottedPath');
|
||
|
|
const STATES = require('./connectionState');
|
||
|
|
const util = require('util');
|
||
|
|
const utils = require('./utils');
|
||
|
|
const MongooseBulkWriteError = require('./error/bulkWriteError');
|
||
|
|
const minimize = require('./helpers/minimize');
|
||
|
|
|
||
|
|
const VERSION_WHERE = 1;
|
||
|
|
const VERSION_INC = 2;
|
||
|
|
const VERSION_ALL = VERSION_WHERE | VERSION_INC;
|
||
|
|
|
||
|
|
const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
|
||
|
|
const modelCollectionSymbol = Symbol('mongoose#Model#collection');
|
||
|
|
const modelDbSymbol = Symbol('mongoose#Model#db');
|
||
|
|
const modelSymbol = require('./helpers/symbols').modelSymbol;
|
||
|
|
const subclassedSymbol = Symbol('mongoose#Model#subclassed');
|
||
|
|
|
||
|
|
const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
|
||
|
|
bson: true,
|
||
|
|
flattenObjectIds: false
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A Model is a class that's your primary tool for interacting with MongoDB.
|
||
|
|
* An instance of a Model is called a [Document](https://mongoosejs.com/docs/api/document.html#Document).
|
||
|
|
*
|
||
|
|
* In Mongoose, the term "Model" refers to subclasses of the `mongoose.Model`
|
||
|
|
* class. You should not use the `mongoose.Model` class directly. The
|
||
|
|
* [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()) and
|
||
|
|
* [`connection.model()`](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.model()) functions
|
||
|
|
* create subclasses of `mongoose.Model` as shown below.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // `UserModel` is a "Model", a subclass of `mongoose.Model`.
|
||
|
|
* const UserModel = mongoose.model('User', new Schema({ name: String }));
|
||
|
|
*
|
||
|
|
* // You can use a Model to create new documents using `new`:
|
||
|
|
* const userDoc = new UserModel({ name: 'Foo' });
|
||
|
|
* await userDoc.save();
|
||
|
|
*
|
||
|
|
* // You also use a model to create queries:
|
||
|
|
* const userFromDb = await UserModel.findOne({ name: 'Foo' });
|
||
|
|
*
|
||
|
|
* @param {Object} doc values for initial set
|
||
|
|
* @param {Object} [fields] optional object containing the fields that were selected in the query which returned this document. You do **not** need to set this parameter to ensure Mongoose handles your [query projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.select()).
|
||
|
|
* @param {Boolean} [skipId=false] optional boolean. If true, mongoose doesn't add an `_id` field to the document.
|
||
|
|
* @inherits Document https://mongoosejs.com/docs/api/document.html
|
||
|
|
* @event `error`: If listening to this event, 'error' is emitted when a document was saved and an `error` occurred. If not listening, the event bubbles to the connection used to create this Model.
|
||
|
|
* @event `index`: Emitted after `Model#ensureIndexes` completes. If an error occurred it is passed with the event.
|
||
|
|
* @event `index-single-start`: Emitted when an individual index starts within `Model#ensureIndexes`. The fields and options being used to build the index are also passed with the event.
|
||
|
|
* @event `index-single-done`: Emitted when an individual index finishes within `Model#ensureIndexes`. If an error occurred it is passed with the event. The fields, options, and index name are also passed.
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
function Model(doc, fields, skipId) {
|
||
|
|
if (fields instanceof Schema) {
|
||
|
|
throw new TypeError('2nd argument to `Model` must be a POJO or string, ' +
|
||
|
|
'**not** a schema. Make sure you\'re calling `mongoose.model()`, not ' +
|
||
|
|
'`mongoose.Model()`.');
|
||
|
|
}
|
||
|
|
Document.call(this, doc, fields, skipId);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Inherits from Document.
|
||
|
|
*
|
||
|
|
* All Model.prototype features are available on
|
||
|
|
* top level (non-sub) documents.
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
Object.setPrototypeOf(Model.prototype, Document.prototype);
|
||
|
|
Model.prototype.$isMongooseModelPrototype = true;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Connection the model uses.
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property db
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.db;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The collection instance this model uses.
|
||
|
|
* A Mongoose collection is a thin wrapper around a [MongoDB Node.js driver collection]([MongoDB Node.js driver collection](https://mongodb.github.io/node-mongodb-native/Next/classes/Collection.html)).
|
||
|
|
* Using `Model.collection` means you bypass Mongoose middleware, validation, and casting.
|
||
|
|
*
|
||
|
|
* This property is read-only. Modifying this property is a no-op.
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property collection
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.collection;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal collection the model uses.
|
||
|
|
*
|
||
|
|
* This property is read-only. Modifying this property is a no-op.
|
||
|
|
*
|
||
|
|
* @api private
|
||
|
|
* @property collection
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
Model.prototype.$__collection;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The name of the model
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property modelName
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.modelName;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Additional properties to attach to the query when calling `save()` and
|
||
|
|
* `isNew` is false.
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property $where
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$where;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If this is a discriminator model, `baseModelName` is the name of
|
||
|
|
* the base model.
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property baseModelName
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.baseModelName;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Event emitter that reports any errors that occurred. Useful for global error
|
||
|
|
* handling.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* MyModel.events.on('error', err => console.log(err.message));
|
||
|
|
*
|
||
|
|
* // Prints a 'CastError' because of the above handler
|
||
|
|
* await MyModel.findOne({ _id: 'Not a valid ObjectId' }).catch(noop);
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @property events
|
||
|
|
* @fires error whenever any query or model function errors
|
||
|
|
* @memberOf Model
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.events;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Compiled middleware for this model. Set in `applyHooks()`.
|
||
|
|
*
|
||
|
|
* @api private
|
||
|
|
* @property _middleware
|
||
|
|
* @memberOf Model
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model._middleware;
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _applyCustomWhere(doc, where) {
|
||
|
|
if (doc.$where == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (const key of Object.keys(doc.$where)) {
|
||
|
|
where[key] = doc.$where[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$__handleSave = function(options, callback) {
|
||
|
|
const saveOptions = {};
|
||
|
|
|
||
|
|
applyWriteConcern(this.$__schema, options);
|
||
|
|
if (typeof options.writeConcern !== 'undefined') {
|
||
|
|
saveOptions.writeConcern = {};
|
||
|
|
if ('w' in options.writeConcern) {
|
||
|
|
saveOptions.writeConcern.w = options.writeConcern.w;
|
||
|
|
}
|
||
|
|
if ('j' in options.writeConcern) {
|
||
|
|
saveOptions.writeConcern.j = options.writeConcern.j;
|
||
|
|
}
|
||
|
|
if ('wtimeout' in options.writeConcern) {
|
||
|
|
saveOptions.writeConcern.wtimeout = options.writeConcern.wtimeout;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if ('w' in options) {
|
||
|
|
saveOptions.w = options.w;
|
||
|
|
}
|
||
|
|
if ('j' in options) {
|
||
|
|
saveOptions.j = options.j;
|
||
|
|
}
|
||
|
|
if ('wtimeout' in options) {
|
||
|
|
saveOptions.wtimeout = options.wtimeout;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ('checkKeys' in options) {
|
||
|
|
saveOptions.checkKeys = options.checkKeys;
|
||
|
|
}
|
||
|
|
|
||
|
|
const session = this.$session();
|
||
|
|
if (!saveOptions.hasOwnProperty('session') && session != null) {
|
||
|
|
saveOptions.session = session;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.$isNew) {
|
||
|
|
// send entire doc
|
||
|
|
const obj = this.toObject(saveToObjectOptions);
|
||
|
|
if ((obj || {})._id === void 0) {
|
||
|
|
// documents must have an _id else mongoose won't know
|
||
|
|
// what to update later if more changes are made. the user
|
||
|
|
// wouldn't know what _id was generated by mongodb either
|
||
|
|
// nor would the ObjectId generated by mongodb necessarily
|
||
|
|
// match the schema definition.
|
||
|
|
immediate(function() {
|
||
|
|
callback(new MongooseError('document must have an _id before saving'));
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.$__version(true, obj);
|
||
|
|
this[modelCollectionSymbol].insertOne(obj, saveOptions).then(
|
||
|
|
ret => callback(null, ret),
|
||
|
|
err => {
|
||
|
|
_setIsNew(this, true);
|
||
|
|
|
||
|
|
callback(err, null);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
this.$__reset();
|
||
|
|
_setIsNew(this, false);
|
||
|
|
// Make it possible to retry the insert
|
||
|
|
this.$__.inserting = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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;
|
||
|
|
}
|
||
|
|
|
||
|
|
_applyCustomWhere(this, where);
|
||
|
|
|
||
|
|
const update = delta[1];
|
||
|
|
if (this.$__schema.options.minimize) {
|
||
|
|
minimize(update);
|
||
|
|
// minimize might leave us with an empty object, which would
|
||
|
|
// lead to MongoDB throwing a "Update document requires atomic operators" error
|
||
|
|
if (Object.keys(update).length === 0) {
|
||
|
|
handleEmptyUpdate.call(this);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this[modelCollectionSymbol].updateOne(where, update, saveOptions).then(
|
||
|
|
ret => {
|
||
|
|
ret.$where = where;
|
||
|
|
callback(null, ret);
|
||
|
|
},
|
||
|
|
err => {
|
||
|
|
this.$__undoReset();
|
||
|
|
|
||
|
|
callback(err);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
handleEmptyUpdate.call(this);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// store the modified paths before the document is reset
|
||
|
|
this.$__.modifiedPaths = this.modifiedPaths();
|
||
|
|
this.$__reset();
|
||
|
|
|
||
|
|
_setIsNew(this, false);
|
||
|
|
|
||
|
|
function handleEmptyUpdate() {
|
||
|
|
const optionsWithCustomValues = Object.assign({}, options, saveOptions);
|
||
|
|
const where = this.$__where();
|
||
|
|
const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
|
||
|
|
if (optimisticConcurrency && !Array.isArray(optimisticConcurrency)) {
|
||
|
|
const key = this.$__schema.options.versionKey;
|
||
|
|
const val = this.$__getValue(key);
|
||
|
|
if (val != null) {
|
||
|
|
where[key] = val;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.constructor.collection.findOne(where, optionsWithCustomValues)
|
||
|
|
.then(documentExists => {
|
||
|
|
const matchedCount = !documentExists ? 0 : 1;
|
||
|
|
callback(null, { $where: where, matchedCount });
|
||
|
|
})
|
||
|
|
.catch(callback);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$__save = function(options, callback) {
|
||
|
|
this.$__handleSave(options, (error, result) => {
|
||
|
|
if (error) {
|
||
|
|
const hooks = this.$__schema.s.hooks;
|
||
|
|
return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
|
||
|
|
callback(error, this);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
let numAffected = 0;
|
||
|
|
const writeConcern = options != null ?
|
||
|
|
options.writeConcern != null ?
|
||
|
|
options.writeConcern.w :
|
||
|
|
options.w :
|
||
|
|
0;
|
||
|
|
if (writeConcern !== 0) {
|
||
|
|
// Skip checking if write succeeded if writeConcern is set to
|
||
|
|
// unacknowledged writes, because otherwise `numAffected` will always be 0
|
||
|
|
if (result != null) {
|
||
|
|
if (Array.isArray(result)) {
|
||
|
|
numAffected = result.length;
|
||
|
|
} else if (result.matchedCount != null) {
|
||
|
|
numAffected = result.matchedCount;
|
||
|
|
} else {
|
||
|
|
numAffected = result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const versionBump = this.$__.version;
|
||
|
|
// was this an update that required a version bump?
|
||
|
|
if (versionBump && !this.$__.inserting) {
|
||
|
|
const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
|
||
|
|
this.$__.version = undefined;
|
||
|
|
const key = this.$__schema.options.versionKey;
|
||
|
|
const version = this.$__getValue(key) || 0;
|
||
|
|
if (numAffected <= 0) {
|
||
|
|
// the update failed. pass an error back
|
||
|
|
this.$__undoReset();
|
||
|
|
const err = this.$__.$versionError ||
|
||
|
|
new VersionError(this, version, this.$__.modifiedPaths);
|
||
|
|
return callback(err);
|
||
|
|
}
|
||
|
|
|
||
|
|
// increment version if was successful
|
||
|
|
if (doIncrement) {
|
||
|
|
this.$__setValue(key, version + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (result != null && numAffected <= 0) {
|
||
|
|
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);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.$__.saving = undefined;
|
||
|
|
this.$__.savedState = {};
|
||
|
|
this.$emit('save', this, numAffected);
|
||
|
|
this.constructor.emit('save', this, numAffected);
|
||
|
|
callback(null, this);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function generateVersionError(doc, modifiedPaths) {
|
||
|
|
const key = doc.$__schema.options.versionKey;
|
||
|
|
if (!key) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
const version = doc.$__getValue(key) || 0;
|
||
|
|
return new VersionError(doc, version, modifiedPaths);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Saves this document by inserting a new document into the database if [document.isNew](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) is `true`,
|
||
|
|
* or sends an [updateOne](https://mongoosejs.com/docs/api/document.html#Document.prototype.updateOne()) operation with just the modified paths if `isNew` is `false`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* product.sold = Date.now();
|
||
|
|
* product = await product.save();
|
||
|
|
*
|
||
|
|
* If save is successful, the returned promise will fulfill with the document
|
||
|
|
* saved.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const newProduct = await product.save();
|
||
|
|
* newProduct === product; // true
|
||
|
|
*
|
||
|
|
* @param {Object} [options] options optional options
|
||
|
|
* @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.session()).
|
||
|
|
* @param {Object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
|
||
|
|
* @param {Boolean} [options.validateBeforeSave] set to false to save without validating.
|
||
|
|
* @param {Boolean} [options.validateModifiedOnly=false] if `true`, Mongoose will only validate modified paths, as opposed to modified paths and `required` paths.
|
||
|
|
* @param {Number|String} [options.w] set the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#w-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
|
||
|
|
* @param {Boolean} [options.j] set to true for MongoDB to wait until this `save()` has been [journaled before resolving the returned promise](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
|
||
|
|
* @param {Number} [options.wtimeout] sets a [timeout for the write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern).
|
||
|
|
* @param {Boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Restrictions-on-Field-Names)
|
||
|
|
* @param {Boolean} [options.timestamps=true] if `false` and [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this `save()`.
|
||
|
|
* @throws {DocumentNotFoundError} if this [save updates an existing document](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) but the document doesn't exist in the database. For example, you will get this error if the document is [deleted between when you retrieved the document and when you saved it](documents.html#updating).
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
* @see middleware https://mongoosejs.com/docs/middleware.html
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.save = async function save(options) {
|
||
|
|
if (typeof options === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.prototype.save() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
let parallelSave;
|
||
|
|
this.$op = 'save';
|
||
|
|
|
||
|
|
if (this.$__.saving) {
|
||
|
|
parallelSave = new ParallelSaveError(this);
|
||
|
|
} else {
|
||
|
|
this.$__.saving = new ParallelSaveError(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
options = new SaveOptions(options);
|
||
|
|
if (options.hasOwnProperty('session')) {
|
||
|
|
this.$session(options.session);
|
||
|
|
}
|
||
|
|
if (this.$__.timestamps != null) {
|
||
|
|
options.timestamps = this.$__.timestamps;
|
||
|
|
}
|
||
|
|
this.$__.$versionError = generateVersionError(this, this.modifiedPaths());
|
||
|
|
|
||
|
|
if (parallelSave) {
|
||
|
|
this.$__handleReject(parallelSave);
|
||
|
|
throw parallelSave;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.$__.saveOptions = options;
|
||
|
|
|
||
|
|
await new Promise((resolve, reject) => {
|
||
|
|
this.$__save(options, error => {
|
||
|
|
this.$__.saving = null;
|
||
|
|
this.$__.saveOptions = null;
|
||
|
|
this.$__.$versionError = null;
|
||
|
|
this.$op = null;
|
||
|
|
if (error != null) {
|
||
|
|
this.$__handleReject(error);
|
||
|
|
return reject(error);
|
||
|
|
}
|
||
|
|
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
|
||
|
|
Model.prototype.$save = Model.prototype.save;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Determines whether versioning should be skipped for the given path
|
||
|
|
*
|
||
|
|
* @param {Document} self
|
||
|
|
* @param {String} path
|
||
|
|
* @return {Boolean} true if versioning should be skipped for the given path
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
function shouldSkipVersioning(self, path) {
|
||
|
|
const skipVersioning = self.$__schema.options.skipVersioning;
|
||
|
|
if (!skipVersioning) return false;
|
||
|
|
|
||
|
|
// Remove any array indexes from the path
|
||
|
|
path = path.replace(/\.\d+\./, '.');
|
||
|
|
|
||
|
|
return skipVersioning[path];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Apply the operation to the delta (update) clause as
|
||
|
|
* well as track versioning for our where clause.
|
||
|
|
*
|
||
|
|
* @param {Document} self
|
||
|
|
* @param {Object} where Unused
|
||
|
|
* @param {Object} delta
|
||
|
|
* @param {Object} data
|
||
|
|
* @param {Mixed} val
|
||
|
|
* @param {String} [op]
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function operand(self, where, delta, data, val, op) {
|
||
|
|
// delta
|
||
|
|
op || (op = '$set');
|
||
|
|
if (!delta[op]) delta[op] = {};
|
||
|
|
delta[op][data.path] = val;
|
||
|
|
// disabled versioning?
|
||
|
|
if (self.$__schema.options.versionKey === false) return;
|
||
|
|
|
||
|
|
// path excluded from versioning?
|
||
|
|
if (shouldSkipVersioning(self, data.path)) return;
|
||
|
|
|
||
|
|
// already marked for versioning?
|
||
|
|
if (VERSION_ALL === (VERSION_ALL & self.$__.version)) return;
|
||
|
|
|
||
|
|
if (self.$__schema.options.optimisticConcurrency) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (op) {
|
||
|
|
case '$set':
|
||
|
|
case '$unset':
|
||
|
|
case '$pop':
|
||
|
|
case '$pull':
|
||
|
|
case '$pullAll':
|
||
|
|
case '$push':
|
||
|
|
case '$addToSet':
|
||
|
|
case '$inc':
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// nothing to do
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ensure updates sent with positional notation are
|
||
|
|
// editing the correct array element.
|
||
|
|
// only increment the version if an array position changes.
|
||
|
|
// modifying elements of an array is ok if position does not change.
|
||
|
|
if (op === '$push' || op === '$addToSet' || op === '$pullAll' || op === '$pull') {
|
||
|
|
if (/\.\d+\.|\.\d+$/.test(data.path)) {
|
||
|
|
increment.call(self);
|
||
|
|
} else {
|
||
|
|
self.$__.version = VERSION_INC;
|
||
|
|
}
|
||
|
|
} else if (/^\$p/.test(op)) {
|
||
|
|
// potentially changing array positions
|
||
|
|
increment.call(self);
|
||
|
|
} else if (Array.isArray(val)) {
|
||
|
|
// $set an array
|
||
|
|
increment.call(self);
|
||
|
|
} else if (/\.\d+\.|\.\d+$/.test(data.path)) {
|
||
|
|
// now handling $set, $unset
|
||
|
|
// subpath of array
|
||
|
|
self.$__.version = VERSION_WHERE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Compiles an update and where clause for a `val` with _atomics.
|
||
|
|
*
|
||
|
|
* @param {Document} self
|
||
|
|
* @param {Object} where
|
||
|
|
* @param {Object} delta
|
||
|
|
* @param {Object} data
|
||
|
|
* @param {Array} value
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function handleAtomics(self, where, delta, data, value) {
|
||
|
|
if (delta.$set && delta.$set[data.path]) {
|
||
|
|
// $set has precedence over other atomics
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof value.$__getAtomics === 'function') {
|
||
|
|
value.$__getAtomics().forEach(function(atomic) {
|
||
|
|
const op = atomic[0];
|
||
|
|
const val = atomic[1];
|
||
|
|
operand(self, where, delta, data, val, op);
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// legacy support for plugins
|
||
|
|
|
||
|
|
const atomics = value[arrayAtomicsSymbol];
|
||
|
|
const ops = Object.keys(atomics);
|
||
|
|
let i = ops.length;
|
||
|
|
let val;
|
||
|
|
let op;
|
||
|
|
|
||
|
|
if (i === 0) {
|
||
|
|
// $set
|
||
|
|
|
||
|
|
if (utils.isMongooseObject(value)) {
|
||
|
|
value = value.toObject({ depopulate: 1, _isNested: true });
|
||
|
|
} else if (value.valueOf) {
|
||
|
|
value = value.valueOf();
|
||
|
|
}
|
||
|
|
|
||
|
|
return operand(self, where, delta, data, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
function iter(mem) {
|
||
|
|
return utils.isMongooseObject(mem)
|
||
|
|
? mem.toObject({ depopulate: 1, _isNested: true })
|
||
|
|
: mem;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (i--) {
|
||
|
|
op = ops[i];
|
||
|
|
val = atomics[op];
|
||
|
|
|
||
|
|
if (utils.isMongooseObject(val)) {
|
||
|
|
val = val.toObject({ depopulate: true, transform: false, _isNested: true });
|
||
|
|
} else if (Array.isArray(val)) {
|
||
|
|
val = val.map(iter);
|
||
|
|
} else if (val.valueOf) {
|
||
|
|
val = val.valueOf();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (op === '$addToSet') {
|
||
|
|
val = { $each: val };
|
||
|
|
}
|
||
|
|
|
||
|
|
operand(self, where, delta, data, val, op);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Produces a special query document of the modified properties used in updates.
|
||
|
|
*
|
||
|
|
* @api private
|
||
|
|
* @method $__delta
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$__delta = function() {
|
||
|
|
const dirty = this.$__dirty();
|
||
|
|
|
||
|
|
const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
|
||
|
|
if (optimisticConcurrency) {
|
||
|
|
if (Array.isArray(optimisticConcurrency)) {
|
||
|
|
const optCon = new Set(optimisticConcurrency);
|
||
|
|
const modPaths = this.modifiedPaths();
|
||
|
|
if (modPaths.find(path => optCon.has(path))) {
|
||
|
|
this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!dirty.length && VERSION_ALL !== this.$__.version) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const where = {};
|
||
|
|
const delta = {};
|
||
|
|
const len = dirty.length;
|
||
|
|
const divergent = [];
|
||
|
|
let d = 0;
|
||
|
|
|
||
|
|
where._id = this._doc._id;
|
||
|
|
// If `_id` is an object, need to depopulate, but also need to be careful
|
||
|
|
// because `_id` can technically be null (see gh-6406)
|
||
|
|
if ((where && where._id && where._id.$__ || null) != null) {
|
||
|
|
where._id = where._id.toObject({ transform: false, depopulate: true });
|
||
|
|
}
|
||
|
|
for (; d < len; ++d) {
|
||
|
|
const data = dirty[d];
|
||
|
|
let value = data.value;
|
||
|
|
const match = checkDivergentArray(this, data.path, value);
|
||
|
|
if (match) {
|
||
|
|
divergent.push(match);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const pop = this.$populated(data.path, true);
|
||
|
|
if (!pop && this.$__.selected) {
|
||
|
|
// If any array was selected using an $elemMatch projection, we alter the path and where clause
|
||
|
|
// NOTE: MongoDB only supports projected $elemMatch on top level array.
|
||
|
|
const pathSplit = data.path.split('.');
|
||
|
|
const top = pathSplit[0];
|
||
|
|
if (this.$__.selected[top] && this.$__.selected[top].$elemMatch) {
|
||
|
|
// If the selected array entry was modified
|
||
|
|
if (pathSplit.length > 1 && pathSplit[1] == 0 && typeof where[top] === 'undefined') {
|
||
|
|
where[top] = this.$__.selected[top];
|
||
|
|
pathSplit[1] = '$';
|
||
|
|
data.path = pathSplit.join('.');
|
||
|
|
}
|
||
|
|
// if the selected array was modified in any other way throw an error
|
||
|
|
else {
|
||
|
|
divergent.push(data.path);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If this path is set to default, and either this path or one of
|
||
|
|
// its parents is excluded, don't treat this path as dirty.
|
||
|
|
if (this.$isDefault(data.path) && this.$__.selected) {
|
||
|
|
if (data.path.indexOf('.') === -1 && isPathExcluded(this.$__.selected, data.path)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const pathsToCheck = parentPaths(data.path);
|
||
|
|
if (pathsToCheck.find(path => isPathExcluded(this.$__.isSelected, path))) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (divergent.length) continue;
|
||
|
|
if (value === undefined) {
|
||
|
|
operand(this, where, delta, data, 1, '$unset');
|
||
|
|
} else if (value === null) {
|
||
|
|
operand(this, where, delta, data, null);
|
||
|
|
} else if (utils.isMongooseArray(value) && value.$path() && value[arrayAtomicsSymbol]) {
|
||
|
|
// arrays and other custom types (support plugins etc)
|
||
|
|
handleAtomics(this, where, delta, data, value);
|
||
|
|
} else if (value[MongooseBuffer.pathSymbol] && Buffer.isBuffer(value)) {
|
||
|
|
// MongooseBuffer
|
||
|
|
value = value.toObject();
|
||
|
|
operand(this, where, delta, data, value);
|
||
|
|
} else {
|
||
|
|
if (this.$__.primitiveAtomics && this.$__.primitiveAtomics[data.path] != null) {
|
||
|
|
const val = this.$__.primitiveAtomics[data.path];
|
||
|
|
const op = firstKey(val);
|
||
|
|
operand(this, where, delta, data, val[op], op);
|
||
|
|
} else {
|
||
|
|
value = clone(value, {
|
||
|
|
depopulate: true,
|
||
|
|
transform: false,
|
||
|
|
virtuals: false,
|
||
|
|
getters: false,
|
||
|
|
omitUndefined: true,
|
||
|
|
_isNested: true
|
||
|
|
});
|
||
|
|
operand(this, where, delta, data, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (divergent.length) {
|
||
|
|
return new DivergentArrayError(divergent);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.$__.version) {
|
||
|
|
this.$__version(where, delta);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Object.keys(delta).length === 0) {
|
||
|
|
return [where, null];
|
||
|
|
}
|
||
|
|
|
||
|
|
return [where, delta];
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Determine if array was populated with some form of filter and is now
|
||
|
|
* being updated in a manner which could overwrite data unintentionally.
|
||
|
|
*
|
||
|
|
* @see https://github.com/Automattic/mongoose/issues/1334
|
||
|
|
* @param {Document} doc
|
||
|
|
* @param {String} path
|
||
|
|
* @param {Any} array
|
||
|
|
* @return {String|undefined}
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function checkDivergentArray(doc, path, array) {
|
||
|
|
// see if we populated this path
|
||
|
|
const pop = doc.$populated(path, true);
|
||
|
|
|
||
|
|
if (!pop && doc.$__.selected) {
|
||
|
|
// If any array was selected using an $elemMatch projection, we deny the update.
|
||
|
|
// NOTE: MongoDB only supports projected $elemMatch on top level array.
|
||
|
|
const top = path.split('.')[0];
|
||
|
|
if (doc.$__.selected[top + '.$']) {
|
||
|
|
return top;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!(pop && utils.isMongooseArray(array))) return;
|
||
|
|
|
||
|
|
// If the array was populated using options that prevented all
|
||
|
|
// documents from being returned (match, skip, limit) or they
|
||
|
|
// deselected the _id field, $pop and $set of the array are
|
||
|
|
// not safe operations. If _id was deselected, we do not know
|
||
|
|
// how to remove elements. $pop will pop off the _id from the end
|
||
|
|
// of the array in the db which is not guaranteed to be the
|
||
|
|
// same as the last element we have here. $set of the entire array
|
||
|
|
// would be similarly destructive as we never received all
|
||
|
|
// elements of the array and potentially would overwrite data.
|
||
|
|
const check = pop.options.match ||
|
||
|
|
pop.options.options && utils.object.hasOwnProperty(pop.options.options, 'limit') || // 0 is not permitted
|
||
|
|
pop.options.options && pop.options.options.skip || // 0 is permitted
|
||
|
|
pop.options.select && // deselected _id?
|
||
|
|
(pop.options.select._id === 0 ||
|
||
|
|
/\s?-_id\s?/.test(pop.options.select));
|
||
|
|
|
||
|
|
if (check) {
|
||
|
|
const atomics = array[arrayAtomicsSymbol];
|
||
|
|
if (Object.keys(atomics).length === 0 || atomics.$set || atomics.$pop) {
|
||
|
|
return path;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Appends versioning to the where and update clauses.
|
||
|
|
*
|
||
|
|
* @api private
|
||
|
|
* @method $__version
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$__version = function(where, delta) {
|
||
|
|
const key = this.$__schema.options.versionKey;
|
||
|
|
if (where === true) {
|
||
|
|
// this is an insert
|
||
|
|
if (key) {
|
||
|
|
setDottedPath(delta, key, 0);
|
||
|
|
this.$__setValue(key, 0);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (key === false) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// updates
|
||
|
|
|
||
|
|
// only apply versioning if our versionKey was selected. else
|
||
|
|
// there is no way to select the correct version. we could fail
|
||
|
|
// fast here and force them to include the versionKey but
|
||
|
|
// thats a bit intrusive. can we do this automatically?
|
||
|
|
|
||
|
|
if (!this.$__isSelected(key)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// $push $addToSet don't need the where clause set
|
||
|
|
if (VERSION_WHERE === (VERSION_WHERE & this.$__.version)) {
|
||
|
|
const value = this.$__getValue(key);
|
||
|
|
if (value != null) where[key] = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (VERSION_INC === (VERSION_INC & this.$__.version)) {
|
||
|
|
if (get(delta.$set, key, null) != null) {
|
||
|
|
// Version key is getting set, means we'll increment the doc's version
|
||
|
|
// after a successful save, so we should set the incremented version so
|
||
|
|
// future saves don't fail (gh-5779)
|
||
|
|
++delta.$set[key];
|
||
|
|
} else {
|
||
|
|
delta.$inc = delta.$inc || {};
|
||
|
|
delta.$inc[key] = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function increment() {
|
||
|
|
this.$__.version = VERSION_ALL;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Signal that we desire an increment of this documents version.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const doc = await Model.findById(id);
|
||
|
|
* doc.increment();
|
||
|
|
* await doc.save();
|
||
|
|
*
|
||
|
|
* @see versionKeys https://mongoosejs.com/docs/guide.html#versionKey
|
||
|
|
* @memberOf Model
|
||
|
|
* @method increment
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.increment = increment;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a query object
|
||
|
|
*
|
||
|
|
* @api private
|
||
|
|
* @method $__where
|
||
|
|
* @memberOf Model
|
||
|
|
* @instance
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$__where = function _where(where) {
|
||
|
|
where || (where = {});
|
||
|
|
|
||
|
|
if (!where._id) {
|
||
|
|
where._id = this._doc._id;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this._doc._id === void 0) {
|
||
|
|
return new MongooseError('No _id found on document!');
|
||
|
|
}
|
||
|
|
|
||
|
|
return where;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Delete this document from the db.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await product.deleteOne();
|
||
|
|
* await Product.findById(product._id); // null
|
||
|
|
*
|
||
|
|
* @return {Query} Query
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.deleteOne = function deleteOne(options) {
|
||
|
|
if (typeof options === 'function' ||
|
||
|
|
typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.prototype.deleteOne() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!options) {
|
||
|
|
options = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
if (options.hasOwnProperty('session')) {
|
||
|
|
this.$session(options.session);
|
||
|
|
}
|
||
|
|
|
||
|
|
const self = this;
|
||
|
|
const where = this.$__where();
|
||
|
|
if (where instanceof Error) {
|
||
|
|
throw where;
|
||
|
|
}
|
||
|
|
const query = self.constructor.deleteOne(where, options);
|
||
|
|
|
||
|
|
if (this.$session() != null) {
|
||
|
|
if (!('session' in query.options)) {
|
||
|
|
query.options.session = this.$session();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
query.pre(function queryPreDeleteOne(cb) {
|
||
|
|
self.constructor._middleware.execPre('deleteOne', self, [self], cb);
|
||
|
|
});
|
||
|
|
query.pre(function callSubdocPreHooks(cb) {
|
||
|
|
each(self.$getAllSubdocs(), (subdoc, cb) => {
|
||
|
|
subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc], cb);
|
||
|
|
}, cb);
|
||
|
|
});
|
||
|
|
query.pre(function skipIfAlreadyDeleted(cb) {
|
||
|
|
if (self.$__.isDeleted) {
|
||
|
|
return cb(Kareem.skipWrappedFunction());
|
||
|
|
}
|
||
|
|
return cb();
|
||
|
|
});
|
||
|
|
query.post(function callSubdocPostHooks(cb) {
|
||
|
|
each(self.$getAllSubdocs(), (subdoc, cb) => {
|
||
|
|
subdoc.constructor._middleware.execPost('deleteOne', subdoc, [subdoc], {}, cb);
|
||
|
|
}, cb);
|
||
|
|
});
|
||
|
|
query.post(function queryPostDeleteOne(cb) {
|
||
|
|
self.constructor._middleware.execPost('deleteOne', self, [self], {}, cb);
|
||
|
|
});
|
||
|
|
|
||
|
|
return query;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the model instance used to create this document if no `name` specified.
|
||
|
|
* If `name` specified, returns the model with the given `name`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const doc = new Tank({});
|
||
|
|
* doc.$model() === Tank; // true
|
||
|
|
* await doc.$model('User').findById(id);
|
||
|
|
*
|
||
|
|
* @param {String} [name] model name
|
||
|
|
* @method $model
|
||
|
|
* @api public
|
||
|
|
* @return {Model}
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.$model = function $model(name) {
|
||
|
|
if (arguments.length === 0) {
|
||
|
|
return this.constructor;
|
||
|
|
}
|
||
|
|
return this[modelDbSymbol].model(name);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the model instance used to create this document if no `name` specified.
|
||
|
|
* If `name` specified, returns the model with the given `name`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const doc = new Tank({});
|
||
|
|
* doc.$model() === Tank; // true
|
||
|
|
* await doc.$model('User').findById(id);
|
||
|
|
*
|
||
|
|
* @param {String} [name] model name
|
||
|
|
* @method model
|
||
|
|
* @api public
|
||
|
|
* @return {Model}
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.prototype.model = Model.prototype.$model;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a document with `_id` only if at least one document exists in the database that matches
|
||
|
|
* the given `filter`, and `null` otherwise.
|
||
|
|
*
|
||
|
|
* Under the hood, `MyModel.exists({ answer: 42 })` is equivalent to
|
||
|
|
* `MyModel.findOne({ answer: 42 }).select({ _id: 1 }).lean()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await Character.deleteMany({});
|
||
|
|
* await Character.create({ name: 'Jean-Luc Picard' });
|
||
|
|
*
|
||
|
|
* await Character.exists({ name: /picard/i }); // { _id: ... }
|
||
|
|
* await Character.exists({ name: /riker/i }); // null
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `findOne()`
|
||
|
|
*
|
||
|
|
* @param {Object} filter
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @return {Query}
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.exists = function exists(filter, options) {
|
||
|
|
_checkContext(this, 'exists');
|
||
|
|
if (typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.exists() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const query = this.findOne(filter).
|
||
|
|
select({ _id: 1 }).
|
||
|
|
lean().
|
||
|
|
setOptions(options);
|
||
|
|
|
||
|
|
return query;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Adds a discriminator type.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* function BaseSchema() {
|
||
|
|
* Schema.apply(this, arguments);
|
||
|
|
*
|
||
|
|
* this.add({
|
||
|
|
* name: String,
|
||
|
|
* createdAt: Date
|
||
|
|
* });
|
||
|
|
* }
|
||
|
|
* util.inherits(BaseSchema, Schema);
|
||
|
|
*
|
||
|
|
* const PersonSchema = new BaseSchema();
|
||
|
|
* const BossSchema = new BaseSchema({ department: String });
|
||
|
|
*
|
||
|
|
* const Person = mongoose.model('Person', PersonSchema);
|
||
|
|
* const Boss = Person.discriminator('Boss', BossSchema);
|
||
|
|
* new Boss().__t; // "Boss". `__t` is the default `discriminatorKey`
|
||
|
|
*
|
||
|
|
* const employeeSchema = new Schema({ boss: ObjectId });
|
||
|
|
* const Employee = Person.discriminator('Employee', employeeSchema, 'staff');
|
||
|
|
* new Employee().__t; // "staff" because of 3rd argument above
|
||
|
|
*
|
||
|
|
* @param {String} name discriminator model name
|
||
|
|
* @param {Schema} schema discriminator model schema
|
||
|
|
* @param {Object|String} [options] If string, same as `options.value`.
|
||
|
|
* @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
|
||
|
|
* @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
|
||
|
|
* @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
|
||
|
|
* @param {Boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
|
||
|
|
* @param {Boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
|
||
|
|
* @return {Model} The newly created discriminator model
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.discriminator = function(name, schema, options) {
|
||
|
|
let model;
|
||
|
|
if (typeof name === 'function') {
|
||
|
|
model = name;
|
||
|
|
name = utils.getFunctionName(model);
|
||
|
|
if (!(model.prototype instanceof Model)) {
|
||
|
|
throw new MongooseError('The provided class ' + name + ' must extend Model');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
options = options || {};
|
||
|
|
const value = utils.isPOJO(options) ? options.value : options;
|
||
|
|
const clone = typeof options.clone === 'boolean' ? options.clone : true;
|
||
|
|
const mergePlugins = typeof options.mergePlugins === 'boolean' ? options.mergePlugins : true;
|
||
|
|
|
||
|
|
_checkContext(this, 'discriminator');
|
||
|
|
|
||
|
|
if (utils.isObject(schema) && !schema.instanceOfSchema) {
|
||
|
|
schema = new Schema(schema);
|
||
|
|
}
|
||
|
|
if (schema instanceof Schema && clone) {
|
||
|
|
schema = schema.clone();
|
||
|
|
}
|
||
|
|
|
||
|
|
schema = discriminator(this, name, schema, value, mergePlugins, options.mergeHooks);
|
||
|
|
if (this.db.models[name] && !schema.options.overwriteModels) {
|
||
|
|
throw new OverwriteModelError(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
schema.$isRootDiscriminator = true;
|
||
|
|
schema.$globalPluginsApplied = true;
|
||
|
|
|
||
|
|
model = this.db.model(model || name, schema, this.$__collection.name);
|
||
|
|
this.discriminators[name] = model;
|
||
|
|
const d = this.discriminators[name];
|
||
|
|
Object.setPrototypeOf(d.prototype, this.prototype);
|
||
|
|
Object.defineProperty(d, 'baseModelName', {
|
||
|
|
value: this.modelName,
|
||
|
|
configurable: true,
|
||
|
|
writable: false
|
||
|
|
});
|
||
|
|
|
||
|
|
// apply methods and statics
|
||
|
|
applyMethods(d, schema);
|
||
|
|
applyStatics(d, schema);
|
||
|
|
|
||
|
|
if (this[subclassedSymbol] != null) {
|
||
|
|
for (const submodel of this[subclassedSymbol]) {
|
||
|
|
submodel.discriminators = submodel.discriminators || {};
|
||
|
|
submodel.discriminators[name] =
|
||
|
|
model.__subclass(model.db, schema, submodel.collection.name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return d;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Make sure `this` is a model
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _checkContext(ctx, fnName) {
|
||
|
|
// Check context, because it is easy to mistakenly type
|
||
|
|
// `new Model.discriminator()` and get an incomprehensible error
|
||
|
|
if (ctx == null || ctx === global) {
|
||
|
|
throw new MongooseError('`Model.' + fnName + '()` cannot run without a ' +
|
||
|
|
'model as `this`. Make sure you are calling `MyModel.' + fnName + '()` ' +
|
||
|
|
'where `MyModel` is a Mongoose model.');
|
||
|
|
} else if (ctx[modelSymbol] == null) {
|
||
|
|
throw new MongooseError('`Model.' + fnName + '()` cannot run without a ' +
|
||
|
|
'model as `this`. Make sure you are not calling ' +
|
||
|
|
'`new Model.' + fnName + '()`');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Model (class) features
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Give the constructor the ability to emit events.
|
||
|
|
*/
|
||
|
|
|
||
|
|
for (const i in EventEmitter.prototype) {
|
||
|
|
Model[i] = EventEmitter.prototype[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This function is responsible for building [indexes](https://www.mongodb.com/docs/manual/indexes/),
|
||
|
|
* unless [`autoIndex`](https://mongoosejs.com/docs/guide.html#autoIndex) is turned off.
|
||
|
|
*
|
||
|
|
* Mongoose calls this function automatically when a model is created using
|
||
|
|
* [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()) or
|
||
|
|
* [`connection.model()`](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.model()), so you
|
||
|
|
* don't need to call `init()` to trigger index builds.
|
||
|
|
*
|
||
|
|
* However, you _may_ need to call `init()` to get back a promise that will resolve when your indexes are finished.
|
||
|
|
* Calling `await Model.init()` is helpful if you need to wait for indexes to build before continuing.
|
||
|
|
* For example, if you want to wait for unique indexes to build before continuing with a test case.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const eventSchema = new Schema({ thing: { type: 'string', unique: true } })
|
||
|
|
* // This calls `Event.init()` implicitly, so you don't need to call
|
||
|
|
* // `Event.init()` on your own.
|
||
|
|
* const Event = mongoose.model('Event', eventSchema);
|
||
|
|
*
|
||
|
|
* await Event.init();
|
||
|
|
* console.log('Indexes are done building!');
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @returns {Promise}
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.init = function init() {
|
||
|
|
_checkContext(this, 'init');
|
||
|
|
if (typeof arguments[0] === 'function') {
|
||
|
|
throw new MongooseError('Model.init() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
this.schema.emit('init', this);
|
||
|
|
|
||
|
|
if (this.$init != null) {
|
||
|
|
return this.$init;
|
||
|
|
}
|
||
|
|
|
||
|
|
const conn = this.db;
|
||
|
|
const _ensureIndexes = async() => {
|
||
|
|
const autoIndex = utils.getOption(
|
||
|
|
'autoIndex',
|
||
|
|
this.schema.options,
|
||
|
|
conn.config,
|
||
|
|
conn.base.options
|
||
|
|
);
|
||
|
|
if (!autoIndex) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return await this.ensureIndexes({ _automatic: true });
|
||
|
|
};
|
||
|
|
const _createCollection = async() => {
|
||
|
|
if ((conn.readyState === STATES.connecting || conn.readyState === STATES.disconnected) && conn._shouldBufferCommands()) {
|
||
|
|
await new Promise(resolve => {
|
||
|
|
conn._queue.push({ fn: resolve });
|
||
|
|
});
|
||
|
|
}
|
||
|
|
const autoCreate = utils.getOption(
|
||
|
|
'autoCreate',
|
||
|
|
this.schema.options,
|
||
|
|
conn.config,
|
||
|
|
conn.base.options
|
||
|
|
);
|
||
|
|
if (!autoCreate) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return await this.createCollection();
|
||
|
|
};
|
||
|
|
|
||
|
|
this.$init = _createCollection().then(() => _ensureIndexes());
|
||
|
|
|
||
|
|
const _catch = this.$init.catch;
|
||
|
|
const _this = this;
|
||
|
|
this.$init.catch = function() {
|
||
|
|
_this.$caught = true;
|
||
|
|
return _catch.apply(_this.$init, arguments);
|
||
|
|
};
|
||
|
|
|
||
|
|
return this.$init;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the collection for this model. By default, if no indexes are specified,
|
||
|
|
* mongoose will not create the collection for the model until any documents are
|
||
|
|
* created. Use this method to create the collection explicitly.
|
||
|
|
*
|
||
|
|
* Note 1: You may need to call this before starting a transaction
|
||
|
|
* See https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations
|
||
|
|
*
|
||
|
|
* Note 2: You don't have to call this if your schema contains index or unique field.
|
||
|
|
* In that case, just use `Model.init()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const userSchema = new Schema({ name: String })
|
||
|
|
* const User = mongoose.model('User', userSchema);
|
||
|
|
*
|
||
|
|
* User.createCollection().then(function(collection) {
|
||
|
|
* console.log('Collection is created!');
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
* @param {Object} [options] see [MongoDB driver docs](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createCollection)
|
||
|
|
* @returns {Promise}
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.createCollection = async function createCollection(options) {
|
||
|
|
_checkContext(this, 'createCollection');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.createCollection() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const collectionOptions = this &&
|
||
|
|
this.schema &&
|
||
|
|
this.schema.options &&
|
||
|
|
this.schema.options.collectionOptions;
|
||
|
|
if (collectionOptions != null) {
|
||
|
|
options = Object.assign({}, collectionOptions, options);
|
||
|
|
}
|
||
|
|
|
||
|
|
const schemaCollation = this &&
|
||
|
|
this.schema &&
|
||
|
|
this.schema.options &&
|
||
|
|
this.schema.options.collation;
|
||
|
|
if (schemaCollation != null) {
|
||
|
|
options = Object.assign({ collation: schemaCollation }, options);
|
||
|
|
}
|
||
|
|
const capped = this &&
|
||
|
|
this.schema &&
|
||
|
|
this.schema.options &&
|
||
|
|
this.schema.options.capped;
|
||
|
|
if (capped != null) {
|
||
|
|
if (typeof capped === 'number') {
|
||
|
|
options = Object.assign({ capped: true, size: capped }, options);
|
||
|
|
} else if (typeof capped === 'object') {
|
||
|
|
options = Object.assign({ capped: true }, capped, options);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const timeseries = this &&
|
||
|
|
this.schema &&
|
||
|
|
this.schema.options &&
|
||
|
|
this.schema.options.timeseries;
|
||
|
|
if (timeseries != null) {
|
||
|
|
options = Object.assign({ timeseries }, options);
|
||
|
|
if (options.expireAfterSeconds != null) {
|
||
|
|
// do nothing
|
||
|
|
} else if (options.expires != null) {
|
||
|
|
utils.expires(options);
|
||
|
|
} else if (this.schema.options.expireAfterSeconds != null) {
|
||
|
|
options.expireAfterSeconds = this.schema.options.expireAfterSeconds;
|
||
|
|
} else if (this.schema.options.expires != null) {
|
||
|
|
options.expires = this.schema.options.expires;
|
||
|
|
utils.expires(options);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const clusteredIndex = this &&
|
||
|
|
this.schema &&
|
||
|
|
this.schema.options &&
|
||
|
|
this.schema.options.clusteredIndex;
|
||
|
|
if (clusteredIndex != null) {
|
||
|
|
options = Object.assign({ clusteredIndex: { ...clusteredIndex, unique: true } }, options);
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
await this.db.createCollection(this.$__collection.collectionName, options);
|
||
|
|
} catch (err) {
|
||
|
|
|
||
|
|
if (err != null && (err.name !== 'MongoServerError' || err.code !== 48)) {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return this.$__collection;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Makes the indexes in MongoDB match the indexes defined in this model's
|
||
|
|
* schema. This function will drop any indexes that are not defined in
|
||
|
|
* the model's schema except the `_id` index, and build any indexes that
|
||
|
|
* are in your schema but not in MongoDB.
|
||
|
|
*
|
||
|
|
* See the [introductory blog post](https://thecodebarbarian.com/whats-new-in-mongoose-5-2-syncindexes)
|
||
|
|
* for more information.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const schema = new Schema({ name: { type: String, unique: true } });
|
||
|
|
* const Customer = mongoose.model('Customer', schema);
|
||
|
|
* await Customer.collection.createIndex({ age: 1 }); // Index is not in schema
|
||
|
|
* // Will drop the 'age' index and create an index on `name`
|
||
|
|
* await Customer.syncIndexes();
|
||
|
|
*
|
||
|
|
* You should be careful about running `syncIndexes()` on production applications under heavy load,
|
||
|
|
* because index builds are expensive operations, and unexpected index drops can lead to degraded
|
||
|
|
* performance. Before running `syncIndexes()`, you can use the [`diffIndexes()` function](#Model.diffIndexes())
|
||
|
|
* to check what indexes `syncIndexes()` will drop and create.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const { toDrop, toCreate } = await Model.diffIndexes();
|
||
|
|
* toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
|
||
|
|
* toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create
|
||
|
|
*
|
||
|
|
* @param {Object} [options] options to pass to `ensureIndexes()`
|
||
|
|
* @param {Boolean} [options.background=null] if specified, overrides each index's `background` property
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.syncIndexes = async function syncIndexes(options) {
|
||
|
|
_checkContext(this, 'syncIndexes');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.syncIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const model = this;
|
||
|
|
|
||
|
|
try {
|
||
|
|
await model.createCollection();
|
||
|
|
} catch (err) {
|
||
|
|
if (err != null && (err.name !== 'MongoServerError' || err.code !== 48)) {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const diffIndexesResult = await model.diffIndexes();
|
||
|
|
const dropped = await model.cleanIndexes({ ...options, toDrop: diffIndexesResult.toDrop });
|
||
|
|
await model.createIndexes({ ...options, toCreate: diffIndexesResult.toCreate });
|
||
|
|
|
||
|
|
return dropped;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Does a dry-run of `Model.syncIndexes()`, returning the indexes that `syncIndexes()` would drop and create if you were to run `syncIndexes()`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const { toDrop, toCreate } = await Model.diffIndexes();
|
||
|
|
* toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
|
||
|
|
* toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create
|
||
|
|
*
|
||
|
|
* @param {Object} [options]
|
||
|
|
* @return {Promise<Object>} contains the indexes that would be dropped in MongoDB and indexes that would be created in MongoDB as `{ toDrop: string[], toCreate: string[] }`.
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.diffIndexes = async function diffIndexes() {
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.syncIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const model = this;
|
||
|
|
|
||
|
|
let dbIndexes = await model.listIndexes().catch(err => {
|
||
|
|
if (err.codeName == 'NamespaceNotFound') {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
throw err;
|
||
|
|
});
|
||
|
|
if (dbIndexes === undefined) {
|
||
|
|
dbIndexes = [];
|
||
|
|
}
|
||
|
|
dbIndexes = getRelatedDBIndexes(model, dbIndexes);
|
||
|
|
|
||
|
|
const schema = model.schema;
|
||
|
|
const schemaIndexes = getRelatedSchemaIndexes(model, schema.indexes());
|
||
|
|
|
||
|
|
const toDrop = getIndexesToDrop(schema, schemaIndexes, dbIndexes);
|
||
|
|
const toCreate = getIndexesToCreate(schema, schemaIndexes, dbIndexes, toDrop);
|
||
|
|
|
||
|
|
return { toDrop, toCreate };
|
||
|
|
};
|
||
|
|
|
||
|
|
function getIndexesToCreate(schema, schemaIndexes, dbIndexes, toDrop) {
|
||
|
|
const toCreate = [];
|
||
|
|
|
||
|
|
for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
|
||
|
|
let found = false;
|
||
|
|
|
||
|
|
const options = decorateDiscriminatorIndexOptions(schema, clone(schemaIndexOptions));
|
||
|
|
|
||
|
|
for (const index of dbIndexes) {
|
||
|
|
if (isDefaultIdIndex(index)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
isIndexEqual(schemaIndexKeysObject, options, index) &&
|
||
|
|
!toDrop.includes(index.name)
|
||
|
|
) {
|
||
|
|
found = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!found) {
|
||
|
|
toCreate.push(schemaIndexKeysObject);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return toCreate;
|
||
|
|
}
|
||
|
|
|
||
|
|
function getIndexesToDrop(schema, schemaIndexes, dbIndexes) {
|
||
|
|
const toDrop = [];
|
||
|
|
|
||
|
|
for (const dbIndex of dbIndexes) {
|
||
|
|
let found = false;
|
||
|
|
// Never try to drop `_id` index, MongoDB server doesn't allow it
|
||
|
|
if (isDefaultIdIndex(dbIndex)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
|
||
|
|
const options = decorateDiscriminatorIndexOptions(schema, clone(schemaIndexOptions));
|
||
|
|
applySchemaCollation(schemaIndexKeysObject, options, schema.options);
|
||
|
|
|
||
|
|
if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
|
||
|
|
found = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!found) {
|
||
|
|
toDrop.push(dbIndex.name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return toDrop;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Deletes all indexes that aren't defined in this model's schema. Used by
|
||
|
|
* `syncIndexes()`.
|
||
|
|
*
|
||
|
|
* The returned promise resolves to a list of the dropped indexes' names as an array
|
||
|
|
*
|
||
|
|
* @param {Function} [callback] optional callback
|
||
|
|
* @return {Promise|undefined} Returns `undefined` if callback is specified, returns a promise if no callback.
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.cleanIndexes = async function cleanIndexes(options) {
|
||
|
|
_checkContext(this, 'cleanIndexes');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.cleanIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
const model = this;
|
||
|
|
|
||
|
|
const collection = model.$__collection;
|
||
|
|
|
||
|
|
if (Array.isArray(options && options.toDrop)) {
|
||
|
|
const res = await _dropIndexes(options.toDrop, collection);
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
|
||
|
|
const res = await model.diffIndexes();
|
||
|
|
return await _dropIndexes(res.toDrop, collection);
|
||
|
|
};
|
||
|
|
|
||
|
|
async function _dropIndexes(toDrop, collection) {
|
||
|
|
if (toDrop.length === 0) {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
|
||
|
|
await Promise.all(toDrop.map(indexName => collection.dropIndex(indexName)));
|
||
|
|
return toDrop;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Lists the indexes currently defined in MongoDB. This may or may not be
|
||
|
|
* the same as the indexes defined in your schema depending on whether you
|
||
|
|
* use the [`autoIndex` option](https://mongoosejs.com/docs/guide.html#autoIndex) and if you
|
||
|
|
* build indexes manually.
|
||
|
|
*
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.listIndexes = async function listIndexes() {
|
||
|
|
_checkContext(this, 'listIndexes');
|
||
|
|
if (typeof arguments[0] === 'function') {
|
||
|
|
throw new MongooseError('Model.listIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.$__collection.buffer) {
|
||
|
|
await new Promise(resolve => {
|
||
|
|
this.$__collection.addQueue(resolve);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.$__collection.listIndexes().toArray();
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sends `createIndex` commands to mongo for each index declared in the schema.
|
||
|
|
* The `createIndex` commands are sent in series.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* Event.ensureIndexes(function (err) {
|
||
|
|
* if (err) return handleError(err);
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* After completion, an `index` event is emitted on this `Model` passing an error if one occurred.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const eventSchema = new Schema({ thing: { type: 'string', unique: true } })
|
||
|
|
* const Event = mongoose.model('Event', eventSchema);
|
||
|
|
*
|
||
|
|
* Event.on('index', function (err) {
|
||
|
|
* if (err) console.error(err); // error occurred during index creation
|
||
|
|
* })
|
||
|
|
*
|
||
|
|
* _NOTE: It is not recommended that you run this in production. Index creation may impact database performance depending on your load. Use with caution._
|
||
|
|
*
|
||
|
|
* @param {Object} [options] internal options
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.ensureIndexes = async function ensureIndexes(options) {
|
||
|
|
_checkContext(this, 'ensureIndexes');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.ensureIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
await new Promise((resolve, reject) => {
|
||
|
|
_ensureIndexes(this, options, (err) => {
|
||
|
|
if (err != null) {
|
||
|
|
return reject(err);
|
||
|
|
}
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Similar to `ensureIndexes()`, except for it uses the [`createIndex`](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createIndex)
|
||
|
|
* function.
|
||
|
|
*
|
||
|
|
* @param {Object} [options] internal options
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.createIndexes = async function createIndexes(options) {
|
||
|
|
_checkContext(this, 'createIndexes');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.createIndexes() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.ensureIndexes(options);
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _ensureIndexes(model, options, callback) {
|
||
|
|
const indexes = model.schema.indexes();
|
||
|
|
let indexError;
|
||
|
|
|
||
|
|
options = options || {};
|
||
|
|
const done = function(err) {
|
||
|
|
if (err && !model.$caught) {
|
||
|
|
model.emit('error', err);
|
||
|
|
}
|
||
|
|
model.emit('index', err || indexError);
|
||
|
|
callback && callback(err || indexError);
|
||
|
|
};
|
||
|
|
|
||
|
|
for (const index of indexes) {
|
||
|
|
if (isDefaultIdIndex(index)) {
|
||
|
|
utils.warn('mongoose: Cannot specify a custom index on `_id` for ' +
|
||
|
|
'model name "' + model.modelName + '", ' +
|
||
|
|
'MongoDB does not allow overwriting the default `_id` index. See ' +
|
||
|
|
'https://bit.ly/mongodb-id-index');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!indexes.length) {
|
||
|
|
immediate(function() {
|
||
|
|
done();
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Indexes are created one-by-one to support how MongoDB < 2.4 deals
|
||
|
|
// with background indexes.
|
||
|
|
|
||
|
|
const indexSingleDone = function(err, fields, options, name) {
|
||
|
|
model.emit('index-single-done', err, fields, options, name);
|
||
|
|
};
|
||
|
|
const indexSingleStart = function(fields, options) {
|
||
|
|
model.emit('index-single-start', fields, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
const baseSchema = model.schema._baseSchema;
|
||
|
|
const baseSchemaIndexes = baseSchema ? baseSchema.indexes() : [];
|
||
|
|
|
||
|
|
immediate(function() {
|
||
|
|
// If buffering is off, do this manually.
|
||
|
|
if (options._automatic && !model.collection.collection) {
|
||
|
|
model.collection.addQueue(create, []);
|
||
|
|
} else {
|
||
|
|
create();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
function create() {
|
||
|
|
if (options._automatic) {
|
||
|
|
if (model.schema.options.autoIndex === false ||
|
||
|
|
(model.schema.options.autoIndex == null && model.db.config.autoIndex === false)) {
|
||
|
|
return done();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const index = indexes.shift();
|
||
|
|
if (!index) {
|
||
|
|
return done();
|
||
|
|
}
|
||
|
|
if (options._automatic && index[1]._autoIndex === false) {
|
||
|
|
return create();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (baseSchemaIndexes.find(i => utils.deepEqual(i, index))) {
|
||
|
|
return create();
|
||
|
|
}
|
||
|
|
|
||
|
|
const indexFields = clone(index[0]);
|
||
|
|
const indexOptions = clone(index[1]);
|
||
|
|
|
||
|
|
delete indexOptions._autoIndex;
|
||
|
|
decorateDiscriminatorIndexOptions(model.schema, indexOptions);
|
||
|
|
applyWriteConcern(model.schema, indexOptions);
|
||
|
|
applySchemaCollation(indexFields, indexOptions, model.schema.options);
|
||
|
|
|
||
|
|
indexSingleStart(indexFields, options);
|
||
|
|
|
||
|
|
if ('background' in options) {
|
||
|
|
indexOptions.background = options.background;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ('toCreate' in options) {
|
||
|
|
if (options.toCreate.length === 0) {
|
||
|
|
return done();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
model.collection.createIndex(indexFields, indexOptions).then(
|
||
|
|
name => {
|
||
|
|
indexSingleDone(null, indexFields, indexOptions, name);
|
||
|
|
create();
|
||
|
|
},
|
||
|
|
err => {
|
||
|
|
if (!indexError) {
|
||
|
|
indexError = err;
|
||
|
|
}
|
||
|
|
if (!model.$caught) {
|
||
|
|
model.emit('error', err);
|
||
|
|
}
|
||
|
|
|
||
|
|
indexSingleDone(err, indexFields, indexOptions);
|
||
|
|
create();
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Schema the model uses.
|
||
|
|
*
|
||
|
|
* @property schema
|
||
|
|
* @static
|
||
|
|
* @api public
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.schema;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Connection instance the model uses.
|
||
|
|
*
|
||
|
|
* @property db
|
||
|
|
* @static
|
||
|
|
* @api public
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.db;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Collection the model uses.
|
||
|
|
*
|
||
|
|
* @property collection
|
||
|
|
* @api public
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.collection;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal collection the model uses.
|
||
|
|
*
|
||
|
|
* @property collection
|
||
|
|
* @api private
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
Model.$__collection;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Base Mongoose instance the model uses.
|
||
|
|
*
|
||
|
|
* @property base
|
||
|
|
* @api public
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.base;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Registered discriminators for this model.
|
||
|
|
*
|
||
|
|
* @property discriminators
|
||
|
|
* @api public
|
||
|
|
* @memberOf Model
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.discriminators;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Translate any aliases fields/conditions so the final query or document object is pure
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await Character.find(Character.translateAliases({
|
||
|
|
* '名': 'Eddard Stark' // Alias for 'name'
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* By default, `translateAliases()` overwrites raw fields with aliased fields.
|
||
|
|
* So if `n` is an alias for `name`, `{ n: 'alias', name: 'raw' }` will resolve to `{ name: 'alias' }`.
|
||
|
|
* However, you can set the `errorOnDuplicates` option to throw an error if there are potentially conflicting paths.
|
||
|
|
* The `translateAliases` option for queries uses `errorOnDuplicates`.
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* Only translate arguments of object type anything else is returned raw
|
||
|
|
*
|
||
|
|
* @param {Object} fields fields/conditions that may contain aliased keys
|
||
|
|
* @param {Boolean} [errorOnDuplicates] if true, throw an error if there's both a key and an alias for that key in `fields`
|
||
|
|
* @return {Object} the translated 'pure' fields/conditions
|
||
|
|
*/
|
||
|
|
Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
|
||
|
|
_checkContext(this, 'translateAliases');
|
||
|
|
|
||
|
|
const translate = (key, value) => {
|
||
|
|
let alias;
|
||
|
|
const translated = [];
|
||
|
|
const fieldKeys = key.split('.');
|
||
|
|
let currentSchema = this.schema;
|
||
|
|
for (const i in fieldKeys) {
|
||
|
|
const name = fieldKeys[i];
|
||
|
|
if (currentSchema && currentSchema.aliases[name]) {
|
||
|
|
alias = currentSchema.aliases[name];
|
||
|
|
if (errorOnDuplicates && alias in fields) {
|
||
|
|
throw new MongooseError(`Provided object has both field "${name}" and its alias "${alias}"`);
|
||
|
|
}
|
||
|
|
// Alias found,
|
||
|
|
translated.push(alias);
|
||
|
|
} else {
|
||
|
|
alias = name;
|
||
|
|
// Alias not found, so treat as un-aliased key
|
||
|
|
translated.push(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if aliased path is a schema
|
||
|
|
if (currentSchema && currentSchema.paths[alias]) {
|
||
|
|
currentSchema = currentSchema.paths[alias].schema;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
currentSchema = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
const translatedKey = translated.join('.');
|
||
|
|
if (fields instanceof Map)
|
||
|
|
fields.set(translatedKey, value);
|
||
|
|
else
|
||
|
|
fields[translatedKey] = value;
|
||
|
|
|
||
|
|
if (translatedKey !== key) {
|
||
|
|
// We'll be using the translated key instead
|
||
|
|
if (fields instanceof Map) {
|
||
|
|
// Delete from map
|
||
|
|
fields.delete(key);
|
||
|
|
} else {
|
||
|
|
// Delete from object
|
||
|
|
delete fields[key]; // We'll be using the translated key instead
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return fields;
|
||
|
|
};
|
||
|
|
|
||
|
|
if (typeof fields === 'object') {
|
||
|
|
// Fields is an object (query conditions or document fields)
|
||
|
|
if (fields instanceof Map) {
|
||
|
|
// A Map was supplied
|
||
|
|
for (const field of new Map(fields)) {
|
||
|
|
fields = translate(field[0], field[1]);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Infer a regular object was supplied
|
||
|
|
for (const key of Object.keys(fields)) {
|
||
|
|
fields = translate(key, fields[key]);
|
||
|
|
if (key[0] === '$') {
|
||
|
|
if (Array.isArray(fields[key])) {
|
||
|
|
for (const i in fields[key]) {
|
||
|
|
// Recursively translate nested queries
|
||
|
|
fields[key][i] = this.translateAliases(fields[key][i]);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this.translateAliases(fields[key]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return fields;
|
||
|
|
} else {
|
||
|
|
// Don't know typeof fields
|
||
|
|
return fields;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Deletes the first document that matches `conditions` from the collection.
|
||
|
|
* It returns an object with the property `deletedCount` indicating how many documents were deleted.
|
||
|
|
* Behaves like `remove()`, but deletes at most one document regardless of the
|
||
|
|
* `single` option.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await Character.deleteOne({ name: 'Eddard Stark' }); // returns {deletedCount: 1}
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* This function triggers `deleteOne` query hooks. Read the
|
||
|
|
* [middleware docs](https://mongoosejs.com/docs/middleware.html#naming) to learn more.
|
||
|
|
*
|
||
|
|
* @param {Object} conditions
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.deleteOne = function deleteOne(conditions, options) {
|
||
|
|
_checkContext(this, 'deleteOne');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.prototype.deleteOne() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.setOptions(options);
|
||
|
|
|
||
|
|
return mq.deleteOne(conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Deletes all of the documents that match `conditions` from the collection.
|
||
|
|
* It returns an object with the property `deletedCount` containing the number of documents deleted.
|
||
|
|
* Behaves like `remove()`, but deletes all documents that match `conditions`
|
||
|
|
* regardless of the `single` option.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await Character.deleteMany({ name: /Stark/, age: { $gte: 18 } }); // returns {deletedCount: x} where x is the number of documents deleted.
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* This function triggers `deleteMany` query hooks. Read the
|
||
|
|
* [middleware docs](https://mongoosejs.com/docs/middleware.html#naming) to learn more.
|
||
|
|
*
|
||
|
|
* @param {Object} conditions
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.deleteMany = function deleteMany(conditions, options) {
|
||
|
|
_checkContext(this, 'deleteMany');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.deleteMany() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.setOptions(options);
|
||
|
|
|
||
|
|
return mq.deleteMany(conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Finds documents.
|
||
|
|
*
|
||
|
|
* Mongoose casts the `filter` to match the model's schema before the command is sent.
|
||
|
|
* See our [query casting tutorial](https://mongoosejs.com/docs/tutorials/query_casting.html) for
|
||
|
|
* more information on how Mongoose casts `filter`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // find all documents
|
||
|
|
* await MyModel.find({});
|
||
|
|
*
|
||
|
|
* // find all documents named john and at least 18
|
||
|
|
* await MyModel.find({ name: 'john', age: { $gte: 18 } }).exec();
|
||
|
|
*
|
||
|
|
* // executes, name LIKE john and only selecting the "name" and "friends" fields
|
||
|
|
* await MyModel.find({ name: /john/i }, 'name friends').exec();
|
||
|
|
*
|
||
|
|
* // passing options
|
||
|
|
* await MyModel.find({ name: /john/i }, null, { skip: 10 }).exec();
|
||
|
|
*
|
||
|
|
* @param {Object|ObjectId} filter
|
||
|
|
* @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
|
||
|
|
* @see query casting https://mongoosejs.com/docs/tutorials/query_casting.html
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.find = function find(conditions, projection, options) {
|
||
|
|
_checkContext(this, 'find');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function' || typeof arguments[3] === 'function') {
|
||
|
|
throw new MongooseError('Model.find() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.select(projection);
|
||
|
|
mq.setOptions(options);
|
||
|
|
|
||
|
|
return mq.find(conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Finds a single document by its _id field. `findById(id)` is almost*
|
||
|
|
* equivalent to `findOne({ _id: id })`. If you want to query by a document's
|
||
|
|
* `_id`, use `findById()` instead of `findOne()`.
|
||
|
|
*
|
||
|
|
* The `id` is cast based on the Schema before sending the command.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `findOne()`
|
||
|
|
*
|
||
|
|
* \* Except for how it treats `undefined`. If you use `findOne()`, you'll see
|
||
|
|
* that `findOne(undefined)` and `findOne({ _id: undefined })` are equivalent
|
||
|
|
* to `findOne({})` and return arbitrary documents. However, mongoose
|
||
|
|
* translates `findById(undefined)` into `findOne({ _id: null })`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // Find the adventure with the given `id`, or `null` if not found
|
||
|
|
* await Adventure.findById(id).exec();
|
||
|
|
*
|
||
|
|
* // select only the adventures name and length
|
||
|
|
* await Adventure.findById(id, 'name length').exec();
|
||
|
|
*
|
||
|
|
* @param {Any} id value of `_id` to query by
|
||
|
|
* @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @return {Query}
|
||
|
|
* @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
|
||
|
|
* @see lean queries https://mongoosejs.com/docs/tutorials/lean.html
|
||
|
|
* @see findById in Mongoose https://masteringjs.io/tutorials/mongoose/find-by-id
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findById = function findById(id, projection, options) {
|
||
|
|
_checkContext(this, 'findById');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.findById() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof id === 'undefined') {
|
||
|
|
id = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.findOne({ _id: id }, projection, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Finds one document.
|
||
|
|
*
|
||
|
|
* The `conditions` are cast to their respective SchemaTypes before the command is sent.
|
||
|
|
*
|
||
|
|
* *Note:* `conditions` is optional, and if `conditions` is null or undefined,
|
||
|
|
* mongoose will send an empty `findOne` command to MongoDB, which will return
|
||
|
|
* an arbitrary document. If you're querying by `_id`, use `findById()` instead.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // Find one adventure whose `country` is 'Croatia', otherwise `null`
|
||
|
|
* await Adventure.findOne({ country: 'Croatia' }).exec();
|
||
|
|
*
|
||
|
|
* // Model.findOne() no longer accepts a callback
|
||
|
|
*
|
||
|
|
* // Select only the adventures name and length
|
||
|
|
* await Adventure.findOne({ country: 'Croatia' }, 'name length').exec();
|
||
|
|
*
|
||
|
|
* @param {Object} [conditions]
|
||
|
|
* @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
|
||
|
|
* @see lean queries https://mongoosejs.com/docs/tutorials/lean.html
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findOne = function findOne(conditions, projection, options) {
|
||
|
|
_checkContext(this, 'findOne');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.findOne() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.select(projection);
|
||
|
|
mq.setOptions(options);
|
||
|
|
|
||
|
|
return mq.findOne(conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Estimates the number of documents in the MongoDB collection. Faster than
|
||
|
|
* using `countDocuments()` for large collections because
|
||
|
|
* `estimatedDocumentCount()` uses collection metadata rather than scanning
|
||
|
|
* the entire collection.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const numAdventures = await Adventure.estimatedDocumentCount();
|
||
|
|
*
|
||
|
|
* @param {Object} [options]
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.estimatedDocumentCount = function estimatedDocumentCount(options) {
|
||
|
|
_checkContext(this, 'estimatedDocumentCount');
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
|
||
|
|
return mq.estimatedDocumentCount(options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Counts number of documents matching `filter` in a database collection.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* Adventure.countDocuments({ type: 'jungle' }, function (err, count) {
|
||
|
|
* console.log('there are %d jungle adventures', count);
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* If you want to count all documents in a large collection,
|
||
|
|
* use the [`estimatedDocumentCount()` function](https://mongoosejs.com/docs/api/model.html#Model.estimatedDocumentCount())
|
||
|
|
* instead. If you call `countDocuments({})`, MongoDB will always execute
|
||
|
|
* a full collection scan and **not** use any indexes.
|
||
|
|
*
|
||
|
|
* The `countDocuments()` function is similar to `count()`, but there are a
|
||
|
|
* [few operators that `countDocuments()` does not support](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#countDocuments).
|
||
|
|
* Below are the operators that `count()` supports but `countDocuments()` does not,
|
||
|
|
* and the suggested replacement:
|
||
|
|
*
|
||
|
|
* - `$where`: [`$expr`](https://www.mongodb.com/docs/manual/reference/operator/query/expr/)
|
||
|
|
* - `$near`: [`$geoWithin`](https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/) with [`$center`](https://www.mongodb.com/docs/manual/reference/operator/query/center/#op._S_center)
|
||
|
|
* - `$nearSphere`: [`$geoWithin`](https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/) with [`$centerSphere`](https://www.mongodb.com/docs/manual/reference/operator/query/centerSphere/#op._S_centerSphere)
|
||
|
|
*
|
||
|
|
* @param {Object} filter
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.countDocuments = function countDocuments(conditions, options) {
|
||
|
|
_checkContext(this, 'countDocuments');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.countDocuments() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
if (options != null) {
|
||
|
|
mq.setOptions(options);
|
||
|
|
}
|
||
|
|
|
||
|
|
return mq.countDocuments(conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a Query for a `distinct` operation.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const query = Link.distinct('url');
|
||
|
|
* query.exec();
|
||
|
|
*
|
||
|
|
* @param {String} field
|
||
|
|
* @param {Object} [conditions] optional
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.distinct = function distinct(field, conditions) {
|
||
|
|
_checkContext(this, 'distinct');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function') {
|
||
|
|
throw new MongooseError('Model.distinct() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
|
||
|
|
return mq.distinct(field, conditions);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a Query, applies the passed conditions, and returns the Query.
|
||
|
|
*
|
||
|
|
* For example, instead of writing:
|
||
|
|
*
|
||
|
|
* User.find({ age: { $gte: 21, $lte: 65 } });
|
||
|
|
*
|
||
|
|
* we can instead write:
|
||
|
|
*
|
||
|
|
* User.where('age').gte(21).lte(65).exec();
|
||
|
|
*
|
||
|
|
* Since the Query class also supports `where` you can continue chaining
|
||
|
|
*
|
||
|
|
* User
|
||
|
|
* .where('age').gte(21).lte(65)
|
||
|
|
* .where('name', /^b/i)
|
||
|
|
* ... etc
|
||
|
|
*
|
||
|
|
* @param {String} path
|
||
|
|
* @param {Object} [val] optional value
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.where = function where(path, val) {
|
||
|
|
_checkContext(this, 'where');
|
||
|
|
|
||
|
|
void val; // eslint
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection).find({});
|
||
|
|
return mq.where.apply(mq, arguments);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a `Query` and specifies a `$where` condition.
|
||
|
|
*
|
||
|
|
* Sometimes you need to query for things in mongodb using a JavaScript expression. You can do so via `find({ $where: javascript })`, or you can use the mongoose shortcut method $where via a Query chain or from your mongoose Model.
|
||
|
|
*
|
||
|
|
* Blog.$where('this.username.indexOf("val") !== -1').exec(function (err, docs) {});
|
||
|
|
*
|
||
|
|
* @param {String|Function} argument is a javascript string or anonymous function
|
||
|
|
* @method $where
|
||
|
|
* @memberOf Model
|
||
|
|
* @return {Query}
|
||
|
|
* @see Query.$where https://mongoosejs.com/docs/api/query.html#Query.prototype.$where
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.$where = function $where() {
|
||
|
|
_checkContext(this, '$where');
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection).find({});
|
||
|
|
return mq.$where.apply(mq, arguments);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Issues a mongodb findOneAndUpdate command.
|
||
|
|
*
|
||
|
|
* Finds a matching document, updates it according to the `update` arg, passing any `options`, and returns the found document (if any) to the callback. The query executes if `callback` is passed else a Query object is returned.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* A.findOneAndUpdate(conditions, update, options) // returns Query
|
||
|
|
* A.findOneAndUpdate(conditions, update) // returns Query
|
||
|
|
* A.findOneAndUpdate() // returns Query
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* All top level update keys which are not `atomic` operation names are treated as set operations:
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const query = { name: 'borne' };
|
||
|
|
* Model.findOneAndUpdate(query, { name: 'jason bourne' }, options)
|
||
|
|
*
|
||
|
|
* // is sent as
|
||
|
|
* Model.findOneAndUpdate(query, { $set: { name: 'jason bourne' }}, options)
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* `findOneAndX` and `findByIdAndX` functions support limited validation that
|
||
|
|
* you can enable by setting the `runValidators` option.
|
||
|
|
*
|
||
|
|
* If you need full-fledged validation, use the traditional approach of first
|
||
|
|
* retrieving the document.
|
||
|
|
*
|
||
|
|
* const doc = await Model.findById(id);
|
||
|
|
* doc.name = 'jason bourne';
|
||
|
|
* await doc.save();
|
||
|
|
*
|
||
|
|
* @param {Object} [conditions]
|
||
|
|
* @param {Object} [update]
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
|
||
|
|
* @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
|
||
|
|
* @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {Boolean} [options.new=false] if true, return the modified document rather than the original
|
||
|
|
* @param {Object|String} [options.fields] Field selection. Equivalent to `.select(fields).findOneAndUpdate()`
|
||
|
|
* @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
|
||
|
|
* @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
|
||
|
|
* @param {Boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
|
||
|
|
* @param {Boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
|
||
|
|
* @param {Boolean} [options.includeResultMetadata] if true, returns the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html)
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Tutorial https://mongoosejs.com/docs/tutorials/findoneandupdate.html
|
||
|
|
* @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findOneAndUpdate = function(conditions, update, options) {
|
||
|
|
_checkContext(this, 'findOneAndUpdate');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function' || typeof arguments[3] === 'function') {
|
||
|
|
throw new MongooseError('Model.findOneAndUpdate() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (arguments.length === 1) {
|
||
|
|
update = conditions;
|
||
|
|
conditions = null;
|
||
|
|
options = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
let fields;
|
||
|
|
if (options) {
|
||
|
|
fields = options.fields || options.projection;
|
||
|
|
}
|
||
|
|
|
||
|
|
update = clone(update, {
|
||
|
|
depopulate: true,
|
||
|
|
_isNested: true
|
||
|
|
});
|
||
|
|
|
||
|
|
decorateUpdateWithVersionKey(update, options, this.schema.options.versionKey);
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.select(fields);
|
||
|
|
|
||
|
|
return mq.findOneAndUpdate(conditions, update, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Issues a mongodb findOneAndUpdate command by a document's _id field.
|
||
|
|
* `findByIdAndUpdate(id, ...)` is equivalent to `findOneAndUpdate({ _id: id }, ...)`.
|
||
|
|
*
|
||
|
|
* Finds a matching document, updates it according to the `update` arg,
|
||
|
|
* passing any `options`, and returns the found document (if any).
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `findOneAndUpdate()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* A.findByIdAndUpdate(id, update, options) // returns Query
|
||
|
|
* A.findByIdAndUpdate(id, update) // returns Query
|
||
|
|
* A.findByIdAndUpdate() // returns Query
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* All top level update keys which are not `atomic` operation names are treated as set operations:
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* Model.findByIdAndUpdate(id, { name: 'jason bourne' }, options)
|
||
|
|
*
|
||
|
|
* // is sent as
|
||
|
|
* Model.findByIdAndUpdate(id, { $set: { name: 'jason bourne' }}, options)
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* `findOneAndX` and `findByIdAndX` functions support limited validation. You can
|
||
|
|
* enable validation by setting the `runValidators` option.
|
||
|
|
*
|
||
|
|
* If you need full-fledged validation, use the traditional approach of first
|
||
|
|
* retrieving the document.
|
||
|
|
*
|
||
|
|
* const doc = await Model.findById(id)
|
||
|
|
* doc.name = 'jason bourne';
|
||
|
|
* await doc.save();
|
||
|
|
*
|
||
|
|
* @param {Object|Number|String} id value of `_id` to query by
|
||
|
|
* @param {Object} [update]
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
|
||
|
|
* @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
|
||
|
|
* @param {Boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
|
||
|
|
* @param {Boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
|
||
|
|
* @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
|
||
|
|
* @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
|
||
|
|
* @param {Boolean} [options.new=false] if true, return the modified document rather than the original
|
||
|
|
* @param {Object|String} [options.select] sets the document fields to return.
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Model.findOneAndUpdate https://mongoosejs.com/docs/api/model.html#Model.findOneAndUpdate()
|
||
|
|
* @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findByIdAndUpdate = function(id, update, options) {
|
||
|
|
_checkContext(this, 'findByIdAndUpdate');
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function' || typeof arguments[3] === 'function') {
|
||
|
|
throw new MongooseError('Model.findByIdAndUpdate() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
// if a model is passed in instead of an id
|
||
|
|
if (id instanceof Document) {
|
||
|
|
id = id._id;
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.findOneAndUpdate.call(this, { _id: id }, update, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Issue a MongoDB `findOneAndDelete()` command.
|
||
|
|
*
|
||
|
|
* Finds a matching document, removes it, and returns the found document (if any).
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `findOneAndDelete()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* A.findOneAndDelete(conditions, options) // return Query
|
||
|
|
* A.findOneAndDelete(conditions) // returns Query
|
||
|
|
* A.findOneAndDelete() // returns Query
|
||
|
|
*
|
||
|
|
* `findOneAndX` and `findByIdAndX` functions support limited validation. You can
|
||
|
|
* enable validation by setting the `runValidators` option.
|
||
|
|
*
|
||
|
|
* If you need full-fledged validation, use the traditional approach of first
|
||
|
|
* retrieving the document.
|
||
|
|
*
|
||
|
|
* const doc = await Model.findById(id)
|
||
|
|
* doc.name = 'jason bourne';
|
||
|
|
* await doc.save();
|
||
|
|
*
|
||
|
|
* @param {Object} conditions
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
|
||
|
|
* @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
|
||
|
|
* @param {Object|String} [options.select] sets the document fields to return.
|
||
|
|
* @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findOneAndDelete = function(conditions, options) {
|
||
|
|
_checkContext(this, 'findOneAndDelete');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.findOneAndDelete() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
let fields;
|
||
|
|
if (options) {
|
||
|
|
fields = options.select;
|
||
|
|
options.select = undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.select(fields);
|
||
|
|
|
||
|
|
return mq.findOneAndDelete(conditions, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Issue a MongoDB `findOneAndDelete()` command by a document's _id field.
|
||
|
|
* In other words, `findByIdAndDelete(id)` is a shorthand for
|
||
|
|
* `findOneAndDelete({ _id: id })`.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `findOneAndDelete()`
|
||
|
|
*
|
||
|
|
* @param {Object|Number|String} id value of `_id` to query by
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Model.findOneAndDelete https://mongoosejs.com/docs/api/model.html#Model.findOneAndDelete()
|
||
|
|
* @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findByIdAndDelete = function(id, options) {
|
||
|
|
_checkContext(this, 'findByIdAndDelete');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.findByIdAndDelete() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.findOneAndDelete({ _id: id }, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Issue a MongoDB `findOneAndReplace()` command.
|
||
|
|
*
|
||
|
|
* Finds a matching document, replaces it with the provided doc, and returns the document.
|
||
|
|
*
|
||
|
|
* This function triggers the following query middleware.
|
||
|
|
*
|
||
|
|
* - `findOneAndReplace()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* A.findOneAndReplace(filter, replacement, options) // return Query
|
||
|
|
* A.findOneAndReplace(filter, replacement) // returns Query
|
||
|
|
* A.findOneAndReplace() // returns Query
|
||
|
|
*
|
||
|
|
* @param {Object} filter Replace the first document that matches this filter
|
||
|
|
* @param {Object} [replacement] Replace with this document
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
|
||
|
|
* @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
|
||
|
|
* @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
|
||
|
|
* @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
|
||
|
|
* @param {Object|String} [options.select] sets the document fields to return.
|
||
|
|
* @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.findOneAndReplace = function(filter, replacement, options) {
|
||
|
|
_checkContext(this, 'findOneAndReplace');
|
||
|
|
|
||
|
|
if (typeof arguments[0] === 'function' || typeof arguments[1] === 'function' || typeof arguments[2] === 'function' || typeof arguments[3] === 'function') {
|
||
|
|
throw new MongooseError('Model.findOneAndReplace() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
let fields;
|
||
|
|
if (options) {
|
||
|
|
fields = options.select;
|
||
|
|
options.select = undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
const mq = new this.Query({}, {}, this, this.$__collection);
|
||
|
|
mq.select(fields);
|
||
|
|
|
||
|
|
return mq.findOneAndReplace(filter, replacement, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Shortcut for saving one or more documents to the database.
|
||
|
|
* `MyModel.create(docs)` does `new MyModel(doc).save()` for every doc in
|
||
|
|
* docs.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `save()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // Insert one new `Character` document
|
||
|
|
* await Character.create({ name: 'Jean-Luc Picard' });
|
||
|
|
*
|
||
|
|
* // Insert multiple new `Character` documents
|
||
|
|
* await Character.create([{ name: 'Will Riker' }, { name: 'Geordi LaForge' }]);
|
||
|
|
*
|
||
|
|
* // Create a new character within a transaction. Note that you **must**
|
||
|
|
* // pass an array as the first parameter to `create()` if you want to
|
||
|
|
* // specify options.
|
||
|
|
* await Character.create([{ name: 'Jean-Luc Picard' }], { session });
|
||
|
|
*
|
||
|
|
* @param {Array|Object} docs Documents to insert, as a spread or array
|
||
|
|
* @param {Object} [options] Options passed down to `save()`. To specify `options`, `docs` **must** be an array, not a spread. See [Model.save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) for available options.
|
||
|
|
* @param {Boolean} [options.ordered] saves the docs in series rather than parallel.
|
||
|
|
* @param {Boolean} [options.aggregateErrors] Aggregate Errors instead of throwing the first one that occurs. Default: false
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.create = async function create(doc, options) {
|
||
|
|
if (typeof options === 'function' ||
|
||
|
|
typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.create() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
_checkContext(this, 'create');
|
||
|
|
|
||
|
|
let args;
|
||
|
|
const discriminatorKey = this.schema.options.discriminatorKey;
|
||
|
|
|
||
|
|
if (Array.isArray(doc)) {
|
||
|
|
args = doc;
|
||
|
|
options = options != null && typeof options === 'object' ? options : {};
|
||
|
|
} else {
|
||
|
|
const last = arguments[arguments.length - 1];
|
||
|
|
options = {};
|
||
|
|
const hasCallback = typeof last === 'function' ||
|
||
|
|
typeof options === 'function' ||
|
||
|
|
typeof arguments[2] === 'function';
|
||
|
|
if (hasCallback) {
|
||
|
|
throw new MongooseError('Model.create() no longer accepts a callback');
|
||
|
|
} else {
|
||
|
|
args = [...arguments];
|
||
|
|
// For backwards compatibility with 6.x, because of gh-5061 Mongoose 6.x and
|
||
|
|
// older would treat a falsy last arg as a callback. We don't want to throw
|
||
|
|
// an error here, because it would look strange if `Test.create({}, void 0)`
|
||
|
|
// threw a callback error. But we also don't want to create an unnecessary document.
|
||
|
|
if (args.length > 1 && !last) {
|
||
|
|
args.pop();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (args.length === 2 &&
|
||
|
|
args[0] != null &&
|
||
|
|
args[1] != null &&
|
||
|
|
args[0].session == null &&
|
||
|
|
last &&
|
||
|
|
getConstructorName(last.session) === 'ClientSession' &&
|
||
|
|
!this.schema.path('session')) {
|
||
|
|
// Probably means the user is running into the common mistake of trying
|
||
|
|
// to use a spread to specify options, see gh-7535
|
||
|
|
utils.warn('WARNING: to pass a `session` to `Model.create()` in ' +
|
||
|
|
'Mongoose, you **must** pass an array as the first argument. See: ' +
|
||
|
|
'https://mongoosejs.com/docs/api/model.html#Model.create()');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (args.length === 0) {
|
||
|
|
return Array.isArray(doc) ? [] : null;
|
||
|
|
}
|
||
|
|
let res = [];
|
||
|
|
const immediateError = typeof options.aggregateErrors === 'boolean' ? !options.aggregateErrors : true;
|
||
|
|
|
||
|
|
delete options.aggregateErrors; // dont pass on the option to "$save"
|
||
|
|
|
||
|
|
if (options.ordered) {
|
||
|
|
for (let i = 0; i < args.length; i++) {
|
||
|
|
try {
|
||
|
|
const doc = args[i];
|
||
|
|
const Model = this.discriminators && doc[discriminatorKey] != null ?
|
||
|
|
this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
|
||
|
|
this;
|
||
|
|
if (Model == null) {
|
||
|
|
throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
|
||
|
|
`found for model "${this.modelName}"`);
|
||
|
|
}
|
||
|
|
let toSave = doc;
|
||
|
|
if (!(toSave instanceof Model)) {
|
||
|
|
toSave = new Model(toSave);
|
||
|
|
}
|
||
|
|
|
||
|
|
await toSave.$save(options);
|
||
|
|
res.push(toSave);
|
||
|
|
} catch (err) {
|
||
|
|
if (!immediateError) {
|
||
|
|
res.push(err);
|
||
|
|
} else {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
} else if (!immediateError) {
|
||
|
|
res = await Promise.allSettled(args.map(async doc => {
|
||
|
|
const Model = this.discriminators && doc[discriminatorKey] != null ?
|
||
|
|
this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
|
||
|
|
this;
|
||
|
|
if (Model == null) {
|
||
|
|
throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
|
||
|
|
`found for model "${this.modelName}"`);
|
||
|
|
}
|
||
|
|
let toSave = doc;
|
||
|
|
|
||
|
|
if (!(toSave instanceof Model)) {
|
||
|
|
toSave = new Model(toSave);
|
||
|
|
}
|
||
|
|
|
||
|
|
await toSave.$save(options);
|
||
|
|
|
||
|
|
return toSave;
|
||
|
|
}));
|
||
|
|
res = res.map(result => result.status === 'fulfilled' ? result.value : result.reason);
|
||
|
|
} else {
|
||
|
|
let firstError = null;
|
||
|
|
res = await Promise.all(args.map(async doc => {
|
||
|
|
const Model = this.discriminators && doc[discriminatorKey] != null ?
|
||
|
|
this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
|
||
|
|
this;
|
||
|
|
if (Model == null) {
|
||
|
|
throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
|
||
|
|
`found for model "${this.modelName}"`);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
let toSave = doc;
|
||
|
|
|
||
|
|
if (!(toSave instanceof Model)) {
|
||
|
|
toSave = new Model(toSave);
|
||
|
|
}
|
||
|
|
|
||
|
|
await toSave.$save(options);
|
||
|
|
|
||
|
|
return toSave;
|
||
|
|
} catch (err) {
|
||
|
|
if (!firstError) {
|
||
|
|
firstError = err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
if (firstError) {
|
||
|
|
throw firstError;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (!Array.isArray(doc) && args.length === 1) {
|
||
|
|
return res[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
return res;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* _Requires a replica set running MongoDB >= 3.6.0._ Watches the
|
||
|
|
* underlying collection for changes using
|
||
|
|
* [MongoDB change streams](https://www.mongodb.com/docs/manual/changeStreams/).
|
||
|
|
*
|
||
|
|
* This function does **not** trigger any middleware. In particular, it
|
||
|
|
* does **not** trigger aggregate middleware.
|
||
|
|
*
|
||
|
|
* The ChangeStream object is an event emitter that emits the following events:
|
||
|
|
*
|
||
|
|
* - 'change': A change occurred, see below example
|
||
|
|
* - 'error': An unrecoverable error occurred. In particular, change streams currently error out if they lose connection to the replica set primary. Follow [this GitHub issue](https://github.com/Automattic/mongoose/issues/6799) for updates.
|
||
|
|
* - 'end': Emitted if the underlying stream is closed
|
||
|
|
* - 'close': Emitted if the underlying stream is closed
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const doc = await Person.create({ name: 'Ned Stark' });
|
||
|
|
* const changeStream = Person.watch().on('change', change => console.log(change));
|
||
|
|
* // Will print from the above `console.log()`:
|
||
|
|
* // { _id: { _data: ... },
|
||
|
|
* // operationType: 'delete',
|
||
|
|
* // ns: { db: 'mydb', coll: 'Person' },
|
||
|
|
* // documentKey: { _id: 5a51b125c5500f5aa094c7bd } }
|
||
|
|
* await doc.remove();
|
||
|
|
*
|
||
|
|
* @param {Array} [pipeline]
|
||
|
|
* @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#watch)
|
||
|
|
* @param {Boolean} [options.hydrate=false] if true and `fullDocument: 'updateLookup'` is set, Mongoose will automatically hydrate `fullDocument` into a fully fledged Mongoose document
|
||
|
|
* @return {ChangeStream} mongoose-specific change stream wrapper, inherits from EventEmitter
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.watch = function(pipeline, options) {
|
||
|
|
_checkContext(this, 'watch');
|
||
|
|
|
||
|
|
const changeStreamThunk = cb => {
|
||
|
|
pipeline = pipeline || [];
|
||
|
|
prepareDiscriminatorPipeline(pipeline, this.schema, 'fullDocument');
|
||
|
|
if (this.$__collection.buffer) {
|
||
|
|
this.$__collection.addQueue(() => {
|
||
|
|
if (this.closed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const driverChangeStream = this.$__collection.watch(pipeline, options);
|
||
|
|
cb(null, driverChangeStream);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
const driverChangeStream = this.$__collection.watch(pipeline, options);
|
||
|
|
cb(null, driverChangeStream);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
options = options || {};
|
||
|
|
options.model = this;
|
||
|
|
|
||
|
|
return new ChangeStream(changeStreamThunk, pipeline, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://www.mongodb.com/docs/manual/release-notes/3.6/#client-sessions)
|
||
|
|
* for benefits like causal consistency, [retryable writes](https://www.mongodb.com/docs/manual/core/retryable-writes/),
|
||
|
|
* and [transactions](https://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
|
||
|
|
*
|
||
|
|
* Calling `MyModel.startSession()` is equivalent to calling `MyModel.db.startSession()`.
|
||
|
|
*
|
||
|
|
* This function does not trigger any middleware.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const session = await Person.startSession();
|
||
|
|
* let doc = await Person.findOne({ name: 'Ned Stark' }, null, { session });
|
||
|
|
* await doc.remove();
|
||
|
|
* // `doc` will always be null, even if reading from a replica set
|
||
|
|
* // secondary. Without causal consistency, it is possible to
|
||
|
|
* // get a doc back from the below query if the query reads from a
|
||
|
|
* // secondary that is experiencing replication lag.
|
||
|
|
* doc = await Person.findOne({ name: 'Ned Stark' }, null, { session, readPreference: 'secondary' });
|
||
|
|
*
|
||
|
|
* @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html#startSession)
|
||
|
|
* @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
|
||
|
|
* @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.startSession = function() {
|
||
|
|
_checkContext(this, 'startSession');
|
||
|
|
|
||
|
|
return this.db.startSession.apply(this.db, arguments);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Shortcut for validating an array of documents and inserting them into
|
||
|
|
* MongoDB if they're all valid. This function is faster than `.create()`
|
||
|
|
* because it only sends one operation to the server, rather than one for each
|
||
|
|
* document.
|
||
|
|
*
|
||
|
|
* Mongoose always validates each document **before** sending `insertMany`
|
||
|
|
* to MongoDB. So if one document has a validation error, no documents will
|
||
|
|
* be saved, unless you set
|
||
|
|
* [the `ordered` option to false](https://www.mongodb.com/docs/manual/reference/method/db.collection.insertMany/#error-handling).
|
||
|
|
*
|
||
|
|
* This function does **not** trigger save middleware.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `insertMany()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* await Movies.insertMany([
|
||
|
|
* { name: 'Star Wars' },
|
||
|
|
* { name: 'The Empire Strikes Back' }
|
||
|
|
* ]);
|
||
|
|
*
|
||
|
|
* @param {Array|Object|*} doc(s)
|
||
|
|
* @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)
|
||
|
|
* @param {Boolean} [options.ordered=true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
|
||
|
|
* @param {Boolean} [options.rawResult=false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `true`, will return the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/InsertManyResult.html) with a `mongoose` property that contains `validationErrors` and `results` if this is an unordered `insertMany`.
|
||
|
|
* @param {Boolean} [options.lean=false] if `true`, skips hydrating and validating the documents. This option is useful if you need the extra performance, but Mongoose won't validate the documents before inserting.
|
||
|
|
* @param {Number} [options.limit=null] this limits the number of documents being processed (validation/casting) by mongoose in parallel, this does **NOT** send the documents in batches to MongoDB. Use this option if you're processing a large number of documents and your app is running out of memory.
|
||
|
|
* @param {String|Object|Array} [options.populate=null] populates the result documents. This option is a no-op if `rawResult` is set.
|
||
|
|
* @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
|
||
|
|
* @return {Promise} resolving to the raw result from the MongoDB driver if `options.rawResult` was `true`, or the documents that passed validation, otherwise
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.insertMany = async function insertMany(arr, options) {
|
||
|
|
_checkContext(this, 'insertMany');
|
||
|
|
if (typeof options === 'function' ||
|
||
|
|
typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.insertMany() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
this.$__insertMany(arr, options, (err, res) => {
|
||
|
|
if (err != null) {
|
||
|
|
return reject(err);
|
||
|
|
}
|
||
|
|
resolve(res);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ignore
|
||
|
|
*
|
||
|
|
* @param {Array} arr
|
||
|
|
* @param {Object} options
|
||
|
|
* @param {Function} callback
|
||
|
|
* @api private
|
||
|
|
* @memberOf Model
|
||
|
|
* @method $__insertMany
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.$__insertMany = function(arr, options, callback) {
|
||
|
|
const _this = this;
|
||
|
|
if (typeof options === 'function') {
|
||
|
|
callback = options;
|
||
|
|
options = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
callback = callback || utils.noop;
|
||
|
|
options = options || {};
|
||
|
|
const limit = options.limit || 1000;
|
||
|
|
const rawResult = !!options.rawResult;
|
||
|
|
const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
|
||
|
|
const throwOnValidationError = typeof options.throwOnValidationError === 'boolean' ? options.throwOnValidationError : false;
|
||
|
|
const lean = !!options.lean;
|
||
|
|
|
||
|
|
if (!Array.isArray(arr)) {
|
||
|
|
arr = [arr];
|
||
|
|
}
|
||
|
|
|
||
|
|
const validationErrors = [];
|
||
|
|
const validationErrorsToOriginalOrder = new Map();
|
||
|
|
const results = ordered ? null : new Array(arr.length);
|
||
|
|
const toExecute = arr.map((doc, index) =>
|
||
|
|
callback => {
|
||
|
|
if (!(doc instanceof _this)) {
|
||
|
|
try {
|
||
|
|
doc = new _this(doc);
|
||
|
|
} catch (err) {
|
||
|
|
return callback(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (options.session != null) {
|
||
|
|
doc.$session(options.session);
|
||
|
|
}
|
||
|
|
// If option `lean` is set to true bypass validation
|
||
|
|
if (lean) {
|
||
|
|
// we have to execute callback at the nextTick to be compatible
|
||
|
|
// with parallelLimit, as `results` variable has TDZ issue if we
|
||
|
|
// execute the callback synchronously
|
||
|
|
return immediate(() => callback(null, doc));
|
||
|
|
}
|
||
|
|
doc.$validate().then(
|
||
|
|
() => { callback(null, doc); },
|
||
|
|
error => {
|
||
|
|
if (ordered === false) {
|
||
|
|
validationErrors.push(error);
|
||
|
|
validationErrorsToOriginalOrder.set(error, index);
|
||
|
|
results[index] = error;
|
||
|
|
return callback(null, null);
|
||
|
|
}
|
||
|
|
callback(error);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
});
|
||
|
|
|
||
|
|
parallelLimit(toExecute, limit, function(error, docs) {
|
||
|
|
if (error) {
|
||
|
|
callback(error, null);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const originalDocIndex = new Map();
|
||
|
|
const validDocIndexToOriginalIndex = new Map();
|
||
|
|
for (let i = 0; i < docs.length; ++i) {
|
||
|
|
originalDocIndex.set(docs[i], i);
|
||
|
|
}
|
||
|
|
|
||
|
|
// We filter all failed pre-validations by removing nulls
|
||
|
|
const docAttributes = docs.filter(function(doc) {
|
||
|
|
return doc != null;
|
||
|
|
});
|
||
|
|
for (let i = 0; i < docAttributes.length; ++i) {
|
||
|
|
validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure validation errors are in the same order as the
|
||
|
|
// original documents, so if both doc1 and doc2 both fail validation,
|
||
|
|
// `Model.insertMany([doc1, doc2])` will always have doc1's validation
|
||
|
|
// error before doc2's. Re: gh-12791.
|
||
|
|
if (validationErrors.length > 0) {
|
||
|
|
validationErrors.sort((err1, err2) => {
|
||
|
|
return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// Quickly escape while there aren't any valid docAttributes
|
||
|
|
if (docAttributes.length === 0) {
|
||
|
|
if (rawResult) {
|
||
|
|
const res = {
|
||
|
|
acknowledged: true,
|
||
|
|
insertedCount: 0,
|
||
|
|
insertedIds: {},
|
||
|
|
mongoose: {
|
||
|
|
validationErrors: validationErrors
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return callback(null, res);
|
||
|
|
}
|
||
|
|
callback(null, []);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const docObjects = docAttributes.map(function(doc) {
|
||
|
|
if (doc.$__schema.options.versionKey) {
|
||
|
|
doc[doc.$__schema.options.versionKey] = 0;
|
||
|
|
}
|
||
|
|
const shouldSetTimestamps = (!options || options.timestamps !== false) && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
|
||
|
|
if (shouldSetTimestamps) {
|
||
|
|
return doc.initializeTimestamps().toObject(internalToObjectOptions);
|
||
|
|
}
|
||
|
|
return doc.toObject(internalToObjectOptions);
|
||
|
|
});
|
||
|
|
|
||
|
|
_this.$__collection.insertMany(docObjects, options).then(
|
||
|
|
res => {
|
||
|
|
for (const attribute of docAttributes) {
|
||
|
|
attribute.$__reset();
|
||
|
|
_setIsNew(attribute, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
|
||
|
|
for (let i = 0; i < results.length; ++i) {
|
||
|
|
if (results[i] === void 0) {
|
||
|
|
results[i] = docs[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return callback(new MongooseBulkWriteError(
|
||
|
|
validationErrors,
|
||
|
|
results,
|
||
|
|
res,
|
||
|
|
'insertMany'
|
||
|
|
));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rawResult) {
|
||
|
|
if (ordered === false) {
|
||
|
|
for (let i = 0; i < results.length; ++i) {
|
||
|
|
if (results[i] === void 0) {
|
||
|
|
results[i] = docs[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decorate with mongoose validation errors in case of unordered,
|
||
|
|
// because then still do `insertMany()`
|
||
|
|
res.mongoose = {
|
||
|
|
validationErrors: validationErrors,
|
||
|
|
results: results
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return callback(null, res);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (options.populate != null) {
|
||
|
|
return _this.populate(docAttributes, options.populate).then(
|
||
|
|
docs => { callback(null, docs); },
|
||
|
|
err => {
|
||
|
|
if (err != null) {
|
||
|
|
err.insertedDocs = docAttributes;
|
||
|
|
}
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
callback(null, docAttributes);
|
||
|
|
},
|
||
|
|
error => {
|
||
|
|
// `writeErrors` is a property reported by the MongoDB driver,
|
||
|
|
// just not if there's only 1 error.
|
||
|
|
if (error.writeErrors == null &&
|
||
|
|
(error.result && error.result.result && error.result.result.writeErrors) != null) {
|
||
|
|
error.writeErrors = error.result.result.writeErrors;
|
||
|
|
}
|
||
|
|
|
||
|
|
// `insertedDocs` is a Mongoose-specific property
|
||
|
|
const hasWriteErrors = error && error.writeErrors;
|
||
|
|
const erroredIndexes = new Set((error && error.writeErrors || []).map(err => err.index));
|
||
|
|
|
||
|
|
if (error.writeErrors != null) {
|
||
|
|
for (let i = 0; i < error.writeErrors.length; ++i) {
|
||
|
|
const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
|
||
|
|
error.writeErrors[i] = {
|
||
|
|
...error.writeErrors[i],
|
||
|
|
index: originalIndex
|
||
|
|
};
|
||
|
|
if (!ordered) {
|
||
|
|
results[originalIndex] = error.writeErrors[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!ordered) {
|
||
|
|
for (let i = 0; i < results.length; ++i) {
|
||
|
|
if (results[i] === void 0) {
|
||
|
|
results[i] = docs[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
error.results = results;
|
||
|
|
}
|
||
|
|
|
||
|
|
let firstErroredIndex = -1;
|
||
|
|
error.insertedDocs = docAttributes.
|
||
|
|
filter((doc, i) => {
|
||
|
|
const isErrored = !hasWriteErrors || erroredIndexes.has(i);
|
||
|
|
|
||
|
|
if (ordered) {
|
||
|
|
if (firstErroredIndex > -1) {
|
||
|
|
return i < firstErroredIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isErrored) {
|
||
|
|
firstErroredIndex = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return !isErrored;
|
||
|
|
}).
|
||
|
|
map(function setIsNewForInsertedDoc(doc) {
|
||
|
|
doc.$__reset();
|
||
|
|
_setIsNew(doc, false);
|
||
|
|
return doc;
|
||
|
|
});
|
||
|
|
|
||
|
|
if (rawResult && ordered === false) {
|
||
|
|
error.mongoose = {
|
||
|
|
validationErrors: validationErrors,
|
||
|
|
results: results
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
callback(error, null);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _setIsNew(doc, val) {
|
||
|
|
doc.$isNew = val;
|
||
|
|
doc.$emit('isNew', val);
|
||
|
|
doc.constructor.emit('isNew', val);
|
||
|
|
|
||
|
|
const subdocs = doc.$getAllSubdocs();
|
||
|
|
for (const subdoc of subdocs) {
|
||
|
|
subdoc.$isNew = val;
|
||
|
|
subdoc.$emit('isNew', val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sends multiple `insertOne`, `updateOne`, `updateMany`, `replaceOne`,
|
||
|
|
* `deleteOne`, and/or `deleteMany` operations to the MongoDB server in one
|
||
|
|
* command. This is faster than sending multiple independent operations (e.g.
|
||
|
|
* if you use `create()`) because with `bulkWrite()` there is only one round
|
||
|
|
* trip to MongoDB.
|
||
|
|
*
|
||
|
|
* Mongoose will perform casting on all operations you provide.
|
||
|
|
*
|
||
|
|
* This function does **not** trigger any middleware, neither `save()`, nor `update()`.
|
||
|
|
* If you need to trigger
|
||
|
|
* `save()` middleware for every document use [`create()`](https://mongoosejs.com/docs/api/model.html#Model.create()) instead.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* Character.bulkWrite([
|
||
|
|
* {
|
||
|
|
* insertOne: {
|
||
|
|
* document: {
|
||
|
|
* name: 'Eddard Stark',
|
||
|
|
* title: 'Warden of the North'
|
||
|
|
* }
|
||
|
|
* }
|
||
|
|
* },
|
||
|
|
* {
|
||
|
|
* updateOne: {
|
||
|
|
* filter: { name: 'Eddard Stark' },
|
||
|
|
* // If you were using the MongoDB driver directly, you'd need to do
|
||
|
|
* // `update: { $set: { title: ... } }` but mongoose adds $set for
|
||
|
|
* // you.
|
||
|
|
* update: { title: 'Hand of the King' }
|
||
|
|
* }
|
||
|
|
* },
|
||
|
|
* {
|
||
|
|
* deleteOne: {
|
||
|
|
* filter: { name: 'Eddard Stark' }
|
||
|
|
* }
|
||
|
|
* }
|
||
|
|
* ]).then(res => {
|
||
|
|
* // Prints "1 1 1"
|
||
|
|
* console.log(res.insertedCount, res.modifiedCount, res.deletedCount);
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* The [supported operations](https://www.mongodb.com/docs/manual/reference/method/db.collection.bulkWrite/#db.collection.bulkWrite) are:
|
||
|
|
*
|
||
|
|
* - `insertOne`
|
||
|
|
* - `updateOne`
|
||
|
|
* - `updateMany`
|
||
|
|
* - `deleteOne`
|
||
|
|
* - `deleteMany`
|
||
|
|
* - `replaceOne`
|
||
|
|
*
|
||
|
|
* @param {Array} ops
|
||
|
|
* @param {Object} [ops.insertOne.document] The document to insert
|
||
|
|
* @param {Object} [ops.updateOne.filter] Update the first document that matches this filter
|
||
|
|
* @param {Object} [ops.updateOne.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
|
||
|
|
* @param {Boolean} [ops.updateOne.upsert=false] If true, insert a doc if none match
|
||
|
|
* @param {Boolean} [ops.updateOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
|
||
|
|
* @param {Object} [ops.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
|
||
|
|
* @param {Array} [ops.updateOne.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
|
||
|
|
* @param {Object} [ops.updateMany.filter] Update all the documents that match this filter
|
||
|
|
* @param {Object} [ops.updateMany.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
|
||
|
|
* @param {Boolean} [ops.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
|
||
|
|
* @param {Boolean} [ops.updateMany.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
|
||
|
|
* @param {Object} [ops.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
|
||
|
|
* @param {Array} [ops.updateMany.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
|
||
|
|
* @param {Object} [ops.deleteOne.filter] Delete the first document that matches this filter
|
||
|
|
* @param {Object} [ops.deleteMany.filter] Delete all documents that match this filter
|
||
|
|
* @param {Object} [ops.replaceOne.filter] Replace the first document that matches this filter
|
||
|
|
* @param {Object} [ops.replaceOne.replacement] The replacement document
|
||
|
|
* @param {Boolean} [ops.replaceOne.upsert=false] If true, insert a doc if no documents match `filter`
|
||
|
|
* @param {Object} [options]
|
||
|
|
* @param {Boolean} [options.ordered=true] If true, execute writes in order and stop at the first error. If false, execute writes in parallel and continue until all writes have either succeeded or errored.
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {String|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
|
||
|
|
* @param {number} [options.wtimeout=null] The [write concern timeout](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout).
|
||
|
|
* @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
|
||
|
|
* @param {Boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
|
||
|
|
* @param {Boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://www.mongodb.com/docs/manual/core/schema-validation/) for all writes in this bulk.
|
||
|
|
* @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
|
||
|
|
* @param {Boolean} [options.strict=null] Overwrites the [`strict` option](https://mongoosejs.com/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
|
||
|
|
* @return {Promise} resolves to a [`BulkWriteOpResult`](https://mongodb.github.io/node-mongodb-native/4.9/classes/BulkWriteResult.html) if the operation succeeds
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.bulkWrite = async function bulkWrite(ops, options) {
|
||
|
|
_checkContext(this, 'bulkWrite');
|
||
|
|
|
||
|
|
if (typeof options === 'function' ||
|
||
|
|
typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.bulkWrite() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
options = options || {};
|
||
|
|
const ordered = options.ordered == null ? true : options.ordered;
|
||
|
|
|
||
|
|
const validations = ops.map(op => castBulkWrite(this, op, options));
|
||
|
|
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
if (ordered) {
|
||
|
|
each(validations, (fn, cb) => fn(cb), error => {
|
||
|
|
if (error) {
|
||
|
|
return reject(error);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ops.length === 0) {
|
||
|
|
return resolve(getDefaultBulkwriteResult());
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
this.$__collection.bulkWrite(ops, options, (error, res) => {
|
||
|
|
if (error) {
|
||
|
|
return reject(error);
|
||
|
|
}
|
||
|
|
|
||
|
|
resolve(res);
|
||
|
|
});
|
||
|
|
} catch (err) {
|
||
|
|
return reject(err);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
let remaining = validations.length;
|
||
|
|
let validOps = [];
|
||
|
|
let validationErrors = [];
|
||
|
|
const results = [];
|
||
|
|
if (remaining === 0) {
|
||
|
|
completeUnorderedValidation.call(this);
|
||
|
|
} else {
|
||
|
|
for (let i = 0; i < validations.length; ++i) {
|
||
|
|
validations[i]((err) => {
|
||
|
|
if (err == null) {
|
||
|
|
validOps.push(i);
|
||
|
|
} else {
|
||
|
|
validationErrors.push({ index: i, error: err });
|
||
|
|
results[i] = err;
|
||
|
|
}
|
||
|
|
if (--remaining <= 0) {
|
||
|
|
completeUnorderedValidation.call(this);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
validationErrors = validationErrors.
|
||
|
|
sort((v1, v2) => v1.index - v2.index).
|
||
|
|
map(v => v.error);
|
||
|
|
|
||
|
|
function completeUnorderedValidation() {
|
||
|
|
const validOpIndexes = validOps;
|
||
|
|
validOps = validOps.sort().map(index => ops[index]);
|
||
|
|
|
||
|
|
if (validOps.length === 0) {
|
||
|
|
return resolve(getDefaultBulkwriteResult());
|
||
|
|
}
|
||
|
|
|
||
|
|
this.$__collection.bulkWrite(validOps, options, (error, res) => {
|
||
|
|
if (error) {
|
||
|
|
if (validationErrors.length > 0) {
|
||
|
|
error.mongoose = error.mongoose || {};
|
||
|
|
error.mongoose.validationErrors = validationErrors;
|
||
|
|
}
|
||
|
|
|
||
|
|
return reject(error);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (let i = 0; i < validOpIndexes.length; ++i) {
|
||
|
|
results[validOpIndexes[i]] = null;
|
||
|
|
}
|
||
|
|
if (validationErrors.length > 0) {
|
||
|
|
if (options.throwOnValidationError) {
|
||
|
|
return reject(new MongooseBulkWriteError(
|
||
|
|
validationErrors,
|
||
|
|
results,
|
||
|
|
res,
|
||
|
|
'bulkWrite'
|
||
|
|
));
|
||
|
|
} else {
|
||
|
|
res.mongoose = res.mongoose || {};
|
||
|
|
res.mongoose.validationErrors = validationErrors;
|
||
|
|
res.mongoose.results = results;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
resolve(res);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* takes an array of documents, gets the changes and inserts/updates documents in the database
|
||
|
|
* according to whether or not the document is new, or whether it has changes or not.
|
||
|
|
*
|
||
|
|
* `bulkSave` uses `bulkWrite` under the hood, so it's mostly useful when dealing with many documents (10K+)
|
||
|
|
*
|
||
|
|
* @param {Array<Document>} documents
|
||
|
|
* @param {Object} [options] options passed to the underlying `bulkWrite()`
|
||
|
|
* @param {Boolean} [options.timestamps] defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
|
||
|
|
* @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
|
||
|
|
* @param {String|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
|
||
|
|
* @param {number} [options.wtimeout=null] The [write concern timeout](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout).
|
||
|
|
* @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
Model.bulkSave = async function bulkSave(documents, options) {
|
||
|
|
options = options || {};
|
||
|
|
|
||
|
|
if (options.timestamps != null) {
|
||
|
|
for (const document of documents) {
|
||
|
|
document.$__.saveOptions = document.$__.saveOptions || {};
|
||
|
|
document.$__.saveOptions.timestamps = options.timestamps;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (const document of documents) {
|
||
|
|
if (document.$__.timestamps != null) {
|
||
|
|
document.$__.saveOptions = document.$__.saveOptions || {};
|
||
|
|
document.$__.saveOptions.timestamps = document.$__.timestamps;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
await Promise.all(documents.map(buildPreSavePromise));
|
||
|
|
|
||
|
|
const writeOperations = this.buildBulkWriteOperations(documents, { skipValidation: true, timestamps: options.timestamps });
|
||
|
|
|
||
|
|
const { bulkWriteResult, bulkWriteError } = await this.bulkWrite(writeOperations, options).then(
|
||
|
|
(res) => ({ bulkWriteResult: res, bulkWriteError: null }),
|
||
|
|
(err) => ({ bulkWriteResult: null, bulkWriteError: err })
|
||
|
|
);
|
||
|
|
|
||
|
|
await Promise.all(
|
||
|
|
documents.map(async(document) => {
|
||
|
|
const documentError = bulkWriteError && bulkWriteError.writeErrors.find(writeError => {
|
||
|
|
const writeErrorDocumentId = writeError.err.op._id || writeError.err.op.q._id;
|
||
|
|
return writeErrorDocumentId.toString() === document._id.toString();
|
||
|
|
});
|
||
|
|
|
||
|
|
if (documentError == null) {
|
||
|
|
await handleSuccessfulWrite(document);
|
||
|
|
}
|
||
|
|
})
|
||
|
|
);
|
||
|
|
|
||
|
|
if (bulkWriteError && bulkWriteError.writeErrors && bulkWriteError.writeErrors.length) {
|
||
|
|
throw bulkWriteError;
|
||
|
|
}
|
||
|
|
|
||
|
|
return bulkWriteResult;
|
||
|
|
};
|
||
|
|
|
||
|
|
function buildPreSavePromise(document) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
document.schema.s.hooks.execPre('save', document, (err) => {
|
||
|
|
if (err) {
|
||
|
|
reject(err);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
function handleSuccessfulWrite(document) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
if (document.$isNew) {
|
||
|
|
_setIsNew(document, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
document.$__reset();
|
||
|
|
document.schema.s.hooks.execPost('save', document, [document], {}, (err) => {
|
||
|
|
if (err) {
|
||
|
|
reject(err);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Apply defaults to the given document or POJO.
|
||
|
|
*
|
||
|
|
* @param {Object|Document} obj object or document to apply defaults on
|
||
|
|
* @returns {Object|Document}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.applyDefaults = function applyDefaults(doc) {
|
||
|
|
if (doc.$__ != null) {
|
||
|
|
applyDefaultsHelper(doc, doc.$__.fields, doc.$__.exclude);
|
||
|
|
|
||
|
|
for (const subdoc of doc.$getAllSubdocs()) {
|
||
|
|
applyDefaults(subdoc, subdoc.$__.fields, subdoc.$__.exclude);
|
||
|
|
}
|
||
|
|
|
||
|
|
return doc;
|
||
|
|
}
|
||
|
|
|
||
|
|
applyDefaultsToPOJO(doc, this.schema);
|
||
|
|
|
||
|
|
return doc;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Cast the given POJO to the model's schema
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const Test = mongoose.model('Test', Schema({ num: Number }));
|
||
|
|
*
|
||
|
|
* const obj = Test.castObject({ num: '42' });
|
||
|
|
* obj.num; // 42 as a number
|
||
|
|
*
|
||
|
|
* Test.castObject({ num: 'not a number' }); // Throws a ValidationError
|
||
|
|
*
|
||
|
|
* @param {Object} obj object or document to cast
|
||
|
|
* @param {Object} options options passed to castObject
|
||
|
|
* @param {Boolean} options.ignoreCastErrors If set to `true` will not throw a ValidationError and only return values that were successfully cast.
|
||
|
|
* @returns {Object} POJO casted to the model's schema
|
||
|
|
* @throws {ValidationError} if casting failed for at least one path
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.castObject = function castObject(obj, options) {
|
||
|
|
options = options || {};
|
||
|
|
const ret = {};
|
||
|
|
|
||
|
|
const schema = this.schema;
|
||
|
|
const paths = Object.keys(schema.paths);
|
||
|
|
|
||
|
|
for (const path of paths) {
|
||
|
|
const schemaType = schema.path(path);
|
||
|
|
if (!schemaType || !schemaType.$isMongooseArray) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const val = get(obj, path);
|
||
|
|
pushNestedArrayPaths(paths, val, path);
|
||
|
|
}
|
||
|
|
|
||
|
|
let error = null;
|
||
|
|
|
||
|
|
for (const path of paths) {
|
||
|
|
const schemaType = schema.path(path);
|
||
|
|
if (schemaType == null) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
let val = get(obj, path, void 0);
|
||
|
|
|
||
|
|
if (val == null) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
|
||
|
|
let cur = ret;
|
||
|
|
for (let i = 0; i < pieces.length - 1; ++i) {
|
||
|
|
if (cur[pieces[i]] == null) {
|
||
|
|
cur[pieces[i]] = isNaN(pieces[i + 1]) ? {} : [];
|
||
|
|
}
|
||
|
|
cur = cur[pieces[i]];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (schemaType.$isMongooseDocumentArray) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) {
|
||
|
|
try {
|
||
|
|
val = Model.castObject.call(schemaType.caster, val);
|
||
|
|
} catch (err) {
|
||
|
|
if (!options.ignoreCastErrors) {
|
||
|
|
error = error || new ValidationError();
|
||
|
|
error.addError(path, err);
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
cur[pieces[pieces.length - 1]] = val;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
val = schemaType.cast(val);
|
||
|
|
cur[pieces[pieces.length - 1]] = val;
|
||
|
|
} catch (err) {
|
||
|
|
if (!options.ignoreCastErrors) {
|
||
|
|
error = error || new ValidationError();
|
||
|
|
error.addError(path, err);
|
||
|
|
}
|
||
|
|
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (error != null) {
|
||
|
|
throw error;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Build bulk write operations for `bulkSave()`.
|
||
|
|
*
|
||
|
|
* @param {Array<Document>} documents The array of documents to build write operations of
|
||
|
|
* @param {Object} options
|
||
|
|
* @param {Boolean} options.skipValidation defaults to `false`, when set to true, building the write operations will bypass validating the documents.
|
||
|
|
* @param {Boolean} options.timestamps defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
|
||
|
|
* @return {Array<Promise>} Returns a array of all Promises the function executes to be awaited.
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, options) {
|
||
|
|
if (!Array.isArray(documents)) {
|
||
|
|
throw new Error(`bulkSave expects an array of documents to be passed, received \`${documents}\` instead`);
|
||
|
|
}
|
||
|
|
|
||
|
|
setDefaultOptions();
|
||
|
|
const discriminatorKey = this.schema.options.discriminatorKey;
|
||
|
|
|
||
|
|
const writeOperations = documents.reduce((accumulator, document, i) => {
|
||
|
|
if (!options.skipValidation) {
|
||
|
|
if (!(document instanceof Document)) {
|
||
|
|
throw new Error(`documents.${i} was not a mongoose document, documents must be an array of mongoose documents (instanceof mongoose.Document).`);
|
||
|
|
}
|
||
|
|
const validationError = document.validateSync();
|
||
|
|
if (validationError) {
|
||
|
|
throw validationError;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const isANewDocument = document.isNew;
|
||
|
|
if (isANewDocument) {
|
||
|
|
const writeOperation = { insertOne: { document } };
|
||
|
|
utils.injectTimestampsOption(writeOperation.insertOne, options.timestamps);
|
||
|
|
accumulator.push(writeOperation);
|
||
|
|
|
||
|
|
return accumulator;
|
||
|
|
}
|
||
|
|
|
||
|
|
const delta = document.$__delta();
|
||
|
|
const isDocumentWithChanges = delta != null && !utils.isEmptyObject(delta[0]);
|
||
|
|
|
||
|
|
if (isDocumentWithChanges) {
|
||
|
|
const where = document.$__where(delta[0]);
|
||
|
|
const changes = delta[1];
|
||
|
|
|
||
|
|
_applyCustomWhere(document, where);
|
||
|
|
|
||
|
|
// Set the discriminator key, so bulk write casting knows which
|
||
|
|
// schema to use re: gh-13907
|
||
|
|
if (document[discriminatorKey] != null && !(discriminatorKey in where)) {
|
||
|
|
where[discriminatorKey] = document[discriminatorKey];
|
||
|
|
}
|
||
|
|
|
||
|
|
document.$__version(where, delta);
|
||
|
|
const writeOperation = { updateOne: { filter: where, update: changes } };
|
||
|
|
utils.injectTimestampsOption(writeOperation.updateOne, options.timestamps);
|
||
|
|
accumulator.push(writeOperation);
|
||
|
|
|
||
|
|
return accumulator;
|
||
|
|
}
|
||
|
|
|
||
|
|
return accumulator;
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
return writeOperations;
|
||
|
|
|
||
|
|
|
||
|
|
function setDefaultOptions() {
|
||
|
|
options = options || {};
|
||
|
|
if (options.skipValidation == null) {
|
||
|
|
options.skipValidation = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
|
||
|
|
* The document returned has no paths marked as modified initially.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // hydrate previous data into a Mongoose document
|
||
|
|
* const mongooseCandy = Candy.hydrate({ _id: '54108337212ffb6d459f854c', type: 'jelly bean' });
|
||
|
|
*
|
||
|
|
* @param {Object} obj
|
||
|
|
* @param {Object|String|String[]} [projection] optional projection containing which fields should be selected for this document
|
||
|
|
* @param {Object} [options] optional options
|
||
|
|
* @param {Boolean} [options.setters=false] if true, apply schema setters when hydrating
|
||
|
|
* @return {Document} document instance
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.hydrate = function(obj, projection, options) {
|
||
|
|
_checkContext(this, 'hydrate');
|
||
|
|
|
||
|
|
if (projection != null) {
|
||
|
|
if (obj != null && obj.$__ != null) {
|
||
|
|
obj = obj.toObject(internalToObjectOptions);
|
||
|
|
}
|
||
|
|
obj = applyProjection(obj, projection);
|
||
|
|
}
|
||
|
|
|
||
|
|
const document = require('./queryHelpers').createModel(this, obj, projection);
|
||
|
|
document.$init(obj, options);
|
||
|
|
return document;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Same as `updateOne()`, except MongoDB will update _all_ documents that match
|
||
|
|
* `filter` (as opposed to just the first one) regardless of the value of
|
||
|
|
* the `multi` option.
|
||
|
|
*
|
||
|
|
* **Note** updateMany will _not_ fire update middleware. Use `pre('updateMany')`
|
||
|
|
* and `post('updateMany')` instead.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const res = await Person.updateMany({ name: /Stark$/ }, { isDeleted: true });
|
||
|
|
* res.matchedCount; // Number of documents matched
|
||
|
|
* res.modifiedCount; // Number of documents modified
|
||
|
|
* res.acknowledged; // Boolean indicating everything went smoothly.
|
||
|
|
* res.upsertedId; // null or an id containing a document that had to be upserted.
|
||
|
|
* res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `updateMany()`
|
||
|
|
*
|
||
|
|
* @param {Object} filter
|
||
|
|
* @param {Object|Array} update
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
|
||
|
|
* @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Query docs https://mongoosejs.com/docs/queries.html
|
||
|
|
* @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output
|
||
|
|
* @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.updateMany = function updateMany(conditions, doc, options) {
|
||
|
|
_checkContext(this, 'updateMany');
|
||
|
|
|
||
|
|
return _update(this, 'updateMany', conditions, doc, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Update _only_ the first document that matches `filter`.
|
||
|
|
*
|
||
|
|
* - Use `replaceOne()` if you want to overwrite an entire document rather than using atomic operators like `$set`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const res = await Person.updateOne({ name: 'Jean-Luc Picard' }, { ship: 'USS Enterprise' });
|
||
|
|
* res.matchedCount; // Number of documents matched
|
||
|
|
* res.modifiedCount; // Number of documents modified
|
||
|
|
* res.acknowledged; // Boolean indicating everything went smoothly.
|
||
|
|
* res.upsertedId; // null or an id containing a document that had to be upserted.
|
||
|
|
* res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `updateOne()`
|
||
|
|
*
|
||
|
|
* @param {Object} filter
|
||
|
|
* @param {Object|Array} update
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
|
||
|
|
* @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Query docs https://mongoosejs.com/docs/queries.html
|
||
|
|
* @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output
|
||
|
|
* @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.updateOne = function updateOne(conditions, doc, options) {
|
||
|
|
_checkContext(this, 'updateOne');
|
||
|
|
|
||
|
|
return _update(this, 'updateOne', conditions, doc, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Replace the existing document with the given document (no atomic operators like `$set`).
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const res = await Person.replaceOne({ _id: 24601 }, { name: 'Jean Valjean' });
|
||
|
|
* res.matchedCount; // Number of documents matched
|
||
|
|
* res.modifiedCount; // Number of documents modified
|
||
|
|
* res.acknowledged; // Boolean indicating everything went smoothly.
|
||
|
|
* res.upsertedId; // null or an id containing a document that had to be upserted.
|
||
|
|
* res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `replaceOne()`
|
||
|
|
*
|
||
|
|
* @param {Object} filter
|
||
|
|
* @param {Object} doc
|
||
|
|
* @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
|
||
|
|
* @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
|
||
|
|
* @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
|
||
|
|
* @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
|
||
|
|
* @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
|
||
|
|
* @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
|
||
|
|
* @return {Query}
|
||
|
|
* @see Query docs https://mongoosejs.com/docs/queries.html
|
||
|
|
* @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
|
||
|
|
* @return {Query}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.replaceOne = function replaceOne(conditions, doc, options) {
|
||
|
|
_checkContext(this, 'replaceOne');
|
||
|
|
|
||
|
|
const versionKey = this && this.schema && this.schema.options && this.schema.options.versionKey || null;
|
||
|
|
if (versionKey && !doc[versionKey]) {
|
||
|
|
doc[versionKey] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return _update(this, 'replaceOne', conditions, doc, options);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Common code for `updateOne()`, `updateMany()`, `replaceOne()`, and `update()`
|
||
|
|
* because they need to do the same thing
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _update(model, op, conditions, doc, options) {
|
||
|
|
const mq = new model.Query({}, {}, model, model.collection);
|
||
|
|
|
||
|
|
// gh-2406
|
||
|
|
// make local deep copy of conditions
|
||
|
|
if (conditions instanceof Document) {
|
||
|
|
conditions = conditions.toObject();
|
||
|
|
} else {
|
||
|
|
conditions = clone(conditions);
|
||
|
|
}
|
||
|
|
options = typeof options === 'function' ? options : clone(options);
|
||
|
|
|
||
|
|
const versionKey = model &&
|
||
|
|
model.schema &&
|
||
|
|
model.schema.options &&
|
||
|
|
model.schema.options.versionKey || null;
|
||
|
|
decorateUpdateWithVersionKey(doc, options, versionKey);
|
||
|
|
|
||
|
|
return mq[op](conditions, doc, options);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Performs [aggregations](https://www.mongodb.com/docs/manual/aggregation/) on the models collection.
|
||
|
|
*
|
||
|
|
* If a `callback` is passed, the `aggregate` is executed and a `Promise` is returned. If a callback is not passed, the `aggregate` itself is returned.
|
||
|
|
*
|
||
|
|
* This function triggers the following middleware.
|
||
|
|
*
|
||
|
|
* - `aggregate()`
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* // Find the max balance of all accounts
|
||
|
|
* const res = await Users.aggregate([
|
||
|
|
* { $group: { _id: null, maxBalance: { $max: '$balance' }}},
|
||
|
|
* { $project: { _id: 0, maxBalance: 1 }}
|
||
|
|
* ]);
|
||
|
|
*
|
||
|
|
* console.log(res); // [ { maxBalance: 98000 } ]
|
||
|
|
*
|
||
|
|
* // Or use the aggregation pipeline builder.
|
||
|
|
* const res = await Users.aggregate().
|
||
|
|
* group({ _id: null, maxBalance: { $max: '$balance' } }).
|
||
|
|
* project('-id maxBalance').
|
||
|
|
* exec();
|
||
|
|
* console.log(res); // [ { maxBalance: 98 } ]
|
||
|
|
*
|
||
|
|
* #### Note:
|
||
|
|
*
|
||
|
|
* - Mongoose does **not** cast aggregation pipelines to the model's schema because `$project` and `$group` operators allow redefining the "shape" of the documents at any stage of the pipeline, which may leave documents in an incompatible format. You can use the [mongoose-cast-aggregation plugin](https://github.com/AbdelrahmanHafez/mongoose-cast-aggregation) to enable minimal casting for aggregation pipelines.
|
||
|
|
* - The documents returned are plain javascript objects, not mongoose documents (since any shape of document can be returned).
|
||
|
|
*
|
||
|
|
* #### More About Aggregations:
|
||
|
|
*
|
||
|
|
* - [Mongoose `Aggregate`](https://mongoosejs.com/docs/api/aggregate.html)
|
||
|
|
* - [An Introduction to Mongoose Aggregate](https://masteringjs.io/tutorials/mongoose/aggregate)
|
||
|
|
* - [MongoDB Aggregation docs](https://www.mongodb.com/docs/manual/applications/aggregation/)
|
||
|
|
*
|
||
|
|
* @see Aggregate https://mongoosejs.com/docs/api/aggregate.html#Aggregate()
|
||
|
|
* @see MongoDB https://www.mongodb.com/docs/manual/applications/aggregation/
|
||
|
|
* @param {Array} [pipeline] aggregation pipeline as an array of objects
|
||
|
|
* @param {Object} [options] aggregation options
|
||
|
|
* @return {Aggregate}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.aggregate = function aggregate(pipeline, options) {
|
||
|
|
_checkContext(this, 'aggregate');
|
||
|
|
|
||
|
|
if (typeof options === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.aggregate() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
const aggregate = new Aggregate(pipeline || []);
|
||
|
|
aggregate.model(this);
|
||
|
|
if (options != null) {
|
||
|
|
aggregate.option(options);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof callback === 'undefined') {
|
||
|
|
return aggregate;
|
||
|
|
}
|
||
|
|
|
||
|
|
return aggregate;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Casts and validates the given object against this model's schema, passing the
|
||
|
|
* given `context` to custom validators.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const Model = mongoose.model('Test', Schema({
|
||
|
|
* name: { type: String, required: true },
|
||
|
|
* age: { type: Number, required: true }
|
||
|
|
* });
|
||
|
|
*
|
||
|
|
* try {
|
||
|
|
* await Model.validate({ name: null }, ['name'])
|
||
|
|
* } catch (err) {
|
||
|
|
* err instanceof mongoose.Error.ValidationError; // true
|
||
|
|
* Object.keys(err.errors); // ['name']
|
||
|
|
* }
|
||
|
|
*
|
||
|
|
* @param {Object} obj
|
||
|
|
* @param {Object|Array|String} pathsOrOptions
|
||
|
|
* @param {Object} [context]
|
||
|
|
* @return {Promise<Object>} casted and validated copy of `obj` if validation succeeded
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.validate = async function validate(obj, pathsOrOptions, context) {
|
||
|
|
if ((arguments.length < 3) || (arguments.length === 3 && typeof arguments[2] === 'function')) {
|
||
|
|
// For convenience, if we're validating a document or an object, make `context` default to
|
||
|
|
// the model so users don't have to always pass `context`, re: gh-10132, gh-10346
|
||
|
|
context = obj;
|
||
|
|
}
|
||
|
|
if (typeof context === 'function' || typeof arguments[3] === 'function') {
|
||
|
|
throw new MongooseError('Model.validate() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
|
||
|
|
let schema = this.schema;
|
||
|
|
const discriminatorKey = schema.options.discriminatorKey;
|
||
|
|
if (schema.discriminators != null && obj != null && obj[discriminatorKey] != null) {
|
||
|
|
schema = getSchemaDiscriminatorByValue(schema, obj[discriminatorKey]) || schema;
|
||
|
|
}
|
||
|
|
let paths = Object.keys(schema.paths);
|
||
|
|
|
||
|
|
if (pathsOrOptions != null) {
|
||
|
|
const _pathsToValidate = typeof pathsOrOptions === 'string' ? new Set(pathsOrOptions.split(' ')) : Array.isArray(pathsOrOptions) ? new Set(pathsOrOptions) : new Set(paths);
|
||
|
|
paths = paths.filter(p => {
|
||
|
|
if (pathsOrOptions.pathsToSkip) {
|
||
|
|
if (Array.isArray(pathsOrOptions.pathsToSkip)) {
|
||
|
|
if (pathsOrOptions.pathsToSkip.find(x => x == p)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else if (typeof pathsOrOptions.pathsToSkip == 'string') {
|
||
|
|
if (pathsOrOptions.pathsToSkip.includes(p)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const pieces = p.split('.');
|
||
|
|
let cur = pieces[0];
|
||
|
|
|
||
|
|
for (const piece of pieces) {
|
||
|
|
if (_pathsToValidate.has(cur)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
cur += '.' + piece;
|
||
|
|
}
|
||
|
|
|
||
|
|
return _pathsToValidate.has(p);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const path of paths) {
|
||
|
|
const schemaType = schema.path(path);
|
||
|
|
if (!schemaType || !schemaType.$isMongooseArray || schemaType.$isMongooseDocumentArray) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const val = get(obj, path);
|
||
|
|
pushNestedArrayPaths(paths, val, path);
|
||
|
|
}
|
||
|
|
|
||
|
|
let error = null;
|
||
|
|
paths = new Set(paths);
|
||
|
|
|
||
|
|
try {
|
||
|
|
obj = this.castObject(obj);
|
||
|
|
} catch (err) {
|
||
|
|
error = err;
|
||
|
|
for (const key of Object.keys(error.errors || {})) {
|
||
|
|
paths.delete(key);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let remaining = paths.size;
|
||
|
|
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
for (const path of paths) {
|
||
|
|
const schemaType = schema.path(path);
|
||
|
|
if (schemaType == null) {
|
||
|
|
_checkDone();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
|
||
|
|
let cur = obj;
|
||
|
|
for (let i = 0; i < pieces.length - 1; ++i) {
|
||
|
|
cur = cur[pieces[i]];
|
||
|
|
}
|
||
|
|
|
||
|
|
const val = get(obj, path, void 0);
|
||
|
|
|
||
|
|
schemaType.doValidate(val, err => {
|
||
|
|
if (err) {
|
||
|
|
error = error || new ValidationError();
|
||
|
|
error.addError(path, err);
|
||
|
|
}
|
||
|
|
_checkDone();
|
||
|
|
}, context, { path: path });
|
||
|
|
}
|
||
|
|
|
||
|
|
function _checkDone() {
|
||
|
|
if (--remaining <= 0) {
|
||
|
|
if (error) {
|
||
|
|
reject(error);
|
||
|
|
} else {
|
||
|
|
resolve(obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Populates document references.
|
||
|
|
*
|
||
|
|
* Changed in Mongoose 6: the model you call `populate()` on should be the
|
||
|
|
* "local field" model, **not** the "foreign field" model.
|
||
|
|
*
|
||
|
|
* #### Available top-level options:
|
||
|
|
*
|
||
|
|
* - path: space delimited path(s) to populate
|
||
|
|
* - select: optional fields to select
|
||
|
|
* - match: optional query conditions to match
|
||
|
|
* - model: optional name of the model to use for population
|
||
|
|
* - options: optional query options like sort, limit, etc
|
||
|
|
* - justOne: optional boolean, if true Mongoose will always set `path` to a document, or `null` if no document was found. If false, Mongoose will always set `path` to an array, which will be empty if no documents are found. Inferred from schema by default.
|
||
|
|
* - strictPopulate: optional boolean, set to `false` to allow populating paths that aren't in the schema.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const Dog = mongoose.model('Dog', new Schema({ name: String, breed: String }));
|
||
|
|
* const Person = mongoose.model('Person', new Schema({
|
||
|
|
* name: String,
|
||
|
|
* pet: { type: mongoose.ObjectId, ref: 'Dog' }
|
||
|
|
* }));
|
||
|
|
*
|
||
|
|
* const pets = await Pet.create([
|
||
|
|
* { name: 'Daisy', breed: 'Beagle' },
|
||
|
|
* { name: 'Einstein', breed: 'Catalan Sheepdog' }
|
||
|
|
* ]);
|
||
|
|
*
|
||
|
|
* // populate many plain objects
|
||
|
|
* const users = [
|
||
|
|
* { name: 'John Wick', dog: pets[0]._id },
|
||
|
|
* { name: 'Doc Brown', dog: pets[1]._id }
|
||
|
|
* ];
|
||
|
|
* await User.populate(users, { path: 'dog', select: 'name' });
|
||
|
|
* users[0].dog.name; // 'Daisy'
|
||
|
|
* users[0].dog.breed; // undefined because of `select`
|
||
|
|
*
|
||
|
|
* @param {Document|Array} docs Either a single document or array of documents to populate.
|
||
|
|
* @param {Object|String} options Either the paths to populate or an object specifying all parameters
|
||
|
|
* @param {string} [options.path=null] The path to populate.
|
||
|
|
* @param {string|PopulateOptions} [options.populate=null] Recursively populate paths in the populated documents. See [deep populate docs](https://mongoosejs.com/docs/populate.html#deep-populate).
|
||
|
|
* @param {boolean} [options.retainNullValues=false] By default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
|
||
|
|
* @param {boolean} [options.getters=false] If true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](https://mongoosejs.com/docs/schematypes.html#schematype-options).
|
||
|
|
* @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
|
||
|
|
* @param {Object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://www.mongodb.com/docs/manual/tutorial/query-documents/), or a function that returns a filter object.
|
||
|
|
* @param {Boolean} [options.skipInvalidIds=false] By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type.
|
||
|
|
* @param {Number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results because it only executes a single query for every document being populated. If you set `perDocumentLimit`, Mongoose will ensure correct `limit` per document by executing a separate query for each document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })` will execute 2 additional queries if `.find()` returns 2 documents.
|
||
|
|
* @param {Boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
|
||
|
|
* @param {Object} [options.options=null] Additional options like `limit` and `lean`.
|
||
|
|
* @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
|
||
|
|
* @param {Function} [callback(err,doc)] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
|
||
|
|
* @return {Promise}
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.populate = async function populate(docs, paths) {
|
||
|
|
_checkContext(this, 'populate');
|
||
|
|
if (typeof paths === 'function' || typeof arguments[2] === 'function') {
|
||
|
|
throw new MongooseError('Model.populate() no longer accepts a callback');
|
||
|
|
}
|
||
|
|
const _this = this;
|
||
|
|
// normalized paths
|
||
|
|
paths = utils.populate(paths);
|
||
|
|
// data that should persist across subPopulate calls
|
||
|
|
const cache = {};
|
||
|
|
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
_populate(_this, docs, paths, cache, (err, res) => {
|
||
|
|
if (err) {
|
||
|
|
return reject(err);
|
||
|
|
}
|
||
|
|
resolve(res);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Populate helper
|
||
|
|
*
|
||
|
|
* @param {Model} model the model to use
|
||
|
|
* @param {Document|Array} docs Either a single document or array of documents to populate.
|
||
|
|
* @param {Object} paths
|
||
|
|
* @param {never} cache Unused
|
||
|
|
* @param {Function} [callback] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
|
||
|
|
* @return {Function}
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _populate(model, docs, paths, cache, callback) {
|
||
|
|
let pending = paths.length;
|
||
|
|
if (paths.length === 0) {
|
||
|
|
return callback(null, docs);
|
||
|
|
}
|
||
|
|
// each path has its own query options and must be executed separately
|
||
|
|
for (const path of paths) {
|
||
|
|
populate(model, docs, path, next);
|
||
|
|
}
|
||
|
|
|
||
|
|
function next(err) {
|
||
|
|
if (err) {
|
||
|
|
return callback(err, null);
|
||
|
|
}
|
||
|
|
if (--pending) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
callback(null, docs);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Populates `docs`
|
||
|
|
*/
|
||
|
|
const excludeIdReg = /\s?-_id\s?/;
|
||
|
|
const excludeIdRegGlobal = /\s?-_id\s?/g;
|
||
|
|
|
||
|
|
function populate(model, docs, options, callback) {
|
||
|
|
const populateOptions = options;
|
||
|
|
if (options.strictPopulate == null) {
|
||
|
|
if (options._localModel != null && options._localModel.schema._userProvidedOptions.strictPopulate != null) {
|
||
|
|
populateOptions.strictPopulate = options._localModel.schema._userProvidedOptions.strictPopulate;
|
||
|
|
} else if (options._localModel != null && model.base.options.strictPopulate != null) {
|
||
|
|
populateOptions.strictPopulate = model.base.options.strictPopulate;
|
||
|
|
} else if (model.base.options.strictPopulate != null) {
|
||
|
|
populateOptions.strictPopulate = model.base.options.strictPopulate;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// normalize single / multiple docs passed
|
||
|
|
if (!Array.isArray(docs)) {
|
||
|
|
docs = [docs];
|
||
|
|
}
|
||
|
|
if (docs.length === 0 || docs.every(utils.isNullOrUndefined)) {
|
||
|
|
return callback();
|
||
|
|
}
|
||
|
|
|
||
|
|
const modelsMap = getModelsMapForPopulate(model, docs, populateOptions);
|
||
|
|
|
||
|
|
if (modelsMap instanceof MongooseError) {
|
||
|
|
return immediate(function() {
|
||
|
|
callback(modelsMap);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
const len = modelsMap.length;
|
||
|
|
let vals = [];
|
||
|
|
|
||
|
|
function flatten(item) {
|
||
|
|
// no need to include undefined values in our query
|
||
|
|
return undefined !== item;
|
||
|
|
}
|
||
|
|
|
||
|
|
let _remaining = len;
|
||
|
|
let hasOne = false;
|
||
|
|
const params = [];
|
||
|
|
for (let i = 0; i < len; ++i) {
|
||
|
|
const mod = modelsMap[i];
|
||
|
|
let select = mod.options.select;
|
||
|
|
let ids = utils.array.flatten(mod.ids, flatten);
|
||
|
|
ids = utils.array.unique(ids);
|
||
|
|
|
||
|
|
const assignmentOpts = {};
|
||
|
|
assignmentOpts.sort = mod &&
|
||
|
|
mod.options &&
|
||
|
|
mod.options.options &&
|
||
|
|
mod.options.options.sort || void 0;
|
||
|
|
assignmentOpts.excludeId = excludeIdReg.test(select) || (select && select._id === 0);
|
||
|
|
|
||
|
|
// Lean transform may delete `_id`, which would cause assignment
|
||
|
|
// to fail. So delay running lean transform until _after_
|
||
|
|
// `_assign()`
|
||
|
|
if (mod.options &&
|
||
|
|
mod.options.options &&
|
||
|
|
mod.options.options.lean &&
|
||
|
|
mod.options.options.lean.transform) {
|
||
|
|
mod.options.options._leanTransform = mod.options.options.lean.transform;
|
||
|
|
mod.options.options.lean = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ids.length === 0 || ids.every(utils.isNullOrUndefined)) {
|
||
|
|
// Ensure that we set to 0 or empty array even
|
||
|
|
// if we don't actually execute a query to make sure there's a value
|
||
|
|
// and we know this path was populated for future sets. See gh-7731, gh-8230
|
||
|
|
--_remaining;
|
||
|
|
_assign(model, [], mod, assignmentOpts);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
hasOne = true;
|
||
|
|
if (typeof populateOptions.foreignField === 'string') {
|
||
|
|
mod.foreignField.clear();
|
||
|
|
mod.foreignField.add(populateOptions.foreignField);
|
||
|
|
}
|
||
|
|
const match = createPopulateQueryFilter(ids, mod.match, mod.foreignField, mod.model, mod.options.skipInvalidIds);
|
||
|
|
if (assignmentOpts.excludeId) {
|
||
|
|
// override the exclusion from the query so we can use the _id
|
||
|
|
// for document matching during assignment. we'll delete the
|
||
|
|
// _id back off before returning the result.
|
||
|
|
if (typeof select === 'string') {
|
||
|
|
select = select.replace(excludeIdRegGlobal, ' ');
|
||
|
|
} else {
|
||
|
|
// preserve original select conditions by copying
|
||
|
|
select = { ...select };
|
||
|
|
delete select._id;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mod.options.options && mod.options.options.limit != null) {
|
||
|
|
assignmentOpts.originalLimit = mod.options.options.limit;
|
||
|
|
} else if (mod.options.limit != null) {
|
||
|
|
assignmentOpts.originalLimit = mod.options.limit;
|
||
|
|
}
|
||
|
|
params.push([mod, match, select, assignmentOpts, _next]);
|
||
|
|
}
|
||
|
|
if (!hasOne) {
|
||
|
|
// If models but no docs, skip further deep populate.
|
||
|
|
if (modelsMap.length !== 0) {
|
||
|
|
return callback();
|
||
|
|
}
|
||
|
|
// If no models to populate but we have a nested populate,
|
||
|
|
// keep trying, re: gh-8946
|
||
|
|
if (populateOptions.populate != null) {
|
||
|
|
const opts = utils.populate(populateOptions.populate).map(pop => Object.assign({}, pop, {
|
||
|
|
path: populateOptions.path + '.' + pop.path
|
||
|
|
}));
|
||
|
|
model.populate(docs, opts).then(res => { callback(null, res); }, err => { callback(err); });
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return callback();
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const arr of params) {
|
||
|
|
_execPopulateQuery.apply(null, arr);
|
||
|
|
}
|
||
|
|
function _next(err, valsFromDb) {
|
||
|
|
if (err != null) {
|
||
|
|
return callback(err, null);
|
||
|
|
}
|
||
|
|
vals = vals.concat(valsFromDb);
|
||
|
|
if (--_remaining === 0) {
|
||
|
|
_done();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function _done() {
|
||
|
|
for (const arr of params) {
|
||
|
|
const mod = arr[0];
|
||
|
|
const assignmentOpts = arr[3];
|
||
|
|
for (const val of vals) {
|
||
|
|
mod.options._childDocs.push(val);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
_assign(model, vals, mod, assignmentOpts);
|
||
|
|
} catch (err) {
|
||
|
|
return callback(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const arr of params) {
|
||
|
|
removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
|
||
|
|
}
|
||
|
|
for (const arr of params) {
|
||
|
|
const mod = arr[0];
|
||
|
|
if (mod.options && mod.options.options && mod.options.options._leanTransform) {
|
||
|
|
for (const doc of vals) {
|
||
|
|
mod.options.options._leanTransform(doc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
callback();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _execPopulateQuery(mod, match, select, assignmentOpts, callback) {
|
||
|
|
let subPopulate = clone(mod.options.populate);
|
||
|
|
const queryOptions = Object.assign({
|
||
|
|
skip: mod.options.skip,
|
||
|
|
limit: mod.options.limit,
|
||
|
|
perDocumentLimit: mod.options.perDocumentLimit
|
||
|
|
}, mod.options.options);
|
||
|
|
|
||
|
|
if (mod.count) {
|
||
|
|
delete queryOptions.skip;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (queryOptions.perDocumentLimit != null) {
|
||
|
|
queryOptions.limit = queryOptions.perDocumentLimit;
|
||
|
|
delete queryOptions.perDocumentLimit;
|
||
|
|
} else if (queryOptions.limit != null) {
|
||
|
|
queryOptions.limit = queryOptions.limit * mod.ids.length;
|
||
|
|
}
|
||
|
|
|
||
|
|
const query = mod.model.find(match, select, queryOptions);
|
||
|
|
// If we're doing virtual populate and projection is inclusive and foreign
|
||
|
|
// field is not selected, automatically select it because mongoose needs it.
|
||
|
|
// If projection is exclusive and client explicitly unselected the foreign
|
||
|
|
// field, that's the client's fault.
|
||
|
|
for (const foreignField of mod.foreignField) {
|
||
|
|
if (foreignField !== '_id' &&
|
||
|
|
query.selectedInclusively() &&
|
||
|
|
!isPathSelectedInclusive(query._fields, foreignField)) {
|
||
|
|
query.select(foreignField);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If using count, still need the `foreignField` so we can match counts
|
||
|
|
// to documents, otherwise we would need a separate `count()` for every doc.
|
||
|
|
if (mod.count) {
|
||
|
|
for (const foreignField of mod.foreignField) {
|
||
|
|
query.select(foreignField);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If we need to sub-populate, call populate recursively
|
||
|
|
if (subPopulate) {
|
||
|
|
// If subpopulating on a discriminator, skip check for non-existent
|
||
|
|
// paths. Because the discriminator may not have the path defined.
|
||
|
|
if (mod.model.baseModelName != null) {
|
||
|
|
if (Array.isArray(subPopulate)) {
|
||
|
|
subPopulate.forEach(pop => { pop.strictPopulate = false; });
|
||
|
|
} else if (typeof subPopulate === 'string') {
|
||
|
|
subPopulate = { path: subPopulate, strictPopulate: false };
|
||
|
|
} else {
|
||
|
|
subPopulate.strictPopulate = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const basePath = mod.options._fullPath || mod.options.path;
|
||
|
|
|
||
|
|
if (Array.isArray(subPopulate)) {
|
||
|
|
for (const pop of subPopulate) {
|
||
|
|
pop._fullPath = basePath + '.' + pop.path;
|
||
|
|
}
|
||
|
|
} else if (typeof subPopulate === 'object') {
|
||
|
|
subPopulate._fullPath = basePath + '.' + subPopulate.path;
|
||
|
|
}
|
||
|
|
|
||
|
|
query.populate(subPopulate);
|
||
|
|
}
|
||
|
|
|
||
|
|
query.exec().then(
|
||
|
|
docs => {
|
||
|
|
for (const val of docs) {
|
||
|
|
leanPopulateMap.set(val, mod.model);
|
||
|
|
}
|
||
|
|
callback(null, docs);
|
||
|
|
},
|
||
|
|
err => {
|
||
|
|
callback(err);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* ignore
|
||
|
|
*/
|
||
|
|
|
||
|
|
function _assign(model, vals, mod, assignmentOpts) {
|
||
|
|
const options = mod.options;
|
||
|
|
const isVirtual = mod.isVirtual;
|
||
|
|
const justOne = mod.justOne;
|
||
|
|
let _val;
|
||
|
|
const lean = options &&
|
||
|
|
options.options &&
|
||
|
|
options.options.lean || false;
|
||
|
|
const len = vals.length;
|
||
|
|
const rawOrder = {};
|
||
|
|
const rawDocs = {};
|
||
|
|
let key;
|
||
|
|
let val;
|
||
|
|
|
||
|
|
// Clone because `assignRawDocsToIdStructure` will mutate the array
|
||
|
|
const allIds = clone(mod.allIds);
|
||
|
|
// optimization:
|
||
|
|
// record the document positions as returned by
|
||
|
|
// the query result.
|
||
|
|
for (let i = 0; i < len; i++) {
|
||
|
|
val = vals[i];
|
||
|
|
if (val == null) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
for (const foreignField of mod.foreignField) {
|
||
|
|
_val = utils.getValue(foreignField, val);
|
||
|
|
if (Array.isArray(_val)) {
|
||
|
|
_val = utils.array.unique(utils.array.flatten(_val));
|
||
|
|
|
||
|
|
for (let __val of _val) {
|
||
|
|
if (__val instanceof Document) {
|
||
|
|
__val = __val._id;
|
||
|
|
}
|
||
|
|
key = String(__val);
|
||
|
|
if (rawDocs[key]) {
|
||
|
|
if (Array.isArray(rawDocs[key])) {
|
||
|
|
rawDocs[key].push(val);
|
||
|
|
rawOrder[key].push(i);
|
||
|
|
} else {
|
||
|
|
rawDocs[key] = [rawDocs[key], val];
|
||
|
|
rawOrder[key] = [rawOrder[key], i];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (isVirtual && !justOne) {
|
||
|
|
rawDocs[key] = [val];
|
||
|
|
rawOrder[key] = [i];
|
||
|
|
} else {
|
||
|
|
rawDocs[key] = val;
|
||
|
|
rawOrder[key] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (_val instanceof Document) {
|
||
|
|
_val = _val._id;
|
||
|
|
}
|
||
|
|
key = String(_val);
|
||
|
|
if (rawDocs[key]) {
|
||
|
|
if (Array.isArray(rawDocs[key])) {
|
||
|
|
rawDocs[key].push(val);
|
||
|
|
rawOrder[key].push(i);
|
||
|
|
} else if (isVirtual ||
|
||
|
|
rawDocs[key].constructor !== val.constructor ||
|
||
|
|
String(rawDocs[key]._id) !== String(val._id)) {
|
||
|
|
// May need to store multiple docs with the same id if there's multiple models
|
||
|
|
// if we have discriminators or a ref function. But avoid converting to an array
|
||
|
|
// if we have multiple queries on the same model because of `perDocumentLimit` re: gh-9906
|
||
|
|
rawDocs[key] = [rawDocs[key], val];
|
||
|
|
rawOrder[key] = [rawOrder[key], i];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
rawDocs[key] = val;
|
||
|
|
rawOrder[key] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// flag each as result of population
|
||
|
|
if (!lean) {
|
||
|
|
val.$__.wasPopulated = val.$__.wasPopulated || true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
assignVals({
|
||
|
|
originalModel: model,
|
||
|
|
// If virtual, make sure to not mutate original field
|
||
|
|
rawIds: mod.isVirtual ? allIds : mod.allIds,
|
||
|
|
allIds: allIds,
|
||
|
|
unpopulatedValues: mod.unpopulatedValues,
|
||
|
|
foreignField: mod.foreignField,
|
||
|
|
rawDocs: rawDocs,
|
||
|
|
rawOrder: rawOrder,
|
||
|
|
docs: mod.docs,
|
||
|
|
path: options.path,
|
||
|
|
options: assignmentOpts,
|
||
|
|
justOne: mod.justOne,
|
||
|
|
isVirtual: mod.isVirtual,
|
||
|
|
allOptions: mod,
|
||
|
|
populatedModel: mod.model,
|
||
|
|
lean: lean,
|
||
|
|
virtual: mod.virtual,
|
||
|
|
count: mod.count,
|
||
|
|
match: mod.match
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Compiler utility.
|
||
|
|
*
|
||
|
|
* @param {String|Function} name model name or class extending Model
|
||
|
|
* @param {Schema} schema
|
||
|
|
* @param {String} collectionName
|
||
|
|
* @param {Connection} connection
|
||
|
|
* @param {Mongoose} base mongoose instance
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.compile = function compile(name, schema, collectionName, connection, base) {
|
||
|
|
const versioningEnabled = schema.options.versionKey !== false;
|
||
|
|
|
||
|
|
if (versioningEnabled && !schema.paths[schema.options.versionKey]) {
|
||
|
|
// add versioning to top level documents only
|
||
|
|
const o = {};
|
||
|
|
o[schema.options.versionKey] = Number;
|
||
|
|
schema.add(o);
|
||
|
|
}
|
||
|
|
let model;
|
||
|
|
if (typeof name === 'function' && name.prototype instanceof Model) {
|
||
|
|
model = name;
|
||
|
|
name = model.name;
|
||
|
|
schema.loadClass(model, false);
|
||
|
|
model.prototype.$isMongooseModelPrototype = true;
|
||
|
|
} else {
|
||
|
|
// generate new class
|
||
|
|
model = function model(doc, fields, skipId) {
|
||
|
|
model.hooks.execPreSync('createModel', doc);
|
||
|
|
if (!(this instanceof model)) {
|
||
|
|
return new model(doc, fields, skipId);
|
||
|
|
}
|
||
|
|
const discriminatorKey = model.schema.options.discriminatorKey;
|
||
|
|
|
||
|
|
if (model.discriminators == null || doc == null || doc[discriminatorKey] == null) {
|
||
|
|
Model.call(this, doc, fields, skipId);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If discriminator key is set, use the discriminator instead (gh-7586)
|
||
|
|
const Discriminator = model.discriminators[doc[discriminatorKey]] ||
|
||
|
|
getDiscriminatorByValue(model.discriminators, doc[discriminatorKey]);
|
||
|
|
if (Discriminator != null) {
|
||
|
|
return new Discriminator(doc, fields, skipId);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, just use the top-level model
|
||
|
|
Model.call(this, doc, fields, skipId);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
model.hooks = schema.s.hooks.clone();
|
||
|
|
model.base = base;
|
||
|
|
model.modelName = name;
|
||
|
|
|
||
|
|
if (!(model.prototype instanceof Model)) {
|
||
|
|
Object.setPrototypeOf(model, Model);
|
||
|
|
Object.setPrototypeOf(model.prototype, Model.prototype);
|
||
|
|
}
|
||
|
|
model.model = function model(name) {
|
||
|
|
return this.db.model(name);
|
||
|
|
};
|
||
|
|
|
||
|
|
model.db = connection;
|
||
|
|
model.prototype.db = connection;
|
||
|
|
model.prototype[modelDbSymbol] = connection;
|
||
|
|
model.discriminators = model.prototype.discriminators = undefined;
|
||
|
|
model[modelSymbol] = true;
|
||
|
|
model.events = new EventEmitter();
|
||
|
|
|
||
|
|
schema._preCompile();
|
||
|
|
|
||
|
|
const _userProvidedOptions = schema._userProvidedOptions || {};
|
||
|
|
|
||
|
|
const collectionOptions = {
|
||
|
|
schemaUserProvidedOptions: _userProvidedOptions,
|
||
|
|
capped: schema.options.capped,
|
||
|
|
Promise: model.base.Promise,
|
||
|
|
modelName: name
|
||
|
|
};
|
||
|
|
if (schema.options.autoCreate !== void 0) {
|
||
|
|
collectionOptions.autoCreate = schema.options.autoCreate;
|
||
|
|
}
|
||
|
|
|
||
|
|
const collection = connection.collection(
|
||
|
|
collectionName,
|
||
|
|
collectionOptions
|
||
|
|
);
|
||
|
|
|
||
|
|
model.prototype.collection = collection;
|
||
|
|
model.prototype.$collection = collection;
|
||
|
|
model.prototype[modelCollectionSymbol] = collection;
|
||
|
|
|
||
|
|
model.prototype.$__setSchema(schema);
|
||
|
|
|
||
|
|
// apply methods and statics
|
||
|
|
applyMethods(model, schema);
|
||
|
|
applyStatics(model, schema);
|
||
|
|
applyHooks(model, schema);
|
||
|
|
applyStaticHooks(model, schema.s.hooks, schema.statics);
|
||
|
|
|
||
|
|
model.schema = model.prototype.$__schema;
|
||
|
|
model.collection = collection;
|
||
|
|
model.$__collection = collection;
|
||
|
|
|
||
|
|
// Create custom query constructor
|
||
|
|
model.Query = function() {
|
||
|
|
Query.apply(this, arguments);
|
||
|
|
};
|
||
|
|
Object.setPrototypeOf(model.Query.prototype, Query.prototype);
|
||
|
|
model.Query.base = Query.base;
|
||
|
|
model.Query.prototype.constructor = Query;
|
||
|
|
applyQueryMiddleware(model.Query, model);
|
||
|
|
applyQueryMethods(model, schema.query);
|
||
|
|
|
||
|
|
return model;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Register custom query methods for this model
|
||
|
|
*
|
||
|
|
* @param {Model} model
|
||
|
|
* @param {Schema} schema
|
||
|
|
* @api private
|
||
|
|
*/
|
||
|
|
|
||
|
|
function applyQueryMethods(model, methods) {
|
||
|
|
for (const i in methods) {
|
||
|
|
model.Query.prototype[i] = methods[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Subclass this model with `conn`, `schema`, and `collection` settings.
|
||
|
|
*
|
||
|
|
* @param {Connection} conn
|
||
|
|
* @param {Schema} [schema]
|
||
|
|
* @param {String} [collection]
|
||
|
|
* @return {Model}
|
||
|
|
* @api private
|
||
|
|
* @memberOf Model
|
||
|
|
* @static
|
||
|
|
* @method __subclass
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.__subclass = function subclass(conn, schema, collection) {
|
||
|
|
// subclass model using this connection and collection name
|
||
|
|
const _this = this;
|
||
|
|
|
||
|
|
const Model = function Model(doc, fields, skipId) {
|
||
|
|
if (!(this instanceof Model)) {
|
||
|
|
return new Model(doc, fields, skipId);
|
||
|
|
}
|
||
|
|
_this.call(this, doc, fields, skipId);
|
||
|
|
};
|
||
|
|
|
||
|
|
Object.setPrototypeOf(Model, _this);
|
||
|
|
Object.setPrototypeOf(Model.prototype, _this.prototype);
|
||
|
|
Model.db = conn;
|
||
|
|
Model.prototype.db = conn;
|
||
|
|
Model.prototype[modelDbSymbol] = conn;
|
||
|
|
|
||
|
|
_this[subclassedSymbol] = _this[subclassedSymbol] || [];
|
||
|
|
_this[subclassedSymbol].push(Model);
|
||
|
|
if (_this.discriminators != null) {
|
||
|
|
Model.discriminators = {};
|
||
|
|
for (const key of Object.keys(_this.discriminators)) {
|
||
|
|
Model.discriminators[key] = _this.discriminators[key].
|
||
|
|
__subclass(_this.db, _this.discriminators[key].schema, collection);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const s = schema && typeof schema !== 'string'
|
||
|
|
? schema
|
||
|
|
: _this.prototype.$__schema;
|
||
|
|
|
||
|
|
const options = s.options || {};
|
||
|
|
const _userProvidedOptions = s._userProvidedOptions || {};
|
||
|
|
|
||
|
|
if (!collection) {
|
||
|
|
collection = _this.prototype.$__schema.get('collection') ||
|
||
|
|
utils.toCollectionName(_this.modelName, this.base.pluralize());
|
||
|
|
}
|
||
|
|
|
||
|
|
const collectionOptions = {
|
||
|
|
schemaUserProvidedOptions: _userProvidedOptions,
|
||
|
|
capped: s && options.capped
|
||
|
|
};
|
||
|
|
|
||
|
|
Model.prototype.collection = conn.collection(collection, collectionOptions);
|
||
|
|
Model.prototype.$collection = Model.prototype.collection;
|
||
|
|
Model.prototype[modelCollectionSymbol] = Model.prototype.collection;
|
||
|
|
Model.collection = Model.prototype.collection;
|
||
|
|
Model.$__collection = Model.collection;
|
||
|
|
// Errors handled internally, so ignore
|
||
|
|
Model.init().catch(() => {});
|
||
|
|
return Model;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper for console.log. Given a model named 'MyModel', returns the string
|
||
|
|
* `'Model { MyModel }'`.
|
||
|
|
*
|
||
|
|
* #### Example:
|
||
|
|
*
|
||
|
|
* const MyModel = mongoose.model('Test', Schema({ name: String }));
|
||
|
|
* MyModel.inspect(); // 'Model { Test }'
|
||
|
|
* console.log(MyModel); // Prints 'Model { Test }'
|
||
|
|
*
|
||
|
|
* @api public
|
||
|
|
*/
|
||
|
|
|
||
|
|
Model.inspect = function() {
|
||
|
|
return `Model { ${this.modelName} }`;
|
||
|
|
};
|
||
|
|
|
||
|
|
if (util.inspect.custom) {
|
||
|
|
// Avoid Node deprecation warning DEP0079
|
||
|
|
Model[util.inspect.custom] = Model.inspect;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Module exports.
|
||
|
|
*/
|
||
|
|
|
||
|
|
module.exports = exports = Model;
|