You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1924 lines
49 KiB
1924 lines
49 KiB
/*!
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var readPref = require('./drivers').ReadPreference;
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var VirtualType = require('./virtualtype');
|
|
var utils = require('./utils');
|
|
var MongooseTypes;
|
|
var Kareem = require('kareem');
|
|
var each = require('async/each');
|
|
var SchemaType = require('./schematype');
|
|
var mpath = require('mpath');
|
|
|
|
var IS_KAREEM_HOOK = {
|
|
aggregate: true,
|
|
count: true,
|
|
find: true,
|
|
findOne: true,
|
|
findOneAndUpdate: true,
|
|
findOneAndRemove: true,
|
|
insertMany: true,
|
|
replaceOne: true,
|
|
update: true,
|
|
updateMany: true,
|
|
updateOne: true
|
|
};
|
|
|
|
/**
|
|
* Schema constructor.
|
|
*
|
|
* ####Example:
|
|
*
|
|
* var child = new Schema({ name: String });
|
|
* var schema = new Schema({ name: String, age: Number, children: [child] });
|
|
* var Tree = mongoose.model('Tree', schema);
|
|
*
|
|
* // setting schema options
|
|
* new Schema({ name: String }, { _id: false, autoIndex: false })
|
|
*
|
|
* ####Options:
|
|
*
|
|
* - [autoIndex](/docs/guide.html#autoIndex): bool - defaults to null (which means use the connection's autoIndex option)
|
|
* - [bufferCommands](/docs/guide.html#bufferCommands): bool - defaults to true
|
|
* - [capped](/docs/guide.html#capped): bool - defaults to false
|
|
* - [collection](/docs/guide.html#collection): string - no default
|
|
* - [emitIndexErrors](/docs/guide.html#emitIndexErrors): bool - defaults to false.
|
|
* - [id](/docs/guide.html#id): bool - defaults to true
|
|
* - [_id](/docs/guide.html#_id): bool - defaults to true
|
|
* - `minimize`: bool - controls [document#toObject](#document_Document-toObject) behavior when called manually - defaults to true
|
|
* - [read](/docs/guide.html#read): string
|
|
* - [safe](/docs/guide.html#safe): bool - defaults to true.
|
|
* - [shardKey](/docs/guide.html#shardKey): bool - defaults to `null`
|
|
* - [strict](/docs/guide.html#strict): bool - defaults to true
|
|
* - [toJSON](/docs/guide.html#toJSON) - object - no default
|
|
* - [toObject](/docs/guide.html#toObject) - object - no default
|
|
* - [typeKey](/docs/guide.html#typeKey) - string - defaults to 'type'
|
|
* - [useNestedStrict](/docs/guide.html#useNestedStrict) - boolean - defaults to false
|
|
* - [validateBeforeSave](/docs/guide.html#validateBeforeSave) - bool - defaults to `true`
|
|
* - [versionKey](/docs/guide.html#versionKey): string - defaults to "__v"
|
|
* - [collation](/docs/guide.html#collation): object - defaults to null (which means use no collation)
|
|
*
|
|
* ####Note:
|
|
*
|
|
* _When nesting schemas, (`children` in the example above), always declare the child schema first before passing it into its parent._
|
|
*
|
|
* @param {Object} definition
|
|
* @param {Object} [options]
|
|
* @inherits NodeJS EventEmitter http://nodejs.org/api/events.html#events_class_events_eventemitter
|
|
* @event `init`: Emitted after the schema is compiled into a `Model`.
|
|
* @api public
|
|
*/
|
|
|
|
function Schema(obj, options) {
|
|
if (!(this instanceof Schema)) {
|
|
return new Schema(obj, options);
|
|
}
|
|
|
|
this.obj = obj;
|
|
this.paths = {};
|
|
this.aliases = {};
|
|
this.subpaths = {};
|
|
this.virtuals = {};
|
|
this.singleNestedPaths = {};
|
|
this.nested = {};
|
|
this.inherits = {};
|
|
this.callQueue = [];
|
|
this._indexes = [];
|
|
this.methods = {};
|
|
this.statics = {};
|
|
this.tree = {};
|
|
this.query = {};
|
|
this.childSchemas = [];
|
|
this.plugins = [];
|
|
|
|
this.s = {
|
|
hooks: new Kareem(),
|
|
kareemHooks: IS_KAREEM_HOOK
|
|
};
|
|
|
|
this.options = this.defaultOptions(options);
|
|
|
|
// build paths
|
|
if (obj) {
|
|
this.add(obj);
|
|
}
|
|
|
|
// check if _id's value is a subdocument (gh-2276)
|
|
var _idSubDoc = obj && obj._id && utils.isObject(obj._id);
|
|
|
|
// ensure the documents get an auto _id unless disabled
|
|
var auto_id = !this.paths['_id'] &&
|
|
(!this.options.noId && this.options._id) && !_idSubDoc;
|
|
|
|
if (auto_id) {
|
|
var _obj = {_id: {auto: true}};
|
|
_obj._id[this.options.typeKey] = Schema.ObjectId;
|
|
this.add(_obj);
|
|
}
|
|
|
|
for (var i = 0; i < this._defaultMiddleware.length; ++i) {
|
|
var m = this._defaultMiddleware[i];
|
|
this[m.kind](m.hook, !!m.isAsync, m.fn);
|
|
}
|
|
|
|
if (this.options.timestamps) {
|
|
this.setupTimestamp(this.options.timestamps);
|
|
}
|
|
|
|
// Assign virtual properties based on alias option
|
|
aliasFields(this);
|
|
}
|
|
|
|
/*!
|
|
* Create virtual properties with alias field
|
|
*/
|
|
function aliasFields(schema) {
|
|
for (var path in schema.paths) {
|
|
if (!schema.paths[path].options) continue;
|
|
|
|
var prop = schema.paths[path].path;
|
|
var alias = schema.paths[path].options.alias;
|
|
|
|
if (alias) {
|
|
if ('string' === typeof alias && alias.length > 0) {
|
|
if (schema.aliases[alias])
|
|
throw new Error('Duplicate alias, alias ' + alias + ' is used more than once');
|
|
else
|
|
schema.aliases[alias] = prop;
|
|
|
|
schema
|
|
.virtual(alias)
|
|
.get((function(p) {
|
|
return function() {
|
|
return this.get(p);
|
|
};
|
|
})(prop))
|
|
.set((function(p) {
|
|
return function(v) {
|
|
return this.set(p, v);
|
|
};
|
|
})(prop));
|
|
} else {
|
|
throw new Error('Invalid value for alias option on ' + prop + ', got ' + alias);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* Inherit from EventEmitter.
|
|
*/
|
|
Schema.prototype = Object.create(EventEmitter.prototype);
|
|
Schema.prototype.constructor = Schema;
|
|
Schema.prototype.instanceOfSchema = true;
|
|
|
|
/**
|
|
* Default middleware attached to a schema. Cannot be changed.
|
|
*
|
|
* This field is used to make sure discriminators don't get multiple copies of
|
|
* built-in middleware. Declared as a constant because changing this at runtime
|
|
* may lead to instability with Model.prototype.discriminator().
|
|
*
|
|
* @api private
|
|
* @property _defaultMiddleware
|
|
*/
|
|
Object.defineProperty(Schema.prototype, '_defaultMiddleware', {
|
|
configurable: false,
|
|
enumerable: false,
|
|
writable: false,
|
|
value: [
|
|
{
|
|
kind: 'pre',
|
|
hook: 'remove',
|
|
isAsync: true,
|
|
fn: function(next, done) {
|
|
if (this.ownerDocument) {
|
|
done();
|
|
next();
|
|
return;
|
|
}
|
|
|
|
var subdocs = this.$__getAllSubdocs();
|
|
|
|
if (!subdocs.length) {
|
|
done();
|
|
next();
|
|
return;
|
|
}
|
|
|
|
each(subdocs, function(subdoc, cb) {
|
|
subdoc.remove({ noop: true }, function(err) {
|
|
cb(err);
|
|
});
|
|
}, function(error) {
|
|
if (error) {
|
|
done(error);
|
|
return;
|
|
}
|
|
next();
|
|
done();
|
|
});
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
/**
|
|
* Array of child schemas (from document arrays and single nested subdocs)
|
|
* and their corresponding compiled models. Each element of the array is
|
|
* an object with 2 properties: `schema` and `model`.
|
|
*
|
|
* This property is typically only useful for plugin authors and advanced users.
|
|
* You do not need to interact with this property at all to use mongoose.
|
|
*
|
|
* @api public
|
|
* @property childSchemas
|
|
*/
|
|
|
|
Object.defineProperty(Schema.prototype, 'childSchemas', {
|
|
configurable: false,
|
|
enumerable: true,
|
|
writable: true
|
|
});
|
|
|
|
/**
|
|
* The original object passed to the schema constructor
|
|
*
|
|
* ####Example:
|
|
*
|
|
* var schema = new Schema({ a: String }).add({ b: String });
|
|
* schema.obj; // { a: String }
|
|
*
|
|
* @api public
|
|
* @property obj
|
|
*/
|
|
|
|
Schema.prototype.obj;
|
|
|
|
/**
|
|
* Schema as flat paths
|
|
*
|
|
* ####Example:
|
|
* {
|
|
* '_id' : SchemaType,
|
|
* , 'nested.key' : SchemaType,
|
|
* }
|
|
*
|
|
* @api private
|
|
* @property paths
|
|
*/
|
|
|
|
Schema.prototype.paths;
|
|
|
|
/**
|
|
* Schema as a tree
|
|
*
|
|
* ####Example:
|
|
* {
|
|
* '_id' : ObjectId
|
|
* , 'nested' : {
|
|
* 'key' : String
|
|
* }
|
|
* }
|
|
*
|
|
* @api private
|
|
* @property tree
|
|
*/
|
|
|
|
Schema.prototype.tree;
|
|
|
|
/**
|
|
* Returns a deep copy of the schema
|
|
*
|
|
* @return {Schema} the cloned schema
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.clone = function() {
|
|
var s = new Schema(this.paths, this.options);
|
|
// Clone the call queue
|
|
var cloneOpts = { retainKeyOrder: true };
|
|
s.callQueue = this.callQueue.map(function(f) { return f; });
|
|
s.methods = utils.clone(this.methods, cloneOpts);
|
|
s.statics = utils.clone(this.statics, cloneOpts);
|
|
s.query = utils.clone(this.query, cloneOpts);
|
|
s.plugins = Array.prototype.slice.call(this.plugins);
|
|
s._indexes = utils.clone(this._indexes, cloneOpts);
|
|
s.s.hooks = this.s.hooks.clone();
|
|
return s;
|
|
};
|
|
|
|
/**
|
|
* Returns default options for this schema, merged with `options`.
|
|
*
|
|
* @param {Object} options
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
Schema.prototype.defaultOptions = function(options) {
|
|
if (options && options.safe === false) {
|
|
options.safe = {w: 0};
|
|
}
|
|
|
|
if (options && options.safe && options.safe.w === 0) {
|
|
// if you turn off safe writes, then versioning goes off as well
|
|
options.versionKey = false;
|
|
}
|
|
|
|
this._userProvidedOptions = utils.clone(options, {
|
|
retainKeyOrder: true
|
|
});
|
|
|
|
options = utils.options({
|
|
strict: true,
|
|
bufferCommands: true,
|
|
capped: false, // { size, max, autoIndexId }
|
|
versionKey: '__v',
|
|
discriminatorKey: '__t',
|
|
minimize: true,
|
|
autoIndex: null,
|
|
shardKey: null,
|
|
read: null,
|
|
validateBeforeSave: true,
|
|
// the following are only applied at construction time
|
|
noId: false, // deprecated, use { _id: false }
|
|
_id: true,
|
|
noVirtualId: false, // deprecated, use { id: false }
|
|
id: true,
|
|
typeKey: 'type',
|
|
retainKeyOrder: false
|
|
}, options);
|
|
|
|
if (options.read) {
|
|
options.read = readPref(options.read);
|
|
}
|
|
|
|
return options;
|
|
};
|
|
|
|
/**
|
|
* Adds key path / schema type pairs to this schema.
|
|
*
|
|
* ####Example:
|
|
*
|
|
* var ToySchema = new Schema;
|
|
* ToySchema.add({ name: 'string', color: 'string', price: 'number' });
|
|
*
|
|
* @param {Object} obj
|
|
* @param {String} prefix
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.add = function add(obj, prefix) {
|
|
prefix = prefix || '';
|
|
var keys = Object.keys(obj);
|
|
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
|
|
if (obj[key] == null) {
|
|
throw new TypeError('Invalid value for schema path `' + prefix + key + '`');
|
|
}
|
|
|
|
if (Array.isArray(obj[key]) && obj[key].length === 1 && obj[key][0] == null) {
|
|
throw new TypeError('Invalid value for schema Array path `' + prefix + key + '`');
|
|
}
|
|
|
|
if (utils.isObject(obj[key]) &&
|
|
(!obj[key].constructor || utils.getFunctionName(obj[key].constructor) === 'Object') &&
|
|
(!obj[key][this.options.typeKey] || (this.options.typeKey === 'type' && obj[key].type.type))) {
|
|
if (Object.keys(obj[key]).length) {
|
|
// nested object { last: { name: String }}
|
|
this.nested[prefix + key] = true;
|
|
this.add(obj[key], prefix + key + '.');
|
|
} else {
|
|
if (prefix) {
|
|
this.nested[prefix.substr(0, prefix.length - 1)] = true;
|
|
}
|
|
this.path(prefix + key, obj[key]); // mixed type
|
|
}
|
|
} else {
|
|
if (prefix) {
|
|
this.nested[prefix.substr(0, prefix.length - 1)] = true;
|
|
}
|
|
this.path(prefix + key, obj[key]);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Reserved document keys.
|
|
*
|
|
* Keys in this object are names that are rejected in schema declarations b/c they conflict with mongoose functionality. Using these key name will throw an error.
|
|
*
|
|
* on, emit, _events, db, get, set, init, isNew, errors, schema, options, modelName, collection, _pres, _posts, toObject
|
|
*
|
|
* _NOTE:_ Use of these terms as method names is permitted, but play at your own risk, as they may be existing mongoose document methods you are stomping on.
|
|
*
|
|
* var schema = new Schema(..);
|
|
* schema.methods.init = function () {} // potentially breaking
|
|
*/
|
|
|
|
Schema.reserved = Object.create(null);
|
|
var reserved = Schema.reserved;
|
|
// Core object
|
|
reserved['prototype'] =
|
|
// EventEmitter
|
|
reserved.emit =
|
|
reserved.on =
|
|
reserved.once =
|
|
reserved.listeners =
|
|
reserved.removeListener =
|
|
// document properties and functions
|
|
reserved.collection =
|
|
reserved.db =
|
|
reserved.errors =
|
|
reserved.init =
|
|
reserved.isModified =
|
|
reserved.isNew =
|
|
reserved.get =
|
|
reserved.modelName =
|
|
reserved.save =
|
|
reserved.schema =
|
|
reserved.toObject =
|
|
reserved.validate =
|
|
reserved.remove =
|
|
// hooks.js
|
|
reserved._pres = reserved._posts = 1;
|
|
|
|
/*!
|
|
* Document keys to print warnings for
|
|
*/
|
|
|
|
var warnings = {};
|
|
warnings.increment = '`increment` should not be used as a schema path name ' +
|
|
'unless you have disabled versioning.';
|
|
|
|
/**
|
|
* Gets/sets schema paths.
|
|
*
|
|
* Sets a path (if arity 2)
|
|
* Gets a path (if arity 1)
|
|
*
|
|
* ####Example
|
|
*
|
|
* schema.path('name') // returns a SchemaType
|
|
* schema.path('name', Number) // changes the schemaType of `name` to Number
|
|
*
|
|
* @param {String} path
|
|
* @param {Object} constructor
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.path = function(path, obj) {
|
|
if (obj === undefined) {
|
|
if (this.paths[path]) {
|
|
return this.paths[path];
|
|
}
|
|
if (this.subpaths[path]) {
|
|
return this.subpaths[path];
|
|
}
|
|
if (this.singleNestedPaths[path]) {
|
|
return this.singleNestedPaths[path];
|
|
}
|
|
|
|
// subpaths?
|
|
return /\.\d+\.?.*$/.test(path)
|
|
? getPositionalPath(this, path)
|
|
: undefined;
|
|
}
|
|
|
|
// some path names conflict with document methods
|
|
if (reserved[path]) {
|
|
throw new Error('`' + path + '` may not be used as a schema pathname');
|
|
}
|
|
|
|
if (warnings[path]) {
|
|
console.log('WARN: ' + warnings[path]);
|
|
}
|
|
|
|
// update the tree
|
|
var subpaths = path.split(/\./),
|
|
last = subpaths.pop(),
|
|
branch = this.tree;
|
|
|
|
subpaths.forEach(function(sub, i) {
|
|
if (!branch[sub]) {
|
|
branch[sub] = {};
|
|
}
|
|
if (typeof branch[sub] !== 'object') {
|
|
var msg = 'Cannot set nested path `' + path + '`. '
|
|
+ 'Parent path `'
|
|
+ subpaths.slice(0, i).concat([sub]).join('.')
|
|
+ '` already set to type ' + branch[sub].name
|
|
+ '.';
|
|
throw new Error(msg);
|
|
}
|
|
branch = branch[sub];
|
|
});
|
|
|
|
branch[last] = utils.clone(obj);
|
|
|
|
this.paths[path] = Schema.interpretAsType(path, obj, this.options);
|
|
|
|
if (this.paths[path].$isSingleNested) {
|
|
for (var key in this.paths[path].schema.paths) {
|
|
this.singleNestedPaths[path + '.' + key] =
|
|
this.paths[path].schema.paths[key];
|
|
}
|
|
for (key in this.paths[path].schema.singleNestedPaths) {
|
|
this.singleNestedPaths[path + '.' + key] =
|
|
this.paths[path].schema.singleNestedPaths[key];
|
|
}
|
|
|
|
this.childSchemas.push({
|
|
schema: this.paths[path].schema,
|
|
model: this.paths[path].caster
|
|
});
|
|
} else if (this.paths[path].$isMongooseDocumentArray) {
|
|
this.childSchemas.push({
|
|
schema: this.paths[path].schema,
|
|
model: this.paths[path].casterConstructor
|
|
});
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Converts type arguments into Mongoose Types.
|
|
*
|
|
* @param {String} path
|
|
* @param {Object} obj constructor
|
|
* @api private
|
|
*/
|
|
|
|
Schema.interpretAsType = function(path, obj, options) {
|
|
if (obj instanceof SchemaType) {
|
|
return obj;
|
|
}
|
|
|
|
if (obj.constructor) {
|
|
var constructorName = utils.getFunctionName(obj.constructor);
|
|
if (constructorName !== 'Object') {
|
|
var oldObj = obj;
|
|
obj = {};
|
|
obj[options.typeKey] = oldObj;
|
|
}
|
|
}
|
|
|
|
// Get the type making sure to allow keys named "type"
|
|
// and default to mixed if not specified.
|
|
// { type: { type: String, default: 'freshcut' } }
|
|
var type = obj[options.typeKey] && (options.typeKey !== 'type' || !obj.type.type)
|
|
? obj[options.typeKey]
|
|
: {};
|
|
|
|
if (utils.getFunctionName(type.constructor) === 'Object' || type === 'mixed') {
|
|
return new MongooseTypes.Mixed(path, obj);
|
|
}
|
|
|
|
if (Array.isArray(type) || Array === type || type === 'array') {
|
|
// if it was specified through { type } look for `cast`
|
|
var cast = (Array === type || type === 'array')
|
|
? obj.cast
|
|
: type[0];
|
|
|
|
if (cast && cast.instanceOfSchema) {
|
|
return new MongooseTypes.DocumentArray(path, cast, obj);
|
|
}
|
|
if (cast &&
|
|
cast[options.typeKey] &&
|
|
cast[options.typeKey].instanceOfSchema) {
|
|
return new MongooseTypes.DocumentArray(path, cast[options.typeKey], cast);
|
|
}
|
|
|
|
if (Array.isArray(cast)) {
|
|
return new MongooseTypes.Array(path, Schema.interpretAsType(path, cast, options), obj);
|
|
}
|
|
|
|
if (typeof cast === 'string') {
|
|
cast = MongooseTypes[cast.charAt(0).toUpperCase() + cast.substring(1)];
|
|
} else if (cast && (!cast[options.typeKey] || (options.typeKey === 'type' && cast.type.type))
|
|
&& utils.getFunctionName(cast.constructor) === 'Object') {
|
|
if (Object.keys(cast).length) {
|
|
// The `minimize` and `typeKey` options propagate to child schemas
|
|
// declared inline, like `{ arr: [{ val: { $type: String } }] }`.
|
|
// See gh-3560
|
|
var childSchemaOptions = {minimize: options.minimize};
|
|
if (options.typeKey) {
|
|
childSchemaOptions.typeKey = options.typeKey;
|
|
}
|
|
//propagate 'strict' option to child schema
|
|
if (options.hasOwnProperty('strict')) {
|
|
childSchemaOptions.strict = options.strict;
|
|
}
|
|
//propagate 'runSettersOnQuery' option to child schema
|
|
if (options.hasOwnProperty('runSettersOnQuery')) {
|
|
childSchemaOptions.runSettersOnQuery = options.runSettersOnQuery;
|
|
}
|
|
var childSchema = new Schema(cast, childSchemaOptions);
|
|
childSchema.$implicitlyCreated = true;
|
|
return new MongooseTypes.DocumentArray(path, childSchema, obj);
|
|
} else {
|
|
// Special case: empty object becomes mixed
|
|
return new MongooseTypes.Array(path, MongooseTypes.Mixed, obj);
|
|
}
|
|
}
|
|
|
|
if (cast) {
|
|
type = cast[options.typeKey] && (options.typeKey !== 'type' || !cast.type.type)
|
|
? cast[options.typeKey]
|
|
: cast;
|
|
|
|
name = typeof type === 'string'
|
|
? type
|
|
: type.schemaName || utils.getFunctionName(type);
|
|
|
|
if (!(name in MongooseTypes)) {
|
|
throw new TypeError('Undefined type `' + name + '` at array `' + path +
|
|
'`');
|
|
}
|
|
}
|
|
|
|
return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options);
|
|
}
|
|
|
|
if (type && type.instanceOfSchema) {
|
|
return new MongooseTypes.Embedded(type, path, obj);
|
|
}
|
|
|
|
var name;
|
|
if (Buffer.isBuffer(type)) {
|
|
name = 'Buffer';
|
|
} else {
|
|
name = typeof type === 'string'
|
|
? type
|
|
// If not string, `type` is a function. Outside of IE, function.name
|
|
// gives you the function name. In IE, you need to compute it
|
|
: type.schemaName || utils.getFunctionName(type);
|
|
}
|
|
|
|
if (name) {
|
|
name = name.charAt(0).toUpperCase() + name.substring(1);
|
|
}
|
|
|
|
if (undefined == MongooseTypes[name]) {
|
|
throw new TypeError('Undefined type `' + name + '` at `' + path +
|
|
'`\n Did you try nesting Schemas? ' +
|
|
'You can only nest using refs or arrays.');
|
|
}
|
|
|
|
obj = utils.clone(obj, { retainKeyOrder: true });
|
|
if (!('runSettersOnQuery' in obj)) {
|
|
obj.runSettersOnQuery = options.runSettersOnQuery;
|
|
}
|
|
return new MongooseTypes[name](path, obj);
|
|
};
|
|
|
|
/**
|
|
* Iterates the schemas paths similar to Array#forEach.
|
|
*
|
|
* The callback is passed the pathname and schemaType as arguments on each iteration.
|
|
*
|
|
* @param {Function} fn callback function
|
|
* @return {Schema} this
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.eachPath = function(fn) {
|
|
var keys = Object.keys(this.paths),
|
|
len = keys.length;
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
fn(keys[i], this.paths[keys[i]]);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Returns an Array of path strings that are required by this schema.
|
|
*
|
|
* @api public
|
|
* @param {Boolean} invalidate refresh the cache
|
|
* @return {Array}
|
|
*/
|
|
|
|
Schema.prototype.requiredPaths = function requiredPaths(invalidate) {
|
|
if (this._requiredpaths && !invalidate) {
|
|
return this._requiredpaths;
|
|
}
|
|
|
|
var paths = Object.keys(this.paths),
|
|
i = paths.length,
|
|
ret = [];
|
|
|
|
while (i--) {
|
|
var path = paths[i];
|
|
if (this.paths[path].isRequired) {
|
|
ret.push(path);
|
|
}
|
|
}
|
|
this._requiredpaths = ret;
|
|
return this._requiredpaths;
|
|
};
|
|
|
|
/**
|
|
* Returns indexes from fields and schema-level indexes (cached).
|
|
*
|
|
* @api private
|
|
* @return {Array}
|
|
*/
|
|
|
|
Schema.prototype.indexedPaths = function indexedPaths() {
|
|
if (this._indexedpaths) {
|
|
return this._indexedpaths;
|
|
}
|
|
this._indexedpaths = this.indexes();
|
|
return this._indexedpaths;
|
|
};
|
|
|
|
/**
|
|
* Returns the pathType of `path` for this schema.
|
|
*
|
|
* Given a path, returns whether it is a real, virtual, nested, or ad-hoc/undefined path.
|
|
*
|
|
* @param {String} path
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.pathType = function(path) {
|
|
if (path in this.paths) {
|
|
return 'real';
|
|
}
|
|
if (path in this.virtuals) {
|
|
return 'virtual';
|
|
}
|
|
if (path in this.nested) {
|
|
return 'nested';
|
|
}
|
|
if (path in this.subpaths) {
|
|
return 'real';
|
|
}
|
|
if (path in this.singleNestedPaths) {
|
|
return 'real';
|
|
}
|
|
|
|
if (/\.\d+\.|\.\d+$/.test(path)) {
|
|
return getPositionalPathType(this, path);
|
|
}
|
|
return 'adhocOrUndefined';
|
|
};
|
|
|
|
/**
|
|
* Returns true iff this path is a child of a mixed schema.
|
|
*
|
|
* @param {String} path
|
|
* @return {Boolean}
|
|
* @api private
|
|
*/
|
|
|
|
Schema.prototype.hasMixedParent = function(path) {
|
|
var subpaths = path.split(/\./g);
|
|
path = '';
|
|
for (var i = 0; i < subpaths.length; ++i) {
|
|
path = i > 0 ? path + '.' + subpaths[i] : subpaths[i];
|
|
if (path in this.paths &&
|
|
this.paths[path] instanceof MongooseTypes.Mixed) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Setup updatedAt and createdAt timestamps to documents if enabled
|
|
*
|
|
* @param {Boolean|Object} timestamps timestamps options
|
|
* @api private
|
|
*/
|
|
Schema.prototype.setupTimestamp = function(timestamps) {
|
|
if (timestamps) {
|
|
var createdAt = handleTimestampOption(timestamps, 'createdAt');
|
|
var updatedAt = handleTimestampOption(timestamps, 'updatedAt');
|
|
var schemaAdditions = {};
|
|
|
|
if (updatedAt && !this.paths[updatedAt]) {
|
|
schemaAdditions[updatedAt] = Date;
|
|
}
|
|
|
|
if (createdAt && !this.paths[createdAt]) {
|
|
schemaAdditions[createdAt] = Date;
|
|
}
|
|
|
|
this.add(schemaAdditions);
|
|
|
|
this.pre('save', function(next) {
|
|
var defaultTimestamp = new Date();
|
|
var auto_id = this._id && this._id.auto;
|
|
|
|
if (createdAt != null && !this.get(createdAt) && this.isSelected(createdAt)) {
|
|
this.set(createdAt, auto_id ? this._id.getTimestamp() : defaultTimestamp);
|
|
}
|
|
|
|
if (updatedAt != null && (this.isNew || this.isModified())) {
|
|
var ts = defaultTimestamp;
|
|
if (this.isNew) {
|
|
if (createdAt != null) {
|
|
ts = this.get(createdAt);
|
|
} else if (auto_id) {
|
|
ts = this._id.getTimestamp();
|
|
}
|
|
}
|
|
this.set(updatedAt, ts);
|
|
}
|
|
|
|
next();
|
|
});
|
|
|
|
var genUpdates = function(currentUpdate, overwrite) {
|
|
var now = new Date();
|
|
var updates = {};
|
|
var _updates = updates;
|
|
if (overwrite) {
|
|
if (currentUpdate && currentUpdate.$set) {
|
|
currentUpdate = currentUpdate.$set;
|
|
updates.$set = {};
|
|
_updates = updates.$set;
|
|
}
|
|
if (updatedAt != null && !currentUpdate[updatedAt]) {
|
|
_updates[updatedAt] = now;
|
|
}
|
|
if (createdAt != null && !currentUpdate[createdAt]) {
|
|
_updates[createdAt] = now;
|
|
}
|
|
return updates;
|
|
}
|
|
updates = { $set: {} };
|
|
currentUpdate = currentUpdate || {};
|
|
|
|
if (updatedAt != null &&
|
|
(!currentUpdate.$currentDate || !currentUpdate.$currentDate[updatedAt])) {
|
|
updates.$set[updatedAt] = now;
|
|
}
|
|
|
|
if (createdAt != null) {
|
|
if (currentUpdate[createdAt]) {
|
|
delete currentUpdate[createdAt];
|
|
}
|
|
if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
|
|
delete currentUpdate.$set[createdAt];
|
|
}
|
|
|
|
updates.$setOnInsert = {};
|
|
updates.$setOnInsert[createdAt] = now;
|
|
}
|
|
|
|
return updates;
|
|
};
|
|
|
|
this.methods.initializeTimestamps = function() {
|
|
if (!this.get(createdAt)) {
|
|
this.set(createdAt, new Date());
|
|
}
|
|
if (!this.get(updatedAt)) {
|
|
this.set(updatedAt, new Date());
|
|
}
|
|
return this;
|
|
};
|
|
|
|
this.pre('findOneAndUpdate', function(next) {
|
|
var overwrite = this.options.overwrite;
|
|
this.findOneAndUpdate({}, genUpdates(this.getUpdate(), overwrite), {
|
|
overwrite: overwrite
|
|
});
|
|
applyTimestampsToChildren(this);
|
|
next();
|
|
});
|
|
|
|
this.pre('update', function(next) {
|
|
var overwrite = this.options.overwrite;
|
|
this.update({}, genUpdates(this.getUpdate(), overwrite), {
|
|
overwrite: overwrite
|
|
});
|
|
applyTimestampsToChildren(this);
|
|
next();
|
|
});
|
|
}
|
|
};
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
function handleTimestampOption(arg, prop) {
|
|
if (typeof arg === 'boolean') {
|
|
return prop;
|
|
}
|
|
if (typeof arg[prop] === 'boolean') {
|
|
return arg[prop] ? prop : null;
|
|
}
|
|
if (!(prop in arg)) {
|
|
return prop;
|
|
}
|
|
return arg[prop];
|
|
}
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
function applyTimestampsToChildren(query) {
|
|
var now = new Date();
|
|
var update = query.getUpdate();
|
|
var keys = Object.keys(update);
|
|
var key;
|
|
var schema = query.model.schema;
|
|
var len;
|
|
var createdAt;
|
|
var updatedAt;
|
|
var timestamps;
|
|
var path;
|
|
|
|
var hasDollarKey = keys.length && keys[0].charAt(0) === '$';
|
|
|
|
if (hasDollarKey) {
|
|
if (update.$push) {
|
|
for (key in update.$push) {
|
|
var $path = schema.path(key);
|
|
if (update.$push[key] &&
|
|
$path &&
|
|
$path.$isMongooseDocumentArray &&
|
|
$path.schema.options.timestamps) {
|
|
timestamps = $path.schema.options.timestamps;
|
|
createdAt = handleTimestampOption(timestamps, 'createdAt');
|
|
updatedAt = handleTimestampOption(timestamps, 'updatedAt');
|
|
if (update.$push[key].$each) {
|
|
update.$push[key].$each.forEach(function(subdoc) {
|
|
if (updatedAt != null) {
|
|
subdoc[updatedAt] = now;
|
|
}
|
|
if (createdAt != null) {
|
|
subdoc[createdAt] = now;
|
|
}
|
|
});
|
|
} else {
|
|
if (updatedAt != null) {
|
|
update.$push[key][updatedAt] = now;
|
|
}
|
|
if (createdAt != null) {
|
|
update.$push[key][createdAt] = now;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (update.$set) {
|
|
for (key in update.$set) {
|
|
path = schema.path(key);
|
|
if (!path) {
|
|
continue;
|
|
}
|
|
if (Array.isArray(update.$set[key]) && path.$isMongooseDocumentArray) {
|
|
len = update.$set[key].length;
|
|
timestamps = schema.path(key).schema.options.timestamps;
|
|
if (timestamps) {
|
|
createdAt = handleTimestampOption(timestamps, 'createdAt');
|
|
updatedAt = handleTimestampOption(timestamps, 'updatedAt');
|
|
for (var i = 0; i < len; ++i) {
|
|
if (updatedAt != null) {
|
|
update.$set[key][i][updatedAt] = now;
|
|
}
|
|
if (createdAt != null) {
|
|
update.$set[key][i][createdAt] = now;
|
|
}
|
|
}
|
|
}
|
|
} else if (update.$set[key] && path.$isSingleNested) {
|
|
timestamps = schema.path(key).schema.options.timestamps;
|
|
if (timestamps) {
|
|
createdAt = handleTimestampOption(timestamps, 'createdAt');
|
|
updatedAt = handleTimestampOption(timestamps, 'updatedAt');
|
|
if (updatedAt != null) {
|
|
update.$set[key][updatedAt] = now;
|
|
}
|
|
if (createdAt != null) {
|
|
update.$set[key][createdAt] = now;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
function getPositionalPathType(self, path) {
|
|
var subpaths = path.split(/\.(\d+)\.|\.(\d+)$/).filter(Boolean);
|
|
if (subpaths.length < 2) {
|
|
return self.paths[subpaths[0]];
|
|
}
|
|
|
|
var val = self.path(subpaths[0]);
|
|
var isNested = false;
|
|
if (!val) {
|
|
return val;
|
|
}
|
|
|
|
var last = subpaths.length - 1,
|
|
subpath,
|
|
i = 1;
|
|
|
|
for (; i < subpaths.length; ++i) {
|
|
isNested = false;
|
|
subpath = subpaths[i];
|
|
|
|
if (i === last && val && !/\D/.test(subpath)) {
|
|
if (val.$isMongooseDocumentArray) {
|
|
var oldVal = val;
|
|
val = new SchemaType(subpath);
|
|
val.cast = function(value, doc, init) {
|
|
return oldVal.cast(value, doc, init)[0];
|
|
};
|
|
val.caster = oldVal.caster;
|
|
val.schema = oldVal.schema;
|
|
} else if (val instanceof MongooseTypes.Array) {
|
|
// StringSchema, NumberSchema, etc
|
|
val = val.caster;
|
|
} else {
|
|
val = undefined;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// ignore if its just a position segment: path.0.subpath
|
|
if (!/\D/.test(subpath)) {
|
|
continue;
|
|
}
|
|
|
|
if (!(val && val.schema)) {
|
|
val = undefined;
|
|
break;
|
|
}
|
|
|
|
var type = val.schema.pathType(subpath);
|
|
isNested = (type === 'nested');
|
|
val = val.schema.path(subpath);
|
|
}
|
|
|
|
self.subpaths[path] = val;
|
|
if (val) {
|
|
return 'real';
|
|
}
|
|
if (isNested) {
|
|
return 'nested';
|
|
}
|
|
return 'adhocOrUndefined';
|
|
}
|
|
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
function getPositionalPath(self, path) {
|
|
getPositionalPathType(self, path);
|
|
return self.subpaths[path];
|
|
}
|
|
|
|
/**
|
|
* Adds a method call to the queue.
|
|
*
|
|
* @param {String} name name of the document method to call later
|
|
* @param {Array} args arguments to pass to the method
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.queue = function(name, args) {
|
|
this.callQueue.push([name, args]);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Defines a pre hook for the document.
|
|
*
|
|
* ####Example
|
|
*
|
|
* var toySchema = new Schema(..);
|
|
*
|
|
* toySchema.pre('save', function (next) {
|
|
* if (!this.created) this.created = new Date;
|
|
* next();
|
|
* })
|
|
*
|
|
* toySchema.pre('validate', function (next) {
|
|
* if (this.name !== 'Woody') this.name = 'Woody';
|
|
* next();
|
|
* })
|
|
*
|
|
* @param {String} method
|
|
* @param {Function} callback
|
|
* @see hooks.js https://github.com/bnoguchi/hooks-js/tree/31ec571cef0332e21121ee7157e0cf9728572cc3
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.pre = function() {
|
|
var name = arguments[0];
|
|
if (IS_KAREEM_HOOK[name]) {
|
|
this.s.hooks.pre.apply(this.s.hooks, arguments);
|
|
return this;
|
|
}
|
|
return this.queue('pre', arguments);
|
|
};
|
|
|
|
/**
|
|
* Defines a post hook for the document
|
|
*
|
|
* var schema = new Schema(..);
|
|
* schema.post('save', function (doc) {
|
|
* console.log('this fired after a document was saved');
|
|
* });
|
|
*
|
|
* schema.post('find', function(docs) {
|
|
* console.log('this fired after you run a find query');
|
|
* });
|
|
*
|
|
* var Model = mongoose.model('Model', schema);
|
|
*
|
|
* var m = new Model(..);
|
|
* m.save(function(err) {
|
|
* console.log('this fires after the `post` hook');
|
|
* });
|
|
*
|
|
* m.find(function(err, docs) {
|
|
* console.log('this fires after the post find hook');
|
|
* });
|
|
*
|
|
* @param {String} method name of the method to hook
|
|
* @param {Function} fn callback
|
|
* @see middleware http://mongoosejs.com/docs/middleware.html
|
|
* @see hooks.js https://www.npmjs.com/package/hooks-fixed
|
|
* @see kareem http://npmjs.org/package/kareem
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.post = function(method, fn) {
|
|
if (IS_KAREEM_HOOK[method]) {
|
|
this.s.hooks.post.apply(this.s.hooks, arguments);
|
|
return this;
|
|
}
|
|
// assuming that all callbacks with arity < 2 are synchronous post hooks
|
|
if (fn.length < 2) {
|
|
return this.queue('on', [arguments[0], function(doc) {
|
|
return fn.call(doc, doc);
|
|
}]);
|
|
}
|
|
|
|
if (fn.length === 3) {
|
|
this.s.hooks.post(method + ':error', fn);
|
|
return this;
|
|
}
|
|
|
|
return this.queue('post', [arguments[0], function(next) {
|
|
// wrap original function so that the callback goes last,
|
|
// for compatibility with old code that is using synchronous post hooks
|
|
var _this = this;
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
fn.call(this, this, function(err) {
|
|
return next.apply(_this, [err].concat(args));
|
|
});
|
|
}]);
|
|
};
|
|
|
|
/**
|
|
* Registers a plugin for this schema.
|
|
*
|
|
* @param {Function} plugin callback
|
|
* @param {Object} [opts]
|
|
* @see plugins
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.plugin = function(fn, opts) {
|
|
if (typeof fn !== 'function') {
|
|
throw new Error('First param to `schema.plugin()` must be a function, ' +
|
|
'got "' + (typeof fn) + '"');
|
|
}
|
|
|
|
if (opts &&
|
|
opts.deduplicate) {
|
|
for (var i = 0; i < this.plugins.length; ++i) {
|
|
if (this.plugins[i].fn === fn) {
|
|
return this;
|
|
}
|
|
}
|
|
}
|
|
this.plugins.push({ fn: fn, opts: opts });
|
|
|
|
fn(this, opts);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Adds an instance method to documents constructed from Models compiled from this schema.
|
|
*
|
|
* ####Example
|
|
*
|
|
* var schema = kittySchema = new Schema(..);
|
|
*
|
|
* schema.method('meow', function () {
|
|
* console.log('meeeeeoooooooooooow');
|
|
* })
|
|
*
|
|
* var Kitty = mongoose.model('Kitty', schema);
|
|
*
|
|
* var fizz = new Kitty;
|
|
* fizz.meow(); // meeeeeooooooooooooow
|
|
*
|
|
* If a hash of name/fn pairs is passed as the only argument, each name/fn pair will be added as methods.
|
|
*
|
|
* schema.method({
|
|
* purr: function () {}
|
|
* , scratch: function () {}
|
|
* });
|
|
*
|
|
* // later
|
|
* fizz.purr();
|
|
* fizz.scratch();
|
|
*
|
|
* @param {String|Object} method name
|
|
* @param {Function} [fn]
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.method = function(name, fn) {
|
|
if (typeof name !== 'string') {
|
|
for (var i in name) {
|
|
this.methods[i] = name[i];
|
|
}
|
|
} else {
|
|
this.methods[name] = fn;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Adds static "class" methods to Models compiled from this schema.
|
|
*
|
|
* ####Example
|
|
*
|
|
* var schema = new Schema(..);
|
|
* schema.static('findByName', function (name, callback) {
|
|
* return this.find({ name: name }, callback);
|
|
* });
|
|
*
|
|
* var Drink = mongoose.model('Drink', schema);
|
|
* Drink.findByName('sanpellegrino', function (err, drinks) {
|
|
* //
|
|
* });
|
|
*
|
|
* If a hash of name/fn pairs is passed as the only argument, each name/fn pair will be added as statics.
|
|
*
|
|
* @param {String|Object} name
|
|
* @param {Function} [fn]
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.static = function(name, fn) {
|
|
if (typeof name !== 'string') {
|
|
for (var i in name) {
|
|
this.statics[i] = name[i];
|
|
}
|
|
} else {
|
|
this.statics[name] = fn;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Defines an index (most likely compound) for this schema.
|
|
*
|
|
* ####Example
|
|
*
|
|
* schema.index({ first: 1, last: -1 })
|
|
*
|
|
* @param {Object} fields
|
|
* @param {Object} [options] Options to pass to [MongoDB driver's `createIndex()` function](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#createIndex)
|
|
* @param {String} [options.expires=null] Mongoose-specific syntactic sugar, uses [ms](https://www.npmjs.com/package/ms) to convert `expires` option into seconds for the `expireAfterSeconds` in the above link.
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.index = function(fields, options) {
|
|
options || (options = {});
|
|
|
|
if (options.expires) {
|
|
utils.expires(options);
|
|
}
|
|
|
|
this._indexes.push([fields, options]);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Sets/gets a schema option.
|
|
*
|
|
* ####Example
|
|
*
|
|
* schema.set('strict'); // 'true' by default
|
|
* schema.set('strict', false); // Sets 'strict' to false
|
|
* schema.set('strict'); // 'false'
|
|
*
|
|
* @param {String} key option name
|
|
* @param {Object} [value] if not passed, the current option value is returned
|
|
* @see Schema ./
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.set = function(key, value, _tags) {
|
|
if (arguments.length === 1) {
|
|
return this.options[key];
|
|
}
|
|
|
|
switch (key) {
|
|
case 'read':
|
|
this.options[key] = readPref(value, _tags);
|
|
break;
|
|
case 'safe':
|
|
this.options[key] = value === false
|
|
? {w: 0}
|
|
: value;
|
|
break;
|
|
case 'timestamps':
|
|
this.setupTimestamp(value);
|
|
this.options[key] = value;
|
|
break;
|
|
default:
|
|
this.options[key] = value;
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Gets a schema option.
|
|
*
|
|
* @param {String} key option name
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.get = function(key) {
|
|
return this.options[key];
|
|
};
|
|
|
|
/**
|
|
* The allowed index types
|
|
*
|
|
* @static indexTypes
|
|
* @receiver Schema
|
|
* @api public
|
|
*/
|
|
|
|
var indexTypes = '2d 2dsphere hashed text'.split(' ');
|
|
|
|
Object.defineProperty(Schema, 'indexTypes', {
|
|
get: function() {
|
|
return indexTypes;
|
|
},
|
|
set: function() {
|
|
throw new Error('Cannot overwrite Schema.indexTypes');
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Returns a list of indexes that this schema declares, via `schema.index()`
|
|
* or by `index: true` in a path's options.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
Schema.prototype.indexes = function() {
|
|
'use strict';
|
|
|
|
var indexes = [];
|
|
var schemaStack = [];
|
|
|
|
var collectIndexes = function(schema, prefix) {
|
|
// Ignore infinitely nested schemas, if we've already seen this schema
|
|
// along this path there must be a cycle
|
|
if (schemaStack.indexOf(schema) !== -1) {
|
|
return;
|
|
}
|
|
schemaStack.push(schema);
|
|
|
|
prefix = prefix || '';
|
|
var key, path, index, field, isObject, options, type;
|
|
var keys = Object.keys(schema.paths);
|
|
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
key = keys[i];
|
|
path = schema.paths[key];
|
|
|
|
if ((path instanceof MongooseTypes.DocumentArray) || path.$isSingleNested) {
|
|
if (path.options.excludeIndexes !== true) {
|
|
collectIndexes(path.schema, prefix + key + '.');
|
|
}
|
|
} else {
|
|
index = path._index || (path.caster && path.caster._index);
|
|
|
|
if (index !== false && index !== null && index !== undefined) {
|
|
field = {};
|
|
isObject = utils.isObject(index);
|
|
options = isObject ? index : {};
|
|
type = typeof index === 'string' ? index :
|
|
isObject ? index.type :
|
|
false;
|
|
|
|
if (type && ~Schema.indexTypes.indexOf(type)) {
|
|
field[prefix + key] = type;
|
|
} else if (options.text) {
|
|
field[prefix + key] = 'text';
|
|
delete options.text;
|
|
} else {
|
|
field[prefix + key] = 1;
|
|
}
|
|
|
|
delete options.type;
|
|
if (!('background' in options)) {
|
|
options.background = true;
|
|
}
|
|
|
|
indexes.push([field, options]);
|
|
}
|
|
}
|
|
}
|
|
|
|
schemaStack.pop();
|
|
|
|
if (prefix) {
|
|
fixSubIndexPaths(schema, prefix);
|
|
} else {
|
|
schema._indexes.forEach(function(index) {
|
|
if (!('background' in index[1])) {
|
|
index[1].background = true;
|
|
}
|
|
});
|
|
indexes = indexes.concat(schema._indexes);
|
|
}
|
|
};
|
|
|
|
collectIndexes(this);
|
|
return indexes;
|
|
|
|
/*!
|
|
* Checks for indexes added to subdocs using Schema.index().
|
|
* These indexes need their paths prefixed properly.
|
|
*
|
|
* schema._indexes = [ [indexObj, options], [indexObj, options] ..]
|
|
*/
|
|
|
|
function fixSubIndexPaths(schema, prefix) {
|
|
var subindexes = schema._indexes,
|
|
len = subindexes.length,
|
|
indexObj,
|
|
newindex,
|
|
klen,
|
|
keys,
|
|
key,
|
|
i = 0,
|
|
j;
|
|
|
|
for (i = 0; i < len; ++i) {
|
|
indexObj = subindexes[i][0];
|
|
keys = Object.keys(indexObj);
|
|
klen = keys.length;
|
|
newindex = {};
|
|
|
|
// use forward iteration, order matters
|
|
for (j = 0; j < klen; ++j) {
|
|
key = keys[j];
|
|
newindex[prefix + key] = indexObj[key];
|
|
}
|
|
|
|
indexes.push([newindex, subindexes[i][1]]);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates a virtual type with the given name.
|
|
*
|
|
* @param {String} name
|
|
* @param {Object} [options]
|
|
* @return {VirtualType}
|
|
*/
|
|
|
|
Schema.prototype.virtual = function(name, options) {
|
|
if (options && options.ref) {
|
|
if (!options.localField) {
|
|
throw new Error('Reference virtuals require `localField` option');
|
|
}
|
|
|
|
if (!options.foreignField) {
|
|
throw new Error('Reference virtuals require `foreignField` option');
|
|
}
|
|
|
|
this.pre('init', function(next, obj) {
|
|
if (mpath.has(name, obj)) {
|
|
var _v = mpath.get(name, obj);
|
|
if (!this.$$populatedVirtuals) {
|
|
this.$$populatedVirtuals = {};
|
|
}
|
|
|
|
if (options.justOne) {
|
|
this.$$populatedVirtuals[name] = Array.isArray(_v) ?
|
|
_v[0] :
|
|
_v;
|
|
} else {
|
|
this.$$populatedVirtuals[name] = Array.isArray(_v) ?
|
|
_v :
|
|
_v == null ? [] : [_v];
|
|
}
|
|
|
|
mpath.unset(name, obj);
|
|
}
|
|
if (this.ownerDocument) {
|
|
next();
|
|
return this;
|
|
} else {
|
|
next();
|
|
}
|
|
});
|
|
|
|
var virtual = this.virtual(name);
|
|
virtual.options = options;
|
|
return virtual.
|
|
get(function() {
|
|
if (!this.$$populatedVirtuals) {
|
|
this.$$populatedVirtuals = {};
|
|
}
|
|
if (name in this.$$populatedVirtuals) {
|
|
return this.$$populatedVirtuals[name];
|
|
}
|
|
return null;
|
|
}).
|
|
set(function(_v) {
|
|
if (!this.$$populatedVirtuals) {
|
|
this.$$populatedVirtuals = {};
|
|
}
|
|
|
|
if (options.justOne) {
|
|
this.$$populatedVirtuals[name] = Array.isArray(_v) ?
|
|
_v[0] :
|
|
_v;
|
|
|
|
if (typeof this.$$populatedVirtuals[name] !== 'object') {
|
|
this.$$populatedVirtuals[name] = null;
|
|
}
|
|
} else {
|
|
this.$$populatedVirtuals[name] = Array.isArray(_v) ?
|
|
_v :
|
|
_v == null ? [] : [_v];
|
|
|
|
this.$$populatedVirtuals[name] = this.$$populatedVirtuals[name].filter(function(doc) {
|
|
return doc && typeof doc === 'object';
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
var virtuals = this.virtuals;
|
|
var parts = name.split('.');
|
|
|
|
if (this.pathType(name) === 'real') {
|
|
throw new Error('Virtual path "' + name + '"' +
|
|
' conflicts with a real path in the schema');
|
|
}
|
|
|
|
virtuals[name] = parts.reduce(function(mem, part, i) {
|
|
mem[part] || (mem[part] = (i === parts.length - 1)
|
|
? new VirtualType(options, name)
|
|
: {});
|
|
return mem[part];
|
|
}, this.tree);
|
|
|
|
return virtuals[name];
|
|
};
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
Schema.prototype._getVirtual = function(name) {
|
|
return _getVirtual(this, name);
|
|
};
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
function _getVirtual(schema, name) {
|
|
if (schema.virtuals[name]) {
|
|
return schema.virtuals[name];
|
|
}
|
|
var parts = name.split('.');
|
|
var cur = '';
|
|
var nestedSchemaPath = '';
|
|
for (var i = 0; i < parts.length; ++i) {
|
|
cur += (cur.length > 0 ? '.' : '') + parts[i];
|
|
if (schema.virtuals[cur]) {
|
|
if (i === parts.length - 1) {
|
|
schema.virtuals[cur].$nestedSchemaPath = nestedSchemaPath;
|
|
return schema.virtuals[cur];
|
|
}
|
|
continue;
|
|
} else if (schema.paths[cur] && schema.paths[cur].schema) {
|
|
schema = schema.paths[cur].schema;
|
|
nestedSchemaPath += (nestedSchemaPath.length > 0 ? '.' : '') + cur;
|
|
cur = '';
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the virtual type with the given `name`.
|
|
*
|
|
* @param {String} name
|
|
* @return {VirtualType}
|
|
*/
|
|
|
|
Schema.prototype.virtualpath = function(name) {
|
|
return this.virtuals[name];
|
|
};
|
|
|
|
/**
|
|
* Removes the given `path` (or [`paths`]).
|
|
*
|
|
* @param {String|Array} path
|
|
*
|
|
* @api public
|
|
*/
|
|
Schema.prototype.remove = function(path) {
|
|
if (typeof path === 'string') {
|
|
path = [path];
|
|
}
|
|
if (Array.isArray(path)) {
|
|
path.forEach(function(name) {
|
|
if (this.path(name)) {
|
|
delete this.paths[name];
|
|
|
|
var pieces = name.split('.');
|
|
var last = pieces.pop();
|
|
var branch = this.tree;
|
|
for (var i = 0; i < pieces.length; ++i) {
|
|
branch = branch[pieces[i]];
|
|
}
|
|
delete branch[last];
|
|
}
|
|
}, this);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Loads an ES6 class into a schema. Maps setters + getters, static methods, and instance methods to schema virtuals, statics, and methods.
|
|
*
|
|
* @param {Function} model
|
|
*/
|
|
Schema.prototype.loadClass = function(model, virtualsOnly) {
|
|
if (model === Object.prototype ||
|
|
model === Function.prototype ||
|
|
model.prototype.hasOwnProperty('$isMongooseModelPrototype')) {
|
|
return this;
|
|
}
|
|
|
|
this.loadClass(Object.getPrototypeOf(model));
|
|
|
|
// Add static methods
|
|
if (!virtualsOnly) {
|
|
Object.getOwnPropertyNames(model).forEach(function(name) {
|
|
if (name.match(/^(length|name|prototype)$/)) {
|
|
return;
|
|
}
|
|
var method = Object.getOwnPropertyDescriptor(model, name);
|
|
if (typeof method.value === 'function') {
|
|
this.static(name, method.value);
|
|
}
|
|
}, this);
|
|
}
|
|
|
|
// Add methods and virtuals
|
|
Object.getOwnPropertyNames(model.prototype).forEach(function(name) {
|
|
if (name.match(/^(constructor)$/)) {
|
|
return;
|
|
}
|
|
var method = Object.getOwnPropertyDescriptor(model.prototype, name);
|
|
if (!virtualsOnly) {
|
|
if (typeof method.value === 'function') {
|
|
this.method(name, method.value);
|
|
}
|
|
}
|
|
if (typeof method.get === 'function') {
|
|
this.virtual(name).get(method.get);
|
|
}
|
|
if (typeof method.set === 'function') {
|
|
this.virtual(name).set(method.set);
|
|
}
|
|
}, this);
|
|
|
|
return this;
|
|
};
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
Schema.prototype._getSchema = function(path) {
|
|
var _this = this;
|
|
var pathschema = _this.path(path);
|
|
var resultPath = [];
|
|
|
|
if (pathschema) {
|
|
pathschema.$fullPath = path;
|
|
return pathschema;
|
|
}
|
|
|
|
function search(parts, schema) {
|
|
var p = parts.length + 1;
|
|
var foundschema;
|
|
var trypath;
|
|
|
|
while (p--) {
|
|
trypath = parts.slice(0, p).join('.');
|
|
foundschema = schema.path(trypath);
|
|
if (foundschema) {
|
|
resultPath.push(trypath);
|
|
|
|
if (foundschema.caster) {
|
|
// array of Mixed?
|
|
if (foundschema.caster instanceof MongooseTypes.Mixed) {
|
|
foundschema.caster.$fullPath = resultPath.join('.');
|
|
return foundschema.caster;
|
|
}
|
|
|
|
// Now that we found the array, we need to check if there
|
|
// are remaining document paths to look up for casting.
|
|
// Also we need to handle array.$.path since schema.path
|
|
// doesn't work for that.
|
|
// If there is no foundschema.schema we are dealing with
|
|
// a path like array.$
|
|
if (p !== parts.length && foundschema.schema) {
|
|
var ret;
|
|
if (parts[p] === '$') {
|
|
if (p + 1 === parts.length) {
|
|
// comments.$
|
|
return foundschema;
|
|
}
|
|
// comments.$.comments.$.title
|
|
ret = search(parts.slice(p + 1), foundschema.schema);
|
|
if (ret) {
|
|
ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
|
|
!foundschema.schema.$isSingleNested;
|
|
}
|
|
return ret;
|
|
}
|
|
// this is the last path of the selector
|
|
ret = search(parts.slice(p), foundschema.schema);
|
|
if (ret) {
|
|
ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
|
|
!foundschema.schema.$isSingleNested;
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
foundschema.$fullPath = resultPath.join('.');
|
|
|
|
return foundschema;
|
|
}
|
|
}
|
|
}
|
|
|
|
// look for arrays
|
|
var parts = path.split('.');
|
|
for (var i = 0; i < parts.length; ++i) {
|
|
if (parts[i] === '$') {
|
|
// Re: gh-5628, because `schema.path()` doesn't take $ into account.
|
|
parts[i] = '0';
|
|
}
|
|
}
|
|
return search(parts, _this);
|
|
};
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
Schema.prototype._getPathType = function(path) {
|
|
var _this = this;
|
|
var pathschema = _this.path(path);
|
|
|
|
if (pathschema) {
|
|
return 'real';
|
|
}
|
|
|
|
function search(parts, schema) {
|
|
var p = parts.length + 1,
|
|
foundschema,
|
|
trypath;
|
|
|
|
while (p--) {
|
|
trypath = parts.slice(0, p).join('.');
|
|
foundschema = schema.path(trypath);
|
|
if (foundschema) {
|
|
if (foundschema.caster) {
|
|
// array of Mixed?
|
|
if (foundschema.caster instanceof MongooseTypes.Mixed) {
|
|
return { schema: foundschema, pathType: 'mixed' };
|
|
}
|
|
|
|
// Now that we found the array, we need to check if there
|
|
// are remaining document paths to look up for casting.
|
|
// Also we need to handle array.$.path since schema.path
|
|
// doesn't work for that.
|
|
// If there is no foundschema.schema we are dealing with
|
|
// a path like array.$
|
|
if (p !== parts.length && foundschema.schema) {
|
|
if (parts[p] === '$') {
|
|
if (p === parts.length - 1) {
|
|
return { schema: foundschema, pathType: 'nested' };
|
|
}
|
|
// comments.$.comments.$.title
|
|
return search(parts.slice(p + 1), foundschema.schema);
|
|
}
|
|
// this is the last path of the selector
|
|
return search(parts.slice(p), foundschema.schema);
|
|
}
|
|
return {
|
|
schema: foundschema,
|
|
pathType: foundschema.$isSingleNested ? 'nested' : 'array'
|
|
};
|
|
}
|
|
return { schema: foundschema, pathType: 'real' };
|
|
} else if (p === parts.length && schema.nested[trypath]) {
|
|
return { schema: schema, pathType: 'nested' };
|
|
}
|
|
}
|
|
return { schema: foundschema || schema, pathType: 'undefined' };
|
|
}
|
|
|
|
// look for arrays
|
|
return search(path.split('.'), _this);
|
|
};
|
|
|
|
|
|
/*!
|
|
* Module exports.
|
|
*/
|
|
|
|
module.exports = exports = Schema;
|
|
|
|
// require down here because of reference issues
|
|
|
|
/**
|
|
* The various built-in Mongoose Schema Types.
|
|
*
|
|
* ####Example:
|
|
*
|
|
* var mongoose = require('mongoose');
|
|
* var ObjectId = mongoose.Schema.Types.ObjectId;
|
|
*
|
|
* ####Types:
|
|
*
|
|
* - [String](#schema-string-js)
|
|
* - [Number](#schema-number-js)
|
|
* - [Boolean](#schema-boolean-js) | Bool
|
|
* - [Array](#schema-array-js)
|
|
* - [Buffer](#schema-buffer-js)
|
|
* - [Date](#schema-date-js)
|
|
* - [ObjectId](#schema-objectid-js) | Oid
|
|
* - [Mixed](#schema-mixed-js)
|
|
*
|
|
* Using this exposed access to the `Mixed` SchemaType, we can use them in our schema.
|
|
*
|
|
* var Mixed = mongoose.Schema.Types.Mixed;
|
|
* new mongoose.Schema({ _user: Mixed })
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
Schema.Types = MongooseTypes = require('./schema/index');
|
|
|
|
/*!
|
|
* ignore
|
|
*/
|
|
|
|
exports.ObjectId = MongooseTypes.ObjectId;
|