@ellipticltd/aml-utils 0.15.32-FLOW-431 → 0.15.32

package/.eslintrc.js

@@ -0,0 +1,22 @@
+const path = require('path');
+
+module.exports = {
+  extends: ['../../.eslintrc.js'],
+  ignorePatterns: ['!**/*'],
+  overrides: [
+    {
+      files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+      rules: {
+        'import/no-extraneous-dependencies': ['error', { packageDir: path.resolve(__dirname, '../../') }],
+      },
+    },
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {},
+    },
+    {
+      files: ['*.js', '*.jsx'],
+      rules: {},
+    },
+  ],
+};

package/jest.config.ts

@@ -0,0 +1,13 @@
+export default {
+  displayName: 'aml-utils',
+  preset: '../../jest.preset.js',
+  globals: {
+    '@swc/jest': {
+      tsconfig: '<rootDir>/tsconfig.spec.json',
+    },
+  },
+  transform: {
+    '^.+\\.[tj]s$': '@swc/jest',
+  },
+  coverageDirectory: '../../coverage/libs/aml-utils',
+};

package/lib/errors/errors.js

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

package/lib/errors/errors.spec.js

@@ -0,0 +1,49 @@
+const { RequestError, Forbidden, Unauthorized, BadRequest, NotFound } = require('./errors');
+
+describe('lib/error', () => {
+  describe('RequestError', () => {
+    it('should inherit from Error', () => {
+      expect(new RequestError() instanceof Error).toEqual(true);
+    });
+
+    describe('Forbidden Error', () => {
+      it('should inherit from Error', () => {
+        expect(new Forbidden() instanceof Error).toEqual(true);
+      });
+
+      it('should inherit from RequestError', () => {
+        expect(new Forbidden() instanceof RequestError).toEqual(true);
+      });
+    });
+
+    describe('Unauthorized Error', () => {
+      it('should inherit from Error', () => {
+        expect(new Unauthorized() instanceof Error).toEqual(true);
+      });
+
+      it('should inherit from RequestError', () => {
+        expect(new Unauthorized() instanceof RequestError).toEqual(true);
+      });
+    });
+
+    describe('BadRequest Error', () => {
+      it('should inherit from Error', () => {
+        expect(new BadRequest() instanceof Error).toEqual(true);
+      });
+
+      it('should inherit from RequestError', () => {
+        expect(new BadRequest() instanceof RequestError).toEqual(true);
+      });
+    });
+
+    describe('NotFound Error', () => {
+      it('should inherit from Error', () => {
+        expect(new NotFound() instanceof Error).toEqual(true);
+      });
+
+      it('should inherit from RequestError', () => {
+        expect(new NotFound() instanceof RequestError).toEqual(true);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,34 @@
+import parseRow from '../parse-row';
+
+describe('parse-row', () => {
+  it('should handle tabs', () => {
+    const input = 'asdas \t asdar \t aaaaa \t bbb bb';
+
+    const result = parseRow(input);
+    expect(result).toHaveLength(4);
+  });
+
+  it('should handle comas', () => {
+    const input = 'asdas, asdar, aaaaa, bbb bb';
+
+    const result = parseRow(input);
+
+    expect(result).toHaveLength(4);
+  });
+
+  it('should handle spaces', () => {
+    const input = 'asdas   asdar   aaaaa   bbb bb';
+
+    const result = parseRow(input);
+
+    expect(result).toHaveLength(4);
+  });
+
+  it('should handle spaces', () => {
+    const input = 'asdas asdar aaaaa bbb bb';
+
+    const result = parseRow(input);
+
+    expect(result).toHaveLength(5);
+  });
+});

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

@@ -0,0 +1,85 @@
+import sanitizeRows from '../sanitizeRows';
+
+describe('sanitize-rows', () => {
+  it('should remove empty rows at the start of the array', () => {
+    const input = [
+      ['', '', ''],
+      ['this', 'is', 'valid'],
+      ['this', 'is', 'valid'],
+    ];
+
+    const result = sanitizeRows(input, () => ({
+      isValid: true,
+    }));
+
+    expect(result).toHaveLength(2);
+  });
+
+  it('should remove empty rows at the end of the array', () => {
+    const input = [
+      ['this', 'is', 'valid'],
+      ['this', 'is', 'valid'],
+      ['', '', ''],
+    ];
+
+    const result = sanitizeRows(input, () => ({
+      isValid: true,
+    }));
+
+    expect(result).toHaveLength(2);
+  });
+
+  it('should remove empty rows at the start and end of the array', () => {
+    const input = [
+      ['', '', ''],
+      ['', '', ''],
+      ['', '', ''],
+      ['this', 'is', 'valid'],
+      ['this', 'is', 'valid'],
+      ['', '', ''],
+      ['', '', ''],
+      ['', '', ''],
+    ];
+
+    const result = sanitizeRows(input, () => ({
+      isValid: true,
+    }));
+
+    expect(result).toHaveLength(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 = jest.fn();
+    returnsFalseOnce.mockReturnValueOnce(false).mockReturnValue(true);
+
+    const result = sanitizeRows(input, returnsFalseOnce);
+    expect(result).toHaveLength(2);
+  });
+
+  it('should allow rows with some empty values', () => {
+    const input = [
+      ['this', 'is', 'invalid'],
+      ['this', 'is', 'valid'],
+      ['this', 'is', 'valid'],
+      ['valid', '', ''],
+      ['', '', ''],
+      ['', '', ''],
+    ];
+
+    const result = sanitizeRows(input, () => ({
+      isValid: true,
+    }));
+
+    expect(result).toHaveLength(4);
+  });
+});

package/lib/file-parser/errors.ts

@@ -0,0 +1,6 @@
+export class TooManyRowsError extends Error {
+  constructor() {
+    super('More than configured number of rows imported');
+    this.name = 'TooManyRowsError';
+  }
+}

package/lib/file-parser/file-parser.ts

@@ -0,0 +1,67 @@
+import parseRow from './parse-row';
+import { TooManyRowsError } from './errors';
+import sanitizeRows, { ProcessingEntry } from './sanitizeRows';
+
+type Dependencies<T extends ProcessingEntry> = {
+  processRow: (cells: string[]) => T;
+};
+
+function chunk<T>(array: T[], size: number): T[][] {
+  if (!array.length) {
+    return [];
+  }
+  const head = array.slice(0, size);
+  const tail = array.slice(size);
+
+  return [head, ...chunk(tail, size)];
+}
+
+async function processChunk<T extends ProcessingEntry>(parsedRows: string[][], dependencies: Dependencies<T>): Promise<T[]> {
+  const { processRow } = dependencies;
+  return new Promise((resolve: (value: T[]) => void, reject: (error: Error) => void): void => {
+    setTimeout(() => {
+      try {
+        const processedRows = parsedRows.map(processRow);
+        resolve(processedRows);
+      } catch (ex) {
+        if (ex instanceof Error) {
+          reject(ex);
+        }
+      }
+    }, 0);
+  });
+}
+
+async function parseFile<T extends ProcessingEntry>(fileContent: string, maxRows: number, dependencies: Dependencies<T>): Promise<T[]> {
+  const { processRow } = dependencies;
+
+  if (fileContent === 'invalidFileType') {
+    throw Error('Invalid file type');
+  }
+
+  const rows = fileContent.split('\n');
+  const parsedRows = rows.map(parseRow);
+
+  const sanitizedRows = sanitizeRows(parsedRows, processRow);
+
+  if (sanitizedRows.length > maxRows) {
+    throw new TooManyRowsError();
+  }
+
+  if (sanitizedRows.length === 0) {
+    throw new Error('No rows');
+  }
+
+  const parsedRowChunks = chunk(sanitizedRows, 30);
+  let results: T[] = [];
+  // 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;
+}
+
+export default parseFile;

package/lib/file-parser/parse-row.ts

@@ -0,0 +1,46 @@
+import { pipe } from 'lodash/fp';
+
+const parseRow = (row: string): string[] => {
+  const trySplitByTab = (line: string | string[]): string | string[] => {
+    if (typeof line === 'string' && line.match('\t')) {
+      return line.split('\t');
+    }
+    return line;
+  };
+
+  const trySplitByComa = (line: string | string[]): string | string[] => {
+    if (typeof line === 'string' && line.match(',')) {
+      return line.split(',');
+    }
+    return line;
+  };
+
+  const trySplitByMultipleSpaces = (line: string | string[]): string | string[] => {
+    if (typeof line === 'string' && line.match(/ {3,}/)) {
+      return line.split(/ {3,}/);
+    }
+    return line;
+  };
+
+  const trySplitBySpace = (line: string | string[]): string | string[] => {
+    if (typeof line === 'string' && line.match(' ')) {
+      return line.split(' ');
+    }
+    return line;
+  };
+
+  const trySplitByNothing = (line: string | string[]): string[] => {
+    if (typeof line === 'string') {
+      return [line];
+    }
+    return line;
+  };
+
+  const splitRow = pipe(trySplitByTab, trySplitByComa, trySplitByMultipleSpaces, trySplitBySpace, trySplitByNothing);
+
+  const cells = splitRow(row);
+
+  return cells.map((c: string) => c.trim());
+};
+
+export default parseRow;

package/lib/file-parser/sanitizeRows.ts

@@ -0,0 +1,22 @@
+export type ProcessingEntry = {
+  isValid: boolean;
+};
+
+const sensicalRowCheck = (cells: string[]): boolean => cells.some((cell: string) => !!cell);
+
+function sanitizeRows<T extends ProcessingEntry>(parsedRows: string[][], processRow: (row: string[]) => T): string[][] {
+  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);
+}
+
+export default sanitizeRows;

package/lib/formatting/formatting.js

@@ -1,17 +1,18 @@
 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}`;
+  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,
+  rethrowError,
+  sqlEscapeWildcard,
 };
-//# sourceMappingURL=formatting.js.map

package/lib/formatting/formatting.spec.js

@@ -0,0 +1,47 @@
+const { sqlEscapeWildcard, rethrowError } = require('./formatting');
+
+describe('formatting.sqlEscapeWildcard', () => {
+  describe('when passed an empty string', () => {
+    it('returns an empty string', () => expect(sqlEscapeWildcard('')).toEqual(''));
+  });
+  describe('when passed a string with no sql wildcards', () => {
+    it('returns the same string', () => {
+      const str = 'foo bar';
+      expect(sqlEscapeWildcard(str)).toEqual(str);
+    });
+  });
+  describe('when passed a string with sql wildcards', () => {
+    it('returns the string with \\ % _ escaped', () => {
+      const str = 'foo\\dfs_erwr%rewr';
+      expect(sqlEscapeWildcard(str)).toEqual('foo\\\\dfs\\_erwr\\%rewr');
+    });
+  });
+});
+
+describe('rethrowError', () => {
+  it('returns an error when given a string', () =>
+    expect(rethrowError('myFunc', { error: 'Oh dear, myFunc is broken' })).toEqual(
+      'myFunc - undefined: undefined - Oh dear, myFunc is broken'
+    ));
+
+  it('returns an error when passed an error object', () =>
+    expect(
+      rethrowError('myFunc', {
+        name: "I'm a teapot",
+        statusCode: 418,
+        error: "I'm a little teapot, short and stout",
+      })
+    ).toEqual("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)).toEqual(expected);
+  });
+});

package/lib/{index.d.ts → index.ts}

@@ -6,4 +6,5 @@ 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 };

package/lib/middleware/middleware.js

@@ -1,22 +1,25 @@
 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);
-    }
+  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,
+  ensureType,
+  ensureUUID,
+  ensureHex32,
+  ensureInteger,
 };
-//# sourceMappingURL=middleware.js.map

package/lib/orm-helpers/ormHelpers.js

@@ -1,17 +1,19 @@
 const _ = require('lodash');
-const includeNested = (orm, models) => _.map(_.toPairs(models), (arg) => {
+
+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;
     }
     return {
-        model,
-        include,
+      model,
+      include,
     };
-});
+  });
+
 module.exports = {
-    includeNested,
+  includeNested,
 };
-//# sourceMappingURL=ormHelpers.js.map

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

@@ -0,0 +1,47 @@
+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', () => expect(includeNested(orm, {})).toEqual([]));
+  });
+
+  describe('when passed an object with no inclusions', () => {
+    it('returns an array of just the key', () =>
+      expect(
+        includeNested(orm, {
+          a: {},
+        })
+      ).toEqual(['a']));
+  });
+
+  describe('when passed a hierarchy of inclusions', () => {
+    it('should nest them in sequelize style', () =>
+      expect(
+        includeNested(orm, {
+          a: {
+            b: {
+              c: {},
+              d: {},
+            },
+          },
+        })
+      ).toEqual([
+        {
+          model: 'a',
+          include: [
+            {
+              model: 'b',
+              include: ['c', 'd'],
+            },
+          ],
+        },
+      ]));
+  });
+});

package/lib/structured-file-parser/errors.ts

@@ -0,0 +1,25 @@
+/* eslint-disable max-classes-per-file */
+export class InvalidFileError extends Error {
+  constructor() {
+    super('Invalid file type');
+    this.name = 'InvalidFileError';
+  }
+}
+export class TooManyRowsError extends Error {
+  constructor() {
+    super('More than configured number of rows imported');
+    this.name = 'TooManyRowsError';
+  }
+}
+export class NoRowsError extends Error {
+  constructor() {
+    super('No rows');
+    this.name = 'NoRowsError';
+  }
+}
+export class InvalidHeadersError extends Error {
+  constructor() {
+    super('Invalid or incomplete headers list');
+    this.name = 'InvalidHeadersError';
+  }
+}