@ellipticltd/aml-utils 0.16.25 → 0.16.27

package/.circleci/config.yml

@@ -0,0 +1,87 @@
+version: 2.1
+
+executors:
+  node-18:
+    docker:
+      - image: cimg/node:18.19.0
+    working_directory: /tmp/workspace
+
+jobs:
+  install:
+    executor: node-18
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - npm-cache-{{ checksum "package-lock.json" }}
+      - run:
+          name: install node modules
+          command: |
+            npm i
+      - save_cache:
+          key: npm-cache-{{ checksum "package-lock.json" }}
+          paths:
+            - node_modules
+      - persist_to_workspace:
+          root: /tmp
+          paths:
+            - workspace
+
+  unit_test:
+    executor: node-18
+    steps:
+      - attach_workspace:
+          at: /tmp
+      - run:
+          name: unit_test
+          command: npm run coverage
+      - store_artifacts:
+          path: coverage
+
+  lint:
+    executor: node-18
+    steps:
+      - attach_workspace:
+          at: /tmp
+      - run:
+          name: lint
+          command: npm run lint
+
+  semantic_release:
+    executor: node-18
+    steps:
+      - checkout
+      - attach_workspace:
+          at: /tmp
+      - add_ssh_keys:
+          fingerprints:
+            - "14:c6:29:a4:9e:45:36:d2:0e:e9:be:41:35:d7:06:23"
+      - run:
+          command: npx semantic-release
+
+workflows:
+  version: 2.1
+  build-test-deploy:
+    jobs:
+      - install:
+          context: npm
+
+      - unit_test:
+          context: npm
+          requires:
+            - install
+
+      - lint:
+          context: npm
+          requires:
+            - install
+
+      - semantic_release:
+          context: npm
+          requires:
+            - lint
+            - unit_test
+
+
+
+# VS Code Extension Version: 1.5.1

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)"
+    ]
+  }
+}

package/.eslintrc

@@ -0,0 +1,45 @@
+{
+  "extends": ["airbnb-base"],
+  "overrides": [
+    {
+      "files": [
+        "*.ts"
+      ],
+      "parser": "@typescript-eslint/parser",
+      "parserOptions": {
+        "project": "tsconfig.json"
+      },
+      "rules": {
+        "no-unused-vars": 0
+        // annoyingly this must be switched off
+        // https://github.com/typescript-eslint/typescript-eslint/issues/46
+      }
+    },
+    {
+      "files": [
+        "*.spec.js"
+      ],
+      "env": {
+        "mocha": true
+      },
+      "rules": {
+        "no-unused-expressions": 0,
+        "chai-friendly/no-unused-expressions": 2
+      },
+      "plugins": [
+        "chai-friendly"
+      ]
+    }
+  ],
+  "rules": {
+    "no-underscore-dangle": 0,
+    "prefer-object-spread": 0,
+    "new-parens": 0,
+    "import/extensions": 0
+  },
+  "settings": {
+    "import/resolver": {
+      "typescript": {}
+    }
+  }
+}

package/.huskyrc

@@ -0,0 +1,5 @@
+{
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
+}

package/.mocharc.json

@@ -0,0 +1,3 @@
+{
+  "require": ["./test/setup.js"]
+}

package/.nvmrc

@@ -0,0 +1 @@
+18.19.0

package/.nycrc.json

@@ -0,0 +1,11 @@
+{
+  "include": [
+    "lib/**/*.js"
+  ],
+  "exclude": [
+    "lib/types.js",
+    "lib/middleware.js"
+  ],
+  "all": true,
+  "check-coverage": false
+}

package/.releaserc.json

@@ -0,0 +1,18 @@
+{
+  "branches": [
+    "master",
+    {
+      "name": "*",
+      "prerelease": true
+    }
+  ],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/npm",
+    [ "@semantic-release/git", {
+      "assets": ["package.json"],
+      "message": "chore(release): ${nextRelease.version} [skip ci]"
+    }]
+  ],
+  "repositoryUrl": "git@bitbucket.org:elliptic/aml-utils.git"
+}

package/.snyk

@@ -0,0 +1,12 @@
+# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
+version: v1.25.0
+ignore: {}
+# patches apply the minimum changes required to fix a vulnerability
+patch:
+  SNYK-JS-LODASH-567746:
+    - stellar-sdk > lodash:
+        patched: '2022-11-24T10:44:51.115Z'
+    - stellar-sdk > stellar-base > lodash:
+        patched: '2022-11-24T10:44:51.115Z'
+    - stellar-sdk > stellar-base > js-xdr > lodash:
+        patched: '2022-11-24T10:44:51.115Z'

package/README.md

@@ -1,19 +1,51 @@
-# aml-utils
+# Elliptic aml-utils
 
-This lib contains some utility functions which originally lived in aml-utils repo.
+This is a library that contains a set of utilities used by aml-api. In particular:
 
-## Running unit tests
+- Custom errors used when returning a response from aml-api, e.g. BadRequest, Forbidden etc.
+- Formatting functions (sql escaping)
+- Validator functions, also used by swagger node middleware. E.g. Bitcoin and Ethereum addresses validators
+- Express middlewares to validate params types
+- An async CSV file parser
 
-Run `npx nx test aml-utils` to execute the unit tests via [Jest](https://jestjs.io).
 
-## Running lint
+Prereqs
+-------
 
-Run `npx nx lint aml-utils` to execute the lint via [ESLint](https://eslint.org/).
+1. Correct version of node (use [nvm](https://github.com/creationix/nvm)).
 
-## Building
+Development
+-----------
 
-Run `npx nx build aml-utils` to build the package
+`nvm use` ensures you are running the correct version of node.js.
 
-##  Publishing
-Run `npx nx publish aml-utils` to build and publish the package
-You can also publish temp version of the package to npm with a tag by running `npx nx publish aml-utils -- --tag "your-tag-name"`
+`npm i` installs your dependencies.
+
+`npm run build:dev`:
+- starts webpack on watch mode, recompiling any changes made to the code
+
+To test your changes locally go to the repo you are working on's package.json and replace:
+ ```
+ @ellipticltd/aml-utils: "*.*.*"
+ ```
+with
+ ```
+@ellipticltd/aml-utils: "file:../aml-utils"
+```
+(if you repositories are in the same directory).
+
+Commiting
+-----------
+
+**N.B. The semantic release process described below currently does not work, meaning this package has to be deployed manually using npm publish.**
+
+**If a permissions error is encountered when authenticating with an npm token, remove .npmrc and authenticate using npm login.**
+
+This repository uses [Semantic release](https://semantic-release.gitbook.io/) for version publishing. To create a new version of the package simply push to bitbucket and CircleCI will create a new version. No change to this repo's package.json is required.
+
+To work out what the next version of package should be a git commit linter is used. This is enforced by Husky and only commits with the following syntax can be [used](https://github.com/conventional-changelog/commitlint/tree/master/@commitlint/config-angular).
+  
+Setting up Semantic release
+-----------
+
+This [article](https://circleci.com/docs/2.0/gh-bb-integration/#creating-a-bitbucket-user-key) explains the integration between Bitbucket and CirlceCI. An NPM token also needs to be provided for the write access to the npm package

package/codecov.yml

@@ -0,0 +1,29 @@
+codecov:
+  require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project:
+      default:
+        target: 85%
+    patch: 
+      default:
+        target: 85%
+    changes: no
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+comment:
+  layout: "reach,diff,flags,tree"
+  behavior: default
+  require_changes: no

package/commitlint.config.js

@@ -0,0 +1 @@
+module.exports = { extends: ['@commitlint/config-angular'] };

package/dist/errors/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+const create = require('create-error');
+const AppError = create('AppError');
+const RequestError = create(AppError, 'RequestError');
+RequestError.toJSON = () => ({
+    message: this.message,
+});
+const Forbidden = create(RequestError, 'ForbiddenError', {
+    status: 403,
+});
+const Unauthorized = create(RequestError, 'UnauthorizedError', {
+    status: 401,
+});
+const BadRequest = create(RequestError, 'BadRequestError', {
+    status: 400,
+});
+const NotFound = create(RequestError, 'NotFoundError', {
+    status: 404,
+});
+const ConflictError = create(RequestError, 'ConflictError', {
+    status: 409,
+});
+const ServerError = create(RequestError, 'ServerError', {
+    status: 500,
+});
+const InvalidArguments = create(RequestError, 'InvalidArgumentsError', {
+    status: 500,
+});
+const ServerTimeout = create(RequestError, 'ServerTimeoutError', {
+    status: 503,
+});
+module.exports = {
+    RequestError,
+    ServerError,
+    Forbidden,
+    Unauthorized,
+    BadRequest,
+    NotFound,
+    ConflictError,
+    InvalidArguments,
+    ServerTimeout,
+};

package/dist/errors/errors.spec.d.ts

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

package/dist/errors/errors.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+const { RequestError, Forbidden, Unauthorized, BadRequest, NotFound, } = require('./errors');
+describe('lib/error', () => {
+    describe('RequestError', () => {
+        it('should inherit from Error', () => (new RequestError instanceof Error).should.be.true);
+        describe('Forbidden Error', () => {
+            it('should inherit from Error', () => new Forbidden instanceof Error);
+            return it('should inherit from RequestError', () => new Forbidden instanceof RequestError);
+        });
+        describe('Unauthorized Error', () => {
+            it('should inherit from Error', () => new Unauthorized instanceof Error);
+            return it('should inherit from RequestError', () => new Unauthorized instanceof RequestError);
+        });
+        describe('BadRequest Error', () => {
+            it('should inherit from Error', () => new BadRequest instanceof Error);
+            return it('should inherit from RequestError', () => new BadRequest instanceof RequestError);
+        });
+        return describe('NotFound Error', () => {
+            it('should inherit from Error', () => new NotFound instanceof Error);
+            return it('should inherit from RequestError', () => new NotFound instanceof RequestError);
+        });
+    });
+});

package/dist/file-parser/__tests/file-parser.spec.d.ts

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

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

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon_1 = __importDefault(require("sinon"));
+const chai_1 = require("chai");
+const file_parser_1 = __importDefault(require("../file-parser"));
+const sanitizeRows = __importStar(require("../sanitzeRows"));
+const parseRow = __importStar(require("../parse-row"));
+describe('file-parser', () => {
+    const dependencies = {
+        processRow: sinon_1.default.spy(),
+    };
+    const parsedRows = [];
+    let mockParseRow;
+    let mockSanitizeRows;
+    let mockSetTimeout;
+    before(() => {
+        mockParseRow = sinon_1.default.stub(parseRow, 'default').returns(parsedRows);
+        mockSanitizeRows = sinon_1.default.stub(sanitizeRows, 'default').returns([{}]);
+        mockSetTimeout = sinon_1.default.stub(global, 'setTimeout').callsFake((callback) => callback());
+    });
+    beforeEach(() => {
+        sinon_1.default.resetHistory();
+    });
+    after(() => {
+        sinon_1.default.restore();
+    });
+    it('should call parseRow once per input new line', async () => {
+        const input = '\n';
+        await file_parser_1.default(input, 50, dependencies);
+        chai_1.expect(mockParseRow).to.be.calledTwice;
+    });
+    it('should call pass parseRow result into sanitizeRows', async () => {
+        const input = '\n';
+        await file_parser_1.default(input, 50, dependencies);
+        chai_1.expect(mockSanitizeRows).to.be.calledOnce;
+        chai_1.expect(mockSanitizeRows).to.be.deep.calledWith([[], []], dependencies.processRow);
+    });
+    it('should throw error when number of rows is more than max rows', async () => {
+        const input = '\n';
+        mockSanitizeRows.returns(new Array(20));
+        try {
+            await file_parser_1.default(input, 10, dependencies);
+            chai_1.expect(1).to.equal(2);
+        }
+        catch (ex) {
+            chai_1.expect(ex.name).to.equal('TooManyRowsError');
+        }
+    });
+    it('should throw error when no rows returned from sanitizeRows', async () => {
+        const input = '\n';
+        mockSanitizeRows.returns([]);
+        try {
+            await file_parser_1.default(input, 10, dependencies);
+            chai_1.expect(1).to.equal(2);
+        }
+        catch (ex) {
+            chai_1.expect(ex.name).to.equal('Error');
+        }
+    });
+    it('should throw error an error when content is "invalidFileType"', async () => {
+        const input = 'invalidFileType';
+        mockSanitizeRows.returns([]);
+        try {
+            await file_parser_1.default(input, 10, dependencies);
+            chai_1.expect(1).to.equal(2);
+        }
+        catch (ex) {
+            chai_1.expect(ex.message).to.equal('Invalid file type');
+        }
+    });
+    it('should call process row once per row in single timeout', async () => {
+        const input = '\n';
+        const fakeRows = (new Array(30)).fill({});
+        mockSanitizeRows.returns(fakeRows);
+        await file_parser_1.default(input, 70, dependencies);
+        chai_1.expect(dependencies.processRow).to.be.callCount(30);
+        chai_1.expect(mockSetTimeout).to.be.calledOnce;
+    });
+    it('should call process row once per row in two timeouts when more than 30 rows', async () => {
+        const input = '\n';
+        const fakeRows = (new Array(50)).fill({});
+        mockSanitizeRows.returns(fakeRows);
+        await file_parser_1.default(input, 70, dependencies);
+        chai_1.expect(dependencies.processRow).to.be.callCount(50);
+        chai_1.expect(mockSetTimeout).to.be.calledTwice;
+    });
+});

package/dist/file-parser/__tests/parse-row.spec.d.ts

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

package/dist/file-parser/__tests/parse-row.spec.js

@@ -0,0 +1,29 @@
+"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 parse_row_1 = __importDefault(require("../parse-row"));
+describe('parse-row', () => {
+    it('should handle tabs', () => {
+        const input = 'asdas \t asdar \t aaaaa \t bbb bb';
+        const result = parse_row_1.default(input);
+        chai_1.expect(result).to.have.length(4);
+    });
+    it('should handle comas', () => {
+        const input = 'asdas, asdar, aaaaa, bbb bb';
+        const result = parse_row_1.default(input);
+        chai_1.expect(result).to.have.length(4);
+    });
+    it('should handle spaces', () => {
+        const input = 'asdas   asdar   aaaaa   bbb bb';
+        const result = parse_row_1.default(input);
+        chai_1.expect(result).to.have.length(4);
+    });
+    it('should handle spaces', () => {
+        const input = 'asdas asdar aaaaa bbb bb';
+        const result = parse_row_1.default(input);
+        chai_1.expect(result).to.have.length(5);
+    });
+});

package/dist/file-parser/__tests/sanitize-rows.spec.d.ts

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

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

@@ -0,0 +1,78 @@
+"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/{lib → dist}/file-parser/errors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TooManyRowsError = void 0;
+// eslint-disable-next-line import/prefer-default-export
 class TooManyRowsError extends Error {
     constructor() {
         super('More than configured number of rows imported');
@@ -8,4 +9,3 @@ class TooManyRowsError extends Error {
     }
 }
 exports.TooManyRowsError = TooManyRowsError;
-//# sourceMappingURL=errors.js.map

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

@@ -1,5 +1,7 @@
-import { ProcessingEntry } from './sanitizeRows';
-type Dependencies<T extends ProcessingEntry> = {
+export declare type ProcessingEntry = {
+    isValid: boolean;
+};
+declare type Dependencies<T extends ProcessingEntry> = {
     processRow: (cells: string[]) => T;
 };
 declare function parseFile<T extends ProcessingEntry>(fileContent: string, maxRows: number, dependencies: Dependencies<T>): Promise<T[]>;

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

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