@bedrockio/yada 1.0.40 → 1.1.0

package/README.md

@@ -19,12 +19,13 @@ Concepts
   - [Object](#object)
   - [Date](#date)
 - [Common Methods](#common-methods)
-  - [Allow](#allow)
-  - [Reject](#reject)
-  - [Append](#append)
-  - [Custom](#custom)
-  - [Default](#default)
-  - [Strip](#strip)
+  - [allow](#allow)
+  - [reject](#reject)
+  - [append](#append)
+  - [custom](#custom)
+  - [default](#default)
+  - [strip](#strip)
+  - [message](#message)
 - [Validation Options](#validation-options)
 - [Error Messages](#error-messages)
 - [Localization](#localization)
@@ -552,6 +553,65 @@ const schema = yd.object({
 Arguments are identical to those passed to [custom](#custom). The field will be
 stripped out if the function returns a truthy value.
 
+### Message
+
+The `message` method allows adding a custom message to schema or field. Note
+that when using with [`getFullMessage`](#error-messages) the custom message will
+not include the nested field name by default:
+
+```js
+const schema = yd.object({
+  name: yd.string().required().message('Please provide your full name.'),
+});
+try {
+  await schema.validate({});
+} catch (error) {
+  console.log(error.getFullMessage());
+  // -> Please provide your full name.
+}
+```
+
+To include the field name, the `{field}` token may be used in the message:
+
+```js
+const schema = yd.object({
+  name: yd
+    .string()
+    .match(/^[A-Z]/)
+    .message('{field} must start with an uppercase letter.'),
+});
+try {
+  await schema.validate({
+    name: 'frank',
+  });
+} catch (error) {
+  console.log(error.getFullMessage());
+  // -> "name" must start with an uppercase letter.
+}
+```
+
+The `{field}` token may also be used when throwing custom errors:
+
+```js
+const schema = yd.object({
+  profile: yd.object({
+    name: yd.custom((value) => {
+      if (value !== 'Frank') {
+        throw new Error('{field} must be "Frank".');
+      }
+    }),
+  }),
+});
+try {
+  await schema.validate({
+    name: 'Bob',
+  });
+} catch (error) {
+  console.log(error.getFullMessage());
+  // -> "name" must be "Frank".
+}
+```
+
 ## Validation Options
 
 Validation options in Yada can be passed at runtime on validation or baked into
@@ -634,7 +694,6 @@ which returns that map:
 ```js
 yd.useLocalizer({
   'Must be at least {length} character{s}.': '{length}文字以上入力して下さい。',
-  'Object failed validation.': '不正な入力がありました。',
 });
 ```
 
@@ -657,13 +716,11 @@ allow quick discovery of strings that have not yet been localized:
 ```js
 yd.useLocalizer({
   'Must be at least {length} character{s}.': '{length}文字以上入力して下さい。',
-  'Object failed validation.': '不正な入力がありました。',
 });
 // Error validation occuring here
 yd.getLocalizedMessages();
 // {
 //   'Must be at least {length} character{s}.': '{length}文字以上入力して下さい。',
-//   'Object failed validation.': '不正な入力がありました。',
 //   'Value must be a string.': 'Value must be a string.',
 //   ...etc
 // }

package/dist/cjs/Schema.js

@@ -13,7 +13,6 @@ const REQUIRED_TYPES = ['default', 'required'];
 /**
  * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
  */
-
 class Schema {
   constructor(meta = {}) {
     this.assertions = [];
@@ -157,8 +156,15 @@ class Schema {
           value = result;
         }
       } catch (error) {
-        if (error instanceof _errors.ArrayError) {
-          details = [...details, ...error.details];
+        const {
+          type
+        } = assertion;
+        if (type === 'type') {
+          details.push(new _errors.TypeError(error, this.meta.type));
+        } else if (type === 'format') {
+          details.push(new _errors.FormatError(error, this.meta.format));
+        } else if (!error.type) {
+          details.push(new _errors.AssertionError(error, type));
         } else {
           details.push(error);
         }
@@ -168,10 +174,7 @@ class Schema {
       }
     }
     if (details.length) {
-      const {
-        message = 'Input failed validation.'
-      } = this.meta;
-      throw new _errors.ValidationError(message, details);
+      throw new _errors.ValidationError(this.meta.message, details);
     }
     return value;
   }
@@ -266,12 +269,11 @@ class Schema {
       }
       return el;
     });
-    const msg = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
+    const message = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
     return this.clone({
       enum: set
     }).assert('enum', async (val, options) => {
       if (val !== undefined) {
-        let error;
         for (let el of set) {
           if (isSchema(el)) {
             try {
@@ -282,28 +284,23 @@ class Schema {
               return await el.validate(val, options);
             } catch (err) {
               const [first] = err.details;
-              const isTypeError = first?.type === 'type';
-              if (!isTypeError) {
-                // Capture the first error object only if it is not
-                // a simple type error to surface error messages on
-                // more complex schemas. Otherwise allow this to fall
-                // through to show more meaningful messages for simple
-                // enums.
-                error ||= err;
+              if (first instanceof _errors.TypeError) {
+                // If the error is a simple type error then continue
+                // to show more meaningful messages for simple enums.
+                continue;
+              } else {
+                // Otherwise throw the error to surface messages on
+                // more complex schemas.
+                throw err;
               }
-              continue;
             }
           } else if (el === val === allow) {
             return;
           }
         }
-        if (error) {
-          throw new _errors.ValidationError(options.message || error.message, error.details);
-        } else {
-          throw new _errors.LocalizedError(options.message || msg, {
-            types: types.join(', ')
-          });
-        }
+        throw new _errors.LocalizedError(message, {
+          types: types.join(', ')
+        });
       }
     });
   }
@@ -344,17 +341,9 @@ class Schema {
   }
   async runAssertion(assertion, value, options = {}) {
     const {
-      type,
       fn
     } = assertion;
-    try {
-      return await fn(value, options);
-    } catch (error) {
-      if ((0, _errors.isSchemaError)(error)) {
-        throw error;
-      }
-      throw new _errors.AssertionError(error.message, error.type || type, error);
-    }
+    return await fn(value, options);
   }
   enumToOpenApi() {
     const {

package/dist/cjs/TypeSchema.js

@@ -10,8 +10,8 @@ class TypeSchema extends _Schema.default {
   constructor(Class, meta) {
     const type = Class.name.toLowerCase();
     super({
-      type,
-      ...meta
+      ...meta,
+      type
     });
   }
   format(name, fn) {

package/dist/cjs/array.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = _default;
 var _Schema = _interopRequireDefault(require("./Schema"));
+var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
 var _errors = require("./errors");
 var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class ArraySchema extends _Schema.default {
+class ArraySchema extends _TypeSchema.default {
   constructor(schemas) {
-    super({
-      message: 'Array failed validation.',
+    super(Array, {
       schemas
     });
     this.setup();
@@ -22,8 +22,7 @@ class ArraySchema extends _Schema.default {
    */
   setup() {
     const {
-      schemas,
-      message
+      schemas
     } = this.meta;
     const schema = schemas.length > 1 ? new _Schema.default().allow(schemas) : schemas[0];
     this.assert('type', (val, options) => {
@@ -36,6 +35,9 @@ class ArraySchema extends _Schema.default {
       return val;
     });
     if (schema) {
+      const {
+        message
+      } = schema.meta;
       this.assert('elements', async (arr, options) => {
         const errors = [];
         const result = [];
@@ -47,7 +49,7 @@ class ArraySchema extends _Schema.default {
             options = (0, _utils.omit)(options, 'message');
             result.push(await schema.validate(el, options));
           } catch (error) {
-            errors.push(new _errors.ElementError('Element failed validation.', i, error.original, error.details));
+            errors.push(new _errors.ElementError(message, i, error.details));
           }
         }
         if (errors.length) {

package/dist/cjs/errors.js

@@ -3,58 +3,38 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ValidationError = exports.LocalizedError = exports.FieldError = exports.ElementError = exports.AssertionError = exports.ArrayError = void 0;
+exports.ValidationError = exports.TypeError = exports.LocalizedError = exports.FormatError = exports.FieldError = exports.ElementError = exports.AssertionError = exports.ArrayError = void 0;
 exports.isSchemaError = isSchemaError;
 var _messages = require("./messages");
 var _localization = require("./localization");
 class LocalizedError extends Error {
-  constructor(message, values) {
+  constructor(message, values = {}) {
     super((0, _localization.localize)(message, values));
-    this.values = values;
-  }
-  get type() {
-    return this.values?.type;
   }
 }
 exports.LocalizedError = LocalizedError;
 class ValidationError extends Error {
-  constructor(message, details = [], type = 'validation') {
-    super((0, _localization.localize)(message));
+  constructor(arg, details = []) {
+    super(getLocalizedMessage(arg));
+    this.type = 'validation';
     this.details = details;
-    this.type = type;
   }
   toJSON() {
-    if (this.canRollup()) {
-      const [first] = this.details;
-      return {
-        ...first.toJSON(),
-        type: this.type
-      };
-    } else {
-      return {
-        type: this.type,
-        message: this.message,
-        details: this.details.map(error => {
-          return error.toJSON();
-        })
-      };
-    }
-  }
-  canRollup() {
     const {
+      message,
       details
     } = this;
-    if (details.length !== 1) {
-      return false;
-    }
-    const [first] = details;
-
-    // Roll up field types as long as they are not
-    // referencing nested fields.
-    return this.isFieldType() && !first.isFieldType?.();
-  }
-  isFieldType() {
-    return this.type === 'field' || this.type === 'element';
+    return {
+      type: this.type,
+      ...(message && {
+        message
+      }),
+      ...(details.length && {
+        details: details.map(error => {
+          return error.toJSON();
+        })
+      })
+    };
   }
   getFullMessage(options) {
     return (0, _messages.getFullMessage)(this, {
@@ -64,12 +44,46 @@ class ValidationError extends Error {
   }
 }
 exports.ValidationError = ValidationError;
+class AssertionError extends ValidationError {
+  constructor(message, type = 'assertion') {
+    super(message);
+    this.type = type;
+  }
+}
+exports.AssertionError = AssertionError;
+class TypeError extends ValidationError {
+  constructor(message, kind) {
+    super(message);
+    this.type = 'type';
+    this.kind = kind;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      kind: this.kind
+    };
+  }
+}
+exports.TypeError = TypeError;
+class FormatError extends ValidationError {
+  constructor(message, format) {
+    super(message);
+    this.type = 'format';
+    this.format = format;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      format: this.format
+    };
+  }
+}
+exports.FormatError = FormatError;
 class FieldError extends ValidationError {
-  constructor(message, field, original, details) {
-    super(message, details, 'field');
+  constructor(message, field, details) {
+    super(message, details);
+    this.type = 'field';
     this.field = field;
-    this.original = original;
-    this.details = details;
   }
   toJSON() {
     return {
@@ -80,11 +94,10 @@ class FieldError extends ValidationError {
 }
 exports.FieldError = FieldError;
 class ElementError extends ValidationError {
-  constructor(message, index, original, details) {
-    super(message, details, 'element');
+  constructor(message, index, details) {
+    super(message, details);
+    this.type = 'element';
     this.index = index;
-    this.original = original;
-    this.details = details;
   }
   toJSON() {
     return {
@@ -94,27 +107,23 @@ class ElementError extends ValidationError {
   }
 }
 exports.ElementError = ElementError;
-class AssertionError extends Error {
-  constructor(message, type, original) {
-    super(message);
-    this.type = type;
-    this.original = original;
-  }
-  toJSON() {
-    return {
-      type: this.type,
-      message: this.message
-    };
-  }
-}
-exports.AssertionError = AssertionError;
-class ArrayError extends Error {
+class ArrayError extends ValidationError {
   constructor(message, details) {
     super(message);
+    this.type = 'array';
     this.details = details;
   }
 }
 exports.ArrayError = ArrayError;
 function isSchemaError(arg) {
-  return arg instanceof ValidationError || arg instanceof AssertionError || arg instanceof ArrayError;
+  return arg instanceof ValidationError;
+}
+function getLocalizedMessage(arg) {
+  if (arg instanceof LocalizedError) {
+    return arg.message;
+  } else if (arg instanceof Error) {
+    return (0, _localization.localize)(arg.message);
+  } else {
+    return (0, _localization.localize)(arg);
+  }
 }

package/dist/cjs/localization.js

@@ -32,6 +32,9 @@ function getLocalized(message) {
   }
 }
 function localize(message, values = {}) {
+  if (!message) {
+    return;
+  }
   let str = message;
   if (str) {
     let localized = getLocalized(message);

package/dist/cjs/messages.js

@@ -4,37 +4,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getFullMessage = getFullMessage;
-var _errors = require("./errors");
 var _localization = require("./localization");
 function getFullMessage(error, options) {
   const {
     delimiter = '\n'
   } = options;
-  if (error.details) {
+  if (error.message) {
+    return getLabeledMessage(error, options);
+  } else if (error.details?.length) {
     return error.details.map(error => {
-      if ((0, _errors.isSchemaError)(error)) {
-        return getFullMessage(error, {
-          ...options,
-          path: getInnerPath(error, options)
-        });
-      } else {
-        return error.message;
-      }
+      return getFullMessage(error, {
+        ...options,
+        path: getInnerPath(error, options)
+      });
     }).join(delimiter);
-  } else {
-    return getLabeledMessage(error, options);
   }
 }
 function getInnerPath(error, options) {
-  const {
-    type
-  } = error;
   const {
     path = []
   } = options;
-  if (type === 'field' && error.field) {
+  if (error.field) {
     return [...path, error.field];
-  } else if (type === 'element') {
+  } else if (error.index != null) {
     return [...path, error.index];
   } else {
     return path;
@@ -48,15 +40,28 @@ function getLabeledMessage(error, options) {
     path = []
   } = options;
   const base = getBase(error.message);
-  if (type !== 'custom' && path.length) {
-    const msg = `{field} ${downcase(base)}`;
-    return (0, _localization.localize)(msg, {
+  let template;
+  if (base.includes('{field}')) {
+    template = base;
+  } else if (canAutoAddField(type, path)) {
+    template = `{field} ${downcase(base)}`;
+  }
+  if (template) {
+    return (0, _localization.localize)(template, {
       field: getFieldLabel(options)
     });
   } else {
     return (0, _localization.localize)(base);
   }
 }
+const DISALLOWED_TYPES = ['field', 'element', 'array', 'custom'];
+
+// Error types that have custom messages should not add the field
+// names automatically. Instead the custom messages can include
+// the {field} token to allow it to be interpolated if required.
+function canAutoAddField(type, path) {
+  return path.length && !DISALLOWED_TYPES.includes(type);
+}
 function getFieldLabel(options) {
   const {
     path = [],

package/dist/cjs/object.js

@@ -21,8 +21,7 @@ class ObjectSchema extends _TypeSchema.default {
   constructor(fields, meta) {
     super(Object, {
       ...meta,
-      fields,
-      message: 'Object failed validation.'
+      fields
     });
     this.setup();
   }
@@ -93,7 +92,10 @@ class ObjectSchema extends _TypeSchema.default {
               };
             }
           } catch (error) {
-            throw new _errors.FieldError('Field failed validation.', key, error.original, error.details);
+            const {
+              message
+            } = schema.meta;
+            throw new _errors.FieldError(message, key, error.details);
           }
         }
       });

package/dist/cjs/tuple.js

@@ -10,7 +10,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 class TupleSchema extends _Schema.default {
   constructor(schemas) {
     super({
-      message: 'Tuple failed validation.',
       schemas
     });
     this.setup();
@@ -21,7 +20,8 @@ class TupleSchema extends _Schema.default {
    */
   setup() {
     const {
-      schemas
+      schemas,
+      message
     } = this.meta;
     this.assert('type', (val, options) => {
       if (typeof val === 'string' && options.cast) {
@@ -63,11 +63,10 @@ class TupleSchema extends _Schema.default {
           }
           result.push(await schema.validate(el, options));
         } catch (error) {
-          if (error.details?.length === 1) {
-            errors.push(new _errors.ElementError(error.details[0].message, i));
-          } else {
-            errors.push(new _errors.ElementError('Element failed validation.', i, error.details));
-          }
+          const {
+            message
+          } = schema.meta;
+          errors.push(new _errors.ElementError(message, i, error.details));
         }
       }
       if (errors.length) {

package/package.json

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

package/src/Schema.js

@@ -1,9 +1,9 @@
 import {
-  isSchemaError,
-  ValidationError,
+  TypeError,
+  FormatError,
   AssertionError,
   LocalizedError,
-  ArrayError,
+  ValidationError,
 } from './errors';
 import { omit } from './utils';
 
@@ -13,7 +13,6 @@ const REQUIRED_TYPES = ['default', 'required'];
 /**
  * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
  */
-
 export default class Schema {
   constructor(meta = {}) {
     this.assertions = [];
@@ -150,8 +149,14 @@ export default class Schema {
           value = result;
         }
       } catch (error) {
-        if (error instanceof ArrayError) {
-          details = [...details, ...error.details];
+        const { type } = assertion;
+
+        if (type === 'type') {
+          details.push(new TypeError(error, this.meta.type));
+        } else if (type === 'format') {
+          details.push(new FormatError(error, this.meta.format));
+        } else if (!error.type) {
+          details.push(new AssertionError(error, type));
         } else {
           details.push(error);
         }
@@ -162,8 +167,7 @@ export default class Schema {
     }
 
     if (details.length) {
-      const { message = 'Input failed validation.' } = this.meta;
-      throw new ValidationError(message, details);
+      throw new ValidationError(this.meta.message, details);
     }
 
     return value;
@@ -249,10 +253,9 @@ export default class Schema {
       }
       return el;
     });
-    const msg = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
+    const message = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
     return this.clone({ enum: set }).assert('enum', async (val, options) => {
       if (val !== undefined) {
-        let error;
         for (let el of set) {
           if (isSchema(el)) {
             try {
@@ -263,31 +266,23 @@ export default class Schema {
               return await el.validate(val, options);
             } catch (err) {
               const [first] = err.details;
-              const isTypeError = first?.type === 'type';
-              if (!isTypeError) {
-                // Capture the first error object only if it is not
-                // a simple type error to surface error messages on
-                // more complex schemas. Otherwise allow this to fall
-                // through to show more meaningful messages for simple
-                // enums.
-                error ||= err;
+              if (first instanceof TypeError) {
+                // If the error is a simple type error then continue
+                // to show more meaningful messages for simple enums.
+                continue;
+              } else {
+                // Otherwise throw the error to surface messages on
+                // more complex schemas.
+                throw err;
               }
-              continue;
             }
           } else if ((el === val) === allow) {
             return;
           }
         }
-        if (error) {
-          throw new ValidationError(
-            options.message || error.message,
-            error.details
-          );
-        } else {
-          throw new LocalizedError(options.message || msg, {
-            types: types.join(', '),
-          });
-        }
+        throw new LocalizedError(message, {
+          types: types.join(', '),
+        });
       }
     });
   }
@@ -330,15 +325,8 @@ export default class Schema {
   }
 
   async runAssertion(assertion, value, options = {}) {
-    const { type, fn } = assertion;
-    try {
-      return await fn(value, options);
-    } catch (error) {
-      if (isSchemaError(error)) {
-        throw error;
-      }
-      throw new AssertionError(error.message, error.type || type, error);
-    }
+    const { fn } = assertion;
+    return await fn(value, options);
   }
 
   enumToOpenApi() {

package/src/TypeSchema.js

@@ -3,7 +3,7 @@ import Schema from './Schema';
 export default class TypeSchema extends Schema {
   constructor(Class, meta) {
     const type = Class.name.toLowerCase();
-    super({ type, ...meta });
+    super({ ...meta, type });
   }
 
   format(name, fn) {

package/src/array.js

@@ -1,10 +1,11 @@
 import Schema from './Schema';
+import TypeSchema from './TypeSchema';
 import { ArrayError, ElementError, LocalizedError } from './errors';
 import { omit } from './utils';
 
-class ArraySchema extends Schema {
+class ArraySchema extends TypeSchema {
   constructor(schemas) {
-    super({ message: 'Array failed validation.', schemas });
+    super(Array, { schemas });
     this.setup();
   }
 
@@ -12,7 +13,7 @@ class ArraySchema extends Schema {
    * @private
    */
   setup() {
-    const { schemas, message } = this.meta;
+    const { schemas } = this.meta;
     const schema =
       schemas.length > 1 ? new Schema().allow(schemas) : schemas[0];
 
@@ -27,6 +28,7 @@ class ArraySchema extends Schema {
     });
 
     if (schema) {
+      const { message } = schema.meta;
       this.assert('elements', async (arr, options) => {
         const errors = [];
         const result = [];
@@ -38,14 +40,7 @@ class ArraySchema extends Schema {
             options = omit(options, 'message');
             result.push(await schema.validate(el, options));
           } catch (error) {
-            errors.push(
-              new ElementError(
-                'Element failed validation.',
-                i,
-                error.original,
-                error.details
-              )
-            );
+            errors.push(new ElementError(message, i, error.details));
           }
         }
         if (errors.length) {

package/src/errors.js

@@ -2,55 +2,31 @@ import { getFullMessage } from './messages';
 import { localize } from './localization';
 
 export class LocalizedError extends Error {
-  constructor(message, values) {
+  constructor(message, values = {}) {
     super(localize(message, values));
-    this.values = values;
-  }
-
-  get type() {
-    return this.values?.type;
   }
 }
 
 export class ValidationError extends Error {
-  constructor(message, details = [], type = 'validation') {
-    super(localize(message));
+  constructor(arg, details = []) {
+    super(getLocalizedMessage(arg));
+    this.type = 'validation';
     this.details = details;
-    this.type = type;
   }
 
   toJSON() {
-    if (this.canRollup()) {
-      const [first] = this.details;
-      return {
-        ...first.toJSON(),
-        type: this.type,
-      };
-    } else {
-      return {
-        type: this.type,
-        message: this.message,
-        details: this.details.map((error) => {
+    const { message, details } = this;
+    return {
+      type: this.type,
+      ...(message && {
+        message,
+      }),
+      ...(details.length && {
+        details: details.map((error) => {
           return error.toJSON();
         }),
-      };
-    }
-  }
-
-  canRollup() {
-    const { details } = this;
-    if (details.length !== 1) {
-      return false;
-    }
-    const [first] = details;
-
-    // Roll up field types as long as they are not
-    // referencing nested fields.
-    return this.isFieldType() && !first.isFieldType?.();
-  }
-
-  isFieldType() {
-    return this.type === 'field' || this.type === 'element';
+      }),
+    };
   }
 
   getFullMessage(options) {
@@ -61,64 +37,91 @@ export class ValidationError extends Error {
   }
 }
 
-export class FieldError extends ValidationError {
-  constructor(message, field, original, details) {
-    super(message, details, 'field');
-    this.field = field;
-    this.original = original;
-    this.details = details;
+export class AssertionError extends ValidationError {
+  constructor(message, type = 'assertion') {
+    super(message);
+    this.type = type;
+  }
+}
+
+export class TypeError extends ValidationError {
+  constructor(message, kind) {
+    super(message);
+    this.type = 'type';
+    this.kind = kind;
   }
 
   toJSON() {
     return {
       ...super.toJSON(),
-      field: this.field,
+      kind: this.kind,
     };
   }
 }
 
-export class ElementError extends ValidationError {
-  constructor(message, index, original, details) {
-    super(message, details, 'element');
-    this.index = index;
-    this.original = original;
-    this.details = details;
+export class FormatError extends ValidationError {
+  constructor(message, format) {
+    super(message);
+    this.type = 'format';
+    this.format = format;
   }
 
   toJSON() {
     return {
       ...super.toJSON(),
-      index: this.index,
+      format: this.format,
     };
   }
 }
 
-export class AssertionError extends Error {
-  constructor(message, type, original) {
-    super(message);
-    this.type = type;
-    this.original = original;
+export class FieldError extends ValidationError {
+  constructor(message, field, details) {
+    super(message, details);
+    this.type = 'field';
+    this.field = field;
   }
 
   toJSON() {
     return {
-      type: this.type,
-      message: this.message,
+      ...super.toJSON(),
+      field: this.field,
+    };
+  }
+}
+
+export class ElementError extends ValidationError {
+  constructor(message, index, details) {
+    super(message, details);
+    this.type = 'element';
+    this.index = index;
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      index: this.index,
     };
   }
 }
 
-export class ArrayError extends Error {
+export class ArrayError extends ValidationError {
   constructor(message, details) {
     super(message);
+    this.type = 'array';
     this.details = details;
   }
 }
 
 export function isSchemaError(arg) {
-  return (
-    arg instanceof ValidationError ||
-    arg instanceof AssertionError ||
-    arg instanceof ArrayError
-  );
+  return arg instanceof ValidationError;
+}
+
+function getLocalizedMessage(arg) {
+  if (arg instanceof LocalizedError) {
+    return arg.message;
+  } else if (arg instanceof Error) {
+    return localize(arg.message);
+  } else {
+    return localize(arg);
+  }
 }

package/src/localization.js

@@ -26,6 +26,9 @@ export function getLocalized(message) {
 }
 
 export function localize(message, values = {}) {
+  if (!message) {
+    return;
+  }
   let str = message;
   if (str) {
     let localized = getLocalized(message);

package/src/messages.js

@@ -1,32 +1,26 @@
-import { isSchemaError } from './errors';
 import { localize } from './localization';
 
 export function getFullMessage(error, options) {
   const { delimiter = '\n' } = options;
-  if (error.details) {
+  if (error.message) {
+    return getLabeledMessage(error, options);
+  } else if (error.details?.length) {
     return error.details
       .map((error) => {
-        if (isSchemaError(error)) {
-          return getFullMessage(error, {
-            ...options,
-            path: getInnerPath(error, options),
-          });
-        } else {
-          return error.message;
-        }
+        return getFullMessage(error, {
+          ...options,
+          path: getInnerPath(error, options),
+        });
       })
       .join(delimiter);
-  } else {
-    return getLabeledMessage(error, options);
   }
 }
 
 function getInnerPath(error, options) {
-  const { type } = error;
   const { path = [] } = options;
-  if (type === 'field' && error.field) {
+  if (error.field) {
     return [...path, error.field];
-  } else if (type === 'element') {
+  } else if (error.index != null) {
     return [...path, error.index];
   } else {
     return path;
@@ -37,9 +31,16 @@ function getLabeledMessage(error, options) {
   const { type } = error;
   const { path = [] } = options;
   const base = getBase(error.message);
-  if (type !== 'custom' && path.length) {
-    const msg = `{field} ${downcase(base)}`;
-    return localize(msg, {
+
+  let template;
+  if (base.includes('{field}')) {
+    template = base;
+  } else if (canAutoAddField(type, path)) {
+    template = `{field} ${downcase(base)}`;
+  }
+
+  if (template) {
+    return localize(template, {
       field: getFieldLabel(options),
     });
   } else {
@@ -47,6 +48,15 @@ function getLabeledMessage(error, options) {
   }
 }
 
+const DISALLOWED_TYPES = ['field', 'element', 'array', 'custom'];
+
+// Error types that have custom messages should not add the field
+// names automatically. Instead the custom messages can include
+// the {field} token to allow it to be interpolated if required.
+function canAutoAddField(type, path) {
+  return path.length && !DISALLOWED_TYPES.includes(type);
+}
+
 function getFieldLabel(options) {
   const { path = [], natural } = options;
   if (natural) {

package/src/object.js

@@ -11,11 +11,7 @@ const BASE_ASSERTIONS = ['type', 'transform', 'field'];
 
 class ObjectSchema extends TypeSchema {
   constructor(fields, meta) {
-    super(Object, {
-      ...meta,
-      fields,
-      message: 'Object failed validation.',
-    });
+    super(Object, { ...meta, fields });
     this.setup();
   }
 
@@ -79,12 +75,8 @@ class ObjectSchema extends TypeSchema {
               };
             }
           } catch (error) {
-            throw new FieldError(
-              'Field failed validation.',
-              key,
-              error.original,
-              error.details
-            );
+            const { message } = schema.meta;
+            throw new FieldError(message, key, error.details);
           }
         }
       });

package/src/tuple.js

@@ -3,7 +3,7 @@ import { ArrayError, ElementError, LocalizedError } from './errors';
 
 class TupleSchema extends Schema {
   constructor(schemas) {
-    super({ message: 'Tuple failed validation.', schemas });
+    super({ schemas });
     this.setup();
   }
 
@@ -11,7 +11,7 @@ class TupleSchema extends Schema {
    * @private
    */
   setup() {
-    const { schemas } = this.meta;
+    const { schemas, message } = this.meta;
 
     this.assert('type', (val, options) => {
       if (typeof val === 'string' && options.cast) {
@@ -52,13 +52,8 @@ class TupleSchema extends Schema {
           }
           result.push(await schema.validate(el, options));
         } catch (error) {
-          if (error.details?.length === 1) {
-            errors.push(new ElementError(error.details[0].message, i));
-          } else {
-            errors.push(
-              new ElementError('Element failed validation.', i, error.details)
-            );
-          }
+          const { message } = schema.meta;
+          errors.push(new ElementError(message, i, error.details));
         }
       }
       if (errors.length) {

package/types/Schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AA8XA,4CAEC;AApXD;;GAEG;AAEH;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,gBAHW,eAAe,GACb,IAAI,CAmBhB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,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,iDAqCC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAMhB;IAED,2BAWC;IAED;;MAOC;IAED;;;;MASC;IAED,kBAEC;IAED,4BAMC;IAID;;OAEG;IACH,kCAFa,IAAI,CAqDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED;;OAEG;IACH,oBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAUC;IAED;;;;;;;;MAoCC;CACF;8BA/WY,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,CAAC"}
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAkXA,4CAEC;AAxWD;;GAEG;AACH;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,gBAHW,eAAe,GACb,IAAI,CAmBhB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,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,IAAI,CAMhB;IAED,2BAWC;IAED;;MAOC;IAED;;;;MASC;IAED,kBAEC;IAED,4BAMC;IAID;;OAEG;IACH,kCAFa,IAAI,CA4ChB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED;;OAEG;IACH,oBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAGC;IAED;;;;;;;;MAoCC;CACF;8BAnWY,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,CAAC"}

package/types/array.d.ts

@@ -8,7 +8,7 @@
  */
 export default function _default(...schemas?: Schema[]): ArraySchema;
 import Schema from "./Schema";
-declare class ArraySchema extends Schema {
+declare class ArraySchema extends TypeSchema {
     constructor(schemas: any);
     /**
      * @private
@@ -18,6 +18,8 @@ declare class ArraySchema extends Schema {
     min(length: any): ArraySchema;
     max(length: any): ArraySchema;
     latlng(): ArraySchema;
+    toString(): string;
 }
+import TypeSchema from "./TypeSchema";
 export {};
 //# sourceMappingURL=array.d.ts.map

package/types/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AA4IA;;;;;;;GAOG;AACH,8CALc,MAAM,iBAUnB;;AArJD;IACE,0BAGC;IAED;;OAEG;IACH,cA4CC;IAED,iCAUC;IAED,8BAUC;IAED,8BAaC;IAED,sBAaC;CA2BF"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAuIA;;;;;;;GAOG;AACH,8CALc,MAAM,iBAUnB;;AA/ID;IACE,0BAGC;IAED;;OAEG;IACH,cAsCC;IAED,iCAUC;IAED,8BAUC;IAED,8BAaC;IAED,sBAaC;IAED,mBAEC;CAuBF"}

package/types/errors.d.ts

@@ -1,40 +1,62 @@
 export function isSchemaError(arg: any): boolean;
 export class LocalizedError extends Error {
-    constructor(message: any, values: any);
-    values: any;
-    get type(): any;
+    constructor(message: any, values?: {});
 }
 export class ValidationError extends Error {
-    constructor(message: any, details?: any[], type?: string);
-    details: any[];
+    constructor(arg: any, details?: any[]);
     type: string;
-    toJSON(): any;
-    canRollup(): boolean;
-    isFieldType(): boolean;
+    details: any[];
+    toJSON(): {
+        details: any[];
+        message: string;
+        type: string;
+    };
     getFullMessage(options: any): any;
 }
+export class AssertionError extends ValidationError {
+    constructor(message: any, type?: string);
+}
+export class TypeError extends ValidationError {
+    constructor(message: any, kind: any);
+    kind: any;
+    toJSON(): {
+        kind: any;
+        details: any[];
+        message: string;
+        type: string;
+    };
+}
+export class FormatError extends ValidationError {
+    constructor(message: any, format: any);
+    format: any;
+    toJSON(): {
+        format: any;
+        details: any[];
+        message: string;
+        type: string;
+    };
+}
 export class FieldError extends ValidationError {
-    constructor(message: any, field: any, original: any, details: any);
+    constructor(message: any, field: any, details: any);
     field: any;
-    original: any;
-    details: any;
+    toJSON(): {
+        field: any;
+        details: any[];
+        message: string;
+        type: string;
+    };
 }
 export class ElementError extends ValidationError {
-    constructor(message: any, index: any, original: any, details: any);
+    constructor(message: any, index: any, details: any);
     index: any;
-    original: any;
-    details: any;
-}
-export class AssertionError extends Error {
-    constructor(message: any, type: any, original: any);
-    type: any;
-    original: any;
     toJSON(): {
-        type: any;
+        index: any;
+        details: any[];
         message: string;
+        type: string;
     };
 }
-export class ArrayError extends Error {
+export class ArrayError extends ValidationError {
     constructor(message: any, details: any);
     details: any;
 }

package/types/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAqHA,iDAMC;AAxHD;IACE,uCAGC;IADC,YAAoB;IAGtB,gBAEC;CACF;AAED;IACE,0DAIC;IAFC,eAAsB;IACtB,aAAgB;IAGlB,cAgBC;IAED,qBAUC;IAED,uBAEC;IAED,kCAKC;CACF;AAED;IACE,mEAKC;IAHC,WAAkB;IAClB,cAAwB;IACxB,aAAsB;CASzB;AAED;IACE,mEAKC;IAHC,WAAkB;IAClB,cAAwB;IACxB,aAAsB;CASzB;AAED;IACE,oDAIC;IAFC,UAAgB;IAChB,cAAwB;IAG1B;;;MAKC;CACF;AAED;IACE,wCAGC;IADC,aAAsB;CAEzB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAkHA,iDAEC;AAjHD;IACE,uCAEC;CACF;AAED;IACE,uCAIC;IAFC,aAAwB;IACxB,eAAsB;IAGxB;;;;MAaC;IAED,kCAKC;CACF;AAED;IACE,yCAGC;CACF;AAED;IACE,qCAIC;IADC,UAAgB;IAGlB;;;;;MAKC;CACF;AAED;IACE,uCAIC;IADC,YAAoB;IAGtB;;;;;MAKC;CACF;AAED;IACE,oDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IACE,oDAIC;IADC,WAAkB;IAGpB;;;;;MAKC;CACF;AAED;IACE,wCAIC;IADC,aAAsB;CAEzB"}

package/types/localization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localization.d.ts","sourceRoot":"","sources":["../src/localization.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH;;WAL8C,MAAM,KAAK,MAAM,SAS9D;AAED,gDAIC;AAED,yDAgBC;AAED;;;GAGG;AACH;;EAEC"}
+{"version":3,"file":"localization.d.ts","sourceRoot":"","sources":["../src/localization.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH;;WAL8C,MAAM,KAAK,MAAM,SAS9D;AAED,gDAIC;AAED,yDAmBC;AAED;;;GAGG;AACH;;EAEC"}

package/types/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.js"],"names":[],"mappings":"AAGA,8DAkBC"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.js"],"names":[],"mappings":"AAEA,8DAcC"}

package/types/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAyMA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAMnB;;;;AA3MD;;GAEG;AAEH;IAUE;;OAEG;IACH,cAmEC;IAED;;OAEG;IACH,kBAEC;IAED;;OAEG;IAEH,YAHW,SAAS,GAAC,MAAM,gBAkC1B;IAED;;OAEG;IACH,gBAFc,MAAM,kBAWnB;IAED;;OAEG;IACH,gBAFc,MAAM,kBAWnB;CAcF"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAiMA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAMnB;;;;AAnMD;;GAEG;AAEH;IAME;;OAEG;IACH,cA+DC;IAED;;OAEG;IACH,kBAEC;IAED;;OAEG;IAEH,YAHW,SAAS,GAAC,MAAM,gBAkC1B;IAED;;OAEG;IACH,gBAFc,MAAM,kBAWnB;IAED;;OAEG;IACH,gBAFc,MAAM,kBAWnB;CAcF"}

package/types/tuple.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../src/tuple.js"],"names":[],"mappings":"AA2FA;;;;;;GAMG;AACH,8CAJc,MAAM,iBASnB;;AApGD;IACE,0BAGC;IAED;;OAEG;IACH,cAyDC;IAED,qBAEC;CAgBF"}
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../src/tuple.js"],"names":[],"mappings":"AAsFA;;;;;;GAMG;AACH,8CAJc,MAAM,iBASnB;;AA/FD;IACE,0BAGC;IAED;;OAEG;IACH,cAoDC;IAED,qBAEC;CAgBF"}