@bedrockio/yada 1.10.0 → 1.10.2

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.10.2
+
+- Shortcut methods for object options.
+
+## 1.10.1
+
+- Refactored object field validation.
+- Fixed issue with base object failing on flat keys.
+- Ensure that arrays only accept a single inner schema.
+
 ## 1.10.0
 
 - Added `style` option to `toJsonSchema` to control disallowed formats for

package/README.md

@@ -255,19 +255,37 @@ be a boolean, either `true` or `false`.
 
 ### Array
 
-Array schemas validate that input is an array. By default elements may be of any
-type, however however other schemas may be passed in as arguments:
+Array schemas validate that input is an array and elements are of the provided
+type:
 
 ```js
-// Allows arrays containing either strings or numbers.
-const schema = yd.array(yd.string(), yd.number());
+// Allows arrays containing strings.
+const schema = yd.array(yd.string());
 ```
 
-A single array may also be passed in place of enumerated arguments:
+These types can be object of a specific shape:
 
 ```js
-// Allows arrays containing either strings or numbers.
-const schema = yd.array([schemas]);
+// Allows arrays containing objects that follow a schema.
+const schema = yd.array(
+  yd.object({
+    name: yd.string().required(),
+  }),
+);
+```
+
+If no inner schema is provided any element type is allowed:
+
+```js
+// Allows any type of element inside the array:
+const schema = yd.array();
+```
+
+To allow mixed types inside the same array use allow:
+
+```js
+// Allows both strings and numbers in the array:
+const schema = yd.array(yd.allow(yd.string(), yd.number()));
 ```
 
 #### Methods:
@@ -285,7 +303,7 @@ well as types for a given position. Compare the following:
 
 ```js
 // Accepts any length of either strings or numbers.
-const schema1 = yd.array(yd.string(), yd.number());
+const schema1 = yd.array(yd.allow(yd.string(), yd.number()));
 // Accepts exactly 2 elements. The first MUST be a
 // string and the second MUST be a number.
 const schema2 = yd.tuple(yd.string(), yd.number());

package/dist/cjs/Schema.js

@@ -181,6 +181,8 @@ class Schema {
           details.push(new _errors.FormatError(message, this.meta.format));
         } else if (error instanceof _errors.LocalizedError) {
           details.push(new _errors.AssertionError(message, type));
+        } else if (error instanceof _errors.AggregateError) {
+          details = [...details, ...error.errors];
         } else {
           details.push(error);
         }

package/dist/cjs/array.js

@@ -5,23 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = _default;
 var _lodash = require("lodash");
-var _Schema = _interopRequireDefault(require("./Schema"));
 var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
 var _errors = require("./errors");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class ArraySchema extends _TypeSchema.default {
-  constructor(schemas, meta) {
-    super(Array, {
-      ...meta,
-      schemas
-    });
+  constructor(meta) {
+    super(Array, meta);
     this.setup();
   }
   setup() {
     const {
-      schemas
+      schema
     } = this.meta;
-    const schema = schemas.length > 1 ? new _Schema.default().allow(schemas) : schemas[0];
     this.assert('type', (val, options) => {
       if (typeof val === 'string' && options.cast) {
         val = val.split(',');
@@ -115,13 +110,15 @@ class ArraySchema extends _TypeSchema.default {
    */
   transform(fn, root = true) {
     const {
-      schemas,
+      schema,
       ...rest
     } = this.meta;
-    const newSchemas = schemas.map(schema => {
-      return schema.transform(fn, false);
+    const transformed = new ArraySchema({
+      ...rest,
+      ...(schema && {
+        schema: schema.transform(fn, false)
+      })
     });
-    const transformed = new ArraySchema(newSchemas, rest);
     if (root) {
       // @ts-ignore
       return transformed;
@@ -136,24 +133,14 @@ class ArraySchema extends _TypeSchema.default {
     return 'array';
   }
   toJsonSchema(options) {
-    let other;
     const {
-      schemas
+      schema
     } = this.meta;
-    if (schemas.length > 1) {
-      other = {
-        anyOf: schemas.map(schema => {
-          return schema.toJsonSchema(options);
-        })
-      };
-    } else if (schemas.length === 1) {
-      other = {
-        items: schemas[0].toJsonSchema(options)
-      };
-    }
     return {
       ...super.toJsonSchema(options),
-      ...other
+      ...(schema && {
+        items: schema?.toJsonSchema(options)
+      })
     };
   }
 }
@@ -161,14 +148,14 @@ class ArraySchema extends _TypeSchema.default {
 /**
  * Creates an [array schema](https://github.com/bedrockio/yada#array).
  *
- * @param {...Schema} [schemas] Optional schemas to validate
- * the different types of elements allowed in the array. If
- * no arguments are passed elements may be of any type. Also
- * accepts a single array argument.
+ * @param {*} [schema] - The schema to validate elements in
+ * the array. If not passed then elements may be of any type.
  */
-function _default(...schemas) {
-  if (Array.isArray(schemas[0])) {
-    schemas = schemas[0];
+function _default(schema) {
+  if (arguments.length > 1) {
+    throw new Error('Arrays may only have a single schema. Use "allow" instead.');
   }
-  return new ArraySchema(schemas);
+  return new ArraySchema({
+    schema
+  });
 }

package/dist/cjs/errors.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ValidationError = exports.TypeError = exports.LocalizedError = exports.FormatError = exports.FieldError = exports.ElementError = exports.AssertionError = exports.ArrayError = exports.AllowedError = void 0;
+exports.ValidationError = exports.TypeError = exports.LocalizedError = exports.FormatError = exports.FieldError = exports.ElementError = exports.AssertionError = exports.ArrayError = exports.AllowedError = exports.AggregateError = void 0;
 exports.isSchemaError = isSchemaError;
 var _localization = require("./localization");
 var _messages = require("./messages");
@@ -54,6 +54,13 @@ class ValidationError extends Error {
   }
 }
 exports.ValidationError = ValidationError;
+class AggregateError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+  }
+}
+exports.AggregateError = AggregateError;
 class AssertionError extends ValidationError {
   constructor(message, type = 'assertion') {
     super(message);

package/dist/cjs/object.js

@@ -21,92 +21,105 @@ const INTEGER_REG = /^\d+$/;
 class ObjectSchema extends _TypeSchema.default {
   constructor(meta) {
     super(Object, meta);
+    this.validateInput();
     this.setup();
   }
+  validateInput() {
+    const {
+      fields
+    } = this.meta;
+    for (let [key, value] of Object.entries(fields || {})) {
+      if (!(0, _Schema.isSchema)(value)) {
+        throw new Error(`Key "${key}" must be a schema.`);
+      }
+    }
+  }
   setup() {
     this.assert('type', val => {
       if (val === null || typeof val !== 'object') {
         throw new _errors.LocalizedError('Must be an object.');
       }
     });
-    this.transformValue((obj, options) => {
+    this.assert('fields', async (obj, options) => {
       const {
+        path = [],
+        original,
+        stripEmpty,
         stripUnknown,
-        stripEmpty
+        allowFlatKeys,
+        expandFlatKeys
       } = options;
-      if (obj) {
-        const result = {};
-        obj = expandFlatSyntax(obj, options);
-        for (let key of Object.keys(obj)) {
-          const value = obj[key];
-          const isUnknown = !isKnownKey(key, this, options);
-          if (value === '' && stripEmpty || isUnknown && stripUnknown) {
+      const {
+        fields
+      } = this.meta;
+      if (!fields) {
+        return;
+      }
+      let passed = obj;
+      if (expandFlatKeys) {
+        passed = expandFlatSyntax(passed);
+      }
+      const keys = new Set([...Object.keys(fields || {}), ...Object.keys(passed)]);
+      let errors = [];
+      const result = {};
+      for (let key of keys) {
+        const value = passed[key];
+        if (value === '' && stripEmpty) {
+          continue;
+        }
+        const schema = getSchema(fields, key, options);
+        if (!schema) {
+          if (stripUnknown) {
             continue;
-          } else if (isUnknown) {
-            throw new _errors.LocalizedError('Unknown field "{key}".', {
-              key,
-              type: 'field'
-            });
-          } else {
-            result[key] = obj[key];
           }
+          throw new _errors.LocalizedError('Unknown field "{key}".', {
+            type: 'field',
+            key
+          });
         }
-        return result;
-      }
-    });
-    for (let [key, schema] of Object.entries(this.export())) {
-      if (!(0, _Schema.isSchema)(schema)) {
-        throw new Error(`Key "${key}" must be a schema.`);
-      }
-      this.assert('field', async (obj, options) => {
-        if (obj) {
-          const {
-            path = [],
-            original
-          } = options;
-          const {
-            strip,
-            required
-          } = schema.meta;
-          const val = obj[key];
-          options = {
+        if (schema.meta.strip?.(value, options)) {
+          continue;
+        }
+        try {
+          const validateOptions = {
             ...options,
-            required,
-            path: [...path, key]
+            path: [...path, key],
+            required: schema.meta.required,
+            // The root object may be transformed by defaults
+            // or returned values so re-pass it here.
+            root: {
+              ...obj,
+              ...result
+            },
+            // The original root represents the root object
+            // before it was transformed.
+            originalRoot: original
           };
-          if (strip && strip(val, options)) {
-            delete obj[key];
-            return;
-          }
-          try {
-            // Do not pass down message into validators
-            // to allow custom messages to take precedence.
-            options = (0, _lodash.omit)(options, 'message');
-            const result = await schema.validate(val, {
-              ...options,
-              // The root object may have been transformed here
-              // by defaults or values returned by custom functions
-              // so re-pass it here.
-              root: obj,
-              // The original root represents the root object
-              // before it was transformed.
-              originalRoot: original
-            });
-            if (result !== undefined) {
-              return {
-                ...obj,
-                [key]: result
-              };
+          if (allowFlatKeys && !value) {
+            // When allowing keys like "profile.name", "profile" will
+            // not be passed so expand the passed object and make sure
+            // the base validates, but do not transform the result.
+            const expanded = expandFlatSyntax(passed);
+            await schema.validate(expanded[key], validateOptions);
+          } else {
+            const transformed = await schema.validate(value, validateOptions);
+            if (transformed !== undefined) {
+              result[key] = transformed;
             }
-          } catch (error) {
-            const {
-              message
-            } = schema.meta;
-            throw new _errors.FieldError(message, key, error.details);
           }
+        } catch (error) {
+          const {
+            message
+          } = schema.meta;
+          errors.push(new _errors.FieldError(message, key, error.details));
         }
-      });
-    }
+      }
+      if (errors.length) {
+        errors = normalizeErrors(errors, options);
+        throw new _errors.AggregateError(this.meta.message, errors);
+      }
+      return result;
+    });
   }
 
   /**
@@ -126,11 +139,8 @@ class ObjectSchema extends _TypeSchema.default {
     path = Array.isArray(path) ? path : path.split('.');
     const [name, ...rest] = path;
     const schema = fields[name];
-    if (!schema) {
-      throw new Error(`Cannot find field "${name}".`);
-    }
     if (rest.length) {
-      return schema.get(rest);
+      return schema?.get(rest);
     } else {
       return schema;
     }
@@ -147,14 +157,15 @@ class ObjectSchema extends _TypeSchema.default {
     path = Array.isArray(path) ? path.join('.') : path;
     const field = this.get(path);
     const {
-      schemas
+      type,
+      schema
     } = field.meta;
-    if (!schemas) {
+    if (type !== 'array') {
       throw new Error(`Field "${path}" is not an array schema.`);
-    } else if (schemas.length !== 1) {
-      throw new Error(`Field "${path}" should contain only one schema.`);
+    } else if (!schema) {
+      throw new Error(`Field "${path}" does not have an inner schema.`);
     }
-    return schemas[0];
+    return schema;
   }
 
   /**
@@ -202,7 +213,11 @@ class ObjectSchema extends _TypeSchema.default {
     }
     const update = {};
     for (let field of fields) {
-      (0, _lodash.set)(update, field, this.get(field).required());
+      const schema = this.get(field);
+      if (!schema) {
+        throw new Error(`Cannot find field "${field}".`);
+      }
+      (0, _lodash.set)(update, field, schema.required());
     }
     return this.append(update);
   }
@@ -288,6 +303,44 @@ class ObjectSchema extends _TypeSchema.default {
     return schema;
   }
 
+  // Options
+
+  /**
+   * Remove properties that are empty strings.
+   */
+  stripEmpty() {
+    return this.options({
+      stripEmpty: true
+    });
+  }
+
+  /**
+   * Remove properties not in the schema.
+   */
+  stripUnknown() {
+    return this.options({
+      stripUnknown: true
+    });
+  }
+
+  /**
+   * Allow flat keys like `profile.name`.
+   */
+  allowFlatKeys() {
+    return this.options({
+      allowFlatKeys: true
+    });
+  }
+
+  /**
+   * Expand flat keys into nested objects.
+   */
+  expandFlatKeys() {
+    return this.options({
+      expandFlatKeys: true
+    });
+  }
+
   /**
    * `stripEmpty` - Removes properties that are empty strings.
    * `stripUnknown` - Removes properties not in the schema.
@@ -328,10 +381,7 @@ class ObjectSchema extends _TypeSchema.default {
     };
   }
 }
-function expandFlatSyntax(obj, options) {
-  if (!options.expandFlatKeys) {
-    return obj;
-  }
+function expandFlatSyntax(obj) {
   const result = {
     ...obj
   };
@@ -343,66 +393,6 @@ function expandFlatSyntax(obj, options) {
   }
   return result;
 }
-function isKnownKey(key, schema, options) {
-  const {
-    fields
-  } = schema.meta;
-  const {
-    allowFlatKeys
-  } = options;
-  if (!fields) {
-    // No fields defined -> all keys are "known".
-    return true;
-  } else if (key in fields) {
-    // Exact match -> key is known.
-    return true;
-  } else if (allowFlatKeys && key.includes('.')) {
-    // Flat syntax "foo.bar".
-    const [base, ...rest] = key.split('.');
-    let subschema = fields[base];
-    if (!subschema) {
-      return false;
-    }
-    const {
-      type,
-      schemas
-    } = subschema.meta;
-    let subkey;
-    if (type === 'array') {
-      // If the subschema is an array then take the first of
-      // its defined schemas as we can safely assume that an
-      // array of objects will be defined as a single element
-      // or multiple schemas will only set the base property.
-      // Test that the element key is valid and take any
-      // further properties as the subkey. Examples:
-      // - profiles.0.name (array of objects)
-      // - profiles.0 (array of stringsmk)
-      const [index, ...other] = rest;
-      if (!INTEGER_REG.test(index)) {
-        return false;
-      }
-      subschema = schemas[0];
-      subkey = other.join('.');
-    } else if (type === 'object') {
-      // If the subschema is an object then simply take any
-      // further properties as the subkey. Example:
-      // - profile.name
-      subkey = rest.join('.');
-    } else {
-      // If the subschema is anything else then disallow it
-      // further properties as the subkey. Example:
-      // - profile.name
-      return false;
-    }
-    if (subschema.meta.type === 'object') {
-      return isKnownKey(subkey, subschema, options);
-    } else {
-      return !subkey;
-    }
-  } else {
-    return false;
-  }
-}
 function mergeFields(aFields, bFields) {
   if (!aFields || !bFields) {
     return aFields || bFields;
@@ -422,6 +412,78 @@ function mergeFields(aFields, bFields) {
   return result;
 }
 
+// Gets the schema for a field allowing for flat
+// keys which may deeply traverse into the object.
+function getSchema(fields, key, options) {
+  const {
+    allowFlatKeys
+  } = options;
+  let schema = fields[key];
+  if (schema) {
+    return schema;
+  }
+  if (!allowFlatKeys || !key.includes('.')) {
+    return;
+  }
+  schema = fields;
+  for (let part of key.split('.')) {
+    const {
+      type,
+      fields
+    } = schema?.meta || {};
+    if (type === 'array') {
+      // If the schema is an array schema then take the first
+      // subschema, however only allow integers in this case,
+      // for example: profiles.0.name.
+
+      if (!INTEGER_REG.test(part)) {
+        return;
+      }
+      schema = schema.meta.schema;
+    } else if (fields) {
+      schema = fields[part];
+    } else {
+      schema = schema?.[part];
+    }
+  }
+  return schema;
+}
+
+// If flat keys are allowed then filter out errors
+// that are the nested duplicates so that they match
+// the actual fields that were passed.
+function normalizeErrors(errors, options) {
+  const {
+    allowFlatKeys
+  } = options;
+  if (allowFlatKeys) {
+    errors = errors.filter(error => {
+      const {
+        field
+      } = error;
+      const flatField = getFlatField(error);
+      if (field !== flatField) {
+        return !errors.some(error => {
+          return error.field === flatField;
+        });
+      }
+      return true;
+    });
+  }
+  return errors;
+}
+function getFlatField(error) {
+  const {
+    field,
+    details
+  } = error;
+  const path = [field];
+  if (details.length === 1 && details[0] instanceof _errors.FieldError) {
+    path.push(getFlatField(details[0]));
+  }
+  return path.join('.');
+}
+
 /**
  * Creates an [object schema](https://github.com/bedrockio/yada#object).
  *

package/package.json

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

package/src/Schema.js

@@ -1,6 +1,7 @@
 import { omit, uniqBy } from 'lodash';
 
 import {
+  AggregateError,
   AllowedError,
   AssertionError,
   FormatError,
@@ -177,6 +178,8 @@ export default class Schema {
           details.push(new FormatError(message, this.meta.format));
         } else if (error instanceof LocalizedError) {
           details.push(new AssertionError(message, type));
+        } else if (error instanceof AggregateError) {
+          details = [...details, ...error.errors];
         } else {
           details.push(error);
         }

package/src/array.js

@@ -1,19 +1,16 @@
 import { omit } from 'lodash';
 
-import Schema from './Schema';
 import TypeSchema from './TypeSchema';
 import { ArrayError, ElementError, LocalizedError } from './errors';
 
 class ArraySchema extends TypeSchema {
-  constructor(schemas, meta) {
-    super(Array, { ...meta, schemas });
+  constructor(meta) {
+    super(Array, meta);
     this.setup();
   }
 
   setup() {
-    const { schemas } = this.meta;
-    const schema =
-      schemas.length > 1 ? new Schema().allow(schemas) : schemas[0];
+    const { schema } = this.meta;
 
     this.assert('type', (val, options) => {
       if (typeof val === 'string' && options.cast) {
@@ -111,14 +108,15 @@ class ArraySchema extends TypeSchema {
    * @returns {this}
    */
   transform(fn, root = true) {
-    const { schemas, ...rest } = this.meta;
+    const { schema, ...rest } = this.meta;
 
-    const newSchemas = schemas.map((schema) => {
-      return schema.transform(fn, false);
+    const transformed = new ArraySchema({
+      ...rest,
+      ...(schema && {
+        schema: schema.transform(fn, false),
+      }),
     });
 
-    const transformed = new ArraySchema(newSchemas, rest);
-
     if (root) {
       // @ts-ignore
       return transformed;
@@ -134,23 +132,12 @@ class ArraySchema extends TypeSchema {
   }
 
   toJsonSchema(options) {
-    let other;
-    const { schemas } = this.meta;
-    if (schemas.length > 1) {
-      other = {
-        anyOf: schemas.map((schema) => {
-          return schema.toJsonSchema(options);
-        }),
-      };
-    } else if (schemas.length === 1) {
-      other = {
-        items: schemas[0].toJsonSchema(options),
-      };
-    }
-
+    const { schema } = this.meta;
     return {
       ...super.toJsonSchema(options),
-      ...other,
+      ...(schema && {
+        items: schema?.toJsonSchema(options),
+      }),
     };
   }
 }
@@ -158,14 +145,16 @@ class ArraySchema extends TypeSchema {
 /**
  * Creates an [array schema](https://github.com/bedrockio/yada#array).
  *
- * @param {...Schema} [schemas] Optional schemas to validate
- * the different types of elements allowed in the array. If
- * no arguments are passed elements may be of any type. Also
- * accepts a single array argument.
+ * @param {*} [schema] - The schema to validate elements in
+ * the array. If not passed then elements may be of any type.
  */
-export default function (...schemas) {
-  if (Array.isArray(schemas[0])) {
-    schemas = schemas[0];
+export default function (schema) {
+  if (arguments.length > 1) {
+    throw new Error(
+      'Arrays may only have a single schema. Use "allow" instead.',
+    );
   }
-  return new ArraySchema(schemas);
+  return new ArraySchema({
+    schema,
+  });
 }

package/src/errors.js

@@ -46,6 +46,13 @@ export class ValidationError extends Error {
   }
 }
 
+export class AggregateError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+  }
+}
+
 export class AssertionError extends ValidationError {
   constructor(message, type = 'assertion') {
     super(message);

package/src/object.js

@@ -2,7 +2,7 @@ import { omit, pick, set } from 'lodash';
 
 import Schema, { isSchema } from './Schema';
 import TypeSchema from './TypeSchema';
-import { FieldError, LocalizedError } from './errors';
+import { AggregateError, FieldError, LocalizedError } from './errors';
 
 const APPEND_ASSERTION_TYPES = ['required', 'type', 'custom'];
 
@@ -15,88 +15,124 @@ const INTEGER_REG = /^\d+$/;
 class ObjectSchema extends TypeSchema {
   constructor(meta) {
     super(Object, meta);
+    this.validateInput();
     this.setup();
   }
 
+  validateInput() {
+    const { fields } = this.meta;
+    for (let [key, value] of Object.entries(fields || {})) {
+      if (!isSchema(value)) {
+        throw new Error(`Key "${key}" must be a schema.`);
+      }
+    }
+  }
+
   setup() {
     this.assert('type', (val) => {
       if (val === null || typeof val !== 'object') {
         throw new LocalizedError('Must be an object.');
       }
     });
-    this.transformValue((obj, options) => {
-      const { stripUnknown, stripEmpty } = options;
-      if (obj) {
-        const result = {};
 
-        obj = expandFlatSyntax(obj, options);
+    this.assert('fields', async (obj, options) => {
+      const {
+        path = [],
+        original,
+        stripEmpty,
+        stripUnknown,
+        allowFlatKeys,
+        expandFlatKeys,
+      } = options;
+
+      const { fields } = this.meta;
+
+      if (!fields) {
+        return;
+      }
+
+      let passed = obj;
+
+      if (expandFlatKeys) {
+        passed = expandFlatSyntax(passed);
+      }
+
+      const keys = new Set([
+        ...Object.keys(fields || {}),
+        ...Object.keys(passed),
+      ]);
+
+      let errors = [];
+      const result = {};
 
-        for (let key of Object.keys(obj)) {
-          const value = obj[key];
-          const isUnknown = !isKnownKey(key, this, options);
+      for (let key of keys) {
+        const value = passed[key];
 
-          if ((value === '' && stripEmpty) || (isUnknown && stripUnknown)) {
+        if (value === '' && stripEmpty) {
+          continue;
+        }
+
+        const schema = getSchema(fields, key, options);
+
+        if (!schema) {
+          if (stripUnknown) {
             continue;
-          } else if (isUnknown) {
-            throw new LocalizedError('Unknown field "{key}".', {
-              key,
-              type: 'field',
-            });
-          } else {
-            result[key] = obj[key];
           }
+          throw new LocalizedError('Unknown field "{key}".', {
+            type: 'field',
+            key,
+          });
+        }
+
+        if (schema.meta.strip?.(value, options)) {
+          continue;
         }
-        return result;
-      }
-    });
-    for (let [key, schema] of Object.entries(this.export())) {
-      if (!isSchema(schema)) {
-        throw new Error(`Key "${key}" must be a schema.`);
-      }
-      this.assert('field', async (obj, options) => {
-        if (obj) {
-          const { path = [], original } = options;
-          const { strip, required } = schema.meta;
-          const val = obj[key];
 
-          options = {
+        try {
+          const validateOptions = {
             ...options,
-            required,
+
             path: [...path, key],
+            required: schema.meta.required,
+
+            // The root object may be transformed by defaults
+            // or returned values so re-pass it here.
+            root: {
+              ...obj,
+              ...result,
+            },
+
+            // The original root represents the root object
+            // before it was transformed.
+            originalRoot: original,
           };
 
-          if (strip && strip(val, options)) {
-            delete obj[key];
-            return;
-          }
+          if (allowFlatKeys && !value) {
+            // When allowing keys like "profile.name", "profile" will
+            // not be passed so expand the passed object and make sure
+            // the base validates, but do not transform the result.
+            const expanded = expandFlatSyntax(passed);
 
-          try {
-            // Do not pass down message into validators
-            // to allow custom messages to take precedence.
-            options = omit(options, 'message');
-            const result = await schema.validate(val, {
-              ...options,
-              // The root object may have been transformed here
-              // by defaults or values returned by custom functions
-              // so re-pass it here.
-              root: obj,
-              // The original root represents the root object
-              // before it was transformed.
-              originalRoot: original,
-            });
-            if (result !== undefined) {
-              return {
-                ...obj,
-                [key]: result,
-              };
+            await schema.validate(expanded[key], validateOptions);
+          } else {
+            const transformed = await schema.validate(value, validateOptions);
+            if (transformed !== undefined) {
+              result[key] = transformed;
             }
-          } catch (error) {
-            const { message } = schema.meta;
-            throw new FieldError(message, key, error.details);
           }
+        } catch (error) {
+          const { message } = schema.meta;
+          errors.push(new FieldError(message, key, error.details));
         }
-      });
-    }
+      }
+
+      if (errors.length) {
+        errors = normalizeErrors(errors, options);
+        throw new AggregateError(this.meta.message, errors);
+      }
+
+      return result;
+    });
   }
 
   /**
@@ -117,12 +153,8 @@ class ObjectSchema extends TypeSchema {
     const [name, ...rest] = path;
     const schema = fields[name];
 
-    if (!schema) {
-      throw new Error(`Cannot find field "${name}".`);
-    }
-
     if (rest.length) {
-      return schema.get(rest);
+      return schema?.get(rest);
     } else {
       return schema;
     }
@@ -138,13 +170,15 @@ class ObjectSchema extends TypeSchema {
   unwind(path) {
     path = Array.isArray(path) ? path.join('.') : path;
     const field = this.get(path);
-    const { schemas } = field.meta;
-    if (!schemas) {
+    const { type, schema } = field.meta;
+
+    if (type !== 'array') {
       throw new Error(`Field "${path}" is not an array schema.`);
-    } else if (schemas.length !== 1) {
-      throw new Error(`Field "${path}" should contain only one schema.`);
+    } else if (!schema) {
+      throw new Error(`Field "${path}" does not have an inner schema.`);
     }
-    return schemas[0];
+
+    return schema;
   }
 
   /**
@@ -195,7 +229,11 @@ class ObjectSchema extends TypeSchema {
     const update = {};
 
     for (let field of fields) {
-      set(update, field, this.get(field).required());
+      const schema = this.get(field);
+      if (!schema) {
+        throw new Error(`Cannot find field "${field}".`);
+      }
+      set(update, field, schema.required());
     }
 
     return this.append(update);
@@ -290,6 +328,44 @@ class ObjectSchema extends TypeSchema {
     return schema;
   }
 
+  // Options
+
+  /**
+   * Remove properties that are empty strings.
+   */
+  stripEmpty() {
+    return this.options({
+      stripEmpty: true,
+    });
+  }
+
+  /**
+   * Remove properties not in the schema.
+   */
+  stripUnknown() {
+    return this.options({
+      stripUnknown: true,
+    });
+  }
+
+  /**
+   * Allow flat keys like `profile.name`.
+   */
+  allowFlatKeys() {
+    return this.options({
+      allowFlatKeys: true,
+    });
+  }
+
+  /**
+   * Expand flat keys into nested objects.
+   */
+  expandFlatKeys() {
+    return this.options({
+      expandFlatKeys: true,
+    });
+  }
+
   /**
    * `stripEmpty` - Removes properties that are empty strings.
    * `stripUnknown` - Removes properties not in the schema.
@@ -330,11 +406,7 @@ class ObjectSchema extends TypeSchema {
   }
 }
 
-function expandFlatSyntax(obj, options) {
-  if (!options.expandFlatKeys) {
-    return obj;
-  }
-
+function expandFlatSyntax(obj) {
   const result = { ...obj };
   for (let [key, value] of Object.entries(result)) {
     if (key.includes('.')) {
@@ -345,65 +417,6 @@ function expandFlatSyntax(obj, options) {
   return result;
 }
 
-function isKnownKey(key, schema, options) {
-  const { fields } = schema.meta;
-  const { allowFlatKeys } = options;
-  if (!fields) {
-    // No fields defined -> all keys are "known".
-    return true;
-  } else if (key in fields) {
-    // Exact match -> key is known.
-    return true;
-  } else if (allowFlatKeys && key.includes('.')) {
-    // Flat syntax "foo.bar".
-    const [base, ...rest] = key.split('.');
-    let subschema = fields[base];
-
-    if (!subschema) {
-      return false;
-    }
-
-    const { type, schemas } = subschema.meta;
-
-    let subkey;
-
-    if (type === 'array') {
-      // If the subschema is an array then take the first of
-      // its defined schemas as we can safely assume that an
-      // array of objects will be defined as a single element
-      // or multiple schemas will only set the base property.
-      // Test that the element key is valid and take any
-      // further properties as the subkey. Examples:
-      // - profiles.0.name (array of objects)
-      // - profiles.0 (array of stringsmk)
-      const [index, ...other] = rest;
-      if (!INTEGER_REG.test(index)) {
-        return false;
-      }
-      subschema = schemas[0];
-      subkey = other.join('.');
-    } else if (type === 'object') {
-      // If the subschema is an object then simply take any
-      // further properties as the subkey. Example:
-      // - profile.name
-      subkey = rest.join('.');
-    } else {
-      // If the subschema is anything else then disallow it
-      // further properties as the subkey. Example:
-      // - profile.name
-      return false;
-    }
-
-    if (subschema.meta.type === 'object') {
-      return isKnownKey(subkey, subschema, options);
-    } else {
-      return !subkey;
-    }
-  } else {
-    return false;
-  }
-}
-
 function mergeFields(aFields, bFields) {
   if (!aFields || !bFields) {
     return aFields || bFields;
@@ -422,6 +435,79 @@ function mergeFields(aFields, bFields) {
   return result;
 }
 
+// Gets the schema for a field allowing for flat
+// keys which may deeply traverse into the object.
+function getSchema(fields, key, options) {
+  const { allowFlatKeys } = options;
+
+  let schema = fields[key];
+
+  if (schema) {
+    return schema;
+  }
+
+  if (!allowFlatKeys || !key.includes('.')) {
+    return;
+  }
+
+  schema = fields;
+
+  for (let part of key.split('.')) {
+    const { type, fields } = schema?.meta || {};
+
+    if (type === 'array') {
+      // If the schema is an array schema then take the first
+      // subschema, however only allow integers in this case,
+      // for example: profiles.0.name.
+
+      if (!INTEGER_REG.test(part)) {
+        return;
+      }
+
+      schema = schema.meta.schema;
+    } else if (fields) {
+      schema = fields[part];
+    } else {
+      schema = schema?.[part];
+    }
+  }
+
+  return schema;
+}
+
+// If flat keys are allowed then filter out errors
+// that are the nested duplicates so that they match
+// the actual fields that were passed.
+function normalizeErrors(errors, options) {
+  const { allowFlatKeys } = options;
+  if (allowFlatKeys) {
+    errors = errors.filter((error) => {
+      const { field } = error;
+      const flatField = getFlatField(error);
+
+      if (field !== flatField) {
+        return !errors.some((error) => {
+          return error.field === flatField;
+        });
+      }
+
+      return true;
+    });
+  }
+  return errors;
+}
+
+function getFlatField(error) {
+  const { field, details } = error;
+  const path = [field];
+
+  if (details.length === 1 && details[0] instanceof FieldError) {
+    path.push(getFlatField(details[0]));
+  }
+
+  return path.join('.');
+}
+
 /**
  * Creates an [object schema](https://github.com/bedrockio/yada#object).
  *

package/types/Schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAiBA,kDAEC;AAED;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;;OAGG;IACH,iBAHW,OAAO,GACL,IAAI,CAUhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDAwCC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,uBANG;QAA2B,GAAG;QACH,KAAK,GAAxB,QAAQ;QAGU,eAAe,GAAjC,OAAO;KACjB,OASA;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,cAEC;IAED;;MAWC;IAED;;MAKC;IAED;;;;MASC;IAED,2BAgDC;IAED,2BAmBC;IAED;;;;;OAKG;IACH,oCAFa,IAAI,CAgBhB;IAED,kBAEC;IAED,YAGC;IAID;;OAEG;IACH,kCAFa,IAAI,CAsDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,yBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;CACF"}
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAkBA,kDAEC;AAED;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;;OAGG;IACH,iBAHW,OAAO,GACL,IAAI,CAUhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDA0CC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,uBANG;QAA2B,GAAG;QACH,KAAK,GAAxB,QAAQ;QAGU,eAAe,GAAjC,OAAO;KACjB,OASA;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,cAEC;IAED;;MAWC;IAED;;MAKC;IAED;;;;MASC;IAED,2BAgDC;IAED,2BAmBC;IAED;;;;;OAKG;IACH,oCAFa,IAAI,CAgBhB;IAED,kBAEC;IAED,YAGC;IAID;;OAEG;IACH,kCAFa,IAAI,CAsDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,yBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;CACF"}

package/types/array.d.ts

@@ -1,14 +1,12 @@
 /**
  * Creates an [array schema](https://github.com/bedrockio/yada#array).
  *
- * @param {...Schema} [schemas] Optional schemas to validate
- * the different types of elements allowed in the array. If
- * no arguments are passed elements may be of any type. Also
- * accepts a single array argument.
+ * @param {*} [schema] - The schema to validate elements in
+ * the array. If not passed then elements may be of any type.
  */
-export default function _default(...schemas?: Schema[]): ArraySchema;
-import Schema from './Schema';
+export default function _default(schema?: any, ...args: any[]): ArraySchema;
 declare class ArraySchema extends TypeSchema {
+    constructor(meta: any);
     setup(): void;
     length(length: any): this;
     min(length: any): this;

package/types/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AA6JA;;;;;;;GAOG;AACH,8CALc,MAAM,EAAA,eAUnB;mBAxKkB,UAAU;AAI7B;IAME,cAsCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED;;;;;OAKG;IACH,yCAFa,IAAI,CAiBhB;IAID,mBAEC;IAED,gCAmBC;CACF;uBAxJsB,cAAc"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAgJA;;;;;GAKG;AACH,0CAHW,GAAC,+BAYX;AA1JD;IACE,uBAGC;IAED,cAoCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED;;;;;OAKG;IACH,yCAFa,IAAI,CAkBhB;IAID,mBAEC;IAED,gCAQC;CACF;uBA5IsB,cAAc"}

package/types/errors.d.ts

@@ -15,6 +15,10 @@ export class ValidationError extends Error {
     getMessage(): any;
     getFullMessage(options: any): any;
 }
+export class AggregateError extends Error {
+    constructor(message: any, errors: any);
+    errors: any;
+}
 export class AssertionError extends ValidationError {
     constructor(message: any, type?: string);
 }

package/types/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAqIA,gEAEC;AApID;IACE,uCAEC;CACF;AAED;IACE,+BAA8C;IAE9C,+CAIC;IAFC,aAAwB;IACxB,eAAsB;IAGxB;;;;MAWC;IAED,kBAOC;IAED,kCAKC;CACF;AAED;IACE,yCAGC;CACF;AAED;IACE,qCAIC;IADC,UAAgB;IAGlB;;;;;MAKC;CACF;AAED;IACE,uCAIC;IADC,YAAoB;IAGtB;;;;;MAKC;CACF;AAED;IAGE,uDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IAGE,uDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IACE,wCAGC;CACF;AAED;IACE,wCAGC;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AA4IA,gEAEC;AA3ID;IACE,uCAEC;CACF;AAED;IACE,+BAA8C;IAE9C,+CAIC;IAFC,aAAwB;IACxB,eAAsB;IAGxB;;;;MAWC;IAED,kBAOC;IAED,kCAKC;CACF;AAED;IACE,uCAGC;IADC,YAAoB;CAEvB;AAED;IACE,yCAGC;CACF;AAED;IACE,qCAIC;IADC,UAAgB;IAGlB;;;;;MAKC;CACF;AAED;IACE,uCAIC;IADC,YAAoB;IAGtB;;;;;MAKC;CACF;AAED;IAGE,uDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IAGE,uDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IACE,wCAGC;CACF;AAED;IACE,wCAGC;CACF"}

package/types/object.d.ts

@@ -14,6 +14,7 @@ export type SchemaMap = {
  */
 declare class ObjectSchema extends TypeSchema {
     constructor(meta: any);
+    validateInput(): void;
     setup(): void;
     /**
      * Gets the schema for the given field. Deep fields accept
@@ -83,6 +84,22 @@ declare class ObjectSchema extends TypeSchema {
      * @param {SchemaMap|Schema} arg Object or schema to append.
      */
     append(arg: SchemaMap | Schema): ObjectSchema;
+    /**
+     * Remove properties that are empty strings.
+     */
+    stripEmpty(): this;
+    /**
+     * Remove properties not in the schema.
+     */
+    stripUnknown(): this;
+    /**
+     * Allow flat keys like `profile.name`.
+     */
+    allowFlatKeys(): this;
+    /**
+     * Expand flat keys into nested objects.
+     */
+    expandFlatKeys(): this;
     /**
      * `stripEmpty` - Removes properties that are empty strings.
      * `stripUnknown` - Removes properties not in the schema.

package/types/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAwaA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAQnB;wBAxaY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IACE,uBAGC;IAED,cA+EC;IAED;;;;;;OAMG;IACH,WAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAsB9B;IAED;;;;;;OAMG;IACH,cAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAY9B;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;;;;OAOG;IACH,mBAHc,MAAM,EAAA,gBAmBnB;IAED;;OAEG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,yCAFa,IAAI,CAiBhB;IAED;;;;;;OAMG;IACH,cAEC;IAED;;;;;;;;;OASG;IACH,YAFW,SAAS,GAAC,MAAM,gBA+B1B;IAED;;;;;;;;;;;OAWG;IACH,kBALG;QAA0B,UAAU,GAA5B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,aAAa,GAA/B,OAAO;QACW,cAAc,GAAhC,OAAO;KAA0B,QAI3C;IAID,gCAmBC;CACF;mBAxUgC,UAAU;uBACpB,cAAc"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AA8fA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAQnB;wBA9fY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IACE,uBAIC;IAED,sBAOC;IAED,cAyGC;IAED;;;;;;OAMG;IACH,WAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAkB9B;IAED;;;;;;OAMG;IACH,cAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAc9B;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;;;;OAOG;IACH,mBAHc,MAAM,EAAA,gBAuBnB;IAED;;OAEG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,yCAFa,IAAI,CAiBhB;IAED;;;;;;OAMG;IACH,cAEC;IAED;;;;;;;;;OASG;IACH,YAFW,SAAS,GAAC,MAAM,gBA+B1B;IAID;;OAEG;IACH,mBAIC;IAED;;OAEG;IACH,qBAIC;IAED;;OAEG;IACH,sBAIC;IAED;;OAEG;IACH,uBAIC;IAED;;;;;;;;;;;OAWG;IACH,kBALG;QAA0B,UAAU,GAA5B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,aAAa,GAA/B,OAAO;QACW,cAAc,GAAhC,OAAO;KAA0B,QAI3C;IAID,gCAmBC;CACF;mBApZgC,UAAU;uBACpB,cAAc"}