@ellipticltd/aml-utils 0.0.3 → 0.0.9

package/.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": ["@ellipticltd"]
+}

package/.nvmrc

@@ -0,0 +1 @@
+10.1.0

package/README.md

@@ -0,0 +1,8 @@
+# Elliptic aml-utils
+
+This is a library that contains a set of utilities used by aml-api. In particular:
+
+- Custom errors used when returning a response from aml-api, e.g. BadRequest, Forbidden etc.
+- Formatting functions (sql escaping)
+- Validator functions, also used by swagger node middleware. E.g. Bitcoin and Ethereum addresses validators
+- Express middlewares to validate params types

package/index.js

@@ -1,12 +1,8 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  module.exports = {
-    types: require('./lib/types'),
-    validations: require('./lib/validations'),
-    errors: require('./lib/errors'),
-    formatting: require('./lib/formatting'),
-    middleware: require('./lib/middleware'),
-    ormHelpers: require('./lib/ormHelpers')
-  };
-
-}).call(this);
+module.exports = {
+  types: require('./lib/types'),
+  validations: require('./lib/validations'),
+  errors: require('./lib/errors'),
+  formatting: require('./lib/formatting'),
+  middleware: require('./lib/middleware'),
+  ormHelpers: require('./lib/ormHelpers'),
+};

package/lib/errors.js

@@ -1,51 +1,53 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  var AppError, BadRequest, Forbidden, InvalidArguments, NotFound, RequestError, ServerError, Unauthorized, create;
-
-  create = require('create-error');
-
-  AppError = create('AppError');
-
-  RequestError = create(AppError, 'RequestError');
-
-  RequestError.toJSON = function() {
-    return {
-      message: this.message
-    };
-  };
-
-  Forbidden = create(RequestError, 'ForbiddenError', {
-    status: 403
-  });
-
-  Unauthorized = create(RequestError, 'UnauthorizedError', {
-    status: 401
-  });
-
-  BadRequest = create(RequestError, 'BadRequestError', {
-    status: 400
-  });
-
-  NotFound = create(RequestError, 'NotFoundError', {
-    status: 404
-  });
-
-  ServerError = create(RequestError, 'ServerError', {
-    status: 500
-  });
-
-  InvalidArguments = create(RequestError, 'InvalidArgumentsError', {
-    status: 500
-  });
-
-  module.exports = {
-    RequestError: RequestError,
-    ServerError: ServerError,
-    Forbidden: Forbidden,
-    Unauthorized: Unauthorized,
-    BadRequest: BadRequest,
-    NotFound: NotFound,
-    InvalidArguments: InvalidArguments
-  };
-
-}).call(this);
+const create = require('create-error');
+
+const AppError = create('AppError');
+
+const RequestError = create(AppError, 'RequestError');
+
+RequestError.toJSON = () => ({
+  message: this.message,
+});
+
+const Forbidden = create(RequestError, 'ForbiddenError', {
+  status: 403,
+});
+
+const Unauthorized = create(RequestError, 'UnauthorizedError', {
+  status: 401,
+});
+
+const BadRequest = create(RequestError, 'BadRequestError', {
+  status: 400,
+});
+
+const NotFound = create(RequestError, 'NotFoundError', {
+  status: 404,
+});
+
+const ConflictError = create(RequestError, 'ConflictError', {
+  status: 409,
+});
+
+const ServerError = create(RequestError, 'ServerError', {
+  status: 500,
+});
+
+const InvalidArguments = create(RequestError, 'InvalidArgumentsError', {
+  status: 500,
+});
+
+const ServerTimeout = create(RequestError, 'ServerTimeoutError', {
+  status: 503,
+});
+
+module.exports = {
+  RequestError,
+  ServerError,
+  Forbidden,
+  Unauthorized,
+  BadRequest,
+  NotFound,
+  ConflictError,
+  InvalidArguments,
+  ServerTimeout,
+};

package/lib/formatting.js

@@ -1,28 +1,18 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  var _, rethrowError, sqlEscapeWildcard;
+const _ = require('lodash');
 
-  _ = require('lodash');
+const rethrowError = (fnName, e) => {
+  let formattedError;
+  if (_.isPlainObject(e.error) || _.isArray(e.error)) {
+    formattedError = `\n${JSON.stringify(e.error, null, 2)}`;
+  } else {
+    formattedError = e.error;
+  }
+  return `${fnName} - ${e.name}: ${e.statusCode} - ${formattedError}`;
+};
 
-  rethrowError = function(fnName, e) {
-    var formattedError;
-    if (_.isPlainObject(e.error) || _.isArray(e.error)) {
-      formattedError = "\n" + (JSON.stringify(e.error, null, 2));
-    } else {
-      formattedError = e.error;
-    }
-    return fnName + " - " + e.name + ": " + e.statusCode + " - " + formattedError;
-  };
+const sqlEscapeWildcard = str => str.replace(/_|%|\\/g, x => `\\${x}`);
 
-  sqlEscapeWildcard = function(str) {
-    return str.replace(/_|%|\\/g, function(x) {
-      return "\\" + x;
-    });
-  };
-
-  module.exports = {
-    rethrowError: rethrowError,
-    sqlEscapeWildcard: sqlEscapeWildcard
-  };
-
-}).call(this);
+module.exports = {
+  rethrowError,
+  sqlEscapeWildcard,
+};

package/lib/middleware.js

@@ -1,33 +1,25 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  var T, ensureHex32, ensureInteger, ensureType, ensureUUID;
+const T = require('./types');
 
-  T = require('./types');
+const ensureType = type => (req, res, next, id, name) => {
+  let error;
+  try {
+    T.ensureType(type, id, `Invalid ${name}`);
+    return next();
+  } catch (error1) {
+    error = error1;
+    return next(error);
+  }
+};
 
-  ensureType = function(type) {
-    return function(req, res, next, id, name) {
-      var error, error1;
-      try {
-        T.ensureType(type, id, "Invalid " + name);
-        return next();
-      } catch (error1) {
-        error = error1;
-        return next(error);
-      }
-    };
-  };
+const ensureUUID = ensureType('UUID');
 
-  ensureUUID = ensureType('UUID');
+const ensureHex32 = ensureType('Hex32');
 
-  ensureHex32 = ensureType('Hex32');
+const ensureInteger = ensureType('IntString');
 
-  ensureInteger = ensureType('IntString');
-
-  module.exports = {
-    ensureType: ensureType,
-    ensureUUID: ensureUUID,
-    ensureHex32: ensureHex32,
-    ensureInteger: ensureInteger
-  };
-
-}).call(this);
+module.exports = {
+  ensureType,
+  ensureUUID,
+  ensureHex32,
+  ensureInteger,
+};

package/lib/ormHelpers.js

@@ -1,28 +1,19 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  var _, includeNested;
+const _ = require('lodash');
 
-  _ = require('lodash');
+const includeNested = (orm, models) =>
+  _.map(_.toPairs(models), (arg) => {
+    const [modelName, inclusion] = arg;
+    const include = includeNested(orm, inclusion);
+    const model = orm[modelName];
+    if (_.isEmpty(include)) {
+      return model;
+    }
+    return {
+      model,
+      include,
+    };
+  });
 
-  includeNested = function(orm, models) {
-    return _.map(_.toPairs(models), function(arg) {
-      var include, inclusion, model, modelName;
-      modelName = arg[0], inclusion = arg[1];
-      include = includeNested(orm, inclusion);
-      model = orm[modelName];
-      if (_.isEmpty(include)) {
-        return model;
-      } else {
-        return {
-          model: model,
-          include: include
-        };
-      }
-    });
-  };
-
-  module.exports = {
-    includeNested: includeNested
-  };
-
-}).call(this);
+module.exports = {
+  includeNested,
+};

package/lib/types.js

@@ -1,179 +1,211 @@
-// Generated by CoffeeScript 1.10.0
-(function() {
-  var E, TC, V, _, customTypes;
+const TC = require('type-check');
 
-  TC = require('type-check');
+const E = require('./errors');
 
-  E = require('./errors');
+const V = require('./validations');
 
-  V = require('./validations');
+const _ = require('lodash');
 
-  _ = require('lodash');
+const customTypes = {
+  Integer: {
+    typeOf: 'Number',
+    validate(x) {
+      return x % 1 === 0;
+    },
+  },
+  IntString: {
+    typeOf: 'String',
+    validate: V.isInt,
+  },
+  BoolString: {
+    typeOf: 'String',
+    validate: V.isBoolean,
+  },
+  Hex32: {
+    typeOf: 'String',
+    validate(x) {
+      return V.isHexadecimal(x) && x.length === 32;
+    },
+  },
+  Email: {
+    typeOf: 'String',
+    validate: V.isEmail,
+  },
+  UUID: {
+    typeOf: 'String',
+    validate: V.isUUID,
+  },
+  UUIDv4: {
+    typeOf: 'String',
+    validate(x) {
+      return V.isUUID(x, 4);
+    },
+  },
+  JSON: {
+    typeOf: 'String',
+    validate: V.isJSON,
+  },
+  Url: {
+    typeOf: 'String',
+    validate: V.isURL,
+  },
+  DateString: {
+    typeOf: 'String',
+    validate: V.isDate,
+  },
+  NonEmptyArray: {
+    typeOf: 'Array',
+    validate: V.nonEmpty,
+  },
+  NonNullString: {
+    typeOf: 'String',
+    validate: V.nonEmpty,
+  },
+  CustomerReference: {
+    typeOf: 'String',
+    validate: V.isCustomerReference,
+  },
+  CustomerLabelName: {
+    typeOf: 'String',
+    validate: V.isCustomerLabelName,
+  },
+  BitcoinAddress: {
+    typeOf: 'String',
+    validate: V.bitcoin.isAddress,
+  },
+  EthereumAddress: {
+    typeOf: 'String',
+    validate: V.ethereum.isAddress,
+  },
+  EthereumTx: {
+    typeOf: 'String',
+    validate: V.ethereum.isTxHash,
+  },
+  EthereumBlockHash: {
+    typeOf: 'String',
+    validate: V.ethereum.isBlockHash,
+  },
+  EthereumWeiAmount: {
+    typeOf: 'String',
+    validate: V.ethereum.isValidWeiAmount,
+  },
+  EthereumAddressCode: {
+    typeOf: 'String',
+    validate: V.ethereum.isAddressCode,
+  },
+  MineId: {
+    typeOf: 'String',
+    validate(x) {
+      return x === 'mine';
+    },
+  },
+  BitcoinTxHash: {
+    typeOf: 'String',
+    validate: V.bitcoin.isTxHash,
+  },
+  BitcoinAddressArray: {
+    typeOf: 'Array',
+    validate(as) {
+      return _.every(as, V.bitcoin.isAddress);
+    },
+  },
+  BitcoinTxHashArray: {
+    typeOf: 'Array',
+    validate(as) {
+      return _.every(as, V.bitcoin.isTxHash);
+    },
+  },
+  BitcoinTxHex: {
+    typeOf: 'String',
+    validate: V.bitcoin.isTxHex,
+  },
+  BitcoinScriptHex: {
+    typeOf: 'String',
+    validate: V.bitcoin.isScriptHex,
+  },
+  BitcoinHDPath: {
+    typeOf: 'String',
+    validate: V.bitcoin.isHDPath,
+  },
+  BitcoinPublicKey: {
+    typeOf: 'String',
+    validate: V.bitcoin.isPublicKey,
+  },
+  BitcoinXpub: {
+    typeOf: 'String',
+    validate: V.bitcoin.isHDPublicKey,
+  },
+  BitcoinTxSignature: {
+    typeOf: 'String',
+    validate: V.bitcoin.isTxSignature,
+  },
+  BitcoinBlockHeight: {
+    typeOf: 'Number',
+    validate: V.bitcoin.isBlockHeight,
+  },
+};
 
-  customTypes = {
-    Integer: {
-      typeOf: 'Number',
-      validate: function(x) {
-        return x % 1 === 0;
-      }
-    },
-    IntString: {
-      typeOf: 'String',
-      validate: V.isInt
-    },
-    BoolString: {
-      typeOf: 'String',
-      validate: V.isBoolean
-    },
-    Hex32: {
-      typeOf: 'String',
-      validate: function(x) {
-        return V.isHexadecimal(x) && (x.length === 32);
-      }
-    },
-    Email: {
-      typeOf: 'String',
-      validate: V.isEmail
-    },
-    UUID: {
-      typeOf: 'String',
-      validate: V.isUUID
-    },
-    UUIDv4: {
-      typeOf: 'String',
-      validate: function(x) {
-        return V.isUUID(x, 4);
-      }
-    },
-    JSON: {
-      typeOf: 'String',
-      validate: V.isJSON
-    },
-    Url: {
-      typeOf: 'String',
-      validate: V.isURL
-    },
-    DateString: {
-      typeOf: 'String',
-      validate: V.isDate
-    },
-    NonEmptyArray: {
-      typeOf: 'Array',
-      validate: V.nonEmpty
-    },
-    NonNullString: {
-      typeOf: 'String',
-      validate: V.nonEmpty
-    },
-    CustomerReference: {
-      typeOf: 'String',
-      validate: V.isCustomerReference
-    },
-    CustomerLabelName: {
-      typeOf: 'String',
-      validate: V.isCustomerLabelName
-    },
-    BitcoinAddress: {
-      typeOf: 'String',
-      validate: V.bitcoin.isAddress
-    },
-    MineId: {
-      typeOf: 'String',
-      validate: function(x) {
-        return x === 'mine';
-      }
-    },
-    BitcoinTxHash: {
-      typeOf: 'String',
-      validate: V.bitcoin.isTxHash
-    },
-    BitcoinAddressArray: {
-      typeOf: 'Array',
-      validate: function(as) {
-        return _.every(as, V.bitcoin.isAddress);
-      }
-    },
-    BitcoinTxHashArray: {
-      typeOf: 'Array',
-      validate: function(as) {
-        return _.every(as, V.bitcoin.isTxHash);
-      }
-    },
-    BitcoinTxHex: {
-      typeOf: 'String',
-      validate: V.bitcoin.isTxHex
-    },
-    BitcoinScriptHex: {
-      typeOf: 'String',
-      validate: V.bitcoin.isScriptHex
-    },
-    BitcoinHDPath: {
-      typeOf: 'String',
-      validate: V.bitcoin.isHDPath
-    },
-    BitcoinPublicKey: {
-      typeOf: 'String',
-      validate: V.bitcoin.isPublicKey
-    },
-    BitcoinXpub: {
-      typeOf: 'String',
-      validate: V.bitcoin.isHDPublicKey
-    },
-    BitcoinTxSignature: {
-      typeOf: 'String',
-      validate: V.bitcoin.isTxSignature
-    },
-    BitcoinBlockHeight: {
-      typeOf: 'Number',
-      validate: V.bitcoin.isBlockHeight
+// add support for nullable properties
+const withNullable = Object.keys(customTypes).reduce((acc, _type) => {
+  acc[_type] = customTypes[_type];
+  const { typeOf, validate } = customTypes[_type];
+
+  // for every type, add Nullable+type. A nullable string can also be empty
+  acc[`Nullable${_type}`] = Object.assign({}, customTypes[_type], {
+    validate: x =>
+      x == null || (typeOf === 'String' && x === '') || validate(x),
+  });
+
+  return acc;
+}, {});
+
+module.exports = {
+  parseType(str) {
+    return TC.parseType(str);
+  },
+  parsedTypeCheck(type, obj) {
+    return TC.parsedTypeCheck(type, obj, this.opts);
+  },
+  typeCheck(type, obj) {
+    return TC.typeCheck(type, obj, this.opts);
+  },
+  opts: {
+    customTypes: withNullable,
+  },
+  ensureType(type, obj, msg) {
+    return V.ensure(this.typeCheck(type, obj), msg);
+  },
+  checkArg(obj, prop, type, msg) {
+    if (msg == null) {
+      msg = `Invalid ${prop}`;
     }
-  };
+    this.ensureType(type, obj[prop], msg);
+    return obj[prop];
+  },
+  checkArgs(input, types) {
+    const inputKeys = {};
+    const [typ] = types;
+    const fields = typ.of;
+    let numInputKeys = 0;
+    let numKeys;
 
-  module.exports = {
-    parseType: function(str) {
-      return TC.parseType(str);
-    },
-    parsedTypeCheck: function(type, obj) {
-      return TC.parsedTypeCheck(type, obj, this.opts);
-    },
-    typeCheck: function(type, obj) {
-      return TC.typeCheck(type, obj, this.opts);
-    },
-    opts: {
-      customTypes: customTypes
-    },
-    ensureType: function(type, obj, msg) {
-      return V.ensure(this.typeCheck(type, obj), msg);
-    },
-    checkArg: function(obj, prop, type, msg) {
-      if (msg == null) {
-        msg = "Invalid " + prop;
-      }
-      this.ensureType(type, obj[prop], msg);
-      return obj[prop];
-    },
-    checkArgs: function(input, types) {
-      var fields, inputKeys, k, key, numInputKeys, numKeys, typ;
-      typ = types[0];
-      numInputKeys = 0;
-      inputKeys = {};
-      for (k in input) {
-        inputKeys[k] = true;
-        numInputKeys++;
-      }
-      fields = typ.of;
-      numKeys = 0;
-      for (key in fields) {
-        types = fields[key];
-        V.ensure(this.parsedTypeCheck(types, input[key]), "Invalid " + key);
-        if (inputKeys[key]) {
-          numKeys++;
-        }
-      }
-      if (!(typ.subset || numInputKeys === numKeys)) {
-        throw new E.BadRequest('invalid extra arguments are present');
+    Object.keys(input).forEach((k) => {
+      inputKeys[k] = true;
+      numInputKeys += 1;
+    });
+
+    numKeys = 0;
+
+    Object.keys(fields).forEach((key) => {
+      types = fields[key];
+      V.ensure(this.parsedTypeCheck(types, input[key]), `Invalid ${key}`);
+      if (inputKeys[key]) {
+        numKeys += 1;
       }
-    }
-  };
+    });
 
-}).call(this);
+    if (!(typ.subset || numInputKeys === numKeys)) {
+      throw new E.BadRequest('invalid extra arguments are present');
+    }
+  },
+};