Align validation errors API and extend Error class

Author: kronicker

lib/errors/validation/attribute-error.js

@@ -2,16 +2,12 @@
 
 const ValidationError = require('./validation-error');
 
-class AttributeError extends ValidationError {
+class AttributeValidationError extends ValidationError {
   constructor(originalError) {
-    super(originalError.instance);
-    this.name = 'AttributeError';
-    this.original = originalError;
-  }
-
-  get message() {
-    return `${this.name}: ${this.original.message}; ${this.instanceInfo}`;
+    const { instance, message } = originalError;
+    super(instance, message);
+    this.originalError = originalError;
   }
 }
 
-module.exports = AttributeError;
+module.exports = AttributeValidationError;

lib/errors/validation/consumable-error.js

@@ -2,16 +2,15 @@
 
 const ValidationError = require('./validation-error');
 
-class ConsumableError extends ValidationError {
+class ConsumableValidationError extends ValidationError {
   constructor(instance, association) {
-    super(...arguments);
-    this.name = 'ConsumableError';
+    super(instance, getMessage(association));
     this.association = association;
   }
-
-  get message() {
-    return `${this.name}: Invalid consumable association: ${this.association.associationAccessor}; ${this.instanceInfo}`;
-  }
 }
 
-module.exports = ConsumableError;
+module.exports = ConsumableValidationError;
+
+function getMessage(association) {
+  return `Invalid consumable association: ${association.associationAccessor}`;
+}

lib/errors/validation/domain-error.js

@@ -2,16 +2,11 @@
 
 const ValidationError = require('./validation-error');
 
-class DomainError extends ValidationError {
-  constructor(instance, originalMessage) {
-    super(...arguments);
-    this.name = 'DomainError';
-    this.originalMessage = originalMessage;
-  }
-
-  get message() {
-    return `${this.name}: ${this.originalMessage}; ${this.instanceInfo}`;
+class DomainValidationError extends ValidationError {
+  constructor(instance, message) {
+    super(instance, message);
+    this.originalMessage = message;
   }
 }
 
-module.exports = DomainError;
+module.exports = DomainValidationError;

lib/errors/validation/fk-error.js

@@ -2,21 +2,19 @@
 
 const ValidationError = require('./validation-error');
 
-class ValidationFkError extends ValidationError {
+class ForeignKeyValidationError extends ValidationError {
   constructor(instance, association) {
-    super(...arguments);
-    this.name = 'ValidationFkError';
-    this.alias = association.associationAccessor;
-    this.fk = association.identifier;
+    const alias = association.associationAccessor;
+    const fk = association.identifier;
+    const value = instance[fk];
+    const message = getMessage(alias, fk, value);
+    super(instance, message);
+    Object.assign(this, { alias, fk, value });
   }
+}
 
-  get message() {
-    return `${this.name}: No ${this.alias} found for ${this.fk}: ${this.value}; ${this.instanceInfo}`;
-  }
+module.exports = ForeignKeyValidationError;
 
-  get value() {
-    return this.instance[this.fk];
-  }
+function getMessage(alias, fk, value) {
+  return `No ${alias} found for ${fk}: ${value}`;
 }
-
-module.exports = ValidationFkError;

lib/errors/validation/uniqueness-error.js

@@ -5,24 +5,24 @@ const map = require('lodash/map');
 const transform = require('lodash/transform');
 const ValidationError = require('./validation-error');
 
-class ValidationUniquenessError extends ValidationError {
-  constructor(instance, index) {
-    super(...arguments);
-    this.name = 'ValidationUniquenessError';
-    this.index = index;
-    this.values = parseValues(instance, index);
-  }
-
-  get message() {
-    return `${this.name}: duplicate value for ${this.index.join()}: ${map(this.values).join()}; ${this.instanceInfo}`;
+class UniquenessValidationError extends ValidationError {
+  constructor(instance, index = []) {
+    const values = parseValues(instance, index);
+    const message = getMessage(index, values);
+    super(instance, message);
+    Object.assign(this, { values, index });
   }
 }
 
-module.exports = ValidationUniquenessError;
+module.exports = UniquenessValidationError;
 
 function parseValues(instance, index) {
   return transform(index, (acc, it) => {
     const attribute = find(instance.rawAttributes, { field: it }).fieldName;
     acc[it] = instance[attribute];
   }, {});
 }
+
+function getMessage(index, values) {
+  return `Duplicate value for ${index.join()}: ${map(values).join()}`;
+}

lib/errors/validation/validation-error.js

@@ -1,22 +1,17 @@
 'use strict';
 
-class ValidationError {
-  constructor(instance) {
-    this.name = 'ValidationError';
-    this.instance = instance;
-  }
-
-  get id() {
-    return this.instance.id;
-  }
-
-  get modelName() {
-    return this.instance.constructor.name;
-  }
-
-  get instanceInfo() {
-    return `${this.modelName} id: ${this.id}`;
+class ValidationError extends Error {
+  constructor(instance, message = '') {
+    const modelName = instance.constructor.name;
+    const id = instance.id;
+    super(getMessage(message, modelName, id));
+    Object.assign(this, { instance, id, modelName });
   }
 }
 
 module.exports = ValidationError;
+
+function getMessage(message, modelName, id) {
+  const instanceInfo = `${modelName} id: ${id}`;
+  return [message, instanceInfo].filter(Boolean).join('; ');
+}