@ellipticltd/aml-utils 0.16.27 → 0.16.29

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

@@ -1,35 +0,0 @@
-import { expect } from 'chai';
-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).to.have.length(4);
-  });
-
-  it('should handle comas', () => {
-    const input = 'asdas, asdar, aaaaa, bbb bb';
-
-    const result = parseRow(input);
-
-    expect(result).to.have.length(4);
-  });
-
-  it('should handle spaces', () => {
-    const input = 'asdas   asdar   aaaaa   bbb bb';
-
-    const result = parseRow(input);
-
-    expect(result).to.have.length(4);
-  });
-
-  it('should handle spaces', () => {
-    const input = 'asdas asdar aaaaa bbb bb';
-
-    const result = parseRow(input);
-
-    expect(result).to.have.length(5);
-  });
-});

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

@@ -1,88 +0,0 @@
-import { expect } from 'chai';
-import sinon from 'sinon';
-import sanitizeRows from '../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 = sanitizeRows(input, () => ({
-      isValid: true,
-    }));
-
-    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 = sanitizeRows(input, () => ({
-      isValid: true,
-    }));
-
-    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 = sanitizeRows(input, () => ({
-      isValid: true,
-    }));
-
-    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.stub();
-    returnsFalseOnce.returns(true);
-    returnsFalseOnce.onFirstCall().returns(false);
-
-    const result = sanitizeRows(input, returnsFalseOnce);
-    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 = sanitizeRows(input, () => ({
-      isValid: true,
-    }));
-
-    expect(result).to.have.length(4);
-  });
-});

package/lib/file-parser/errors.ts

@@ -1,7 +0,0 @@
-// eslint-disable-next-line import/prefer-default-export
-export class TooManyRowsError extends Error {
-  constructor() {
-    super('More than configured number of rows imported');
-    this.name = 'TooManyRowsError';
-  }
-}

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

@@ -1,84 +0,0 @@
-import parseRow from './parse-row';
-import { TooManyRowsError } from './errors';
-import sanitizeRows from './sanitzeRows';
-
-export type ProcessingEntry = {
-  isValid: boolean,
-};
-
-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[] | undefined) => void,
-      reject: (error: Error) => void,
-    ): void => {
-      setTimeout(
-        () => {
-          try {
-            const processedRows = parsedRows.map(processRow);
-            resolve(processedRows);
-          } catch (ex) {
-            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

@@ -1,52 +0,0 @@
-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/sanitzeRows.ts

@@ -1,32 +0,0 @@
-import { ProcessingEntry } from './file-parser';
-
-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.spec.js

@@ -1,45 +0,0 @@
-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/index.ts

@@ -1,19 +0,0 @@
-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';
-import structuredFileParser from './structured-file-parser/structured-file-parser';
-
-export {
-  types,
-  validations,
-  errors,
-  formatting,
-  fileParser,
-  structuredFileParser,
-  middleware,
-  ormHelpers,
-};

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

@@ -1,41 +0,0 @@
-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/structured-file-parser/errors.ts

@@ -1,25 +0,0 @@
-/* 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';
-  }
-}

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

@@ -1,52 +0,0 @@
-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/structured-file-parser/sanitize-rows.ts

@@ -1,24 +0,0 @@
-const sensicalRowCheck = (cells: string[]): boolean => (
-  cells.some((cell: string) => !!cell)
-);
-
-function sanitizeRows(parsedRows: string[][]): string[][] {
-  const firstSensicalRowIndex = parsedRows.findIndex(sensicalRowCheck);
-
-  const lastSensicalRowIndex = [...parsedRows]
-    .reverse()
-    .findIndex(sensicalRowCheck);
-
-  if (firstSensicalRowIndex < 0) {
-    return [];
-  }
-
-  const sanitizedRows = [...parsedRows].splice(
-    firstSensicalRowIndex,
-    parsedRows.length - firstSensicalRowIndex - lastSensicalRowIndex,
-  );
-
-  return sanitizedRows;
-}
-
-export default sanitizeRows;

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

@@ -1,155 +0,0 @@
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
-import parseRow from './parse-row';
-import {
-  InvalidFileError,
-  TooManyRowsError,
-  NoRowsError,
-  InvalidHeadersError,
-} from './errors';
-import sanitizeRows from './sanitize-rows';
-
-export type ProcessingEntry = {
-  isValid: boolean;
-};
-
-type Dependencies<T extends ProcessingEntry> = {
-  processRow: (cells: string[], headers: string[]) => T;
-};
-
-type CompleteDependencies<T extends ProcessingEntry, U extends string[]> = {
-  processRow: (cells: string[], headers: U) => T;
-  headers: U;
-};
-
-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, U extends string[]>(
-  parsedRows: string[][],
-  dependencies: CompleteDependencies<T, U>,
-): Promise<T[]> {
-  const { processRow, headers } = dependencies;
-  // @ts-ignore
-  return new Promise(
-    (
-      resolve: (value: T[] | undefined) => void,
-      reject: (error: Error) => void,
-    ): void => {
-      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
-export const hasHeaderRow = (
-  rows: string[][],
-  requiredHeaderNames: string[],
-): boolean => {
-  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;
-};
-
-export const isHeaderRowValid = (
-  rows: string[][],
-  requiredHeaderNames: string[],
-): boolean => {
-  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<T extends ProcessingEntry>(
-  fileContent: string,
-  maxRows: number,
-  requiredHeaderNames: string[],
-  dependencies: Dependencies<T>,
-): Promise<T[]> {
-  if (fileContent === 'invalidFileType') {
-    throw new InvalidFileError();
-  }
-
-  const rows = fileContent.split('\n');
-  const parsedRows = rows.map(parseRow);
-
-  const sanitizedRows = sanitizeRows(parsedRows);
-
-  if (sanitizedRows.length > maxRows) {
-    throw new TooManyRowsError();
-  }
-
-  if (sanitizedRows.length === 0) {
-    throw new NoRowsError();
-  }
-
-  const containsHeaders = hasHeaderRow(sanitizedRows, requiredHeaderNames);
-  if (
-    containsHeaders
-    && !isHeaderRowValid(sanitizedRows, requiredHeaderNames)
-  ) {
-    throw new InvalidHeadersError();
-  }
-
-  const firstSanitizedRow = sanitizedRows[0];
-
-  if (!firstSanitizedRow) {
-    throw new NoRowsError();
-  }
-
-  const headers = containsHeaders
-    ? firstSanitizedRow.map((value) => value.toLowerCase())
-    : requiredHeaderNames;
-
-  const dataRows = containsHeaders ? sanitizedRows.splice(1) : sanitizedRows;
-
-  if (dataRows.length === 0) {
-    throw new NoRowsError();
-  }
-
-  const parsedRowChunks = chunk(dataRows, 30);
-  let results: T[] = [];
-  for (const currentRowChunk of parsedRowChunks) {
-    const chunkResult = await processChunk(currentRowChunk, {
-      ...dependencies,
-      headers,
-    });
-    results = results.concat(chunkResult);
-  }
-
-  return results;
-}
-
-export default parseFile;