@bedrockio/yada 1.0.7 → 1.0.9

package/README.md

@@ -22,6 +22,7 @@ Concepts
   - [Reject](#reject)
   - [Custom](#custom)
   - [Default](#default)
+  - [Strip](#strip)
 - [Validation Options](#validation-options)
 - [Error Messages](#error-messages)
 - [Localization](#localization)
@@ -300,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
@@ -376,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
@@ -467,6 +490,24 @@ console.log(await schema.validate()); // "hi!"
 console.log(await schema.validate('hello!')); // "hello!"
 ```
 
+### Strip
+
+The `strip` method serves as a way to conditionally exclude fields when the
+schema is used inside an object schema:
+
+```js
+const schema = yd.object({
+  name: yd.string(),
+  age: yd.number().strip((val, { self }) => {
+    // That's private!
+    return !self;
+  }),
+});
+```
+
+Arguments are identical to those passed to [custom](#custom). The field will be
+stripped out if the function returns a truthy value.
+
 ## Validation Options
 
 Validation options in Yada can be passed at runtime on validation or baked into

package/dist/cjs/Schema.js

@@ -46,6 +46,11 @@ class Schema {
       return await fn(val, options);
     });
   }
+  strip(strip) {
+    return this.clone({
+      strip
+    });
+  }
   allow(...set) {
     return this.assertEnum(set, true);
   }
@@ -120,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

@@ -48,9 +48,22 @@ class ObjectSchema extends _TypeSchema.default {
     for (let [key, schema] of Object.entries(this.meta.fields)) {
       this.assert('field', async (obj, options) => {
         if (obj) {
-          let val;
+          const val = obj[key];
+          const {
+            strip
+          } = schema.meta;
+          if (strip && strip(val, options)) {
+            delete obj[key];
+            return;
+          }
           try {
-            val = await schema.validate(obj[key], options);
+            const result = await schema.validate(val, options);
+            if (result !== undefined) {
+              return {
+                ...obj,
+                [key]: result
+              };
+            }
           } catch (error) {
             if (error.details?.length === 1) {
               const {
@@ -62,18 +75,21 @@ class ObjectSchema extends _TypeSchema.default {
               throw new _errors.FieldError('Field failed validation.', key, error.original, error.details);
             }
           }
-          return {
-            ...obj,
-            ...(val !== undefined && {
-              [key]: val
-            })
-          };
         }
       });
     }
   }
   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.7",
+  "version": "1.0.9",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",

package/src/Schema.js

@@ -46,6 +46,10 @@ export default class Schema {
     });
   }
 
+  strip(strip) {
+    return this.clone({ strip });
+  }
+
   allow(...set) {
     return this.assertEnum(set, true);
   }
@@ -123,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

@@ -38,9 +38,22 @@ class ObjectSchema extends TypeSchema {
     for (let [key, schema] of Object.entries(this.meta.fields)) {
       this.assert('field', async (obj, options) => {
         if (obj) {
-          let val;
+          const val = obj[key];
+          const { strip } = schema.meta;
+
+          if (strip && strip(val, options)) {
+            delete obj[key];
+            return;
+          }
+
           try {
-            val = await schema.validate(obj[key], options);
+            const result = await schema.validate(val, options);
+            if (result !== undefined) {
+              return {
+                ...obj,
+                [key]: result,
+              };
+            }
           } catch (error) {
             if (error.details?.length === 1) {
               const { message, original } = error.details[0];
@@ -54,19 +67,22 @@ class ObjectSchema extends TypeSchema {
               );
             }
           }
-          return {
-            ...obj,
-            ...(val !== undefined && {
-              [key]: val,
-            }),
-          };
         }
       });
     }
   }
 
   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

@@ -693,6 +693,29 @@ describe('custom', () => {
   });
 });
 
+describe('strip', () => {
+  it('should conditionally strip out fields', async () => {
+    const schema = yd.object({
+      name: yd.string(),
+      age: yd.number().strip((val, { self }) => {
+        return !self;
+      }),
+    });
+    const result = await schema.validate(
+      {
+        name: 'Brett',
+        age: 25,
+      },
+      {
+        isPrivate: true,
+      }
+    );
+    expect(result).toEqual({
+      name: 'Brett',
+    });
+  });
+});
+
 describe('array', () => {
   it('should validate an optional array', async () => {
     const schema = yd.array();
@@ -955,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({