/*!

* Module dependencies.

*/

var Aggregate = require('./aggregate');

var Document = require('./document');

var DocumentNotFoundError = require('./error').DocumentNotFoundError;

var DivergentArrayError = require('./error').DivergentArrayError;

var Error = require('./error');

var EventEmitter = require('events').EventEmitter;

var OverwriteModelError = require('./error').OverwriteModelError;

var PromiseProvider = require('./promise_provider');

var Query = require('./query');

var Schema = require('./schema');

var VersionError = require('./error').VersionError;

var applyHooks = require('./services/model/applyHooks');

var applyMethods = require('./services/model/applyMethods');

var applyStatics = require('./services/model/applyStatics');

var cast = require('./cast');

var castUpdate = require('./services/query/castUpdate');

var discriminator = require('./services/model/discriminator');

var isPathSelectedInclusive = require('./services/projection/isPathSelectedInclusive');

var get = require('lodash.get');

var mpath = require('mpath');

var parallel = require('async/parallel');

var parallelLimit = require('async/parallelLimit');

var setDefaultsOnInsert = require('./services/setDefaultsOnInsert');

var util = require('util');

var utils = require('./utils');

var VERSION_WHERE = 1,

VERSION_INC = 2,

VERSION_ALL = VERSION_WHERE | VERSION_INC;

/**

* Model constructor

*

* Provides the interface to MongoDB collections as well as creates document instances.

*

* @param {Object} doc values with which to create the document

* @inherits Document http://mongoosejs.com/docs/api.html#document-js

* @event `error`: If listening to this event, 'error' is emitted when a document was saved without passing a callback 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, true);

}

/*!

* Inherits from Document.

*

* All Model.prototype features are available on

* top level (non-sub) documents.

*/

Model.prototype.__proto__ = Document.prototype;

Model.prototype.$isMongooseModelPrototype = true;

/**

* Connection the model uses.

*

* @api public

* @property db

*/

Model.prototype.db;

/**

* Collection the model uses.

*

* @api public

* @property collection

*/

Model.prototype.collection;

/**

* The name of the model

*

* @api public

* @property modelName

*/

Model.prototype.modelName;

/**

* Additional properties to attach to the query when calling `save()` and

* `isNew` is false.

*

* @api public

* @property $where

*/

Model.prototype.$where;

/**

* If this is a discriminator model, `baseModelName` is the name of

* the base model.

*

* @api public

* @property baseModelName

*/

Model.prototype.baseModelName;

Model.prototype.$__handleSave = function(options, callback) {

var _this = this;

var i;

var keys;

var len;

if (!options.safe && this.schema.options.safe) {

options.safe = this.schema.options.safe;

}

if (typeof options.safe === 'boolean') {

options.safe = null;

}

var safe = options.safe ? utils.clone(options.safe, { retainKeyOrder: true }) : options.safe;

if (this.isNew) {

// send entire doc

var toObjectOptions = {};

toObjectOptions.retainKeyOrder = this.schema.options.retainKeyOrder;

toObjectOptions.depopulate = 1;

toObjectOptions._skipDepopulateTopLevel = true;

toObjectOptions.transform = false;

toObjectOptions.flattenDecimals = false;

var obj = this.toObject(toObjectOptions);

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 my mongodb necessarily

// match the schema definition.

setTimeout(function() {

callback(new Error('document must have an _id before saving'));

}, 0);

return;

}

this.$__version(true, obj);

this.collection.insert(obj, safe, function(err, ret) {

if (err) {

_this.isNew = true;

_this.emit('isNew', true);

_this.constructor.emit('isNew', true);

callback(err);

return;

}

callback(null, ret);

});

this.$__reset();

this.isNew = false;

this.emit('isNew', false);

this.constructor.emit('isNew', false);

// Make it possible to retry the insert

this.$__.inserting = true;

} else {

// Make sure we don't treat it as a new object on error,

// since it already exists

this.$__.inserting = false;

var delta = this.$__delta();

if (delta) {

if (delta instanceof Error) {

callback(delta);

return;

}

var where = this.$__where(delta[0]);

if (where instanceof Error) {

callback(where);

return;

}

if (this.$where) {

keys = Object.keys(this.$where);

len = keys.length;

for (i = 0; i < len; ++i) {

where[keys[i]] = this.$where[keys[i]];

}

}

this.collection.update(where, delta[1], safe, function(err, ret) {

if (err) {

callback(err);

return;

}

ret.$where = where;

callback(null, ret);

});

} else {

this.$__reset();

callback();

return;

}

this.emit('isNew', false);

this.constructor.emit('isNew', false);

}

};

/*!

* ignore

*/

Model.prototype.$__save = function(options, callback) {

var _this = this;

_this.$__handleSave(options, function(error, result) {

if (error) {

return _this.schema.s.hooks.execPost('save:error', _this, [_this], { error: error }, function(error) {

callback(error);

});

}

_this.$__reset();

var numAffected = 0;

if (result) {

if (Array.isArray(result)) {

numAffected = result.length;

} else if (result.result && result.result.n !== undefined) {

numAffected = result.result.n;

} else if (result.result && result.result.nModified !== undefined) {

numAffected = result.result.nModified;

} else {

numAffected = result;

}

}

if (_this.schema.options &&

_this.schema.options.saveErrorIfNotFound &&

numAffected <= 0) {

error = new DocumentNotFoundError(result.$where);

return _this.schema.s.hooks.execPost('save:error', _this, [_this], { error: error }, function(error) {

callback(error);

});

}

// was this an update that required a version bump?

if (_this.$__.version && !_this.$__.inserting) {

var doIncrement = VERSION_INC === (VERSION_INC & _this.$__.version);

_this.$__.version = undefined;

if (numAffected <= 0) {

// the update failed. pass an error back

var err = new VersionError(_this);

return callback(err);

}

// increment version if was successful

if (doIncrement) {

var key = _this.schema.options.versionKey;

var version = _this.getValue(key) | 0;

_this.setValue(key, version + 1);

}

}

_this.emit('save', _this, numAffected);

_this.constructor.emit('save', _this, numAffected);

callback(null, _this, numAffected);

});

};

/**

* Saves this document.

*

* ####Example:

*

* product.sold = Date.now();

* product.save(function (err, product, numAffected) {

* if (err) ..

* })

*

* The callback will receive three parameters

*

* 1. `err` if an error occurred

* 2. `product` which is the saved `product`

* 3. `numAffected` will be 1 when the document was successfully persisted to MongoDB, otherwise 0. Unless you tweak mongoose's internals, you don't need to worry about checking this parameter for errors - checking `err` is sufficient to make sure your document was properly saved.

*

* As an extra measure of flow control, save will return a Promise.

* ####Example:

* product.save().then(function(product) {

* ...

* });

*

* For legacy reasons, mongoose stores object keys in reverse order on initial

* save. That is, `{ a: 1, b: 2 }` will be saved as `{ b: 2, a: 1 }` in

* MongoDB. To override this behavior, set

* [the `toObject.retainKeyOrder` option](http://mongoosejs.com/docs/api.html#document_Document-toObject)

* to true on your schema.

*

* @param {Object} [options] options optional options

* @param {Object} [options.safe] overrides [schema's safe option](http://mongoosejs.com//docs/guide.html#safe)

* @param {Boolean} [options.validateBeforeSave] set to false to save without validating.

* @param {Function} [fn] optional callback

* @return {Promise} Promise

* @api public

* @see middleware http://mongoosejs.com/docs/middleware.html

*/

Model.prototype.save = function(options, fn) {

if (typeof options === 'function') {

fn = options;

options = undefined;

}

if (!options) {

options = {};

}

if (fn) {

fn = this.constructor.$wrapCallback(fn);

}

return this.$__save(options, fn);

};

/*!

* 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

*/

function shouldSkipVersioning(self, path) {

var 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

* @param {Object} delta

* @param {Object} data

* @param {Mixed} val

* @param {String} [operation]

*/

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;

switch (op) {

case '$set':

case '$unset':

case '$pop':

case '$pull':

case '$pullAll':

case '$push':

case '$pushAll':

case '$addToSet':

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 === '$pushAll' || op === '$addToSet') {

self.$__.version = VERSION_INC;

} else if (/^\$p/.test(op)) {

// potentially changing array positions

self.increment();

} else if (Array.isArray(val)) {

// $set an array

self.increment();

} 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

*/

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) {

var op = atomic[0];

var val = atomic[1];

if (self.schema.options.usePushEach && op === '$pushAll') {

op = '$push';

val = { $each: val };

}

operand(self, where, delta, data, val, op);

});

return;

}

// legacy support for plugins

var atomics = value._atomics,

ops = Object.keys(atomics),

i = ops.length,

val,

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

*/

Model.prototype.$__delta = function() {

var dirty = this.$__dirty();

if (!dirty.length && VERSION_ALL !== this.$__.version) return;

var where = {},

delta = {},

len = dirty.length,

divergent = [],

d = 0;

where._id = this._doc._id;

if (where._id.toObject) {

where._id = where._id.toObject({ transform: false, depopulate: true });

}

for (; d < len; ++d) {

var data = dirty[d];

var value = data.value;

var match = checkDivergentArray(this, data.path, value);

if (match) {

divergent.push(match);

continue;

}

var 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.

var pathSplit = data.path.split('.');

var 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 (divergent.length) continue;

if (undefined === value) {

operand(this, where, delta, data, 1, '$unset');

} else if (value === null) {

operand(this, where, delta, data, null);

} else if (value._path && value._atomics) {

// arrays and other custom types (support plugins etc)

handleAtomics(this, where, delta, data, value);

} else if (value._path && Buffer.isBuffer(value)) {

// MongooseBuffer

value = value.toObject();

operand(this, where, delta, data, value);

} else {

value = utils.clone(value, {depopulate: 1, _isNested: true});

operand(this, where, delta, data, value);

}

}

if (divergent.length) {

return new DivergentArrayError(divergent);

}

if (this.$__.version) {

this.$__version(where, delta);

}

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

* @return {String|undefined}

*/

function checkDivergentArray(doc, path, array) {

// see if we populated this path

var 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.

var top = path.split('.')[0];

if (doc.$__.selected[top + '.$']) {

return top;

}

}

if (!(pop && array && array.isMongooseArray)) 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 similarily destructive as we never received all

// elements of the array and potentially would overwrite data.

var 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) {

var atomics = array._atomics;

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

*/

Model.prototype.$__version = function(where, delta) {

var key = this.schema.options.versionKey;

if (where === true) {

// this is an insert

if (key) this.setValue(key, delta[key] = 0);

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)) {

var value = this.getValue(key);

if (value != null) where[key] = value;

}

if (VERSION_INC === (VERSION_INC & this.$__.version)) {

if (!delta.$set || typeof delta.$set[key] === 'undefined') {

delta.$inc || (delta.$inc = {});

delta.$inc[key] = 1;

}

}

};

/**

* Signal that we desire an increment of this documents version.

*

* ####Example:

*

* Model.findById(id, function (err, doc) {

* doc.increment();

* doc.save(function (err) { .. })

* })

*

* @see versionKeys http://mongoosejs.com/docs/guide.html#versionKey

* @api public

*/

Model.prototype.increment = function increment() {

this.$__.version = VERSION_ALL;

return this;

};

/**

* Returns a query object

*

* @api private

* @method $__where

* @memberOf Model

*/

Model.prototype.$__where = function _where(where) {

where || (where = {});

if (!where._id) {

where._id = this._doc._id;

}

if (this._doc._id == null) {

return new Error('No _id found on document!');

}

return where;

};

/**

* Removes this document from the db.

*

* ####Example:

* product.remove(function (err, product) {

* if (err) return handleError(err);

* Product.findById(product._id, function (err, product) {

* console.log(product) // null

* })

* })

*

*

* As an extra measure of flow control, remove will return a Promise (bound to `fn` if passed) so it could be chained, or hooked to recive errors

*

* ####Example:

* product.remove().then(function (product) {

* ...

* }).catch(function (err) {

* assert.ok(err)

* })

*

* @param {function(err,product)} [fn] optional callback

* @return {Promise} Promise

* @api public

*/

Model.prototype.remove = function remove(options, fn) {

if (typeof options === 'function') {

fn = options;

options = undefined;

}

var _this = this;

if (!options) {

options = {};

}

if (this.$__.removing) {

if (fn) {

this.$__.removing.then(

function(res) { fn(null, res); },

function(err) { fn(err); });

}

return this;

}

if (this.$__.isDeleted) {

setImmediate(function() {

fn(null, _this);

});

return this;

}

var Promise = PromiseProvider.get();

if (fn) {

fn = this.constructor.$wrapCallback(fn);

}

this.$__.removing = new Promise.ES6(function(resolve, reject) {

var where = _this.$__where();

if (where instanceof Error) {

reject(where);

fn && fn(where);

return;

}

if (!options.safe && _this.schema.options.safe) {

options.safe = _this.schema.options.safe;

}

_this.collection.remove(where, options, function(err) {

if (!err) {

_this.$__.isDeleted = true;

_this.emit('remove', _this);

_this.constructor.emit('remove', _this);

resolve(_this);

fn && fn(null, _this);

return;

}

_this.$__.isDeleted = false;

reject(err);

fn && fn(err);

});

});

return this.$__.removing;

};

/**

* Returns another Model instance.

*

* ####Example:

*

* var doc = new Tank;

* doc.model('User').findById(id, callback);

*

* @param {String} name model name

* @api public

*/

Model.prototype.model = function model(name) {

return this.db.model(name);

};

/**

* Adds a discriminator type.

*

* ####Example:

*

* function BaseSchema() {

* Schema.apply(this, arguments);

*

* this.add({

* name: String,

* createdAt: Date

* });

* }

* util.inherits(BaseSchema, Schema);

*

* var PersonSchema = new BaseSchema();

* var BossSchema = new BaseSchema({ department: String });

*

* var Person = mongoose.model('Person', PersonSchema);

* var Boss = Person.discriminator('Boss', BossSchema);

*

* @param {String} name discriminator model name

* @param {Schema} schema discriminator model schema

* @api public

*/

Model.discriminator = function(name, schema) {

var model;

if (typeof name === 'function') {

model = name;

name = utils.getFunctionName(model);

if (!(model.prototype instanceof Model)) {

throw new Error('The provided class ' + name + ' must extend Model');

}

}

schema = discriminator(this, name, schema);

if (this.db.models[name]) {

throw new OverwriteModelError(name);

}

schema.$isRootDiscriminator = true;

model = this.db.model(model || name, schema, this.collection.name);

this.discriminators[name] = model;

var d = this.discriminators[name];

d.prototype.__proto__ = this.prototype;

Object.defineProperty(d, 'baseModelName', {

value: this.modelName,

configurable: true,

writable: false

});

// apply methods and statics

applyMethods(d, schema);

applyStatics(d, schema);

return d;

};

// Model (class) features

/*!

* Give the constructor the ability to emit events.

*/

for (var i in EventEmitter.prototype) {

Model[i] = EventEmitter.prototype[i];

}

/**

* Performs any async initialization of this model against MongoDB. Currently,

* this function is only responsible for building [indexes](https://docs.mongodb.com/manual/indexes/),

* unless [`autoIndex`](http://mongoosejs.com/docs/guide.html#autoIndex) is turned off.

*

* This function is called automatically, so you don't need to call it.

* This function is also idempotent, so you may call it to get back a promise

* that will resolve when your indexes are finished building as an alternative

* to `MyModel.on('index')`

*

* ####Example:

*

* var 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.

* var Event = mongoose.model('Event', eventSchema);

*

* Event.init().then(function(Event) {

* // You can also use `Event.on('index')` if you prefer event emitters

* // over promises.

* console.log('Indexes are done building!');

* });

*

* @api public

* @param {Function} [callback]

* @returns {Promise}

*/

Model.init = function init(callback) {

this.schema.emit('init', this);

if (this.$init) {

return this.$init;

}

var _this = this;

var Promise = PromiseProvider.get();

this.$init = new Promise.ES6(function(resolve, reject) {

if ((_this.schema.options.autoIndex) ||

(_this.schema.options.autoIndex == null && _this.db.config.autoIndex)) {

_this.ensureIndexes({ _automatic: true, __noPromise: true }, function(error) {

if (error) {

callback && callback(error);

return reject(error);

}

callback && callback(null, _this);

resolve(_this);

});

}

return _this;

});

return this.$init;

};

/**

* Sends `createIndex` commands to mongo for each index declared in the schema.

* The `createIndex` commands are sent in series.

*

* ####Example:

*

* Event.createIndexes(function (err) {

* if (err) return handleError(err);

* });

*

* After completion, an `index` event is emitted on this `Model` passing an error if one occurred.

*

* ####Example:

*

* var eventSchema = new Schema({ thing: { type: 'string', unique: true }})

* var 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

* @param {Function} [cb] optional callback

* @return {Promise}

* @api public

*/

Model.createIndexes = Model.ensureIndexes = function createIndexes(options, callback) {

if (typeof options === 'function') {

callback = options;

options = null;

}

if (options && options.__noPromise) {

_createIndexes(this, options, callback);

return;

}

if (callback) {

callback = this.$wrapCallback(callback);

}

var _this = this;

var Promise = PromiseProvider.get();

return new Promise.ES6(function(resolve, reject) {

_createIndexes(_this, options || {}, function(error) {

if (error) {

callback && callback(error);

reject(error);

}

callback && callback();

resolve();

});

});

};

function _createIndexes(model, options, callback) {

var indexes = model.schema.indexes();

var done = function(err) {

if (err && model.schema.options.emitIndexErrors) {

model.emit('error', err);

}

model.emit('index', err);

callback && callback(err);

};