@ellipticltd/aml-utils 0.0.12 → 0.1.1-ts.0

package/dist/formatting.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = __importStar(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/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = {
+    types: require('./types'),
+    validations: require('./validations'),
+    errors: require('./errors'),
+    formatting: require('./formatting'),
+    middleware: require('./middleware'),
+    ormHelpers: require('./ormHelpers'),
+};

package/dist/middleware.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/middleware.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/dist/ormHelpers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ormHelpers.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = __importStar(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/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const TC = __importStar(require("type-check"));
+const _ = __importStar(require("lodash"));
+const validations_1 = __importDefault(require("./validations"));
+const E = __importStar(require("./errors"));
+const customTypes = {
+    Integer: {
+        typeOf: 'Number',
+        validate(x) {
+            return x % 1 === 0;
+        },
+    },
+    IntString: {
+        typeOf: 'String',
+        validate: validations_1.default.isInt,
+    },
+    BoolString: {
+        typeOf: 'String',
+        validate: validations_1.default.isBoolean,
+    },
+    Hex32: {
+        typeOf: 'String',
+        validate(x) {
+            return validations_1.default.isHexadecimal(x) && x.length === 32;
+        },
+    },
+    Email: {
+        typeOf: 'String',
+        validate: validations_1.default.isEmail,
+    },
+    UUID: {
+        typeOf: 'String',
+        validate: validations_1.default.isUUID,
+    },
+    UUIDv4: {
+        typeOf: 'String',
+        validate(x) {
+            return validations_1.default.isUUID(x, 4);
+        },
+    },
+    JSON: {
+        typeOf: 'String',
+        validate: validations_1.default.isJSON,
+    },
+    Url: {
+        typeOf: 'String',
+        validate: validations_1.default.isURL,
+    },
+    NonEmptyArray: {
+        typeOf: 'Array',
+        validate: validations_1.default.nonEmpty,
+    },
+    NonNullString: {
+        typeOf: 'String',
+        validate: validations_1.default.nonEmpty,
+    },
+    CustomerReference: {
+        typeOf: 'String',
+        validate: validations_1.default.isCustomerReference,
+    },
+    CustomerLabelName: {
+        typeOf: 'String',
+        validate: validations_1.default.isCustomerLabelName,
+    },
+    BitcoinAddress: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isAddress,
+    },
+    EthereumAddress: {
+        typeOf: 'String',
+        validate: validations_1.default.ethereum.isAddress,
+    },
+    EthereumTx: {
+        typeOf: 'String',
+        validate: validations_1.default.ethereum.isTxHash,
+    },
+    EthereumBlockHash: {
+        typeOf: 'String',
+        validate: validations_1.default.ethereum.isBlockHash,
+    },
+    EthereumWeiAmount: {
+        typeOf: 'String',
+        validate: validations_1.default.ethereum.isValidWeiAmount,
+    },
+    EthereumAddressCode: {
+        typeOf: 'String',
+        validate: validations_1.default.ethereum.isAddressCode,
+    },
+    MineId: {
+        typeOf: 'String',
+        validate(x) {
+            return x === 'mine';
+        },
+    },
+    BitcoinTxHash: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isTxHash,
+    },
+    BitcoinAddressArray: {
+        typeOf: 'Array',
+        validate(as) {
+            return _.every(as, validations_1.default.bitcoin.isAddress);
+        },
+    },
+    BitcoinTxHashArray: {
+        typeOf: 'Array',
+        validate(as) {
+            return _.every(as, validations_1.default.bitcoin.isTxHash);
+        },
+    },
+    BitcoinTxHex: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isTxHex,
+    },
+    BitcoinScriptHex: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isScriptHex,
+    },
+    BitcoinHDPath: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isHDPath,
+    },
+    BitcoinPublicKey: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isPublicKey,
+    },
+    BitcoinXpub: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isHDPublicKey,
+    },
+    BitcoinTxSignature: {
+        typeOf: 'String',
+        validate: validations_1.default.bitcoin.isTxSignature,
+    },
+    BitcoinBlockHeight: {
+        typeOf: 'Number',
+        validate: validations_1.default.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 validations_1.default.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];
+            validations_1.default.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/dist/validations.d.ts

@@ -0,0 +1,49 @@
+declare type ValidatorFunction = (...args: any) => any;
+declare type Validations = {
+    _validate: (Err: new (msg: string) => Error, pred: (x: any) => boolean, x: any, msg: string) => any;
+    _validateArg: (pred: (x: any) => boolean, x: any, msg: string) => any;
+    _tryCheck: (fn: (arg: any) => any, arg: any) => boolean;
+    exists: (x: any) => boolean;
+    argExists: (x: any, msg: string) => boolean;
+    nonEmpty: ValidatorFunction;
+    isNonEmptyString: ValidatorFunction;
+    ensureShortEnough: ValidatorFunction;
+    ensure: ValidatorFunction;
+    check: {
+        matches: ValidatorFunction;
+        wasFound: ValidatorFunction;
+        wasCreated: ValidatorFunction;
+        isTrue: ValidatorFunction;
+        isFalse: ValidatorFunction;
+    };
+    isCustomerReference: ValidatorFunction;
+    isCustomerLabelName: ValidatorFunction;
+    ethereum: {
+        isAddress: ValidatorFunction;
+        isBlockHash: ValidatorFunction;
+        isTxHash: ValidatorFunction;
+        isAddressCode: ValidatorFunction;
+        isValidWeiAmount: ValidatorFunction;
+    };
+    bitcoin: {
+        isAddress: ValidatorFunction;
+        isHDPublicKey: ValidatorFunction;
+        isPublicKey: ValidatorFunction;
+        isTxHash: ValidatorFunction;
+        isTxHex: ValidatorFunction;
+        isHDPath: ValidatorFunction;
+        isScriptHex: ValidatorFunction;
+        isTxSignature: ValidatorFunction;
+        isBlockHeight: ValidatorFunction;
+    };
+    bitcoinCash: {
+        isAddress: ValidatorFunction;
+        isTxHash: ValidatorFunction;
+    };
+    litecoin: {
+        isAddress: ValidatorFunction;
+        isTxHash: ValidatorFunction;
+    };
+};
+declare const _default: Validations & IValidatorStatic;
+export default _default;

package/dist/validations.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = __importStar(require("lodash"));
+const V = __importStar(require("validator"));
+const E = __importStar(require("./errors"));
+const { crypto: { Signature }, HDPrivateKey, HDPublicKey, PublicKey, Script, Transaction, } = require('bitcore-lib');
+const addressValidator = require('wallet-address-validator');
+const web3 = require('web3-utils');
+const helpers = {};
+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;
+    },
+    argExists(x, msg) {
+        return this._validateArg(this.exists, x, msg);
+    },
+    nonEmpty(x) {
+        return (x != null ? x.length : undefined) > 0;
+    },
+    isNonEmptyString(x) {
+        return _.isString(x) && (x != null ? x.length : 0) > 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);
+    },
+    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 > 0 : false) &&
+            (x != null ? x.length <= 100 : false));
+    },
+    isCustomerLabelName(x) {
+        return (_.isString(x) &&
+            (x != null ? x.length > 0 : false) &&
+            (x != null ? x.length <= 50 : false));
+    },
+    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.assign(validations, helpers);
+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));
+});
+exports.default = validations;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ellipticltd/aml-utils",
-  "version": "0.0.12",
+  "version": "0.1.1-ts.0",
   "description": "Utilities, helpers, validations, type-checking, etc",
   "engines": {
     "node": "10.1.0",
@@ -11,10 +11,12 @@
     "url": "git+ssh://git@bitbucket.org/elliptic/aml-utils.git"
   },
   "homepage": "https://bitbucket.org/elliptic/aml-utils#readme",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
-    "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",
+    "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",
     "preprocess": "npm run compile"
   },
   "author": "Adam Joyce <adam@ellipitc.co>",
@@ -22,7 +24,7 @@
   "dependencies": {
     "bitcore-lib": "5.0.0-beta.1",
     "create-error": "0.3.1",
-    "lodash": "4.17.4",
+    "lodash": "^4.17.11",
     "type-check": "0.3.2",
     "validator": "10.10.0",
     "wallet-address-validator": "0.2.4",
@@ -30,11 +32,18 @@
   },
   "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.14.0",
-    "mocha": "3.5.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"
   }
 }