@ellipticltd/aml-utils 0.7.0 → 0.8.0-EN-2570.1

package/dist/file-parser/sanitzeRows.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sensicalRowCheck = (cells) => (cells.some((cell) => !!cell));
+function sanitizeRows(parsedRows, processRow) {
+    const firstSensicalRowIndex = parsedRows
+        .findIndex(sensicalRowCheck);
+    const lastSensicalRowIndex = [...parsedRows]
+        .reverse()
+        .findIndex(sensicalRowCheck);
+    const sanitizedRows = parsedRows
+        .splice(firstSensicalRowIndex, parsedRows.length - firstSensicalRowIndex - lastSensicalRowIndex);
+    const firstRow = processRow(sanitizedRows[0]);
+    if (firstRow.isValid) {
+        return sanitizedRows;
+    }
+    return sanitizedRows.splice(1);
+}
+exports.default = sanitizeRows;

package/dist/formatting/formatting.d.ts

@@ -0,0 +1,2 @@
+export function rethrowError(fnName: any, e: any): string;
+export function sqlEscapeWildcard(str: any): any;

package/dist/formatting/formatting.js

@@ -0,0 +1,17 @@
+"use strict";
+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/dist/formatting/formatting.spec.d.ts

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

package/dist/formatting/formatting.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+const chai = require('chai');
+const { sqlEscapeWildcard, rethrowError } = require('./formatting');
+const { expect } = chai;
+describe('formatting.sqlEscapeWildcard', () => {
+    describe('when passed an empty string', () => {
+        it('returns an empty string', () => sqlEscapeWildcard('').should.equal(''));
+    });
+    describe('when passed a string with no sql wildcards', () => {
+        it('returns the same string', () => {
+            const str = 'foo bar';
+            return sqlEscapeWildcard(str).should.equal(str);
+        });
+    });
+    return describe('when passed a string with sql wildcards', () => {
+        it('returns the string with \\ % _ escaped', () => {
+            const str = 'foo\\dfs_erwr%rewr';
+            return sqlEscapeWildcard(str).should.equal('foo\\\\dfs\\_erwr\\%rewr');
+        });
+    });
+});
+describe('rethrowError', () => {
+    it('returns an error when given a string', () => rethrowError('myFunc', { error: 'Oh dear, myFunc is broken' })
+        .should.equal('myFunc - undefined: undefined - Oh dear, myFunc is broken'));
+    it('returns an error when passed an error object', () => rethrowError('myFunc', {
+        name: "I'm a teapot",
+        statusCode: 418,
+        error: "I'm a little teapot, short and stout",
+    }).should.equal("myFunc - I'm a teapot: 418 - I'm a little teapot, short and stout"));
+    it('accepts an array containing an error', () => {
+        const thrownError = rethrowError('myFunc', {
+            error: ["I'm a teapot", 418, "I'm a little teapot, short and stout"],
+        });
+        const expected = JSON.stringify('myFunc - undefined: undefined - \n[\n  "I\'m a teapot",\n  418,\n  "I\'m a little teapot, short and stout"\n]');
+        expect(JSON.stringify(thrownError)).to.equal(expected);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import types from './types/types';
+import validations from './validations/validations';
+import errors from './errors/errors';
+import formatting from './formatting/formatting';
+import middleware from './middleware/middleware';
+import ormHelpers from './orm-helpers/ormHelpers';
+import fileParser from './file-parser/file-parser';
+export { types, validations, errors, formatting, fileParser, middleware, ormHelpers, };

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ormHelpers = exports.middleware = exports.fileParser = exports.formatting = exports.errors = exports.validations = exports.types = void 0;
+const types_1 = __importDefault(require("./types/types"));
+exports.types = types_1.default;
+const validations_1 = __importDefault(require("./validations/validations"));
+exports.validations = validations_1.default;
+const errors_1 = __importDefault(require("./errors/errors"));
+exports.errors = errors_1.default;
+const formatting_1 = __importDefault(require("./formatting/formatting"));
+exports.formatting = formatting_1.default;
+const middleware_1 = __importDefault(require("./middleware/middleware"));
+exports.middleware = middleware_1.default;
+const ormHelpers_1 = __importDefault(require("./orm-helpers/ormHelpers"));
+exports.ormHelpers = ormHelpers_1.default;
+const file_parser_1 = __importDefault(require("./file-parser/file-parser"));
+exports.fileParser = file_parser_1.default;

package/dist/middleware/middleware.d.ts

@@ -0,0 +1,4 @@
+export function ensureType(type: any): (req: any, res: any, next: any, id: any, name: any) => any;
+export function ensureUUID(req: any, res: any, next: any, id: any, name: any): any;
+export function ensureHex32(req: any, res: any, next: any, id: any, name: any): any;
+export function ensureInteger(req: any, res: any, next: any, id: any, name: any): any;

package/dist/middleware/middleware.js

@@ -0,0 +1,22 @@
+"use strict";
+const T = require('../types/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/orm-helpers/ormHelpers.d.ts

@@ -0,0 +1 @@
+export function includeNested(orm: any, models: any): any;

package/dist/orm-helpers/ormHelpers.js

@@ -0,0 +1,17 @@
+"use strict";
+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/dist/orm-helpers/ormHelpers.spec.d.ts

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

package/dist/orm-helpers/ormHelpers.spec.js

@@ -0,0 +1,38 @@
+"use strict";
+const { includeNested } = require('./ormHelpers');
+describe('ormIncludeNested', () => {
+    const orm = {
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd',
+    };
+    describe('when passed an empty object', () => {
+        it('returns an empty array', () => includeNested(orm, {}).should.deep.equal([]));
+    });
+    describe('when passed an object with no inclusions', () => {
+        it('returns an array of just the key', () => includeNested(orm, {
+            a: {},
+        }).should.deep.equal(['a']));
+    });
+    describe('when passed a hierarchy of inclusions', () => {
+        it('should nest them in sequelize style', () => includeNested(orm, {
+            a: {
+                b: {
+                    c: {},
+                    d: {},
+                },
+            },
+        }).should.deep.equal([
+            {
+                model: 'a',
+                include: [
+                    {
+                        model: 'b',
+                        include: ['c', 'd'],
+                    },
+                ],
+            },
+        ]));
+    });
+});

package/dist/types/types.d.ts

@@ -0,0 +1,17 @@
+declare const withNullable: {};
+export function parseType(str: any): any;
+export function parseType(str: any): any;
+export function parsedTypeCheck(type: any, obj: any): any;
+export function parsedTypeCheck(type: any, obj: any): any;
+export function typeCheck(type: any, obj: any): any;
+export function typeCheck(type: any, obj: any): any;
+export namespace opts {
+    export { withNullable as customTypes };
+}
+export function ensureType(type: any, obj: any, msg: any): boolean;
+export function ensureType(type: any, obj: any, msg: any): boolean;
+export function checkArg(obj: any, prop: any, type: any, msg: any): any;
+export function checkArg(obj: any, prop: any, type: any, msg: any): any;
+export function checkArgs(input: any, types: any): void;
+export function checkArgs(input: any, types: any): void;
+export {};

package/dist/types/types.js

@@ -0,0 +1,203 @@
+"use strict";
+const TC = require('type-check');
+const _ = require('lodash');
+const E = require('../errors/errors');
+const V = require('../validations/validations');
+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) {
+        let message;
+        if (msg == null) {
+            message = `Invalid ${prop}`;
+        }
+        else {
+            message = msg;
+        }
+        this.ensureType(type, obj[prop], message);
+        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) => {
+            const objTypes = fields[key];
+            V.ensure(this.parsedTypeCheck(objTypes, 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/validations.d.ts

@@ -0,0 +1,116 @@
+export function _validate(Err: any, pred: any, x: any, msg: any): any;
+export function _validate(Err: any, pred: any, x: any, msg: any): any;
+export function _validateArg(pred: any, x: any, msg: any): any;
+export function _validateArg(pred: any, x: any, msg: any): any;
+export function _tryCheck(fn: any, arg: any): boolean;
+export function _tryCheck(fn: any, arg: any): boolean;
+export function exists(x: any): boolean;
+export function exists(x: any): boolean;
+export function nonEmpty(x: any): boolean;
+export function nonEmpty(x: any): boolean;
+export function isNonEmptyString(x: any): boolean;
+export function isNonEmptyString(x: any): boolean;
+export function ensureShortEnough(limit: any, x: any): boolean;
+export function ensureShortEnough(limit: any, x: any): boolean;
+export function ensure(crit: any, msg: any): boolean;
+export function ensure(crit: any, msg: any): boolean;
+export function argExists(x: any, msg: any): any;
+export function argExists(x: any, msg: any): any;
+export namespace check {
+    function matches(required: any, given: any, msg: any): boolean;
+    function matches(required: any, given: any, msg: any): boolean;
+    function wasFound(type: any): (item: any) => any;
+    function wasFound(type: any): (item: any) => any;
+    function wasCreated(msg: any): (arr: any) => any;
+    function wasCreated(msg: any): (arr: any) => any;
+    function isTrue(crit: any, msg: any): boolean;
+    function isTrue(crit: any, msg: any): boolean;
+    function isFalse(crit: any, msg: any): boolean;
+    function isFalse(crit: any, msg: any): boolean;
+}
+export function isCustomerReference(x: any): boolean;
+export function isCustomerReference(x: any): boolean;
+export function isCustomerLabelName(x: any): boolean;
+export function isCustomerLabelName(x: any): boolean;
+export namespace binanceCoin {
+    function isAddress(str: any): boolean;
+    function isAddress(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace bitcoin {
+    function isAddress(str: any): any;
+    function isAddress(str: any): any;
+    function isBech32Address(str: any): boolean;
+    function isBech32Address(str: any): boolean;
+    function isHDPublicKey(str: any): boolean;
+    function isHDPublicKey(str: any): boolean;
+    function isPublicKey(str: any): boolean;
+    function isPublicKey(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHex(str: any): boolean;
+    function isTxHex(str: any): boolean;
+    function isHDPath(str: any): any;
+    function isHDPath(str: any): any;
+    function isScriptHex(str: any): boolean;
+    function isScriptHex(str: any): boolean;
+    function isTxSignature(str: any): boolean;
+    function isTxSignature(str: any): boolean;
+    function isBlockHeight(obj: any): boolean;
+    function isBlockHeight(obj: any): boolean;
+}
+export namespace bitcoinCash {
+    function isAddress(str: any): boolean;
+    function isAddress(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace ethereum {
+    function isAddress(str: any): any;
+    function isAddress(str: any): any;
+    function isBlockHash(str: any): any;
+    function isBlockHash(str: any): any;
+    function isTxHash(str: any): any;
+    function isTxHash(str: any): any;
+    function isAddressCode(str: any): any;
+    function isAddressCode(str: any): any;
+    function isValidWeiAmount(str: any): boolean;
+    function isValidWeiAmount(str: any): boolean;
+}
+export namespace horizen {
+    function isAddress(str: any): any;
+    function isAddress(str: any): any;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace litecoin {
+    function isAddress(str: any): boolean;
+    function isAddress(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace ripple {
+    function isAddress(str: any): any;
+    function isAddress(str: any): any;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace stellar {
+    function isAddress(str: any): boolean;
+    function isAddress(str: any): boolean;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace zcash {
+    function isAddress(str: any): any;
+    function isAddress(str: any): any;
+    function isTxHash(str: any): boolean;
+    function isTxHash(str: any): boolean;
+}
+export namespace zilliqa {
+    function isAddress(str: any): boolean;
+    function isAddress(str: any): boolean;
+    function isTxHash(str: any): any;
+    function isTxHash(str: any): any;
+}