diff options
author | lizi00164331 <li.zi30@zte.com.cn> | 2017-08-07 11:39:39 +0800 |
---|---|---|
committer | lizi00164331 <li.zi30@zte.com.cn> | 2017-08-07 11:39:39 +0800 |
commit | 21d72c4a80fe2937d0c4ddd20624b27adbcd989b (patch) | |
tree | e5013ee12f74f8452e01cbff16e7b0158bc456cb /common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema | |
parent | f533e73e2ae32e010b16abdcf7985abaf31ab843 (diff) |
Upload the ESR GUI seed code
Issue-ID: AAI-68
Change-Id: Ia50ce0570c2fabecd77199d4e8454f56fe587c4e
Signed-off-by: lizi00164331 <li.zi30@zte.com.cn>
Diffstat (limited to 'common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema')
14 files changed, 2684 insertions, 0 deletions
diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/array.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/array.js new file mode 100644 index 0000000..06a708a --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/array.js @@ -0,0 +1,314 @@ +/*! + * Module dependencies. + */ + +var SchemaType = require('../schematype'); +var CastError = SchemaType.CastError; +var Types = { + Boolean: require('./boolean'), + Date: require('./date'), + Number: require('./number'), + String: require('./string'), + ObjectId: require('./objectid'), + Buffer: require('./buffer') +}; +var MongooseArray = require('../types').Array; +var EmbeddedDoc = require('../types').Embedded; +var Mixed = require('./mixed'); +var cast = require('../cast'); +var util = require('util'); +var utils = require('../utils'); +var castToNumber = require('./operators/helpers').castToNumber; +var geospatial = require('./operators/geospatial'); + +/** + * Array SchemaType constructor + * + * @param {String} key + * @param {SchemaType} cast + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaArray(key, cast, options, schemaOptions) { + var typeKey = 'type'; + if (schemaOptions && schemaOptions.typeKey) { + typeKey = schemaOptions.typeKey; + } + + if (cast) { + var castOptions = {}; + + if (utils.getFunctionName(cast.constructor) === 'Object') { + if (cast[typeKey]) { + // support { type: Woot } + castOptions = utils.clone(cast); // do not alter user arguments + delete castOptions[typeKey]; + cast = cast[typeKey]; + } else { + cast = Mixed; + } + } + + // support { type: 'String' } + var name = typeof cast === 'string' + ? cast + : utils.getFunctionName(cast); + + var caster = name in Types + ? Types[name] + : cast; + + this.casterConstructor = caster; + if (typeof caster === 'function') { + this.caster = new caster(null, castOptions); + } else { + this.caster = caster; + } + + if (!(this.caster instanceof EmbeddedDoc)) { + this.caster.path = key; + } + } + + SchemaType.call(this, key, options, 'Array'); + + var defaultArr; + var fn; + + if (this.defaultValue != null) { + defaultArr = this.defaultValue; + fn = typeof defaultArr === 'function'; + } + + if (!('defaultValue' in this) || this.defaultValue !== void 0) { + this.default(function() { + var arr = []; + if (fn) { + arr = defaultArr(); + } else if (defaultArr != null) { + arr = defaultArr; + } + // Leave it up to `cast()` to convert the array + return arr; + }); + } +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaArray.schemaName = 'Array'; + +/*! + * Inherits from SchemaType. + */ +SchemaArray.prototype = Object.create(SchemaType.prototype); +SchemaArray.prototype.constructor = SchemaArray; + +/** + * Check if the given value satisfies a required validator. The given value + * must be not null nor undefined, and have a non-zero length. + * + * @param {Any} value + * @return {Boolean} + * @api public + */ + +SchemaArray.prototype.checkRequired = function(value) { + return !!(value && value.length); +}; + +/** + * Overrides the getters application for the population special-case + * + * @param {Object} value + * @param {Object} scope + * @api private + */ + +SchemaArray.prototype.applyGetters = function(value, scope) { + if (this.caster.options && this.caster.options.ref) { + // means the object id was populated + return value; + } + + return SchemaType.prototype.applyGetters.call(this, value, scope); +}; + +/** + * Casts values for set(). + * + * @param {Object} value + * @param {Document} doc document that triggers the casting + * @param {Boolean} init whether this is an initialization cast + * @api private + */ + +SchemaArray.prototype.cast = function(value, doc, init) { + if (Array.isArray(value)) { + if (!value.length && doc) { + var indexes = doc.schema.indexedPaths(); + + for (var i = 0, l = indexes.length; i < l; ++i) { + var pathIndex = indexes[i][0][this.path]; + if (pathIndex === '2dsphere' || pathIndex === '2d') { + return; + } + } + } + + if (!(value && value.isMongooseArray)) { + value = new MongooseArray(value, this.path, doc); + } else if (value && value.isMongooseArray) { + // We need to create a new array, otherwise change tracking will + // update the old doc (gh-4449) + value = new MongooseArray(value, this.path, doc); + } + + if (this.caster) { + try { + for (i = 0, l = value.length; i < l; i++) { + value[i] = this.caster.cast(value[i], doc, init); + } + } catch (e) { + // rethrow + throw new CastError('[' + e.kind + ']', util.inspect(value), this.path, e); + } + } + + return value; + } + // gh-2442: if we're loading this from the db and its not an array, mark + // the whole array as modified. + if (!!doc && !!init) { + doc.markModified(this.path); + } + return this.cast([value], doc, init); +}; + +/** + * Casts values for queries. + * + * @param {String} $conditional + * @param {any} [value] + * @api private + */ + +SchemaArray.prototype.castForQuery = function($conditional, value) { + var handler, + val; + + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with Array.'); + } + + val = handler.call(this, value); + } else { + val = $conditional; + var proto = this.casterConstructor.prototype; + var method = proto && (proto.castForQuery || proto.cast); + var caster = this.caster; + + if (Array.isArray(val)) { + val = val.map(function(v) { + if (utils.isObject(v) && v.$elemMatch) { + return v; + } + if (method) { + v = method.call(caster, v); + } + return v; + }); + } else if (method) { + val = method.call(caster, val); + } + } + + return val; +}; + +function cast$all(val) { + if (!Array.isArray(val)) { + val = [val]; + } + + val = val.map(function(v) { + if (utils.isObject(v)) { + var o = {}; + o[this.path] = v; + return cast(this.casterConstructor.schema, o)[this.path]; + } + return v; + }, this); + + return this.castForQuery(val); +} + +function cast$elemMatch(val) { + var keys = Object.keys(val); + var numKeys = keys.length; + var key; + var value; + for (var i = 0; i < numKeys; ++i) { + key = keys[i]; + value = val[key]; + if (key.indexOf('$') === 0 && value) { + val[key] = this.castForQuery(key, value); + } + } + + return cast(this.casterConstructor.schema, val); +} + +var handle = SchemaArray.prototype.$conditionalHandlers = {}; + +handle.$all = cast$all; +handle.$options = String; +handle.$elemMatch = cast$elemMatch; +handle.$geoIntersects = geospatial.cast$geoIntersects; +handle.$or = handle.$and = function(val) { + if (!Array.isArray(val)) { + throw new TypeError('conditional $or/$and require array'); + } + + var ret = []; + for (var i = 0; i < val.length; ++i) { + ret.push(cast(this.casterConstructor.schema, val[i])); + } + + return ret; +}; + +handle.$near = +handle.$nearSphere = geospatial.cast$near; + +handle.$within = +handle.$geoWithin = geospatial.cast$within; + +handle.$size = +handle.$minDistance = +handle.$maxDistance = castToNumber; + +handle.$eq = +handle.$gt = +handle.$gte = +handle.$in = +handle.$lt = +handle.$lte = +handle.$ne = +handle.$nin = +handle.$regex = SchemaArray.prototype.castForQuery; + +/*! + * Module exports. + */ + +module.exports = SchemaArray; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/boolean.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/boolean.js new file mode 100644 index 0000000..206d9fd --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/boolean.js @@ -0,0 +1,103 @@ +/*! + * Module dependencies. + */ + +var utils = require('../utils'); + +var SchemaType = require('../schematype'); + +/** + * Boolean SchemaType constructor. + * + * @param {String} path + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaBoolean(path, options) { + SchemaType.call(this, path, options, 'Boolean'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaBoolean.schemaName = 'Boolean'; + +/*! + * Inherits from SchemaType. + */ +SchemaBoolean.prototype = Object.create(SchemaType.prototype); +SchemaBoolean.prototype.constructor = SchemaBoolean; + +/** + * Check if the given value satisfies a required validator. For a boolean + * to satisfy a required validator, it must be strictly equal to true or to + * false. + * + * @param {Any} value + * @return {Boolean} + * @api public + */ + +SchemaBoolean.prototype.checkRequired = function(value) { + return value === true || value === false; +}; + +/** + * Casts to boolean + * + * @param {Object} value + * @api private + */ + +SchemaBoolean.prototype.cast = function(value) { + if (value === null) { + return value; + } + if (value === '0') { + return false; + } + if (value === 'true') { + return true; + } + if (value === 'false') { + return false; + } + return !!value; +}; + +SchemaBoolean.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, {}); + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} val + * @api private + */ + +SchemaBoolean.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = SchemaBoolean.$conditionalHandlers[$conditional]; + + if (handler) { + return handler.call(this, val); + } + + return this.cast(val); + } + + return this.cast($conditional); +}; + +/*! + * Module exports. + */ + +module.exports = SchemaBoolean; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/buffer.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/buffer.js new file mode 100644 index 0000000..e7fe814 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/buffer.js @@ -0,0 +1,188 @@ +/*! + * Module dependencies. + */ + +var handleBitwiseOperator = require('./operators/bitwise'); +var utils = require('../utils'); + +var MongooseBuffer = require('../types').Buffer; +var SchemaType = require('../schematype'); + +var Binary = MongooseBuffer.Binary; +var CastError = SchemaType.CastError; +var Document; + +/** + * Buffer SchemaType constructor + * + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaBuffer(key, options) { + SchemaType.call(this, key, options, 'Buffer'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaBuffer.schemaName = 'Buffer'; + +/*! + * Inherits from SchemaType. + */ +SchemaBuffer.prototype = Object.create(SchemaType.prototype); +SchemaBuffer.prototype.constructor = SchemaBuffer; + +/** + * Check if the given value satisfies a required validator. To satisfy a + * required validator, a buffer must not be null or undefined and have + * non-zero length. + * + * @param {Any} value + * @param {Document} doc + * @return {Boolean} + * @api public + */ + +SchemaBuffer.prototype.checkRequired = function(value, doc) { + if (SchemaType._isRef(this, value, doc, true)) { + return !!value; + } + return !!(value && value.length); +}; + +/** + * Casts contents + * + * @param {Object} value + * @param {Document} doc document that triggers the casting + * @param {Boolean} init + * @api private + */ + +SchemaBuffer.prototype.cast = function(value, doc, init) { + var ret; + if (SchemaType._isRef(this, value, doc, init)) { + // wait! we may need to cast this to a document + + if (value === null || value === undefined) { + return value; + } + + // lazy load + Document || (Document = require('./../document')); + + if (value instanceof Document) { + value.$__.wasPopulated = true; + return value; + } + + // setting a populated path + if (Buffer.isBuffer(value)) { + return value; + } else if (!utils.isObject(value)) { + throw new CastError('buffer', value, this.path); + } + + // Handle the case where user directly sets a populated + // path to a plain object; cast to the Model used in + // the population query. + var path = doc.$__fullPath(this.path); + var owner = doc.ownerDocument ? doc.ownerDocument() : doc; + var pop = owner.populated(path, true); + ret = new pop.options.model(value); + ret.$__.wasPopulated = true; + return ret; + } + + // documents + if (value && value._id) { + value = value._id; + } + + if (value && value.isMongooseBuffer) { + return value; + } + + if (Buffer.isBuffer(value)) { + if (!value || !value.isMongooseBuffer) { + value = new MongooseBuffer(value, [this.path, doc]); + } + + return value; + } else if (value instanceof Binary) { + ret = new MongooseBuffer(value.value(true), [this.path, doc]); + if (typeof value.sub_type !== 'number') { + throw new CastError('buffer', value, this.path); + } + ret._subtype = value.sub_type; + return ret; + } + + if (value === null) { + return value; + } + + var type = typeof value; + if (type === 'string' || type === 'number' || Array.isArray(value)) { + if (type === 'number') { + value = [value]; + } + ret = new MongooseBuffer(value, [this.path, doc]); + return ret; + } + + throw new CastError('buffer', value, this.path); +}; + +/*! + * ignore + */ +function handleSingle(val) { + return this.castForQuery(val); +} + +SchemaBuffer.prototype.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, { + $bitsAllClear: handleBitwiseOperator, + $bitsAnyClear: handleBitwiseOperator, + $bitsAllSet: handleBitwiseOperator, + $bitsAnySet: handleBitwiseOperator, + $gt: handleSingle, + $gte: handleSingle, + $lt: handleSingle, + $lte: handleSingle + }); + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} [value] + * @api private + */ + +SchemaBuffer.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with Buffer.'); + } + return handler.call(this, val); + } + val = $conditional; + return this.cast(val).toObject({ transform: false }); +}; + +/*! + * Module exports. + */ + +module.exports = SchemaBuffer; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/date.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/date.js new file mode 100644 index 0000000..b7bcf22 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/date.js @@ -0,0 +1,296 @@ +/*! + * Module requirements. + */ + +var MongooseError = require('../error'); +var utils = require('../utils'); + +var SchemaType = require('../schematype'); + +var CastError = SchemaType.CastError; + +/** + * Date SchemaType constructor. + * + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaDate(key, options) { + SchemaType.call(this, key, options, 'Date'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaDate.schemaName = 'Date'; + +/*! + * Inherits from SchemaType. + */ +SchemaDate.prototype = Object.create(SchemaType.prototype); +SchemaDate.prototype.constructor = SchemaDate; + +/** + * Declares a TTL index (rounded to the nearest second) for _Date_ types only. + * + * This sets the `expireAfterSeconds` index option available in MongoDB >= 2.1.2. + * This index type is only compatible with Date types. + * + * ####Example: + * + * // expire in 24 hours + * new Schema({ createdAt: { type: Date, expires: 60*60*24 }}); + * + * `expires` utilizes the `ms` module from [guille](https://github.com/guille/) allowing us to use a friendlier syntax: + * + * ####Example: + * + * // expire in 24 hours + * new Schema({ createdAt: { type: Date, expires: '24h' }}); + * + * // expire in 1.5 hours + * new Schema({ createdAt: { type: Date, expires: '1.5h' }}); + * + * // expire in 7 days + * var schema = new Schema({ createdAt: Date }); + * schema.path('createdAt').expires('7d'); + * + * @param {Number|String} when + * @added 3.0.0 + * @return {SchemaType} this + * @api public + */ + +SchemaDate.prototype.expires = function(when) { + if (!this._index || this._index.constructor.name !== 'Object') { + this._index = {}; + } + + this._index.expires = when; + utils.expires(this._index); + return this; +}; + +/** + * Check if the given value satisfies a required validator. To satisfy + * a required validator, the given value must be an instance of `Date`. + * + * @param {Any} value + * @param {Document} doc + * @return {Boolean} + * @api public + */ + +SchemaDate.prototype.checkRequired = function(value) { + return value instanceof Date; +}; + +/** + * Sets a minimum date validator. + * + * ####Example: + * + * var s = new Schema({ d: { type: Date, min: Date('1970-01-01') }) + * var M = db.model('M', s) + * var m = new M({ d: Date('1969-12-31') }) + * m.save(function (err) { + * console.error(err) // validator error + * m.d = Date('2014-12-08'); + * m.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MIN} token which will be replaced with the invalid value + * var min = [Date('1970-01-01'), 'The value of path `{PATH}` ({VALUE}) is beneath the limit ({MIN}).']; + * var schema = new Schema({ d: { type: Date, min: min }) + * var M = mongoose.model('M', schema); + * var s= new M({ d: Date('1969-12-31') }); + * s.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `d` (1969-12-31) is before the limit (1970-01-01). + * }) + * + * @param {Date} value minimum date + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaDate.prototype.min = function(value, message) { + if (this.minValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.minValidator; + }, this); + } + + if (value) { + var msg = message || MongooseError.messages.Date.min; + msg = msg.replace(/{MIN}/, (value === Date.now ? 'Date.now()' : this.cast(value).toString())); + var _this = this; + this.validators.push({ + validator: this.minValidator = function(val) { + var min = (value === Date.now ? value() : _this.cast(value)); + return val === null || val.valueOf() >= min.valueOf(); + }, + message: msg, + type: 'min', + min: value + }); + } + + return this; +}; + +/** + * Sets a maximum date validator. + * + * ####Example: + * + * var s = new Schema({ d: { type: Date, max: Date('2014-01-01') }) + * var M = db.model('M', s) + * var m = new M({ d: Date('2014-12-08') }) + * m.save(function (err) { + * console.error(err) // validator error + * m.d = Date('2013-12-31'); + * m.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MAX} token which will be replaced with the invalid value + * var max = [Date('2014-01-01'), 'The value of path `{PATH}` ({VALUE}) exceeds the limit ({MAX}).']; + * var schema = new Schema({ d: { type: Date, max: max }) + * var M = mongoose.model('M', schema); + * var s= new M({ d: Date('2014-12-08') }); + * s.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `d` (2014-12-08) exceeds the limit (2014-01-01). + * }) + * + * @param {Date} maximum date + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaDate.prototype.max = function(value, message) { + if (this.maxValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.maxValidator; + }, this); + } + + if (value) { + var msg = message || MongooseError.messages.Date.max; + msg = msg.replace(/{MAX}/, (value === Date.now ? 'Date.now()' : this.cast(value).toString())); + var _this = this; + this.validators.push({ + validator: this.maxValidator = function(val) { + var max = (value === Date.now ? value() : _this.cast(value)); + return val === null || val.valueOf() <= max.valueOf(); + }, + message: msg, + type: 'max', + max: value + }); + } + + return this; +}; + +/** + * Casts to date + * + * @param {Object} value to cast + * @api private + */ + +SchemaDate.prototype.cast = function(value) { + // If null or undefined + if (value === null || value === void 0 || value === '') { + return null; + } + + if (value instanceof Date) { + if (isNaN(value.valueOf())) { + throw new CastError('date', value, this.path); + } + + return value; + } + + var date; + + if (typeof value === 'boolean') { + throw new CastError('date', value, this.path); + } + + if (value instanceof Number || typeof value === 'number' + || String(value) == Number(value)) { + // support for timestamps + date = new Date(Number(value)); + } else if (value.valueOf) { + // support for moment.js + date = new Date(value.valueOf()); + } + + if (!isNaN(date.valueOf())) { + return date; + } + + throw new CastError('date', value, this.path); +}; + +/*! + * Date Query casting. + * + * @api private + */ + +function handleSingle(val) { + return this.cast(val); +} + +SchemaDate.prototype.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, { + $gt: handleSingle, + $gte: handleSingle, + $lt: handleSingle, + $lte: handleSingle + }); + + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} [value] + * @api private + */ + +SchemaDate.prototype.castForQuery = function($conditional, val) { + var handler; + + if (arguments.length !== 2) { + return this.cast($conditional); + } + + handler = this.$conditionalHandlers[$conditional]; + + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with Date.'); + } + + return handler.call(this, val); +}; + +/*! + * Module exports. + */ + +module.exports = SchemaDate; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/documentarray.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/documentarray.js new file mode 100644 index 0000000..96da049 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/documentarray.js @@ -0,0 +1,313 @@ +/* eslint no-empty: 1 */ + +/*! + * Module dependencies. + */ + +var ArrayType = require('./array'); +var CastError = require('../error/cast'); +var MongooseDocumentArray = require('../types/documentarray'); +var SchemaType = require('../schematype'); +var Subdocument = require('../types/embedded'); +var util = require('util'); + +/** + * SubdocsArray SchemaType constructor + * + * @param {String} key + * @param {Schema} schema + * @param {Object} options + * @inherits SchemaArray + * @api public + */ + +function DocumentArray(key, schema, options) { + // compile an embedded document for this schema + function EmbeddedDocument() { + Subdocument.apply(this, arguments); + } + + EmbeddedDocument.prototype = Object.create(Subdocument.prototype); + EmbeddedDocument.prototype.$__setSchema(schema); + EmbeddedDocument.schema = schema; + + // apply methods + for (var i in schema.methods) { + EmbeddedDocument.prototype[i] = schema.methods[i]; + } + + // apply statics + for (i in schema.statics) { + EmbeddedDocument[i] = schema.statics[i]; + } + + EmbeddedDocument.options = options; + + ArrayType.call(this, key, EmbeddedDocument, options); + + this.schema = schema; + this.$isMongooseDocumentArray = true; + var fn = this.defaultValue; + + if (!('defaultValue' in this) || fn !== void 0) { + this.default(function() { + var arr = fn.call(this); + if (!Array.isArray(arr)) { + arr = [arr]; + } + // Leave it up to `cast()` to convert this to a documentarray + return arr; + }); + } +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +DocumentArray.schemaName = 'DocumentArray'; + +/*! + * Inherits from ArrayType. + */ +DocumentArray.prototype = Object.create(ArrayType.prototype); +DocumentArray.prototype.constructor = DocumentArray; + +/** + * Performs local validations first, then validations on each embedded doc + * + * @api private + */ + +DocumentArray.prototype.doValidate = function(array, fn, scope, options) { + var _this = this; + SchemaType.prototype.doValidate.call(this, array, function(err) { + if (err) { + return fn(err); + } + + var count = array && array.length; + var error; + + if (!count) { + return fn(); + } + if (options && options.updateValidator) { + return fn(); + } + + // handle sparse arrays, do not use array.forEach which does not + // iterate over sparse elements yet reports array.length including + // them :( + + function callback(err) { + if (err) { + error = err; + } + --count || fn(error); + } + + for (var i = 0, len = count; i < len; ++i) { + // sidestep sparse entries + var doc = array[i]; + if (!doc) { + --count || fn(error); + continue; + } + + // If you set the array index directly, the doc might not yet be + // a full fledged mongoose subdoc, so make it into one. + if (!(doc instanceof Subdocument)) { + doc = array[i] = new _this.casterConstructor(doc, array, undefined, + undefined, i); + } + + // HACK: use $__original_validate to avoid promises so bluebird doesn't + // complain + if (doc.$__original_validate) { + doc.$__original_validate({__noPromise: true}, callback); + } else { + doc.validate({__noPromise: true}, callback); + } + } + }, scope); +}; + +/** + * Performs local validations first, then validations on each embedded doc. + * + * ####Note: + * + * This method ignores the asynchronous validators. + * + * @return {MongooseError|undefined} + * @api private + */ + +DocumentArray.prototype.doValidateSync = function(array, scope) { + var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, array, scope); + if (schemaTypeError) { + return schemaTypeError; + } + + var count = array && array.length, + resultError = null; + + if (!count) { + return; + } + + // handle sparse arrays, do not use array.forEach which does not + // iterate over sparse elements yet reports array.length including + // them :( + + for (var i = 0, len = count; i < len; ++i) { + // only first error + if (resultError) { + break; + } + // sidestep sparse entries + var doc = array[i]; + if (!doc) { + continue; + } + + var subdocValidateError = doc.validateSync(); + + if (subdocValidateError) { + resultError = subdocValidateError; + } + } + + return resultError; +}; + +/** + * Casts contents + * + * @param {Object} value + * @param {Document} document that triggers the casting + * @api private + */ + +DocumentArray.prototype.cast = function(value, doc, init, prev, options) { + var selected, + subdoc, + i; + + if (!Array.isArray(value)) { + // gh-2442 mark whole array as modified if we're initializing a doc from + // the db and the path isn't an array in the document + if (!!doc && init) { + doc.markModified(this.path); + } + return this.cast([value], doc, init, prev); + } + + if (!(value && value.isMongooseDocumentArray) && + (!options || !options.skipDocumentArrayCast)) { + value = new MongooseDocumentArray(value, this.path, doc); + if (prev && prev._handlers) { + for (var key in prev._handlers) { + doc.removeListener(key, prev._handlers[key]); + } + } + } else if (value && value.isMongooseDocumentArray) { + // We need to create a new array, otherwise change tracking will + // update the old doc (gh-4449) + value = new MongooseDocumentArray(value, this.path, doc); + } + + i = value.length; + + while (i--) { + if (!value[i]) { + continue; + } + // Check if the document has a different schema (re gh-3701) + if ((value[i] instanceof Subdocument) && + value[i].schema !== this.casterConstructor.schema) { + value[i] = value[i].toObject({transform: false}); + } + if (!(value[i] instanceof Subdocument) && value[i]) { + if (init) { + if (doc) { + selected || (selected = scopePaths(this, doc.$__.selected, init)); + } else { + selected = true; + } + + subdoc = new this.casterConstructor(null, value, true, selected, i); + value[i] = subdoc.init(value[i]); + } else { + try { + subdoc = prev.id(value[i]._id); + } catch (e) { + } + + if (prev && subdoc) { + // handle resetting doc with existing id but differing data + // doc.array = [{ doc: 'val' }] + subdoc.set(value[i]); + // if set() is hooked it will have no return value + // see gh-746 + value[i] = subdoc; + } else { + try { + subdoc = new this.casterConstructor(value[i], value, undefined, + undefined, i); + // if set() is hooked it will have no return value + // see gh-746 + value[i] = subdoc; + } catch (error) { + var valueInErrorMessage = util.inspect(value[i]); + throw new CastError('embedded', valueInErrorMessage, + value._path, error); + } + } + } + } + } + + return value; +}; + +/*! + * Scopes paths selected in a query to this array. + * Necessary for proper default application of subdocument values. + * + * @param {DocumentArray} array - the array to scope `fields` paths + * @param {Object|undefined} fields - the root fields selected in the query + * @param {Boolean|undefined} init - if we are being created part of a query result + */ + +function scopePaths(array, fields, init) { + if (!(init && fields)) { + return undefined; + } + + var path = array.path + '.', + keys = Object.keys(fields), + i = keys.length, + selected = {}, + hasKeys, + key; + + while (i--) { + key = keys[i]; + if (key.indexOf(path) === 0) { + hasKeys || (hasKeys = true); + selected[key.substring(path.length)] = fields[key]; + } + } + + return hasKeys && selected || undefined; +} + +/*! + * Module exports. + */ + +module.exports = DocumentArray; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/embedded.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/embedded.js new file mode 100644 index 0000000..1d3d892 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/embedded.js @@ -0,0 +1,177 @@ +'use strict'; + +/*! + * Module dependencies. + */ + +var SchemaType = require('../schematype'); +var Subdocument = require('../types/subdocument'); +var castToNumber = require('./operators/helpers').castToNumber; +var geospatial = require('./operators/geospatial'); + +module.exports = Embedded; + +/** + * Sub-schema schematype constructor + * + * @param {Schema} schema + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function Embedded(schema, path, options) { + var _embedded = function(value, path, parent) { + var _this = this; + Subdocument.apply(this, arguments); + this.$parent = parent; + if (parent) { + parent.on('save', function() { + _this.emit('save', _this); + }); + + parent.on('isNew', function(val) { + _this.isNew = val; + _this.emit('isNew', val); + }); + } + }; + _embedded.prototype = Object.create(Subdocument.prototype); + _embedded.prototype.$__setSchema(schema); + _embedded.schema = schema; + _embedded.$isSingleNested = true; + _embedded.prototype.$basePath = path; + _embedded.prototype.toBSON = function() { + return this.toObject({ + transform: false, + retainKeyOrder: schema.options.retainKeyOrder + }); + }; + + // apply methods + for (var i in schema.methods) { + _embedded.prototype[i] = schema.methods[i]; + } + + // apply statics + for (i in schema.statics) { + _embedded[i] = schema.statics[i]; + } + + this.caster = _embedded; + this.schema = schema; + this.$isSingleNested = true; + SchemaType.call(this, path, options, 'Embedded'); +} + +Embedded.prototype = Object.create(SchemaType.prototype); + +/** + * Special case for when users use a common location schema to represent + * locations for use with $geoWithin. + * https://docs.mongodb.org/manual/reference/operator/query/geoWithin/ + * + * @param {Object} val + * @api private + */ + +Embedded.prototype.$conditionalHandlers.$geoWithin = function(val) { + return { $geometry: this.castForQuery(val.$geometry) }; +}; + +/*! + * ignore + */ + +Embedded.prototype.$conditionalHandlers.$near = +Embedded.prototype.$conditionalHandlers.$nearSphere = geospatial.cast$near; + +Embedded.prototype.$conditionalHandlers.$within = +Embedded.prototype.$conditionalHandlers.$geoWithin = geospatial.cast$within; + +Embedded.prototype.$conditionalHandlers.$geoIntersects = + geospatial.cast$geoIntersects; + +Embedded.prototype.$conditionalHandlers.$minDistance = castToNumber; +Embedded.prototype.$conditionalHandlers.$maxDistance = castToNumber; + +/** + * Casts contents + * + * @param {Object} value + * @api private + */ + +Embedded.prototype.cast = function(val, doc, init) { + if (val && val.$isSingleNested) { + return val; + } + var subdoc = new this.caster(void 0, doc ? doc.$__.selected : void 0, doc); + if (init) { + subdoc.init(val); + } else { + subdoc.set(val, undefined, true); + } + return subdoc; +}; + +/** + * Casts contents for query + * + * @param {string} [$conditional] optional query operator (like `$eq` or `$in`) + * @param {any} value + * @api private + */ + +Embedded.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + if (!handler) { + throw new Error('Can\'t use ' + $conditional); + } + return handler.call(this, val); + } + val = $conditional; + if (val == null) { + return val; + } + + return new this.caster(val); +}; + +/** + * Async validation on this single nested doc. + * + * @api private + */ + +Embedded.prototype.doValidate = function(value, fn, scope) { + SchemaType.prototype.doValidate.call(this, value, function(error) { + if (error) { + return fn(error); + } + if (!value) { + return fn(null); + } + value.validate(fn, {__noPromise: true}); + }, scope); +}; + +/** + * Synchronously validate this single nested doc + * + * @api private + */ + +Embedded.prototype.doValidateSync = function(value, scope) { + var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope); + if (schemaTypeError) { + return schemaTypeError; + } + if (!value) { + return; + } + return value.validateSync(); +}; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/index.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/index.js new file mode 100644 index 0000000..f2935c1 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/index.js @@ -0,0 +1,30 @@ + +/*! + * Module exports. + */ + +exports.String = require('./string'); + +exports.Number = require('./number'); + +exports.Boolean = require('./boolean'); + +exports.DocumentArray = require('./documentarray'); + +exports.Embedded = require('./embedded'); + +exports.Array = require('./array'); + +exports.Buffer = require('./buffer'); + +exports.Date = require('./date'); + +exports.ObjectId = require('./objectid'); + +exports.Mixed = require('./mixed'); + +// alias + +exports.Oid = exports.ObjectId; +exports.Object = exports.Mixed; +exports.Bool = exports.Boolean; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/mixed.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/mixed.js new file mode 100644 index 0000000..e4c23ca --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/mixed.js @@ -0,0 +1,80 @@ +/*! + * Module dependencies. + */ + +var SchemaType = require('../schematype'); +var utils = require('../utils'); + +/** + * Mixed SchemaType constructor. + * + * @param {String} path + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function Mixed(path, options) { + if (options && options.default) { + var def = options.default; + if (Array.isArray(def) && def.length === 0) { + // make sure empty array defaults are handled + options.default = Array; + } else if (!options.shared && utils.isObject(def) && Object.keys(def).length === 0) { + // prevent odd "shared" objects between documents + options.default = function() { + return {}; + }; + } + } + + SchemaType.call(this, path, options, 'Mixed'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +Mixed.schemaName = 'Mixed'; + +/*! + * Inherits from SchemaType. + */ +Mixed.prototype = Object.create(SchemaType.prototype); +Mixed.prototype.constructor = Mixed; + +/** + * Casts `val` for Mixed. + * + * _this is a no-op_ + * + * @param {Object} value to cast + * @api private + */ + +Mixed.prototype.cast = function(val) { + return val; +}; + +/** + * Casts contents for queries. + * + * @param {String} $cond + * @param {any} [val] + * @api private + */ + +Mixed.prototype.castForQuery = function($cond, val) { + if (arguments.length === 2) { + return val; + } + return $cond; +}; + +/*! + * Module exports. + */ + +module.exports = Mixed; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/number.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/number.js new file mode 100644 index 0000000..a91f6dd --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/number.js @@ -0,0 +1,290 @@ +/*! + * Module requirements. + */ + +var SchemaType = require('../schematype'); +var CastError = SchemaType.CastError; +var handleBitwiseOperator = require('./operators/bitwise'); +var MongooseError = require('../error'); +var utils = require('../utils'); +var Document; + +/** + * Number SchemaType constructor. + * + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaNumber(key, options) { + SchemaType.call(this, key, options, 'Number'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaNumber.schemaName = 'Number'; + +/*! + * Inherits from SchemaType. + */ +SchemaNumber.prototype = Object.create(SchemaType.prototype); +SchemaNumber.prototype.constructor = SchemaNumber; + +/** + * Check if the given value satisfies a required validator. + * + * @param {Any} value + * @param {Document} doc + * @return {Boolean} + * @api public + */ + +SchemaNumber.prototype.checkRequired = function checkRequired(value, doc) { + if (SchemaType._isRef(this, value, doc, true)) { + return !!value; + } + return typeof value === 'number' || value instanceof Number; +}; + +/** + * Sets a minimum number validator. + * + * ####Example: + * + * var s = new Schema({ n: { type: Number, min: 10 }) + * var M = db.model('M', s) + * var m = new M({ n: 9 }) + * m.save(function (err) { + * console.error(err) // validator error + * m.n = 10; + * m.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MIN} token which will be replaced with the invalid value + * var min = [10, 'The value of path `{PATH}` ({VALUE}) is beneath the limit ({MIN}).']; + * var schema = new Schema({ n: { type: Number, min: min }) + * var M = mongoose.model('Measurement', schema); + * var s= new M({ n: 4 }); + * s.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `n` (4) is beneath the limit (10). + * }) + * + * @param {Number} value minimum number + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaNumber.prototype.min = function(value, message) { + if (this.minValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.minValidator; + }, this); + } + + if (value !== null && value !== undefined) { + var msg = message || MongooseError.messages.Number.min; + msg = msg.replace(/{MIN}/, value); + this.validators.push({ + validator: this.minValidator = function(v) { + return v == null || v >= value; + }, + message: msg, + type: 'min', + min: value + }); + } + + return this; +}; + +/** + * Sets a maximum number validator. + * + * ####Example: + * + * var s = new Schema({ n: { type: Number, max: 10 }) + * var M = db.model('M', s) + * var m = new M({ n: 11 }) + * m.save(function (err) { + * console.error(err) // validator error + * m.n = 10; + * m.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MAX} token which will be replaced with the invalid value + * var max = [10, 'The value of path `{PATH}` ({VALUE}) exceeds the limit ({MAX}).']; + * var schema = new Schema({ n: { type: Number, max: max }) + * var M = mongoose.model('Measurement', schema); + * var s= new M({ n: 4 }); + * s.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `n` (4) exceeds the limit (10). + * }) + * + * @param {Number} maximum number + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaNumber.prototype.max = function(value, message) { + if (this.maxValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.maxValidator; + }, this); + } + + if (value !== null && value !== undefined) { + var msg = message || MongooseError.messages.Number.max; + msg = msg.replace(/{MAX}/, value); + this.validators.push({ + validator: this.maxValidator = function(v) { + return v == null || v <= value; + }, + message: msg, + type: 'max', + max: value + }); + } + + return this; +}; + +/** + * Casts to number + * + * @param {Object} value value to cast + * @param {Document} doc document that triggers the casting + * @param {Boolean} init + * @api private + */ + +SchemaNumber.prototype.cast = function(value, doc, init) { + if (SchemaType._isRef(this, value, doc, init)) { + // wait! we may need to cast this to a document + + if (value === null || value === undefined) { + return value; + } + + // lazy load + Document || (Document = require('./../document')); + + if (value instanceof Document) { + value.$__.wasPopulated = true; + return value; + } + + // setting a populated path + if (typeof value === 'number') { + return value; + } else if (Buffer.isBuffer(value) || !utils.isObject(value)) { + throw new CastError('number', value, this.path); + } + + // Handle the case where user directly sets a populated + // path to a plain object; cast to the Model used in + // the population query. + var path = doc.$__fullPath(this.path); + var owner = doc.ownerDocument ? doc.ownerDocument() : doc; + var pop = owner.populated(path, true); + var ret = new pop.options.model(value); + ret.$__.wasPopulated = true; + return ret; + } + + var val = value && typeof value._id !== 'undefined' ? + value._id : // documents + value; + + if (!isNaN(val)) { + if (val === null) { + return val; + } + if (val === '') { + return null; + } + if (typeof val === 'string' || typeof val === 'boolean') { + val = Number(val); + } + if (val instanceof Number) { + return val; + } + if (typeof val === 'number') { + return val; + } + if (val.toString && !Array.isArray(val) && val.toString() == Number(val)) { + return new Number(val); + } + } + + throw new CastError('number', value, this.path); +}; + +/*! + * ignore + */ + +function handleSingle(val) { + return this.cast(val); +} + +function handleArray(val) { + var _this = this; + if (!Array.isArray(val)) { + return [this.cast(val)]; + } + return val.map(function(m) { + return _this.cast(m); + }); +} + +SchemaNumber.prototype.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, { + $bitsAllClear: handleBitwiseOperator, + $bitsAnyClear: handleBitwiseOperator, + $bitsAllSet: handleBitwiseOperator, + $bitsAnySet: handleBitwiseOperator, + $gt: handleSingle, + $gte: handleSingle, + $lt: handleSingle, + $lte: handleSingle, + $mod: handleArray + }); + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} [value] + * @api private + */ + +SchemaNumber.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with Number.'); + } + return handler.call(this, val); + } + val = this.cast($conditional); + return val; +}; + +/*! + * Module exports. + */ + +module.exports = SchemaNumber; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/objectid.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/objectid.js new file mode 100644 index 0000000..2885823 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/objectid.js @@ -0,0 +1,207 @@ +/* eslint no-empty: 1 */ + +/*! + * Module dependencies. + */ + +var SchemaType = require('../schematype'), + CastError = SchemaType.CastError, + oid = require('../types/objectid'), + utils = require('../utils'), + Document; + +/** + * ObjectId SchemaType constructor. + * + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function ObjectId(key, options) { + SchemaType.call(this, key, options, 'ObjectID'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +ObjectId.schemaName = 'ObjectId'; + +/*! + * Inherits from SchemaType. + */ +ObjectId.prototype = Object.create(SchemaType.prototype); +ObjectId.prototype.constructor = ObjectId; + +/** + * Adds an auto-generated ObjectId default if turnOn is true. + * @param {Boolean} turnOn auto generated ObjectId defaults + * @api public + * @return {SchemaType} this + */ + +ObjectId.prototype.auto = function(turnOn) { + if (turnOn) { + this.default(defaultId); + this.set(resetId); + } + + return this; +}; + +/** + * Check if the given value satisfies a required validator. + * + * @param {Any} value + * @param {Document} doc + * @return {Boolean} + * @api public + */ + +ObjectId.prototype.checkRequired = function checkRequired(value, doc) { + if (SchemaType._isRef(this, value, doc, true)) { + return !!value; + } + return value instanceof oid; +}; + +/** + * Casts to ObjectId + * + * @param {Object} value + * @param {Object} doc + * @param {Boolean} init whether this is an initialization cast + * @api private + */ + +ObjectId.prototype.cast = function(value, doc, init) { + if (SchemaType._isRef(this, value, doc, init)) { + // wait! we may need to cast this to a document + + if (value === null || value === undefined) { + return value; + } + + // lazy load + Document || (Document = require('./../document')); + + if (value instanceof Document) { + value.$__.wasPopulated = true; + return value; + } + + // setting a populated path + if (value instanceof oid) { + return value; + } else if (Buffer.isBuffer(value) || !utils.isObject(value)) { + throw new CastError('ObjectId', value, this.path); + } + + // Handle the case where user directly sets a populated + // path to a plain object; cast to the Model used in + // the population query. + var path = doc.$__fullPath(this.path); + var owner = doc.ownerDocument ? doc.ownerDocument() : doc; + var pop = owner.populated(path, true); + var ret = value; + if (!doc.$__.populated || + !doc.$__.populated[path] || + !doc.$__.populated[path].options || + !doc.$__.populated[path].options.options || + !doc.$__.populated[path].options.options.lean) { + ret = new pop.options.model(value); + ret.$__.wasPopulated = true; + } + + return ret; + } + + if (value === null || value === undefined) { + return value; + } + + if (value instanceof oid) { + return value; + } + + if (value._id) { + if (value._id instanceof oid) { + return value._id; + } + if (value._id.toString instanceof Function) { + try { + return new oid(value._id.toString()); + } catch (e) { + } + } + } + + if (value.toString instanceof Function) { + try { + return new oid(value.toString()); + } catch (err) { + throw new CastError('ObjectId', value, this.path); + } + } + + throw new CastError('ObjectId', value, this.path); +}; + +/*! + * ignore + */ + +function handleSingle(val) { + return this.cast(val); +} + +ObjectId.prototype.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, { + $gt: handleSingle, + $gte: handleSingle, + $lt: handleSingle, + $lte: handleSingle + }); + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} [val] + * @api private + */ + +ObjectId.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with ObjectId.'); + } + return handler.call(this, val); + } + return this.cast($conditional); +}; + +/*! + * ignore + */ + +function defaultId() { + return new oid(); +} + +function resetId(v) { + this.$__._id = null; + return v; +} + +/*! + * Module exports. + */ + +module.exports = ObjectId; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/bitwise.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/bitwise.js new file mode 100644 index 0000000..c1fdd34 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/bitwise.js @@ -0,0 +1,36 @@ +/*! + * Module requirements. + */ + +var CastError = require('../../error/cast'); + +/*! + * ignore + */ + +function handleBitwiseOperator(val) { + var _this = this; + if (Array.isArray(val)) { + return val.map(function(v) { + return _castNumber(_this.path, v); + }); + } else if (Buffer.isBuffer(val)) { + return val; + } + // Assume trying to cast to number + return _castNumber(_this.path, val); +} + +/*! + * ignore + */ + +function _castNumber(path, num) { + var v = Number(num); + if (isNaN(v)) { + throw new CastError('number', num, path); + } + return v; +} + +module.exports = handleBitwiseOperator; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/geospatial.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/geospatial.js new file mode 100644 index 0000000..b490d2d --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/geospatial.js @@ -0,0 +1,100 @@ +/*! + * Module requirements. + */ + +var castArraysOfNumbers = require('./helpers').castArraysOfNumbers; +var castToNumber = require('./helpers').castToNumber; + +/*! + * ignore + */ + +exports.cast$geoIntersects = cast$geoIntersects; +exports.cast$near = cast$near; +exports.cast$within = cast$within; + +function cast$near(val) { + var SchemaArray = require('../array'); + + if (Array.isArray(val)) { + castArraysOfNumbers(val, this); + return val; + } + + _castMinMaxDistance(this, val); + + if (val && val.$geometry) { + return cast$geometry(val, this); + } + + return SchemaArray.prototype.castForQuery.call(this, val); +} + +function cast$geometry(val, self) { + switch (val.$geometry.type) { + case 'Polygon': + case 'LineString': + case 'Point': + castArraysOfNumbers(val.$geometry.coordinates, self); + break; + default: + // ignore unknowns + break; + } + + _castMinMaxDistance(this, val); + + return val; +} + +function cast$within(val) { + _castMinMaxDistance(this, val); + + if (val.$box || val.$polygon) { + var type = val.$box ? '$box' : '$polygon'; + val[type].forEach(function(arr) { + if (!Array.isArray(arr)) { + var msg = 'Invalid $within $box argument. ' + + 'Expected an array, received ' + arr; + throw new TypeError(msg); + } + arr.forEach(function(v, i) { + arr[i] = castToNumber.call(this, v); + }); + }); + } else if (val.$center || val.$centerSphere) { + type = val.$center ? '$center' : '$centerSphere'; + val[type].forEach(function(item, i) { + if (Array.isArray(item)) { + item.forEach(function(v, j) { + item[j] = castToNumber.call(this, v); + }); + } else { + val[type][i] = castToNumber.call(this, item); + } + }); + } else if (val.$geometry) { + cast$geometry(val, this); + } + + return val; +} + +function cast$geoIntersects(val) { + var geo = val.$geometry; + if (!geo) { + return; + } + + cast$geometry(val, this); + return val; +} + +function _castMinMaxDistance(self, val) { + if (val.$maxDistance) { + val.$maxDistance = castToNumber.call(self, val.$maxDistance); + } + if (val.$minDistance) { + val.$minDistance = castToNumber.call(self, val.$minDistance); + } +} diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/helpers.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/helpers.js new file mode 100644 index 0000000..850354a --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/operators/helpers.js @@ -0,0 +1,34 @@ +'use strict'; + +/*! + * Module requirements. + */ + +var Types = { + Number: require('../number') +}; + +/*! + * @ignore + */ + +exports.castToNumber = castToNumber; +exports.castArraysOfNumbers = castArraysOfNumbers; + +/*! + * @ignore + */ + +function castToNumber(val) { + return Types.Number.prototype.cast.call(this, val); +} + +function castArraysOfNumbers(arr, self) { + arr.forEach(function(v, i) { + if (Array.isArray(v)) { + castArraysOfNumbers(v, self); + } else { + arr[i] = castToNumber.call(self, v); + } + }); +} diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/string.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/string.js new file mode 100644 index 0000000..eae40b8 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/schema/string.js @@ -0,0 +1,516 @@ +/*! + * Module dependencies. + */ + +var SchemaType = require('../schematype'); +var CastError = SchemaType.CastError; +var MongooseError = require('../error'); +var utils = require('../utils'); +var Document; + +/** + * String SchemaType constructor. + * + * @param {String} key + * @param {Object} options + * @inherits SchemaType + * @api public + */ + +function SchemaString(key, options) { + this.enumValues = []; + this.regExp = null; + SchemaType.call(this, key, options, 'String'); +} + +/** + * This schema type's name, to defend against minifiers that mangle + * function names. + * + * @api public + */ +SchemaString.schemaName = 'String'; + +/*! + * Inherits from SchemaType. + */ +SchemaString.prototype = Object.create(SchemaType.prototype); +SchemaString.prototype.constructor = SchemaString; + +/** + * Adds an enum validator + * + * ####Example: + * + * var states = ['opening', 'open', 'closing', 'closed'] + * var s = new Schema({ state: { type: String, enum: states }}) + * var M = db.model('M', s) + * var m = new M({ state: 'invalid' }) + * m.save(function (err) { + * console.error(String(err)) // ValidationError: `invalid` is not a valid enum value for path `state`. + * m.state = 'open' + * m.save(callback) // success + * }) + * + * // or with custom error messages + * var enum = { + * values: ['opening', 'open', 'closing', 'closed'], + * message: 'enum validator failed for path `{PATH}` with value `{VALUE}`' + * } + * var s = new Schema({ state: { type: String, enum: enu }) + * var M = db.model('M', s) + * var m = new M({ state: 'invalid' }) + * m.save(function (err) { + * console.error(String(err)) // ValidationError: enum validator failed for path `state` with value `invalid` + * m.state = 'open' + * m.save(callback) // success + * }) + * + * @param {String|Object} [args...] enumeration values + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaString.prototype.enum = function() { + if (this.enumValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.enumValidator; + }, this); + this.enumValidator = false; + } + + if (arguments[0] === void 0 || arguments[0] === false) { + return this; + } + + var values; + var errorMessage; + + if (utils.isObject(arguments[0])) { + values = arguments[0].values; + errorMessage = arguments[0].message; + } else { + values = arguments; + errorMessage = MongooseError.messages.String.enum; + } + + for (var i = 0; i < values.length; i++) { + if (undefined !== values[i]) { + this.enumValues.push(this.cast(values[i])); + } + } + + var vals = this.enumValues; + this.enumValidator = function(v) { + return undefined === v || ~vals.indexOf(v); + }; + this.validators.push({ + validator: this.enumValidator, + message: errorMessage, + type: 'enum', + enumValues: vals + }); + + return this; +}; + +/** + * Adds a lowercase setter. + * + * ####Example: + * + * var s = new Schema({ email: { type: String, lowercase: true }}) + * var M = db.model('M', s); + * var m = new M({ email: 'SomeEmail@example.COM' }); + * console.log(m.email) // someemail@example.com + * + * @api public + * @return {SchemaType} this + */ + +SchemaString.prototype.lowercase = function(shouldApply) { + if (arguments.length > 0 && !shouldApply) { + return this; + } + return this.set(function(v, self) { + if (typeof v !== 'string') { + v = self.cast(v); + } + if (v) { + return v.toLowerCase(); + } + return v; + }); +}; + +/** + * Adds an uppercase setter. + * + * ####Example: + * + * var s = new Schema({ caps: { type: String, uppercase: true }}) + * var M = db.model('M', s); + * var m = new M({ caps: 'an example' }); + * console.log(m.caps) // AN EXAMPLE + * + * @api public + * @return {SchemaType} this + */ + +SchemaString.prototype.uppercase = function(shouldApply) { + if (arguments.length > 0 && !shouldApply) { + return this; + } + return this.set(function(v, self) { + if (typeof v !== 'string') { + v = self.cast(v); + } + if (v) { + return v.toUpperCase(); + } + return v; + }); +}; + +/** + * Adds a trim setter. + * + * The string value will be trimmed when set. + * + * ####Example: + * + * var s = new Schema({ name: { type: String, trim: true }}) + * var M = db.model('M', s) + * var string = ' some name ' + * console.log(string.length) // 11 + * var m = new M({ name: string }) + * console.log(m.name.length) // 9 + * + * @api public + * @return {SchemaType} this + */ + +SchemaString.prototype.trim = function(shouldTrim) { + if (arguments.length > 0 && !shouldTrim) { + return this; + } + return this.set(function(v, self) { + if (typeof v !== 'string') { + v = self.cast(v); + } + if (v) { + return v.trim(); + } + return v; + }); +}; + +/** + * Sets a minimum length validator. + * + * ####Example: + * + * var schema = new Schema({ postalCode: { type: String, minlength: 5 }) + * var Address = db.model('Address', schema) + * var address = new Address({ postalCode: '9512' }) + * address.save(function (err) { + * console.error(err) // validator error + * address.postalCode = '95125'; + * address.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MINLENGTH} token which will be replaced with the minimum allowed length + * var minlength = [5, 'The value of path `{PATH}` (`{VALUE}`) is shorter than the minimum allowed length ({MINLENGTH}).']; + * var schema = new Schema({ postalCode: { type: String, minlength: minlength }) + * var Address = mongoose.model('Address', schema); + * var address = new Address({ postalCode: '9512' }); + * address.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `postalCode` (`9512`) is shorter than the minimum length (5). + * }) + * + * @param {Number} value minimum string length + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaString.prototype.minlength = function(value, message) { + if (this.minlengthValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.minlengthValidator; + }, this); + } + + if (value !== null && value !== undefined) { + var msg = message || MongooseError.messages.String.minlength; + msg = msg.replace(/{MINLENGTH}/, value); + this.validators.push({ + validator: this.minlengthValidator = function(v) { + return v === null || v.length >= value; + }, + message: msg, + type: 'minlength', + minlength: value + }); + } + + return this; +}; + +/** + * Sets a maximum length validator. + * + * ####Example: + * + * var schema = new Schema({ postalCode: { type: String, maxlength: 9 }) + * var Address = db.model('Address', schema) + * var address = new Address({ postalCode: '9512512345' }) + * address.save(function (err) { + * console.error(err) // validator error + * address.postalCode = '95125'; + * address.save() // success + * }) + * + * // custom error messages + * // We can also use the special {MAXLENGTH} token which will be replaced with the maximum allowed length + * var maxlength = [9, 'The value of path `{PATH}` (`{VALUE}`) exceeds the maximum allowed length ({MAXLENGTH}).']; + * var schema = new Schema({ postalCode: { type: String, maxlength: maxlength }) + * var Address = mongoose.model('Address', schema); + * var address = new Address({ postalCode: '9512512345' }); + * address.validate(function (err) { + * console.log(String(err)) // ValidationError: The value of path `postalCode` (`9512512345`) exceeds the maximum allowed length (9). + * }) + * + * @param {Number} value maximum string length + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaString.prototype.maxlength = function(value, message) { + if (this.maxlengthValidator) { + this.validators = this.validators.filter(function(v) { + return v.validator !== this.maxlengthValidator; + }, this); + } + + if (value !== null && value !== undefined) { + var msg = message || MongooseError.messages.String.maxlength; + msg = msg.replace(/{MAXLENGTH}/, value); + this.validators.push({ + validator: this.maxlengthValidator = function(v) { + return v === null || v.length <= value; + }, + message: msg, + type: 'maxlength', + maxlength: value + }); + } + + return this; +}; + +/** + * Sets a regexp validator. + * + * Any value that does not pass `regExp`.test(val) will fail validation. + * + * ####Example: + * + * var s = new Schema({ name: { type: String, match: /^a/ }}) + * var M = db.model('M', s) + * var m = new M({ name: 'I am invalid' }) + * m.validate(function (err) { + * console.error(String(err)) // "ValidationError: Path `name` is invalid (I am invalid)." + * m.name = 'apples' + * m.validate(function (err) { + * assert.ok(err) // success + * }) + * }) + * + * // using a custom error message + * var match = [ /\.html$/, "That file doesn't end in .html ({VALUE})" ]; + * var s = new Schema({ file: { type: String, match: match }}) + * var M = db.model('M', s); + * var m = new M({ file: 'invalid' }); + * m.validate(function (err) { + * console.log(String(err)) // "ValidationError: That file doesn't end in .html (invalid)" + * }) + * + * Empty strings, `undefined`, and `null` values always pass the match validator. If you require these values, enable the `required` validator also. + * + * var s = new Schema({ name: { type: String, match: /^a/, required: true }}) + * + * @param {RegExp} regExp regular expression to test against + * @param {String} [message] optional custom error message + * @return {SchemaType} this + * @see Customized Error Messages #error_messages_MongooseError-messages + * @api public + */ + +SchemaString.prototype.match = function match(regExp, message) { + // yes, we allow multiple match validators + + var msg = message || MongooseError.messages.String.match; + + var matchValidator = function(v) { + if (!regExp) { + return false; + } + + var ret = ((v != null && v !== '') + ? regExp.test(v) + : true); + return ret; + }; + + this.validators.push({ + validator: matchValidator, + message: msg, + type: 'regexp', + regexp: regExp + }); + return this; +}; + +/** + * Check if the given value satisfies a required validator. + * + * @param {Any} value + * @param {Document} doc + * @return {Boolean} + * @api public + */ + +SchemaString.prototype.checkRequired = function checkRequired(value, doc) { + if (SchemaType._isRef(this, value, doc, true)) { + return !!value; + } + return (value instanceof String || typeof value === 'string') && value.length; +}; + +/** + * Casts to String + * + * @api private + */ + +SchemaString.prototype.cast = function(value, doc, init) { + if (SchemaType._isRef(this, value, doc, init)) { + // wait! we may need to cast this to a document + + if (value === null || value === undefined) { + return value; + } + + // lazy load + Document || (Document = require('./../document')); + + if (value instanceof Document) { + value.$__.wasPopulated = true; + return value; + } + + // setting a populated path + if (typeof value === 'string') { + return value; + } else if (Buffer.isBuffer(value) || !utils.isObject(value)) { + throw new CastError('string', value, this.path); + } + + // Handle the case where user directly sets a populated + // path to a plain object; cast to the Model used in + // the population query. + var path = doc.$__fullPath(this.path); + var owner = doc.ownerDocument ? doc.ownerDocument() : doc; + var pop = owner.populated(path, true); + var ret = new pop.options.model(value); + ret.$__.wasPopulated = true; + return ret; + } + + // If null or undefined + if (value === null || value === undefined) { + return value; + } + + if (typeof value !== 'undefined') { + // handle documents being passed + if (value._id && typeof value._id === 'string') { + return value._id; + } + + // Re: gh-647 and gh-3030, we're ok with casting using `toString()` + // **unless** its the default Object.toString, because "[object Object]" + // doesn't really qualify as useful data + if (value.toString && value.toString !== Object.prototype.toString) { + return value.toString(); + } + } + + throw new CastError('string', value, this.path); +}; + +/*! + * ignore + */ + +function handleSingle(val) { + return this.castForQuery(val); +} + +function handleArray(val) { + var _this = this; + if (!Array.isArray(val)) { + return [this.castForQuery(val)]; + } + return val.map(function(m) { + return _this.castForQuery(m); + }); +} + +SchemaString.prototype.$conditionalHandlers = + utils.options(SchemaType.prototype.$conditionalHandlers, { + $all: handleArray, + $gt: handleSingle, + $gte: handleSingle, + $lt: handleSingle, + $lte: handleSingle, + $options: handleSingle, + $regex: handleSingle, + $not: handleSingle + }); + +/** + * Casts contents for queries. + * + * @param {String} $conditional + * @param {any} [val] + * @api private + */ + +SchemaString.prototype.castForQuery = function($conditional, val) { + var handler; + if (arguments.length === 2) { + handler = this.$conditionalHandlers[$conditional]; + if (!handler) { + throw new Error('Can\'t use ' + $conditional + ' with String.'); + } + return handler.call(this, val); + } + val = $conditional; + if (Object.prototype.toString.call(val) === '[object RegExp]') { + return val; + } + return this.cast(val); +}; + +/*! + * Module exports. + */ + +module.exports = SchemaString; |