mongo-schema - npm Package Compare versions

Comparing version 0.1.1 to 0.1.2

bower.json

 {
   "name": "tiny-webrtc",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "homepage": "https://github.com/paul-em/tiny-webrtc",
@@ -5,0 +5,0 @@ "authors": [

lib/mongo-schema.js

 var has_require = typeof require !== 'undefined';
 
 var MongoSchema = function () {
-  var self = this;
-  var types = [
-    'string',
-    'number',
-    'boolean',
-    'objectid',
-    'date'
-  ];
+    var self = this;
+    var types = [
+      'string',
+      'number',
+      'boolean',
+      'objectid',
+      'date'
+    ];
 
-  this.check = function (data, schema, update) {
-    var errors = [];
-    for (var key in schema) {
-      if (!schema.hasOwnProperty(key)) continue;
-      var value = data[key];
-      var properties = schema[key];
-      if (isArray(properties)) {
-        if (!isArray(value)) {
-          delete data[key];
-          continue;
+    var factoryDefaults = {
+      'string': function () {
+        return ''
+      },
+      'number': function () {
+        return 0;
+      },
+      'boolean': function () {
+        return true;
+      },
+      'objectid': function () {
+        return '';
+      },
+      'date': function () {
+        return Math.floor(+new Date() / 1000)
+      }
+    };
+
+    this.check = function (data, schema, update) {
+      var errors = [];
+      for (var key in schema) {
+        if (!schema.hasOwnProperty(key)) continue;
+        var value = data[key];
+        var properties = schema[key];
+        if (isArray(properties)) {
+          if (!isArray(value)) {
+            delete data[key];
+            continue;
+          } else {
+            for (var i in value) {
+              if (!value.hasOwnProperty(i)) continue;
+              errors = errors.concat(self.check(value[i], properties[0]));
+            }
+          }
+        } else if (isObject(properties) && !isNull(properties) && !isDefObject(properties) && !normalizeType(properties)) {
+          var errs = self.check(value, properties);
+          errors = errors.concat(errs);
         } else {
-          for(var i in value){
-            if(!value.hasOwnProperty(i)) continue;
-            errors = errors.concat(self.check(value[i], properties[0]));
+          var type;
+          if (isDefObject(properties)) {
+            type = properties.type;
+          } else {
+            type = properties;
+            properties = {};
           }
-        }
-      } else if (isObject(properties) && !isNull(properties) && !isDefObject(properties) && !normalizeType(properties)) {
-        var errs = self.check(value, properties);
-        errors = errors.concat(errs);
-      } else {
-        var type;
-        if (isDefObject(properties)) {
-          type = properties.type;
-        } else {
-          type = properties;
-          properties = {};
-        }
-        if (isNull(value) && update && !properties.required) {
-          data[key] = undefined;
-          continue;
-        }
+          if (isNull(value) && update && !properties.required) {
+            data[key] = undefined;
+            continue;
+          }
 
-        var normType = normalizeType(type);
-        if (!normType) {
-          throw new Error("type " + type + " not available");
-        }
-        switch (normType) {
-          case 'string':
-            if ((!isString(value) && !isNumber(value)) || isNaN(value)) {
-              value = undefined;
-              if (properties.required) {
-                errors.push(key + " - required not set on '" + value + "'");
+          var normType = normalizeType(type);
+          if (!normType) {
+            throw new Error("type " + type + " not available");
+          }
+          switch (normType) {
+            case 'string':
+              if ((!isString(value) && !isNumber(value)) || isNaN(value)) {
+                value = undefined;
+                if (properties.required) {
+                  errors.push(key + " - required not set on '" + value + "'");
+                }
+              } else {
+                value = value + '';
+
+                if (!isUndefined(properties.minLength) && value.length < properties.minLength) {
+                  errors.push(key + " - minLength " + properties.minLength + " not fulfilled on '" + value + "'");
+                  delete data[key];
+                  continue;
+                }
+
+                if (!isUndefined(properties.maxLength) && value.length > properties.maxLength) {
+                  errors.push(key + " - maxLength " + properties.regex + " not fulfilled on '" + value + "'");
+                  value = value.substr(0, properties.maxLength);
+                }
+
+                if (!isUndefined(properties.regex) && !properties.regex.test(value)) {
+                  errors.push(key + " - regex " + properties.regex + " not fulfilled '" + value + "'");
+                  delete data[key];
+                  continue;
+                }
               }
-            } else {
-              value = value + '';
 
-              if (!isUndefined(properties.minLength) && value.length < properties.minLength) {
-                errors.push(key + " - minLength " + properties.minLength + " not fulfilled on '" + value + "'");
+              if (value === undefined) {
                 delete data[key];
-                continue;
+              } else {
+                data[key] = value;
               }
+              continue;
+            case 'number':
+              if (isArray(value) || isNull(value)) {
+                value = undefined;
+              }
 
-              if (!isUndefined(properties.maxLength) && value.length > properties.maxLength) {
-                errors.push(key + " - maxLength " + properties.regex + " not fulfilled on '" + value + "'");
-                value = value.substr(0, properties.maxLength);
+              value = value * 1;
+              if (isNaN(value)) {
+                value = undefined;
               }
 
-              if (!isUndefined(properties.regex) && !properties.regex.test(value)) {
-                errors.push(key + " - regex " + properties.regex + " not fulfilled '" + value + "'");
+              if (properties.required && isUndefined(value)) {
+                errors.push(key + " - required not set on '" + value + "'");
                 delete data[key];
                 continue;
               }
-            }
 
-            if (value === undefined) {
-              delete data[key];
-            } else {
-              data[key] = value;
-            }
-            continue;
-          case 'number':
-            if (isArray(value) || isNull(value)) {
-              value = undefined;
-            }
-
-            value = value * 1;
-            if (isNaN(value)) {
-              value = undefined;
-            }
-
-            if (properties.required && isUndefined(value)) {
-              errors.push(key + " - required not set on '" + value + "'");
-              delete data[key];
+              if (!isUndefined(value) && !isUndefined(properties.min) && value < properties.min) {
+                errors.push(key + " - min " + properties.min + " not fulfilled '" + value + "'");
+                delete data[key];
+                continue;
+              }
+              if (!isUndefined(value) && !isUndefined(properties.max) && value > properties.max) {
+                errors.push(key + " - max " + properties.max + " not fulfilled on '" + value + "'");
+                delete data[key];
+                continue;
+              }
+              if (value === undefined) {
+                delete data[key];
+              } else {
+                data[key] = value;
+              }
               continue;
-            }
-
-            if (!isUndefined(value) && !isUndefined(properties.min) && value < properties.min) {
-              errors.push(key + " - min " + properties.min + " not fulfilled '" + value + "'");
-              delete data[key];
+            case 'boolean':
+              if (properties.required && isUndefined(value)) {
+                errors.push(key + " - required not set '" + value + "'");
+                delete data[key];
+                continue;
+              } else if (isUndefined(value)) {
+                delete data[key];
+                continue;
+              }
+              data[key] = !!value;
               continue;
-            }
-            if (!isUndefined(value) && !isUndefined(properties.max) && value > properties.max) {
-              errors.push(key + " - max " + properties.max + " not fulfilled on '" + value + "'");
-              delete data[key];
-              continue;
-            }
-            if (value === undefined) {
-              delete data[key];
-            } else {
-              data[key] = value;
-            }
-            continue;
-          case 'boolean':
-            if (properties.required && isUndefined(value)) {
-              errors.push(key + " - required not set '" + value + "'");
-              delete data[key];
-              continue;
-            } else if (isUndefined(value)) {
-              delete data[key];
-              continue;
-            }
-            data[key] = !!value;
-            continue;
-          case 'date':
-            if (value instanceof Date) {
-              value = Math.floor(value.getTime() / 1000);
-            }
-            value = value * 1;
-            if (isNaN(value)) {
-              value = undefined;
-            } else {
-              if (value.toString().length === 13) {
-                value = Math.floor(value / 1000);
+            case 'date':
+              if (value instanceof Date) {
+                value = Math.floor(value.getTime() / 1000);
               }
-              if (value.toString().length !== 10) {
+              value = value * 1;
+              if (isNaN(value)) {
                 value = undefined;
+              } else {
+                if (value.toString().length === 13) {
+                  value = Math.floor(value / 1000);
+                }
+                if (value.toString().length !== 10) {
+                  value = undefined;
+                }
               }
-            }
 
-            if (properties.required && isUndefined(value)) {
-              errors.push(key + " - required not set on '" + value + "'");
-              delete data[key];
+              if (properties.required && isUndefined(value)) {
+                errors.push(key + " - required not set on '" + value + "'");
+                delete data[key];
+                continue;
+              }
+
+              if (value === undefined) {
+                delete data[key];
+              } else {
+                data[key] = value;
+              }
               continue;
-            }
+            case 'objectid':
+              if (typeof value !== "string" || (typeof value == "string" && value.length !== 24)) {
+                delete data[key];
+                value = undefined;
+              }
 
-            if (value === undefined) {
-              delete data[key];
-            } else {
-              data[key] = value;
-            }
-            continue;
-          case 'objectid':
-            if (typeof value !== "string" || (typeof value == "string" && value.length !== 24)) {
-              delete data[key];
-              value = undefined;
-            }
+              if (properties.required && isUndefined(value)) {
+                errors.push(key + " - required not set '" + value + "'");
+                delete data[key];
+                continue;
+              }
 
-            if (properties.required && isUndefined(value)) {
-              errors.push(key + " - required not set '" + value + "'");
-              delete data[key];
+              if (value === undefined) {
+                delete data[key];
+              } else {
+                data[key] = value;
+              }
               continue;
-            }
+          }
 
-            if (value === undefined) {
-              delete data[key];
-            } else {
-              data[key] = value;
-            }
-            continue;
         }
+      }
+      return errors;
+    };
 
+    this.defaults = function (schema) {
+      var defaults = {};
+      for (var key in schema) {
+        if (!schema.hasOwnProperty(key)) continue;
+        var properties = schema[key];
+        if (isArray(properties)) {
+          defaults[key] = [];
+        } else if (isObject(properties) && !isNull(properties) && !isDefObject(properties) && !normalizeType(properties)) {
+          defaults[key] = self.defaults(properties);
+        } else if (properties) {
+          var type;
+          if (isDefObject(properties)) {
+            type = properties.type;
+          } else {
+            type = properties;
+            properties = {};
+          }
+          type = normalizeType(type);
+          if ((properties.required || !isUndefined(getDefault(properties))) && !isUndefined(factoryDefaults[type])) {
+            defaults[key] = getDefault(properties) || factoryDefaults[type]();
+          } else {
+            defaults[key] = undefined;
+          }
+        }
       }
-    }
-    return errors;
-  };
+      return defaults;
+    };
 
-  this.getDefaults = function (schema) {
-
-  };
-
-  function normalizeType(type) {
-    if (isObject(type) && type.name) {
-      type = type.name.toLowerCase();
-      if (types.indexOf(type) !== -1) {
-        return type;
-      } else {
-        return false;
+    function getDefault(prop) {
+      if (isObject(prop) && !isNull(prop) && !isUndefined(prop.default)) {
+        return prop.default;
       }
+      return undefined;
     }
-    if (isString(type)) {
-      type = type.toLowerCase();
-      if (types.indexOf(type) !== -1) {
-        return type;
-      } else {
-        return false;
+
+    function normalizeType(type) {
+      if (isObject(type) && type.name) {
+        type = type.name.toLowerCase();
+        if (types.indexOf(type) !== -1) {
+          return type;
+        } else {
+          return false;
+        }
       }
+      if (isString(type)) {
+        type = type.toLowerCase();
+        if (types.indexOf(type) !== -1) {
+          return type;
+        } else {
+          return false;
+        }
+      }
+      return false;
     }
-    return false;
-  }
 
-  function isDefObject(obj) {
-    return isObject(obj) && !isNull(obj) && !isArray(obj) && !isUndefined(obj.type);
-  }
+    function isDefObject(obj) {
+      return isObject(obj) && !isNull(obj) && !isArray(obj) && !isUndefined(obj.type);
+    }
 
-  function isArray(value) {
-    return Object.prototype.toString.call(value) === '[object Array]'
-  }
+    function isArray(value) {
+      return Object.prototype.toString.call(value) === '[object Array]'
+    }
 
-  function isObject(value) {
-    return value === Object(value);
-  }
+    function isObject(value) {
+      return value === Object(value);
+    }
 
-  function isNumber(value) {
-    return typeof value == 'number' || Object.prototype.toString.call(value) === '[object Number]'
-  }
+    function isNumber(value) {
+      return typeof value == 'number' || Object.prototype.toString.call(value) === '[object Number]'
+    }
 
-  function isNaN(value) {
-    return isNumber(value) && value != +value;
-  }
+    function isNaN(value) {
+      return isNumber(value) && value != +value;
+    }
 
-  // Is a given value a boolean?
-  function isBoolean(value) {
-    return value === true || value === false || Object.prototype.toString.call(value) == '[object Boolean]';
-  }
+// Is a given value a boolean?
+    function isBoolean(value) {
+      return value === true || value === false || Object.prototype.toString.call(value) == '[object Boolean]';
+    }
 
-  // Is a given value equal to null?
-  function isNull(value) {
-    return value === null;
-  }
+// Is a given value equal to null?
+    function isNull(value) {
+      return value === null;
+    }
 
-  // Is a given variable undefined?
-  function isUndefined(value) {
-    return value === void 0;
-  }
+// Is a given variable undefined?
+    function isUndefined(value) {
+      return value === void 0;
+    }
 
-  function isString(value) {
-    return typeof value == 'string' || Object.prototype.toString.call(value) == '[object String]';
+    function isString(value) {
+      return typeof value == 'string' || Object.prototype.toString.call(value) == '[object String]';
+    }
   }
-};
+  ;
 
@@ -246,5 +296,4 @@
   var mongoSchema = new MongoSchema();
-  exports = module.exports = function (data, schema, update) {
-    return mongoSchema.check(data, schema, update);
-  };
+  exports.check = mongoSchema.check;
+  exports.defaults = mongoSchema.defaults;
 }

package.json

 {
   "name": "mongo-schema",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "main": "lib/mongo-schema.js",
@@ -5,0 +5,0 @@ "description": "Basic schema for mongodb",

README.md

@@ -61,3 +61,3 @@ # mongo-schema [![Build Status](https://secure.travis-ci.org/paul-em/mongo-schema.png?branch=master)](http://travis-ci.org/paul-em/mongo-schema)
     var data = _.clone(numberSchemaTest);
-    var errs = schema(data, numberSchema);
+    var errs = schema.check(data, numberSchema);
     assert.strictEqual(errs.length, 0);
@@ -64,0 +64,0 @@ assert.strictEqual(data.successTestNumber1, 123);

test/mongo-schema_test.js

@@ -61,3 +61,3 @@ var schema = require("../lib/mongo-schema.js");
     var data = _.clone(numberSchemaTest);
-    var errs = schema(data, numberSchema);
+    var errs = schema.check(data, numberSchema);
     assert.strictEqual(errs.length, 0);
@@ -79,3 +79,3 @@ assert.strictEqual(data.successTestNumber1, 123);
     var data = _.clone(numberSchemaTest);
-    var errs = schema(data, numberSchemaReq);
+    var errs = schema.check(data, numberSchemaReq);
     assert.strictEqual(errs.length, 7);
@@ -98,3 +98,3 @@ assert.equal(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(numberSchemaTest);
-    var errs = schema(data, numberSchemaMinMax);
+    var errs = schema.check(data, numberSchemaMinMax);
     assert.strictEqual(errs.length, 2);
@@ -169,3 +169,3 @@ assert.equal(errs[0].toLowerCase().indexOf("min") !== -1, true);
     var data = _.clone(stringSchemaTest);
-    var errs = schema(data, stringSchema);
+    var errs = schema.check(data, stringSchema);
     assert.strictEqual(errs.length, 0);
@@ -186,3 +186,3 @@ assert.strictEqual(data.successTestString1, "Hellow");
     var data = _.clone(stringSchemaTest);
-    var errs = schema(data, stringSchemaReq);
+    var errs = schema.check(data, stringSchemaReq);
     assert.strictEqual(errs.length, 6);
@@ -204,3 +204,3 @@ assert.equal(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(stringSchemaTest);
-    var errs = schema(data, stringSchemaMinMax);
+    var errs = schema.check(data, stringSchemaMinMax);
     assert.strictEqual(errs.length, 2);
@@ -217,3 +217,3 @@ assert.equal(errs[0].toLowerCase().indexOf("minlength") !== -1, true);
     var data = _.clone(stringSchemaTest);
-    var errs = schema(data, stringSchemaRegex);
+    var errs = schema.check(data, stringSchemaRegex);
     assert.strictEqual(errs.length, 1);
@@ -271,3 +271,3 @@ assert.equal(errs[0].toLowerCase().indexOf("regex") !== -1, true);
     var data = _.clone(boolSchemaTest);
-    var errs = schema(data, boolSchema);
+    var errs = schema.check(data, boolSchema);
     assert.strictEqual(errs.length, 0);
@@ -290,3 +290,3 @@ assert.strictEqual(data.successTestBool1, true);
     var data = _.clone(boolSchemaTest);
-    var errs = schema(data, boolSchemaReq);
+    var errs = schema.check(data, boolSchemaReq);
     assert.strictEqual(errs.length, 2);
@@ -345,3 +345,3 @@ assert.strictEqual(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(objectIdSchemaTest);
-    var errs = schema(data, objectIdSchema);
+    var errs = schema.check(data, objectIdSchema);
     assert.strictEqual(errs.length, 0);
@@ -362,3 +362,3 @@ assert.strictEqual(data.successTestObjectId1, "529c3acb044bdcc93700006f");
     var data = _.clone(objectIdSchemaTest);
-    var errs = schema(data, objectIdSchemaReq);
+    var errs = schema.check(data, objectIdSchemaReq);
     assert.strictEqual(errs.length, 7);
@@ -427,3 +427,3 @@ assert.strictEqual(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(dateSchemaTest);
-    var errs = schema(data, dateSchema);
+    var errs = schema.check(data, dateSchema);
     assert.strictEqual(errs.length, 0);
@@ -448,3 +448,3 @@ assert.strictEqual(data.successTestDate1, 1390528951);
     var data = _.clone(dateSchemaTest);
-    var errs = schema(data, dateSchemaReq);
+    var errs = schema.check(data, dateSchemaReq);
     assert.strictEqual(errs.length, 7);
@@ -507,3 +507,3 @@ assert.strictEqual(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(collectionSchemaTest);
-    var errs = schema(data, collectionSchema);
+    var errs = schema.check(data, collectionSchema);
     assert.strictEqual(errs.length, 0);
@@ -521,3 +521,3 @@ assert.strictEqual(data.collection[0].test, 123);
     var data = _.clone(collectionSchemaTest);
-    var errs = schema(data, collectionSchemaReq);
+    var errs = schema.check(data, collectionSchemaReq);
     assert.strictEqual(errs.length, 2);
@@ -558,3 +558,3 @@ assert.strictEqual(errs[0].toLowerCase().indexOf("required") !== -1, true);
     var data = _.clone(updateSchemaTest);
-    var errs = schema(data, updateSchema, true);
+    var errs = schema.check(data, updateSchema, true);
     assert.strictEqual(errs.length, 0);
@@ -570,3 +570,3 @@ assert.strictEqual(data.deleteTest, undefined);
     var data = _.clone(updateSchemaTest);
-    var errs = schema(data, updateSchemaReq, true);
+    var errs = schema.check(data, updateSchemaReq, true);
     assert.strictEqual(errs.length, 3);
@@ -581,2 +581,86 @@ assert.strictEqual(errs[0].toLowerCase().indexOf("required") !== -1, true);
   });
+});
+
+
+var defaultSchema = {
+  defaultStr: String,
+  defaultNumber: Number,
+  defaultBoolean: Boolean,
+  defaultObjectId: "ObjectId",
+  defaultDate: Date,
+  defaultCollection: [
+    {val: String}
+  ],
+  defaultObj: {
+    defaultNumber: Number
+  },
+  defaultStrReq: { type: String, required: true },
+  defaultNumberReq: { type: Number, required: true },
+  defaultBooleanReq: { type: Boolean, required: true },
+  defaultObjectIdReq: { type: "ObjectId", required: true },
+  defaultDateReq: { type: Date, required: true },
+  defaultCollectionReq: [
+    {val: { type: String, required: true }}
+  ],
+  defaultObjReq: {
+    defaultNumber: { type: Number, required: true }
+  },
+  defaultStrGiven: { type: String, default: "Given" },
+  defaultNumberGiven: { type: Number, default: 17 },
+  defaultBooleanGiven: { type: Boolean, default: true },
+  defaultObjectIdGiven: { type: "ObjectId", default: "5282da0c1341462d029f608e" },
+  defaultDateGiven: { type: Date, default: 946681200 },
+  defaultCollectionGiven: [
+    {val: { type: String, default: "Given" }}
+  ],
+  defaultObjGiven: {
+    defaultNumber: { type: Number, default: 17 }
+  }
+};
+
+describe("testDefaultSchema", function () {
+  it("should ignore wrong formats and return no errors", function (done) {
+    var defaults = schema.defaults(defaultSchema);
+    assert.strictEqual(defaults.defaultStr, undefined);
+    assert.strictEqual(defaults.hasOwnProperty("defaultStr"), true);
+
+    assert.strictEqual(defaults.defaultNumber, undefined);
+    assert.strictEqual(defaults.hasOwnProperty("defaultNumber"), true);
+
+    assert.strictEqual(defaults.defaultBoolean, undefined);
+    assert.strictEqual(defaults.hasOwnProperty("defaultBoolean"), true);
+
+    assert.strictEqual(defaults.defaultObjectId, undefined);
+    assert.strictEqual(defaults.hasOwnProperty("defaultObjectId"), true);
+
+    assert.strictEqual(defaults.defaultDate, undefined);
+    assert.strictEqual(defaults.hasOwnProperty("defaultDate"), true);
+
+    assert.strictEqual(typeof defaults.defaultCollection, "object");
+    assert.strictEqual(defaults.defaultCollection.length, 0);
+
+    assert.strictEqual(typeof defaults.defaultObj, "object");
+    assert.strictEqual(defaults.defaultObj.defaultNumber, undefined);
+    assert.strictEqual(defaults.defaultObj.hasOwnProperty("defaultNumber"), true);
+
+    assert.strictEqual(defaults.defaultStrReq, "");
+    assert.strictEqual(defaults.defaultNumberReq, 0);
+    assert.strictEqual(defaults.defaultBooleanReq, true);
+    assert.strictEqual(defaults.defaultObjectIdReq, "");
+    assert.strictEqual(Math.abs(Math.round(new Date().getTime() / 1000) - defaults.defaultDateReq) < 5, true);
+    assert.strictEqual(typeof defaults.defaultCollectionReq, "object");
+    assert.strictEqual(defaults.defaultCollectionReq.length, 0);
+    assert.strictEqual(typeof defaults.defaultObjReq, "object");
+    assert.strictEqual(defaults.defaultObjReq.defaultNumber, 0);
+
+    assert.strictEqual(defaults.defaultStrGiven,  "Given");
+    assert.strictEqual(defaults.defaultNumberGiven, 17);
+    assert.strictEqual(defaults.defaultBooleanGiven, true);
+    assert.strictEqual(defaults.defaultObjectIdGiven, "5282da0c1341462d029f608e");
+    assert.strictEqual(defaults.defaultDateGiven,946681200);
+    assert.strictEqual(defaults.defaultCollectionGiven.length, 0);
+    assert.strictEqual(typeof defaults.defaultObjGiven, "object");
+    assert.strictEqual(defaults.defaultObjGiven.defaultNumber, 17);
+    done();
+  });
 });

No alert changes

Improved metrics

Total package byte prevSize

44711

increased by13.77%

Lines of code

899

increased by15.55%

No dependency changes