@bedrockio/yada 1.0.8 → 1.0.9

package/README.md

@@ -301,11 +301,6 @@ const schema = yd
   .required();
 ```
 
-#### Methods:
-
-- `append` - Appends the passed argument to create a new object schema. Accepts
-  either an object or another `.object()` schema.
-
 ## Date
 
 Dates are similar to the basic types with the exception that in addition to date
@@ -377,6 +372,33 @@ await schema.validate(true); // pass
 await schema.validate('true'); // error!
 ```
 
+### Append
+
+Appends another schema:
+
+```js
+const schema1 = yd.string();
+const schema2 = yd.custom((str) => {
+  if (str === 'foo') {
+    throw new Error('Cannot be foo!');
+  }
+});
+const schema = schema1.append(schema2);
+```
+
+Note that when applied to an object schema the fields will be merged. In this
+case a plain object is also accepted:
+
+```js
+const schema1 = yd.object({
+  foo: yd.string(),
+});
+const schema2 = yd.object({
+  bar: yd.string(),
+});
+const schema = schema1.append(schema2);
+```
+
 ### Custom
 
 The `custom` schema allows for custom validations expressed in code. A custom

package/dist/cjs/Schema.js

@@ -125,6 +125,11 @@ class Schema {
     };
     return clone;
   }
+  append(schema) {
+    const merged = this.clone(schema.meta);
+    merged.assertions = [...this.assertions, ...schema.assertions];
+    return merged;
+  }
 
   // Private
 

package/dist/cjs/object.js

@@ -80,7 +80,16 @@ class ObjectSchema extends _TypeSchema.default {
     }
   }
   append(arg) {
-    const schema = (0, _Schema.isSchema)(arg) ? arg : new ObjectSchema(arg);
+    let schema;
+    if (arg instanceof ObjectSchema) {
+      schema = arg;
+    } else if ((0, _Schema.isSchema)(arg)) {
+      // If the schema is of a different type then
+      // simply append it and don't merge fields.
+      return super.append(arg);
+    } else {
+      schema = new ObjectSchema(arg);
+    }
     const fields = {
       ...this.meta.fields,
       ...schema.meta.fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",

package/src/Schema.js

@@ -127,6 +127,12 @@ export default class Schema {
     return clone;
   }
 
+  append(schema) {
+    const merged = this.clone(schema.meta);
+    merged.assertions = [...this.assertions, ...schema.assertions];
+    return merged;
+  }
+
   // Private
 
   assertEnum(set, allow) {

package/src/object.js

@@ -73,7 +73,16 @@ class ObjectSchema extends TypeSchema {
   }
 
   append(arg) {
-    const schema = isSchema(arg) ? arg : new ObjectSchema(arg);
+    let schema;
+    if (arg instanceof ObjectSchema) {
+      schema = arg;
+    } else if (isSchema(arg)) {
+      // If the schema is of a different type then
+      // simply append it and don't merge fields.
+      return super.append(arg);
+    } else {
+      schema = new ObjectSchema(arg);
+    }
 
     const fields = {
       ...this.meta.fields,

package/test/all.test.js

@@ -978,6 +978,56 @@ describe('default', () => {
   });
 });
 
+describe('append', () => {
+  it('should allow appending to a string schema', async () => {
+    const custom = yd.custom((str) => {
+      if (str === 'fop') {
+        throw new Error('You misspelled foo!');
+      }
+    });
+
+    const schema = yd.string().append(custom);
+
+    await assertPass(schema, 'foo');
+    await assertFail(schema, 'fop', ['You misspelled foo!']);
+  });
+
+  it('should append a custom schema to an object schema', async () => {
+    const custom = yd.custom((obj) => {
+      if (obj.foo === 'fop') {
+        throw new Error('You misspelled foo!');
+      }
+    });
+
+    const schema = yd
+      .object({
+        foo: yd.string(),
+      })
+      .append(custom);
+
+    await assertPass(schema, { foo: 'foo' });
+    await assertFail(schema, { foo: 'fop' }, ['You misspelled foo!']);
+  });
+
+  it('should preserve defaults', async () => {
+    const custom = yd.custom((str) => {
+      if (str === 'fop') {
+        throw new Error('You misspelled foo!');
+      }
+    });
+    const schema = yd.string().required();
+
+    await assertPass(schema.default('foo').append(custom));
+    await assertPass(schema.append(custom).default('foo'));
+    await assertFail(schema.default('fop').append(custom), undefined, [
+      'You misspelled foo!',
+    ]);
+    await assertFail(schema.append(custom).default('fop'), undefined, [
+      'You misspelled foo!',
+    ]);
+  });
+});
+
 describe('serialization', () => {
   it('should correctly serialize object error', async () => {
     const schema = yd.object({