@ellipticltd/aml-utils 0.1.1-ts.4 → 0.1.1

package/.npmignore

@@ -0,0 +1,4 @@
+**/*.coffee
+test/
+.history
+.vscode

package/index.d.ts

@@ -0,0 +1 @@
+declare module '@ellipticltd/aml-utils';

package/index.js

@@ -0,0 +1,8 @@
+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/{dist → lib}/errors.js

@@ -1,43 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const create = require('create-error');
+
 const AppError = create('AppError');
+
 const RequestError = create(AppError, 'RequestError');
-RequestError.toJSON = function () {
-    return { message: this.message };
-};
+
+RequestError.toJSON = () => ({
+  message: this.message,
+});
+
 const Forbidden = create(RequestError, 'ForbiddenError', {
-    status: 403,
+  status: 403,
 });
+
 const Unauthorized = create(RequestError, 'UnauthorizedError', {
-    status: 401,
+  status: 401,
 });
+
 const BadRequest = create(RequestError, 'BadRequestError', {
-    status: 400,
+  status: 400,
 });
+
 const NotFound = create(RequestError, 'NotFoundError', {
-    status: 404,
+  status: 404,
 });
+
 const ConflictError = create(RequestError, 'ConflictError', {
-    status: 409,
+  status: 409,
 });
+
 const ServerError = create(RequestError, 'ServerError', {
-    status: 500,
+  status: 500,
 });
+
 const InvalidArguments = create(RequestError, 'InvalidArgumentsError', {
-    status: 500,
+  status: 500,
 });
+
 const ServerTimeout = create(RequestError, 'ServerTimeoutError', {
-    status: 503,
-});
-exports.default = {
-    RequestError,
-    Forbidden,
-    Unauthorized,
-    BadRequest,
-    NotFound,
-    ConflictError,
-    ServerError,
-    InvalidArguments,
-    ServerTimeout,
+  status: 503,
+});
+
+module.exports = {
+  RequestError,
+  ServerError,
+  Forbidden,
+  Unauthorized,
+  BadRequest,
+  NotFound,
+  ConflictError,
+  InvalidArguments,
+  ServerTimeout,
 };

package/lib/formatting.js

@@ -0,0 +1,18 @@
+const _ = 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}`;
+};
+
+const sqlEscapeWildcard = str => str.replace(/_|%|\\/g, x => `\\${x}`);
+
+module.exports = {
+  rethrowError,
+  sqlEscapeWildcard,
+};

package/lib/middleware.js

@@ -0,0 +1,25 @@
+const 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);
+  }
+};
+
+const ensureUUID = ensureType('UUID');
+
+const ensureHex32 = ensureType('Hex32');
+
+const ensureInteger = ensureType('IntString');
+
+module.exports = {
+  ensureType,
+  ensureUUID,
+  ensureHex32,
+  ensureInteger,
+};

package/lib/ormHelpers.js

@@ -0,0 +1,19 @@
+const _ = 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,
+    };
+  });
+
+module.exports = {
+  includeNested,
+};

package/lib/types.js

@@ -0,0 +1,211 @@
+const TC = require('type-check');
+
+const E = require('./errors');
+
+const V = require('./validations');
+
+const _ = 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,
+  },
+};
+
+// 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;
+
+    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;
+      }
+    });
+
+    if (!(typ.subset || numInputKeys === numKeys)) {
+      throw new E.BadRequest('invalid extra arguments are present');
+    }
+  },
+};

package/lib/validations.js

@@ -0,0 +1,236 @@
+const E = require('./errors');
+const V = require('validator');
+const _ = require('lodash');
+const {
+  crypto: { Signature },
+  HDPrivateKey,
+  HDPublicKey,
+  PublicKey,
+  Script,
+  Transaction,
+} = require('bitcore-lib');
+const addressValidator = require('wallet-address-validator');
+const web3 = require('web3-utils');
+
+const validations = {
+  _validate(Err, pred, x, msg) {
+    if (pred(x)) {
+      return x;
+    }
+    throw new Err(msg);
+  },
+  _validateArg(pred, x, msg) {
+    return this._validate(E.InvalidArguments, pred, x, msg);
+  },
+  _tryCheck(fn, arg) {
+    try {
+      fn(arg);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+
+  exists(x) {
+    return x != null;
+  },
+  nonEmpty(x) {
+    return (x != null ? x.length : undefined) > 0;
+  },
+  isNonEmptyString(x) {
+    return _.isString(x) && (x != null ? x.length : undefined) > 0;
+  },
+  ensureShortEnough(limit, x) {
+    const l = x != null ? x.length : undefined;
+    if (l <= limit) {
+      return true;
+    }
+    throw new E.BadRequest(`Max query size exceeded: ${l} / ${limit}`);
+  },
+  ensure(crit, msg) {
+    if (crit) {
+      return true;
+    }
+    throw new E.BadRequest(msg);
+  },
+  argExists(x, msg) {
+    return this._validateArg(this.exists, x, msg);
+  },
+
+  check: {
+    matches(required, given, msg) {
+      given = _.uniq(given);
+      const crit = _.intersection(given, required).length === given.length;
+      if (crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+    wasFound(type) {
+      return (item) => {
+        if (item == null) {
+          throw new E.NotFound(`Unknown ${type}`);
+        } else {
+          return item;
+        }
+      };
+    },
+    wasCreated(msg) {
+      return (arr) => {
+        if (!arr[1]) {
+          throw new E.BadRequest(msg);
+        } else {
+          return arr;
+        }
+      };
+    },
+    isTrue(crit, msg) {
+      if (crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+    isFalse(crit, msg) {
+      if (!crit) {
+        return true;
+      }
+      throw new E.BadRequest(msg);
+    },
+  },
+
+  isCustomerReference(x) {
+    return (
+      _.isString(x) &&
+      (x != null ? x.length : undefined) > 0 &&
+      (x != null ? x.length : undefined) <= 100
+    );
+  },
+  isCustomerLabelName(x) {
+    return (
+      _.isString(x) &&
+      (x != null ? x.length : undefined) > 0 &&
+      (x != null ? x.length : undefined) <= 50
+    );
+  },
+  ethereum: {
+    isAddress(str) {
+      return web3.isAddress(str);
+    },
+    isBlockHash(str) {
+      return str.length === 66 && web3.isHexStrict(str);
+    },
+    isTxHash(str) {
+      return str.length === 66 && web3.isHexStrict(str);
+    },
+    isAddressCode(str) {
+      return web3.isHexStrict(str);
+    },
+    isValidWeiAmount(str) {
+      try {
+        web3.fromWei(str);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+  },
+  bitcoin: {
+    isAddress(str) {
+      const network =
+        process.env.BITCOIN_NETWORK === 'testnet' ? 'testnet' : 'livenet';
+      return typeof str === 'string' && addressValidator.validate(str.trim(), 'BTC', network);
+    },
+    isHDPublicKey(str) {
+      try {
+        HDPublicKey(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isPublicKey(str) {
+      try {
+        PublicKey(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+    isTxHex(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      try {
+        Transaction(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isHDPath(str) {
+      return HDPrivateKey.isValidPath(str);
+    },
+    isScriptHex(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      try {
+        Script(str);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isTxSignature(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      try {
+        const b = Buffer.from(str, 'hex');
+        Signature.fromTxFormat(b);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    isBlockHeight(obj) {
+      return _.isInteger(+obj) && parseInt(obj, 10) >= 0;
+    },
+  },
+  bitcoinCash: {
+    isAddress(str) {
+      return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}|^(bitcoincash:)?[q|p][a-z0-9]{41}|^(BITCOINCASH:)?[Q|P][A-Z0-9]{41}/.test(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  },
+  litecoin: {
+    isAddress(str) {
+      return /^[3LM][a-km-zA-HJ-NP-Z1-9]{24,33}|^ltc1[ac-hj-np-z02-9]{6,86}|^LTC1[AC-HJ-NP-Z02-9]{6,86}/.test(str);
+    },
+    isTxHash(str) {
+      if (!V.isHexadecimal(`${str}`)) {
+        return false;
+      }
+      return str.length === 64;
+    },
+  }
+};
+
+Object.keys(V).forEach((k) => {
+  const v = V[k];
+  // don't trigger validation with null values (prevents swagger 500 error)
+  validations[k] = x => (x === null ? false : v(x));
+});
+
+module.exports = validations;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ellipticltd/aml-utils",
-  "version": "0.1.1-ts.4",
+  "version": "0.1.1",
   "description": "Utilities, helpers, validations, type-checking, etc",
   "engines": {
     "node": "10.1.0",
@@ -11,13 +11,10 @@
     "url": "git+ssh://git@bitbucket.org/elliptic/aml-utils.git"
   },
   "homepage": "https://bitbucket.org/elliptic/aml-utils#readme",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "index.js",
   "scripts": {
-    "prepublish": "npm run build",
-    "test": "npm run build && mocha --reporter spec --compilers coffee:coffee-script/register --require 'test/index.coffee'",
-    "lint": "tslint --project tsconfig.json -c tslint.json lib/**/*.ts",
-    "build": "tsc",
+    "test": "./node_modules/.bin/mocha --reporter spec --compilers coffee:coffee-script/register --require 'test/index.coffee'",
+    "compile": "./node_modules/coffee-script/bin/coffee -c index.coffee **/*.coffee",
     "preprocess": "npm run compile"
   },
   "author": "Adam Joyce <adam@ellipitc.co>",
@@ -33,18 +30,11 @@
   },
   "devDependencies": {
     "@ellipticltd/eslint-config": "0.0.3",
-    "@types/express": "^4.17.0",
-    "@types/lodash": "^4.14.135",
-    "@types/node": "^12.0.10",
-    "@types/validator": "^10.11.1",
     "chai": "4.1.1",
     "coffee-script": "1.12.7",
     "eslint": "5.9.0",
     "eslint-config-airbnb-base": "13.1.0",
     "eslint-plugin-import": "^2.18.0",
-    "mocha": "3.5.0",
-    "tslint": "^5.18.0",
-    "tslint-config-airbnb": "^5.11.1",
-    "typescript": "^3.5.2"
+    "mocha": "3.5.0"
   }
 }

package/.idea/aml-utils.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>