offshore/lib/offshore/error/index.js

An ORM for Node.js

/**
 * Module dependencies
 */

var util = require('util');
var _ = require('lodash');
var WLError = require('./WLError');
var WLValidationError = require('./WLValidationError');


/**
 * A classifier which normalizes a mystery error into a simple,
 * consistent format.  This ensures that our instance which is
 * "new"-ed up belongs to one of a handful of distinct categories
 * and has a predictable method signature and properties.
 *
 * The returned error instance will always be or extend from
 * `WLError` (which extends from `Error`)
 *
 * NOTE:
 * This method should eventually be deprecated in a
 * future version of Offshore.  It exists to help
 * w/ error type negotiation.  In general, Offshore
 * should use WLError, or errors which extend from it
 * to construct error objects of the appropriate type.
 * In other words, no ** new ** errors should need to
 * be wrapped in a call to `errorify` - instead, code
 * necessary to handle any new error conditions should
 * construct a `WLError` directly and return that.
 *
 * @param  {???} err
 * @return {WLError}
 */
module.exports = function errorify(err) {

  // If specified `err` is already a WLError, just return it.
  if (typeof err === 'object' && err instanceof WLError) return err;

  return duckType(err);
};


/**
 * Determine which type of error we're working with.
 * Err... using hacks.
 *
 * @return {[type]} [description]
 */
function duckType(err) {

  // Validation or constraint violation error (`E_VALIDATION`)
  //
  // i.e. detected before talking to adapter, like `minLength`
  // i.e. constraint violation reported by adapter, like `unique`
  if (/* _isValidationError(err) || */ _isConstraintViolation(err)) {

    // Dress `unique` rule violations to be consistent with other
    // validation errors.
    return new WLValidationError(err);
  }

  // Unexpected miscellaneous error  (`E_UNKNOWN`)
  //
  // (i.e. helmet fire. The database crashed or something. Or there's an adapter
  //  bug. Or a bug in WL core.)
  return new WLError({
    originalError: err
  });
}


/**
 * @param  {?} err
 * @return {Boolean} whether this is an adapter-level constraint
 * violation (e.g. `unique`)
 */
function _isConstraintViolation(err) {

  // If a proper error code is specified, this error can be classified.
  if (err && typeof err === 'object' && err.code === 'E_UNIQUE') {
    return true;
  }

  // Otherwise, there is not enough information to call this a
  // constraint violation error and provide proper explanation to
  // the architect.
  else return false;
}


// /**
//  * @param  {?} err
//  * @return {Boolean} whether this is a validation error (e.g. minLength exceeded for attribute)
//  */
// function _isValidationError(err) {
//   return _.isObject(err) && err.ValidationError;
// }