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

package/dist/index.d.ts

@@ -1,81 +0,0 @@
-import * as errors from "./errors";
-declare const amlUtils: {
-    types: {
-        parseType(str: any): any;
-        parsedTypeCheck(type: any, obj: any): any;
-        typeCheck(type: any, obj: any): any;
-        opts: {
-            customTypes: {};
-        };
-        ensureType(type: any, obj: any, msg: string): any;
-        checkArg(obj: any, prop: any, type: any, msg: string): any;
-        checkArgs(input: {
-            [K: string]: any;
-        }, types: any[]): void;
-    };
-    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: (...args: any) => any;
-        isNonEmptyString: (...args: any) => any;
-        ensureShortEnough: (...args: any) => any;
-        ensure: (...args: any) => any;
-        check: {
-            matches: (...args: any) => any;
-            wasFound: (...args: any) => any;
-            wasCreated: (...args: any) => any;
-            isTrue: (...args: any) => any;
-            isFalse: (...args: any) => any;
-        };
-        isCustomerReference: (...args: any) => any;
-        isCustomerLabelName: (...args: any) => any;
-        ethereum: {
-            isAddress: (...args: any) => any;
-            isBlockHash: (...args: any) => any;
-            isTxHash: (...args: any) => any;
-            isAddressCode: (...args: any) => any;
-            isValidWeiAmount: (...args: any) => any;
-        };
-        bitcoin: {
-            isAddress: (...args: any) => any;
-            isHDPublicKey: (...args: any) => any;
-            isPublicKey: (...args: any) => any;
-            isTxHash: (...args: any) => any;
-            isTxHex: (...args: any) => any;
-            isHDPath: (...args: any) => any;
-            isScriptHex: (...args: any) => any;
-            isTxSignature: (...args: any) => any;
-            isBlockHeight: (...args: any) => any;
-        };
-        bitcoinCash: {
-            isAddress: (...args: any) => any;
-            isTxHash: (...args: any) => any;
-        };
-        litecoin: {
-            isAddress: (...args: any) => any;
-            isTxHash: (...args: any) => any;
-        };
-    } & IValidatorStatic;
-    errors: typeof errors;
-    formatting: {
-        rethrowError: (fnName: string, e: {
-            error: Error | Error[];
-            statusCode: number;
-            name: string;
-        }) => string;
-        sqlEscapeWildcard: (str: string) => string;
-    };
-    middleware: {
-        ensureType: (type: string) => (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction, id: any, name: string) => void;
-        ensureUUID: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction, id: any, name: string) => void;
-        ensureHex32: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction, id: any, name: string) => void;
-        ensureInteger: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction, id: any, name: string) => void;
-    };
-    ormHelpers: {
-        includeNested: (orm: any, models: any) => any;
-    };
-};
-export default amlUtils;

package/dist/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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 types_1 = __importDefault(require("./types"));
-const validations_1 = __importDefault(require("./validations"));
-const errors = __importStar(require("./errors"));
-const formatting_1 = __importDefault(require("./formatting"));
-const middleware_1 = __importDefault(require("./middleware"));
-const ormHelpers_1 = __importDefault(require("./ormHelpers"));
-const amlUtils = {
-    types: types_1.default,
-    validations: validations_1.default,
-    errors,
-    formatting: formatting_1.default,
-    middleware: middleware_1.default,
-    ormHelpers: ormHelpers_1.default,
-};
-exports.default = amlUtils;

package/dist/middleware.d.ts

@@ -1,8 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-declare const _default: {
-    ensureType: (type: string) => (req: Request, res: Response, next: NextFunction, id: any, name: string) => void;
-    ensureUUID: (req: Request, res: Response, next: NextFunction, id: any, name: string) => void;
-    ensureHex32: (req: Request, res: Response, next: NextFunction, id: any, name: string) => void;
-    ensureInteger: (req: Request, res: Response, next: NextFunction, id: any, name: string) => void;
-};
-export default _default;

package/dist/middleware.js

@@ -1,23 +0,0 @@
-"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');
-exports.default = {
-    ensureType,
-    ensureUUID,
-    ensureHex32,
-    ensureInteger,
-};

package/dist/ormHelpers.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    includeNested: (orm: any, models: any) => any;
-};
-export default _default;

package/dist/ormHelpers.js

@@ -1,25 +0,0 @@
-"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,
-    };
-});
-exports.default = {
-    includeNested,
-};

package/dist/test.d.ts

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

package/dist/test.js

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

package/dist/types.d.ts

@@ -1,14 +0,0 @@
-declare const _default: {
-    parseType(str: any): any;
-    parsedTypeCheck(type: any, obj: any): any;
-    typeCheck(type: any, obj: any): any;
-    opts: {
-        customTypes: {};
-    };
-    ensureType(type: any, obj: any, msg: string): any;
-    checkArg(obj: any, prop: any, type: any, msg: string): any;
-    checkArgs(input: {
-        [K: string]: any;
-    }, types: any[]): void;
-};
-export default _default;

package/dist/types.js

@@ -1,207 +0,0 @@
-"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;
-}, {});
-exports.default = {
-    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

@@ -1,49 +0,0 @@
-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

@@ -1,239 +0,0 @@
-"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 });
-/// <reference path="../node_modules/@types/validator/index.d.ts" />
-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;