New: Default validation strategies

Author: nzakas

README.md

@@ -100,6 +100,48 @@ const result = {
 
 ## Tips and Tricks
 
+### Named merge strategies
+
+Instead of specifying a `merge()` method, you can specify one of the following strings to use a default merge strategy:
+
+* `"assign"` - use `Object.assign()` to merge the two values into one object.
+* `"overwrite"` - the second value always replaces the first.
+* `"replace"` - the second value replaces the first if the second is not `undefined`.
+
+For example:
+
+```js
+const schema = new ObjectSchema({
+    name: {
+        merge: "replace",
+        validate() {}
+    }
+});
+```
+
+### Named validation strategies
+
+Instead of specifying a `validate()` method, you can specify one of the following strings to use a default validation strategy:
+
+* `"array"` - value must be an array.
+* `"boolean"` - value must be a boolean.
+* `"number"` - value must be a number.
+* `"object"` - value must be an object.
+* `"object?"` - value must be an object or null.
+* `"string"` - value must be a string.
+* `"string!"` - value must be a non-empty string.
+
+For example:
+
+```js
+const schema = new ObjectSchema({
+    name: {
+        merge: "replace",
+        validate: "string"
+    }
+});
+```
+
 ### Remove Keys During Merge
 
 If the merge strategy for a key returns `undefined`, then the key will not appear in the final object. For example:
@@ -161,4 +203,4 @@ In this example, even though `date` is an optional key, it is required to be pre
 
 ## License
 
-BSD 3-Clause
+BSD 3-Clause

src/index.js

@@ -4,3 +4,4 @@
 
 exports.ObjectSchema = require("./object-schema").ObjectSchema;
 exports.MergeStrategy = require("./merge-strategy").MergeStrategy;
+exports.ValidationStrategy = require("./validation-strategy").ValidationStrategy;

src/object-schema.js

@@ -9,6 +9,7 @@
 //-----------------------------------------------------------------------------
 
 const { MergeStrategy } = require("./merge-strategy");
+const { ValidationStrategy } = require("./validation-strategy");
 
 //-----------------------------------------------------------------------------
 // Private
@@ -39,15 +40,15 @@ function validateDefinition(name, strategy) {
         if (!(strategy.merge in MergeStrategy)) {
             throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
         }
-
-        return;
-    }
-
-    if (typeof strategy.merge !== "function") {
+    } else if (typeof strategy.merge !== "function") {
         throw new TypeError(`Definition for key "${name}" must have a merge property.`);
     }
 
-    if (typeof strategy.validate !== "function") {
+    if (typeof strategy.validate === "string") {
+        if (!(strategy.validate in ValidationStrategy)) {
+            throw new TypeError(`Definition for key "${name}" missing valid validation strategy.`);
+        }
+    } else if (typeof strategy.validate !== "function") {
         throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
     }
 }
@@ -182,7 +183,10 @@ class ObjectSchema {
 
             // now apply remaining validation strategy
             try {
-                strategy.validate.call(strategy, object[key]);
+                const validate = (typeof strategy.validate === "string")
+                    ? ValidationStrategy[strategy.validate]
+                    : strategy.validate;
+                validate.call(strategy, object[key]);
             } catch (ex) {
                 ex.message = `Key "${key}": ` + ex.message;
                 throw ex;

src/validation-strategy.js

@@ -0,0 +1,102 @@
+/**
+ * @filedescription Validation Strategy
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Class
+//-----------------------------------------------------------------------------
+
+/**
+ * Container class for several different validation strategies.
+ */
+class ValidationStrategy {
+
+    /**
+     * Validates that a value is an array.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static array(value) {
+        if (!Array.isArray(value)) {
+            throw new TypeError("Expected an array.");
+        }
+    }
+
+    /**
+     * Validates that a value is a boolean.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static boolean(value) {
+        if (typeof value !== "boolean") {
+            throw new TypeError("Expected a Boolean.");
+        }
+    }
+
+    /**
+     * Validates that a value is a number.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static number(value) {
+        if (typeof value !== "number") {
+            throw new TypeError("Expected a number.");
+        }
+    }
+
+    /**
+     * Validates that a value is a object.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static object(value) {
+        if (!value || typeof value !== "object") {
+            throw new TypeError("Expected an object.");
+        }
+    }
+
+    /**
+     * Validates that a value is a object or null.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static "object?"(value) {
+        if (typeof value !== "object") {
+            throw new TypeError("Expected an object or null.");
+        }
+    }
+
+    /**
+     * Validates that a value is a string.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static string(value) {
+        if (typeof value !== "string") {
+            throw new TypeError("Expected a string.");
+        }
+    }
+
+    /**
+     * Validates that a value is a non-empty string.
+     * @param {*} value The value to validate.
+     * @returns {void}
+     * @throws {TypeError} If the value is invalid. 
+     */
+    static "string!"(value) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw new TypeError("Expected a non-empty string.");
+        }
+    }
+
+}
+
+exports.ValidationStrategy = ValidationStrategy;

tests/object-schema.js

@@ -59,6 +59,28 @@ describe("ObjectSchema", () => {
             }, /Definition for key "foo" must have a validate\(\) method/);
         });
 
+        it("should throw an error when merge is an invalid string", () => {
+            assert.throws(() => {
+                new ObjectSchema({
+                    foo: {
+                        merge: "bar",
+                        validate() { }
+                    }
+                });
+            }, /key "foo" missing valid merge strategy/);
+        });
+
+        it("should throw an error when validate is an invalid string", () => {
+            assert.throws(() => {
+                new ObjectSchema({
+                    foo: {
+                        merge: "assign",
+                        validate: "s"
+                    }
+                });
+            }, /key "foo" missing valid validation strategy/);
+        });
+
     });
 
 
@@ -85,6 +107,7 @@ describe("ObjectSchema", () => {
             assert.throws(() => {
                 schema.merge({ foo: true }, { foo: true });
             }, /Key "foo": Boom!/);
+        
         });
 
         it("should call the merge() strategy for one key when called", () => {
@@ -335,6 +358,38 @@ describe("ObjectSchema", () => {
             }, /Key "foo": Invalid key/);
         });
 
+        it("should throw an error when an expected key is found but is invalid with a string validator", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate: "string"
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Key "foo": Expected a string/);
+        });
+
+        it("should throw an error when an expected key is found but is invalid with a number validator", () => {
+
+            schema = new ObjectSchema({
+                foo: {
+                    merge() {
+                        return "bar";
+                    },
+                    validate: "number"
+                }
+            });
+
+            assert.throws(() => {
+                schema.validate({ foo: true });
+            }, /Key "foo": Expected a number/);
+        });
+
         it("should throw an error when a required key is missing", () => {
 
             schema = new ObjectSchema({