@ellipticltd/aml-utils 0.16.25 → 0.16.27

package/{lib → dist}/file-parser/parse-row.js

@@ -32,9 +32,8 @@ const parseRow = (row) => {
         }
         return line;
     };
-    const splitRow = (0, fp_1.pipe)(trySplitByTab, trySplitByComa, trySplitByMultipleSpaces, trySplitBySpace, trySplitByNothing);
+    const splitRow = fp_1.pipe(trySplitByTab, trySplitByComa, trySplitByMultipleSpaces, trySplitBySpace, trySplitByNothing);
     const cells = splitRow(row);
     return cells.map((c) => c.trim());
 };
 exports.default = parseRow;
-//# sourceMappingURL=parse-row.js.map

package/{lib/file-parser/sanitizeRows.d.ts → dist/file-parser/sanitzeRows.d.ts}

@@ -1,5 +1,3 @@
-export type ProcessingEntry = {
-    isValid: boolean;
-};
+import { ProcessingEntry } from './file-parser';
 declare function sanitizeRows<T extends ProcessingEntry>(parsedRows: string[][], processRow: (row: string[]) => T): string[][];
 export default sanitizeRows;

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.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/{lib → dist}/index.d.ts

@@ -6,4 +6,4 @@ import middleware from './middleware/middleware';
 import ormHelpers from './orm-helpers/ormHelpers';
 import fileParser from './file-parser/file-parser';
 import structuredFileParser from './structured-file-parser/structured-file-parser';
-export { types, validations, errors, formatting, fileParser, structuredFileParser, middleware, ormHelpers };
+export { types, validations, errors, formatting, fileParser, structuredFileParser, middleware, ormHelpers, };

package/dist/index.js

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

@@ -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.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/{lib → dist}/structured-file-parser/errors.js

@@ -30,4 +30,3 @@ class InvalidHeadersError extends Error {
     }
 }
 exports.InvalidHeadersError = InvalidHeadersError;
-//# sourceMappingURL=errors.js.map

package/{lib → dist}/structured-file-parser/parse-row.js

@@ -32,9 +32,8 @@ const parseRow = (row) => {
         }
         return line;
     };
-    const splitRow = (0, fp_1.pipe)(trySplitByTab, trySplitByComa, trySplitByMultipleSpaces, trySplitBySpace, trySplitByNothing);
+    const splitRow = fp_1.pipe(trySplitByTab, trySplitByComa, trySplitByMultipleSpaces, trySplitBySpace, trySplitByNothing);
     const cells = splitRow(row);
     return cells.map((c) => c.trim());
 };
 exports.default = parseRow;
-//# sourceMappingURL=parse-row.js.map

package/{lib → dist}/structured-file-parser/sanitize-rows.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const sensicalRowCheck = (cells) => cells.some((cell) => !!cell);
+const sensicalRowCheck = (cells) => (cells.some((cell) => !!cell));
 function sanitizeRows(parsedRows) {
     const firstSensicalRowIndex = parsedRows.findIndex(sensicalRowCheck);
-    const lastSensicalRowIndex = [...parsedRows].reverse().findIndex(sensicalRowCheck);
+    const lastSensicalRowIndex = [...parsedRows]
+        .reverse()
+        .findIndex(sensicalRowCheck);
     if (firstSensicalRowIndex < 0) {
         return [];
     }
@@ -11,4 +13,3 @@ function sanitizeRows(parsedRows) {
     return sanitizedRows;
 }
 exports.default = sanitizeRows;
-//# sourceMappingURL=sanitize-rows.js.map

package/{lib → dist}/structured-file-parser/structured-file-parser.d.ts

@@ -1,7 +1,7 @@
-export type ProcessingEntry = {
+export declare type ProcessingEntry = {
     isValid: boolean;
 };
-type Dependencies<T extends ProcessingEntry> = {
+declare type Dependencies<T extends ProcessingEntry> = {
     processRow: (cells: string[], headers: string[]) => T;
 };
 export declare const hasHeaderRow: (rows: string[][], requiredHeaderNames: string[]) => boolean;

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

@@ -0,0 +1,98 @@
+"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/{lib → dist}/types/types.d.ts

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