New: Built-in merge strategies

src/object-schema.js

@@ -4,6 +4,12 @@
 
 "use strict";
 
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const { MergeStrategy } = require("./merge-strategy");
+
 //-----------------------------------------------------------------------------
 // Private
 //-----------------------------------------------------------------------------
@@ -29,12 +35,20 @@ const requiredKeys = Symbol("requiredKeys");
  */
 function validateDefinition(name, strategy) {
 
+    if (typeof strategy.merge === "string") {
+        if (!(strategy.merge in MergeStrategy)) {
+            throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
+        }
+
+        return;
+    }
+
     if (typeof strategy.merge !== "function") {
-        throw new Error(`Definition for key "${name}" must have a merge() method.`);
+        throw new TypeError(`Definition for key "${name}" must have a merge property.`);
     }
 
     if (typeof strategy.validate !== "function") {
-        throw new Error(`Definition for key "${name}" must have a validate() method.`);
+        throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
     }
 }
 
@@ -75,6 +89,14 @@ class ObjectSchema {
         for (const key of Object.keys(definitions)) {
             validateDefinition(key, definitions[key]);
 
+            // normalize the merge method in case there's a string
+            if (typeof definitions[key].merge === "string") {
+                definitions[key] = {
+                    ...definitions[key],
+                    merge: MergeStrategy[definitions[key].merge]
+                };
+            };
+
             this[strategies].set(key, definitions[key]);
 
             if (definitions[key].required) {
@@ -177,4 +199,4 @@ class ObjectSchema {
     }
 }
 
-exports.ObjectSchema = ObjectSchema;
+exports.ObjectSchema = ObjectSchema;

tests/object-schema.js

@@ -40,7 +40,7 @@ describe("ObjectSchema", () => {
                         validate() { }
                     }
                 });
-            }, /Definition for key "foo" must have a merge\(\) method/);
+            }, /Definition for key "foo" must have a merge property/);
         });
 
         it("should throw an error when a strategy is missing a merge() method", () => {
@@ -179,6 +179,38 @@ describe("ObjectSchema", () => {
             assert.propertyVal(result, "bar", "baz");
         });
 
+        it("should call the merge() strategy when defined as 'overwrite'", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge: "overwrite",
+                    validate() { }
+                }
+            });
+
+            const result = schema.merge(
+                { foo: true },
+                { foo: false }
+            );
+            assert.propertyVal(result, "foo", false);
+        });
+
+        it("should call the merge() strategy when defined as 'assign'", () => {
+            schema = new ObjectSchema({
+                foo: {
+                    merge: "assign",
+                    validate() { }
+                }
+            });
+
+            const result = schema.merge(
+                { foo: { bar: true } },
+                { foo: { baz: false } }
+            );
+
+            assert.strictEqual(result.foo.bar, true);
+            assert.strictEqual(result.foo.baz, false);
+        });
+
     });
 
     describe("validate()", () => {