@bedrockio/yada 1.0.40 → 1.1.1

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

@@ -9,11 +9,6 @@ var _errors = require("./errors");
 var _utils = require("./utils");
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform'];
 const REQUIRED_TYPES = ['default', 'required'];
-
-/**
- * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
- */
-
 class Schema {
   constructor(meta = {}) {
     this.assertions = [];
@@ -52,24 +47,14 @@ class Schema {
 
   /**
    * Validate by a custom function. [Link](https://github.com/bedrockio/yada#custom)
-   * @param {CustomSignature} args
+   * @param {Function} fn
    * @returns {this}
    */
-  custom(...args) {
-    let type, fn;
-    if (typeof args[0] === 'function') {
-      type = 'custom';
-      fn = args[0];
-    } else {
-      type = args[0];
-      fn = args[1];
-    }
-    if (!type) {
-      throw new Error('Assertion type required.');
-    } else if (!fn) {
+  custom(fn) {
+    if (!fn) {
       throw new Error('Assertion function required.');
     }
-    return this.clone().assert(type, async (val, options) => {
+    return this.clone().assert('custom', async (val, options) => {
       return await fn(val, options);
     });
   }
@@ -157,8 +142,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 instanceof _errors.LocalizedError) {
+          details.push(new _errors.AssertionError(error, type));
         } else {
           details.push(error);
         }
@@ -168,10 +160,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 +255,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 +270,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 +327,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 serializeError(error);
+        })
+      })
+    };
   }
   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,33 @@ 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);
+  }
+}
+function serializeError(error) {
+  if (error.toJSON) {
+    return error.toJSON();
+  } else {
+    return {
+      ...error,
+      message: error.message
+    };
+  }
 }

package/dist/cjs/index.js

@@ -115,10 +115,10 @@ function reject(...args) {
 
 /**
  * Validate by a custom function. [Link](https://github.com/bedrockio/yada#custom)
- * @param {import("./Schema").CustomSignature} args
+ * @param {Function} fn
  */
-function custom(...args) {
-  return new _Schema.default().custom(...args);
+function custom(fn) {
+  return new _Schema.default().custom(fn);
 }
 var _default = {
   array: _array.default,

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 type && 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.1",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",