@ellipticltd/aml-utils 0.16.27 → 0.16.29

package/dist/file-parser/__tests/sanitize-rows.spec.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const sinon_1 = __importDefault(require("sinon"));
-const sanitzeRows_1 = __importDefault(require("../sanitzeRows"));
-describe('sanitize-rows', () => {
-    it('should remove empty rows at the start of the array', () => {
-        const input = [
-            ['', '', ''],
-            ['this', 'is', 'valid'],
-            ['this', 'is', 'valid'],
-        ];
-        const result = sanitzeRows_1.default(input, () => ({
-            isValid: true,
-        }));
-        chai_1.expect(result).to.have.length(2);
-    });
-    it('should remove empty rows at the end of the array', () => {
-        const input = [
-            ['this', 'is', 'valid'],
-            ['this', 'is', 'valid'],
-            ['', '', ''],
-        ];
-        const result = sanitzeRows_1.default(input, () => ({
-            isValid: true,
-        }));
-        chai_1.expect(result).to.have.length(2);
-    });
-    it('should remove empty rows at the start and end of the array', () => {
-        const input = [
-            ['', '', ''],
-            ['', '', ''],
-            ['', '', ''],
-            ['this', 'is', 'valid'],
-            ['this', 'is', 'valid'],
-            ['', '', ''],
-            ['', '', ''],
-            ['', '', ''],
-        ];
-        const result = sanitzeRows_1.default(input, () => ({
-            isValid: true,
-        }));
-        chai_1.expect(result).to.have.length(2);
-    });
-    it('should remove the first row if it is not empty and not valid', () => {
-        const input = [
-            ['', '', ''],
-            ['this', 'is', 'invalid'],
-            ['this', 'is', 'valid'],
-            ['this', 'is', 'valid'],
-            ['', '', ''],
-            ['', '', ''],
-            ['', '', ''],
-        ];
-        const returnsFalseOnce = sinon_1.default.stub();
-        returnsFalseOnce.returns(true);
-        returnsFalseOnce.onFirstCall().returns(false);
-        const result = sanitzeRows_1.default(input, returnsFalseOnce);
-        chai_1.expect(result).to.have.length(2);
-    });
-    it('should allow rows with some empty values', () => {
-        const input = [
-            ['this', 'is', 'invalid'],
-            ['this', 'is', 'valid'],
-            ['this', 'is', 'valid'],
-            ['valid', '', ''],
-            ['', '', ''],
-            ['', '', ''],
-        ];
-        const result = sanitzeRows_1.default(input, () => ({
-            isValid: true,
-        }));
-        chai_1.expect(result).to.have.length(4);
-    });
-});

package/dist/file-parser/file-parser.js

@@ -1,55 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const parse_row_1 = __importDefault(require("./parse-row"));
-const errors_1 = require("./errors");
-const sanitzeRows_1 = __importDefault(require("./sanitzeRows"));
-function chunk(array, size) {
-    if (!array.length) {
-        return [];
-    }
-    const head = array.slice(0, size);
-    const tail = array.slice(size);
-    return [head, ...chunk(tail, size)];
-}
-async function processChunk(parsedRows, dependencies) {
-    const { processRow } = dependencies;
-    return new Promise((resolve, reject) => {
-        setTimeout(() => {
-            try {
-                const processedRows = parsedRows.map(processRow);
-                resolve(processedRows);
-            }
-            catch (ex) {
-                reject(ex);
-            }
-        }, 0);
-    });
-}
-async function parseFile(fileContent, maxRows, dependencies) {
-    const { processRow } = dependencies;
-    if (fileContent === 'invalidFileType') {
-        throw Error('Invalid file type');
-    }
-    const rows = fileContent.split('\n');
-    const parsedRows = rows.map(parse_row_1.default);
-    const sanitizedRows = sanitzeRows_1.default(parsedRows, processRow);
-    if (sanitizedRows.length > maxRows) {
-        throw new errors_1.TooManyRowsError();
-    }
-    if (sanitizedRows.length === 0) {
-        throw new Error('No rows');
-    }
-    const parsedRowChunks = chunk(sanitizedRows, 30);
-    let results = [];
-    // eslint-disable-next-line no-restricted-syntax
-    for (const currentRowChunk of parsedRowChunks) {
-        // eslint-disable-next-line no-await-in-loop
-        const chunkResult = await processChunk(currentRowChunk, dependencies);
-        results = results.concat(chunkResult);
-    }
-    return results;
-}
-exports.default = parseFile;

package/dist/file-parser/sanitzeRows.js

@@ -1,18 +0,0 @@
-"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.js

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

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

package/dist/formatting/formatting.spec.js

@@ -1,37 +0,0 @@
-"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.js

@@ -1,22 +0,0 @@
-"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.structuredFileParser = 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;
-const structured_file_parser_1 = __importDefault(require("./structured-file-parser/structured-file-parser"));
-exports.structuredFileParser = structured_file_parser_1.default;

package/dist/middleware/middleware.js

@@ -1,22 +0,0 @@
-"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.js

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

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

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

@@ -1,38 +0,0 @@
-"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/structured-file-parser/structured-file-parser.js

@@ -1,98 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHeaderRowValid = exports.hasHeaderRow = void 0;
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
-const parse_row_1 = __importDefault(require("./parse-row"));
-const errors_1 = require("./errors");
-const sanitize_rows_1 = __importDefault(require("./sanitize-rows"));
-function chunk(array, size) {
-    if (!array.length) {
-        return [];
-    }
-    const head = array.slice(0, size);
-    const tail = array.slice(size);
-    return [head, ...chunk(tail, size)];
-}
-async function processChunk(parsedRows, dependencies) {
-    const { processRow, headers } = dependencies;
-    // @ts-ignore
-    return new Promise((resolve, reject) => {
-        setTimeout(() => {
-            try {
-                const processedRows = parsedRows.map((row) => processRow(row, headers));
-                resolve(processedRows);
-            }
-            catch (ex) {
-                // @ts-ignore
-                reject(ex);
-            }
-        }, 0);
-    });
-}
-// a row is said to contain headers if two valid header names are present
-exports.hasHeaderRow = (rows, requiredHeaderNames) => {
-    const firstRow = rows[0];
-    if (!firstRow) {
-        return false;
-    }
-    const foundIndex = firstRow.findIndex((value) => requiredHeaderNames.includes(value.toLowerCase()));
-    if (foundIndex < 0) {
-        return false;
-    }
-    const containsSecondHeader = firstRow
-        .filter((_val, i) => i !== foundIndex)
-        .some((value) => requiredHeaderNames.includes(value.toLowerCase()));
-    return containsSecondHeader;
-};
-exports.isHeaderRowValid = (rows, requiredHeaderNames) => {
-    const firstRow = rows[0];
-    if (!firstRow) {
-        return false;
-    }
-    return (requiredHeaderNames.every((header) => firstRow.map((value) => value.toLowerCase()).includes(header)) && requiredHeaderNames.length === firstRow.length);
-};
-async function parseFile(fileContent, maxRows, requiredHeaderNames, dependencies) {
-    if (fileContent === 'invalidFileType') {
-        throw new errors_1.InvalidFileError();
-    }
-    const rows = fileContent.split('\n');
-    const parsedRows = rows.map(parse_row_1.default);
-    const sanitizedRows = sanitize_rows_1.default(parsedRows);
-    if (sanitizedRows.length > maxRows) {
-        throw new errors_1.TooManyRowsError();
-    }
-    if (sanitizedRows.length === 0) {
-        throw new errors_1.NoRowsError();
-    }
-    const containsHeaders = exports.hasHeaderRow(sanitizedRows, requiredHeaderNames);
-    if (containsHeaders
-        && !exports.isHeaderRowValid(sanitizedRows, requiredHeaderNames)) {
-        throw new errors_1.InvalidHeadersError();
-    }
-    const firstSanitizedRow = sanitizedRows[0];
-    if (!firstSanitizedRow) {
-        throw new errors_1.NoRowsError();
-    }
-    const headers = containsHeaders
-        ? firstSanitizedRow.map((value) => value.toLowerCase())
-        : requiredHeaderNames;
-    const dataRows = containsHeaders ? sanitizedRows.splice(1) : sanitizedRows;
-    if (dataRows.length === 0) {
-        throw new errors_1.NoRowsError();
-    }
-    const parsedRowChunks = chunk(dataRows, 30);
-    let results = [];
-    for (const currentRowChunk of parsedRowChunks) {
-        const chunkResult = await processChunk(currentRowChunk, {
-            ...dependencies,
-            headers,
-        });
-        results = results.concat(chunkResult);
-    }
-    return results;
-}
-exports.default = parseFile;

package/dist/types/types.js

@@ -1,203 +0,0 @@
-"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');
-        }
-    },
-};