ok

10 files changed, 1187 insertions, 0 deletions

diff --git a/node_modules/mongoose/lib/schema/array.js b/node_modules/mongoose/lib/schema/array.js
new file mode 100644
index 0000000..6458a73
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/array.js
@@ -0,0 +1,232 @@
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , NumberSchema = require('./number')
+  , Types = {
+        Boolean: require('./boolean')
+      , Date: require('./date')
+      , Number: ArrayNumberSchema
+      , String: require('./string')
+      , ObjectId: require('./objectid')
+      , Buffer: require('./buffer')
+    }
+  , MongooseArray = require('../types').Array
+  , Mixed = require('./mixed')
+  , Query = require('../query')
+  , isMongooseObject = require('../utils').isMongooseObject
+
+/**
+ * Array SchemaType constructor
+ *
+ * @param {String} key
+ * @param {SchemaType} cast
+ * @api private
+ */
+
+function SchemaArray (key, cast, options) {
+  SchemaType.call(this, key, options);
+
+  if (cast) {
+    var castOptions = {};
+
+    if ('Object' === cast.constructor.name) {
+      if (cast.type) {
+        // support { type: Woot }
+        castOptions = cast;
+        cast = cast.type;
+        delete castOptions.type;
+      } else {
+        cast = Mixed;
+      }
+    }
+
+    var caster = cast.name in Types ? Types[cast.name] : cast;
+    this.casterConstructor = caster;
+    this.caster = new caster(null, castOptions);
+  }
+
+  var self = this
+    , defaultArr
+    , fn;
+
+  if (this.defaultValue) {
+    defaultArr = this.defaultValue;
+    fn = 'function' == typeof defaultArr;
+  }
+
+  this.default(function(){
+    var arr = fn ? defaultArr() : defaultArr || [];
+    return new MongooseArray(arr, self.path, this);
+  });
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+SchemaArray.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+SchemaArray.prototype.checkRequired = function (value) {
+  return !!(value && value.length);
+};
+
+/**
+ * Overrides the getters application for the population special-case
+ * TODO: implement this in SchemaObjectIdArray
+ *
+ * @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 contents
+ *
+ * @param {Object} value
+ * @param {Document} document that triggers the casting
+ * @param {Boolean} whether this is an initialization cast
+ * @api private
+ */
+
+SchemaArray.prototype.cast = function (value, doc, init) {
+  if (Array.isArray(value)) {
+    if (!(value instanceof MongooseArray)) {
+      value = new MongooseArray(value, this.path, doc);
+    }
+
+    if (this.caster) {
+      try {
+        for (var i = 0, l = value.length; i < l; i++) {
+          value[i] = this.caster.cast(value[i], doc, init);
+        }
+      } catch (e) {
+        // rethrow
+        throw new CastError(e.type, value);
+      }
+    }
+
+    return value;
+  } else {
+    return this.cast([value], doc, init);
+  }
+};
+
+SchemaArray.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 Array.");
+    val = handler.call(this, val);
+  } else {
+    val = $conditional;
+    var proto = this.casterConstructor.prototype;
+    var method = proto.castForQuery || proto.cast;
+    if (Array.isArray(val)) {
+      val = val.map(function (v) {
+        if (method) v = method.call(proto, v);
+        return isMongooseObject(v)
+          ? v.toObject()
+          : v;
+      });
+    } else if (method) {
+      val = method.call(proto, val);
+    }
+  }
+  return val && isMongooseObject(val)
+    ? val.toObject()
+    : val;
+};
+
+SchemaArray.prototype.$conditionalHandlers = {
+    '$all': function handle$all (val) {
+      if (!Array.isArray(val)) {
+        val = [val];
+      }
+
+      val = val.map(function (v) {
+        if (v && 'Object' === v.constructor.name) {
+          var o = {};
+          o[this.path] = v;
+          var query = new Query(o);
+          query.cast(this.casterConstructor);
+          return query._conditions[this.path];
+        }
+        return v;
+      }, this);
+
+      return this.castForQuery(val);
+    }
+  , '$elemMatch': function (val) {
+      var query = new Query(val);
+      query.cast(this.casterConstructor);
+      return query._conditions;
+    }
+  , '$size': function (val) {
+      return ArrayNumberSchema.prototype.cast.call(this, val);
+    }
+  , '$ne': SchemaArray.prototype.castForQuery
+  , '$in': SchemaArray.prototype.castForQuery
+  , '$nin': SchemaArray.prototype.castForQuery
+  , '$regex': SchemaArray.prototype.castForQuery
+  , '$near': SchemaArray.prototype.castForQuery
+  , '$nearSphere': SchemaArray.prototype.castForQuery
+  , '$within': function(val) {
+      var query = new Query(val);
+      query.cast(this.casterConstructor)
+      return query._conditions;
+    }
+  , '$maxDistance': function (val) {
+      return ArrayNumberSchema.prototype.cast.call(this, val);
+    }
+};
+
+/**
+ * Number casting for arrays (equivalent, but without MongoseNumber)
+ *
+ * @see GH-176
+ * @param {Object} value
+ * @api private
+ */
+
+// subclass number schema to override casting
+// to disallow non-numbers being saved
+function ArrayNumberSchema (key, options) {
+  NumberSchema.call(this, key, options);
+}
+
+ArrayNumberSchema.prototype.__proto__ = NumberSchema.prototype;
+
+ArrayNumberSchema.prototype.cast = function (value) {
+  if (!isNaN(value)) {
+    if (value instanceof Number || typeof value == 'number' ||
+       (value.toString && value.toString() == Number(value)))
+      return Number(value);
+  }
+
+  throw new CastError('number', value);
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = SchemaArray;
diff --git a/node_modules/mongoose/lib/schema/boolean.js b/node_modules/mongoose/lib/schema/boolean.js
new file mode 100644
index 0000000..574fdd8
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/boolean.js
@@ -0,0 +1,59 @@
+
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype');
+
+/**
+ * Boolean SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @api private
+ */
+
+function SchemaBoolean (path, options) {
+  SchemaType.call(this, path, options);
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+SchemaBoolean.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for date
+ *
+ * @api private
+ */
+
+SchemaBoolean.prototype.checkRequired = function (value) {
+  return value === true || value === false;
+};
+
+/**
+ * Casts to boolean
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+SchemaBoolean.prototype.cast = function (value) {
+  if (value === null) return value;
+  if (value === '0') return false;
+  return !!value;
+};
+
+SchemaBoolean.prototype.castForQuery = function ($conditional, val) {
+  if (arguments.length === 1) {
+    val = $conditional;
+  }
+  return this.cast(val);
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = SchemaBoolean;
diff --git a/node_modules/mongoose/lib/schema/buffer.js b/node_modules/mongoose/lib/schema/buffer.js
new file mode 100644
index 0000000..64e12a2
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/buffer.js
@@ -0,0 +1,106 @@
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , BufferNumberSchema = function () {}
+  , MongooseBuffer = require('../types').Buffer
+  , Binary = MongooseBuffer.Binary
+  , Query = require('../query');
+
+/**
+ * Buffer SchemaType constructor
+ *
+ * @param {String} key
+ * @param {SchemaType} cast
+ * @api private
+ */
+
+function SchemaBuffer (key, options) {
+  SchemaType.call(this, key, options, 'Buffer');
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+SchemaBuffer.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+SchemaBuffer.prototype.checkRequired = function (value) {
+  return !!(value && value.length);
+};
+
+/**
+ * Casts contents
+ *
+ * @param {Object} value
+ * @param {Document} document that triggers the casting
+ * @api private
+ */
+
+SchemaBuffer.prototype.cast = function (value, doc, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (Buffer.isBuffer(value)) {
+    if (!(value instanceof MongooseBuffer)) {
+      value = new MongooseBuffer(value, [this.path, doc]);
+    }
+
+    return value;
+  } else if (value instanceof Binary) {
+    return new MongooseBuffer(value.value(true), [this.path, doc]);
+  }
+
+  if ('string' === typeof value || Array.isArray(value)) {
+    return new MongooseBuffer(value, [this.path, doc]);
+  }
+
+  throw new CastError('buffer', value);
+};
+
+function handleSingle (val) {
+  return this.castForQuery(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.castForQuery(m);
+  });
+}
+
+SchemaBuffer.prototype.$conditionalHandlers = {
+    '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$gt' : handleSingle
+  , '$lt' : handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+};
+
+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);
+  } else {
+    val = $conditional;
+    return this.cast(val).toObject();
+  }
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = SchemaBuffer;
diff --git a/node_modules/mongoose/lib/schema/date.js b/node_modules/mongoose/lib/schema/date.js
new file mode 100644
index 0000000..3a7bda8
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/date.js
@@ -0,0 +1,116 @@
+
+/**
+ * Module requirements.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError;
+
+/**
+ * Date SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @api private
+ */
+
+function SchemaDate (key, options) {
+  SchemaType.call(this, key, options);
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+SchemaDate.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for date
+ *
+ * @api private
+ */
+
+SchemaDate.prototype.checkRequired = function (value) {
+  return value instanceof Date;
+};
+
+/**
+ * Casts to date
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+SchemaDate.prototype.cast = function (value) {
+  if (value === null || value === '')
+    return null;
+
+  if (value instanceof Date)
+    return value;
+
+  var date;
+
+  // support for timestamps
+  if (value instanceof Number || 'number' == typeof value 
+      || String(value) == Number(value))
+    date = new Date(Number(value));
+
+  // support for date strings
+  else if (value.toString)
+    date = new Date(value.toString());
+
+  if (date.toString() != 'Invalid Date')
+    return date;
+
+  throw new CastError('date', value);
+};
+
+/**
+ * Date Query casting.
+ *
+ * @api private
+ */
+
+function handleSingle (val) {
+  return this.cast(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.cast(m);
+  });
+}
+
+SchemaDate.prototype.$conditionalHandlers = {
+    '$lt': handleSingle
+  , '$lte': handleSingle
+  , '$gt': handleSingle
+  , '$gte': handleSingle
+  , '$ne': handleSingle
+  , '$in': handleArray
+  , '$nin': handleArray
+  , '$all': handleArray
+};
+
+SchemaDate.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+
+  if (2 !== arguments.length) {
+    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/node_modules/mongoose/lib/schema/documentarray.js b/node_modules/mongoose/lib/schema/documentarray.js
new file mode 100644
index 0000000..38276ff
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/documentarray.js
@@ -0,0 +1,141 @@
+
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , ArrayType = require('./array')
+  , MongooseDocumentArray = require('../types/documentarray')
+  , Subdocument = require('../types/embedded')
+  , CastError = SchemaType.CastError
+  , Document = require('../document');
+
+/**
+ * SubdocsArray SchemaType constructor
+ *
+ * @param {String} key
+ * @param {Schema} schema
+ * @param {Object} options
+ * @api private
+ */
+
+function DocumentArray (key, schema, options) {
+  // compile an embedded document for this schema
+  // TODO Move this into parent model compilation for performance improvement?
+  function EmbeddedDocument () {
+    Subdocument.apply(this, arguments);
+  };
+
+  EmbeddedDocument.prototype.__proto__ = Subdocument.prototype;
+  EmbeddedDocument.prototype.schema = schema;
+  EmbeddedDocument.schema = schema;
+
+  // apply methods
+  for (var i in schema.methods) {
+    EmbeddedDocument.prototype[i] = schema.methods[i];
+  }
+
+  // apply statics
+  for (var i in schema.statics)
+    EmbeddedDocument[i] = schema.statics[i];
+
+  ArrayType.call(this, key, EmbeddedDocument, options);
+
+  this.caster = EmbeddedDocument;
+  this.caster.options = options;
+
+  var self = this;
+
+  this.schema = schema;
+  this.default(function(){
+    return new MongooseDocumentArray([], self.path, this);
+  });
+};
+
+/**
+ * Inherits from ArrayType.
+ */
+
+DocumentArray.prototype.__proto__ = ArrayType.prototype;
+
+/**
+ * Performs local validations first, then validations on each embedded doc
+ *
+ * @api private
+ */
+
+DocumentArray.prototype.doValidate = function (array, fn, scope) {
+  var self = this;
+  SchemaType.prototype.doValidate.call(this, array, function(err){
+    if (err) return fn(err);
+
+    var count = array && array.length
+      , error = false;
+
+    if (!count) return fn();
+
+    array.forEach(function(doc, index){
+      doc.validate(function(err){
+        if (err && !error){
+          // rewrite they key
+          err.key = self.key + '.' + index + '.' + err.key;
+          fn(err);
+          error = true;
+        } else {
+          --count || fn();
+        }
+      });
+    });
+  }, scope);
+};
+
+/**
+ * Casts contents
+ *
+ * @param {Object} value
+ * @param {Document} document that triggers the casting
+ * @api private
+ */
+
+DocumentArray.prototype.cast = function (value, doc, init, prev) {
+  var subdoc
+    , i
+
+  if (Array.isArray(value)) {
+    if (!(value instanceof MongooseDocumentArray)) {
+      value = new MongooseDocumentArray(value, this.path, doc);
+    }
+
+    i = value.length;
+
+    while (i--) {
+      if (!(value[i] instanceof Subdocument)) {
+        if (init) {
+          subdoc = new this.caster(null, value);
+          // skip _id for pre-init hooks
+          delete subdoc._doc._id;
+          value[i] = subdoc.init(value[i]);
+        } else {
+          subdoc = prev && prev.id(value[i]._id) ||
+                   new this.caster(null, value);
+          subdoc.set(value[i]);
+          // if set() is hooked it will have no return value
+          // see gh-746
+          value[i] = subdoc;
+        }
+      }
+    }
+
+    return value;
+  } else {
+    return this.cast([value], doc, init, prev);
+  }
+
+  throw new CastError('documentarray', value);
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = DocumentArray;
diff --git a/node_modules/mongoose/lib/schema/index.js b/node_modules/mongoose/lib/schema/index.js
new file mode 100644
index 0000000..ac424c3
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/index.js
@@ -0,0 +1,22 @@
+
+/**
+ * Module exports.
+ */
+
+exports.String = require('./string');
+
+exports.Number = require('./number');
+
+exports.Boolean = require('./boolean');
+
+exports.DocumentArray = require('./documentarray');
+
+exports.Array = require('./array');
+
+exports.Buffer = require('./buffer');
+
+exports.Date = require('./date');
+
+exports.ObjectId = require('./objectid');
+
+exports.Mixed = require('./mixed');
diff --git a/node_modules/mongoose/lib/schema/mixed.js b/node_modules/mongoose/lib/schema/mixed.js
new file mode 100644
index 0000000..6f98be0
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/mixed.js
@@ -0,0 +1,63 @@
+
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype');
+
+/**
+ * Mixed SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @api private
+ */
+
+function Mixed (path, options) {
+  // make sure empty array defaults are handled
+  if (options &&
+      options.default &&
+      Array.isArray(options.default) &&
+      0 === options.default.length) {
+    options.default = Array;
+  }
+
+  SchemaType.call(this, path, options);
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+Mixed.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for mixed type
+ *
+ * @api private
+ */
+
+Mixed.prototype.checkRequired = function (val) {
+  return true;
+};
+
+/**
+ * Noop casting
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+Mixed.prototype.cast = function (val) {
+  return val;
+};
+
+Mixed.prototype.castForQuery = function ($cond, val) {
+  if (arguments.length === 2) return val;
+  return $cond;
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = Mixed;
diff --git a/node_modules/mongoose/lib/schema/number.js b/node_modules/mongoose/lib/schema/number.js
new file mode 100644
index 0000000..75a14f6
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/number.js
@@ -0,0 +1,142 @@
+/**
+ * Module requirements.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , MongooseNumber = require('../types/number');
+
+/**
+ * Number SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @api private
+ */
+
+function SchemaNumber (key, options) {
+  SchemaType.call(this, key, options, 'Number');
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+SchemaNumber.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for number
+ *
+ * @api private
+ */
+
+SchemaNumber.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return typeof value == 'number' || value instanceof Number;
+  }
+};
+
+/**
+ * Sets a maximum number validator
+ *
+ * @param {Number} minimum number
+ * @api public
+ */
+
+SchemaNumber.prototype.min = function (value, message) {
+  if (this.minValidator)
+    this.validators = this.validators.filter(function(v){
+      return v[1] != 'min';
+    });
+  if (value != null)
+    this.validators.push([function(v){
+      return v === null || v >= value;
+    }, 'min']);
+  return this;
+};
+
+/**
+ * Sets a maximum number validator
+ *
+ * @param {Number} maximum number
+ * @api public
+ */
+
+SchemaNumber.prototype.max = function (value, message) {
+  if (this.maxValidator)
+    this.validators = this.validators.filter(function(v){
+      return v[1] != 'max';
+    });
+  if (value != null)
+    this.validators.push([this.maxValidator = function(v){
+      return v === null || v <= value;
+    }, 'max']);
+  return this;
+};
+
+/**
+ * Casts to number
+ *
+ * @param {Object} value to cast
+ * @param {Document} document that triggers the casting
+ * @api private
+ */
+
+SchemaNumber.prototype.cast = function (value, doc, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (!isNaN(value)){
+    if (null === value) return value;
+    if ('' === value) return null;
+    if ('string' === typeof value) value = Number(value);
+    if (value instanceof Number || typeof value == 'number' ||
+       (value.toString && value.toString() == Number(value)))
+      return new MongooseNumber(value, this.path, doc);
+  }
+
+  throw new CastError('number', value);
+};
+
+function handleSingle (val) {
+  return this.cast(val).valueOf();
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.cast(m).valueOf();
+  });
+}
+
+SchemaNumber.prototype.$conditionalHandlers = {
+    '$lt' : handleSingle
+  , '$lte': handleSingle
+  , '$gt' : handleSingle
+  , '$gte': handleSingle
+  , '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$mod': handleArray
+  , '$all': handleArray
+};
+
+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);
+  } else {
+    val = this.cast($conditional);
+    return val == null ? val : val.valueOf();
+  }
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = SchemaNumber;
diff --git a/node_modules/mongoose/lib/schema/objectid.js b/node_modules/mongoose/lib/schema/objectid.js
new file mode 100644
index 0000000..a83f95d
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/objectid.js
@@ -0,0 +1,126 @@
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , driver = global.MONGOOSE_DRIVER_PATH || './../drivers/node-mongodb-native'
+  , oid = require('../types/objectid');
+
+
+/**
+ * ObjectId SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @api private
+ */
+
+function ObjectId (key, options) {
+  SchemaType.call(this, key, options, 'ObjectID');
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+ObjectId.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+ObjectId.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return value instanceof oid;
+  }
+};
+
+/**
+ * Casts to ObjectId
+ *
+ * @param {Object} value
+ * @param {Object} scope
+ * @param {Boolean} whether this is an initialization cast
+ * @api private
+ */
+
+ObjectId.prototype.cast = function (value, scope, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (value === null) return value;
+
+  if (value instanceof oid)
+    return value;
+
+  if (value._id && value._id instanceof oid)
+    return value._id;
+
+  if (value.toString)
+    return oid.fromString(value.toString());
+
+  throw new CastError('object id', value);
+};
+
+function handleSingle (val) {
+  return this.cast(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map(function (m) {
+    return self.cast(m);
+  });
+}
+
+ObjectId.prototype.$conditionalHandlers = {
+    '$ne': handleSingle
+  , '$in': handleArray
+  , '$nin': handleArray
+  , '$gt': handleSingle
+  , '$lt': handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+  , '$all': handleArray
+};
+
+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);
+  } else {
+    val = $conditional;
+    return this.cast(val);
+  }
+};
+
+/**
+ * Adds an auto-generated ObjectId default if turnOn is true.
+ * @param {Boolean} turnOn auto generated ObjectId defaults
+ * @api private
+ */
+
+ObjectId.prototype.auto = function (turnOn) {
+  if (turnOn) {
+    this.default(function(){
+      return new oid();
+    });
+    this.set(function (v) {
+      this.__id = null;
+      return v;
+    })
+  }
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = ObjectId;
diff --git a/node_modules/mongoose/lib/schema/string.js b/node_modules/mongoose/lib/schema/string.js
new file mode 100644
index 0000000..5187e4f
--- /dev/null
+++ b/node_modules/mongoose/lib/schema/string.js
@@ -0,0 +1,180 @@
+
+/**
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError;
+
+/**
+ * String SchemaType constructor.
+ *
+ * @param {String} key
+ * @api private
+ */
+
+function SchemaString (key, options) {
+  this.enumValues = [];
+  this.regExp = null;
+  SchemaType.call(this, key, options, 'String');
+};
+
+/**
+ * Inherits from SchemaType.
+ */
+
+SchemaString.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Adds enumeration values
+ *
+ * @param {multiple} enumeration values
+ * @api public
+ */
+
+SchemaString.prototype.enum = function () {
+  var len = arguments.length;
+  if (!len || undefined === arguments[0] || false === arguments[0]) {
+    if (this.enumValidator){
+      this.enumValidator = false;
+      this.validators = this.validators.filter(function(v){
+        return v[1] != 'enum';
+      });
+    }
+    return;
+  }
+
+  for (var i = 0; i < len; i++) {
+    if (undefined !== arguments[i]) {
+      this.enumValues.push(this.cast(arguments[i]));
+    }
+  }
+
+  if (!this.enumValidator) {
+    var values = this.enumValues;
+    this.enumValidator = function(v){
+      return ~values.indexOf(v);
+    };
+    this.validators.push([this.enumValidator, 'enum']);
+  }
+};
+
+/**
+ * Adds a lowercase setter
+ *
+ * @api public
+ */
+
+SchemaString.prototype.lowercase = function () {
+  return this.set(function (v) {
+    return v.toLowerCase();
+  });
+};
+
+/**
+ * Adds an uppercase setter
+ *
+ * @api public
+ */
+
+SchemaString.prototype.uppercase = function () {
+  return this.set(function (v) {
+    return v.toUpperCase();
+  });
+};
+
+/**
+ * Adds a trim setter
+ *
+ * @api public
+ */
+
+SchemaString.prototype.trim = function () {
+  return this.set(function (v) {
+    return v.trim();
+  });
+};
+
+/**
+ * Sets a regexp test
+ *
+ * @param {RegExp} regular expression to test against
+ * @param {String} optional validator message
+ * @api public
+ */
+
+SchemaString.prototype.match = function(regExp){
+  this.validators.push([function(v){
+    return regExp.test(v);
+  }, 'regexp']);
+};
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+SchemaString.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return (value instanceof String || typeof value == 'string') && value.length;
+  }
+};
+
+/**
+ * Casts to String
+ *
+ * @api private
+ */
+
+SchemaString.prototype.cast = function (value, scope, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+  if (value === null) return value;
+  if ('undefined' !== typeof value && value.toString) return value.toString();
+  throw new CastError('string', value);
+};
+
+function handleSingle (val) {
+  return this.castForQuery(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map(function (m) {
+    return self.castForQuery(m);
+  });
+}
+
+SchemaString.prototype.$conditionalHandlers = {
+    '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$gt' : handleSingle
+  , '$lt' : handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+  , '$all': handleArray
+  , '$regex': handleSingle
+};
+
+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);
+  } else {
+    val = $conditional;
+    if (val instanceof RegExp) return val;
+    return this.cast(val);
+  }
+};
+
+/**
+ * Module exports.
+ */
+
+module.exports = SchemaString;