lesgo 0.6.0 → 0.7.0

package/src/services/pagination/Paginator.js

@@ -0,0 +1,254 @@
+import LesgoException from '../../exceptions/LesgoException';
+import validateFields from '../../utils/validateFields';
+
+const FILE = 'Services/pagination/Paginator';
+
+export default class Paginator {
+  /**
+   * Constructor
+   *
+   * @param db
+   * @param sql
+   * @param sqlParams
+   * @param options
+   */
+  constructor(db, sql, sqlParams, options = {}, connection = {}) {
+    const validFields = [
+      { key: 'db', type: 'object', required: true },
+      { key: 'sql', type: 'string', required: true },
+      { key: 'sqlParams', type: 'object', required: true },
+      { key: 'perPage', type: 'number', required: false },
+      { key: 'currentPage', type: 'number', required: false },
+      { key: 'connection', type: 'object', required: false },
+    ];
+
+    let validated = {};
+    try {
+      validated = validateFields(
+        {
+          db,
+          sql,
+          sqlParams,
+          ...options,
+          connection,
+        },
+        validFields
+      );
+    } catch (error) {
+      throw new LesgoException(
+        error.message,
+        `${FILE}::FIELD_VALIDATION_EXCEPTION`,
+        500,
+        {
+          ...options,
+          error,
+        }
+      );
+    }
+
+    const { perPage, currentPage } = validated;
+
+    this.dbProp = db;
+    this.sqlProp = sql;
+    this.sqlParamsProp = sqlParams;
+    this.perPageProp = perPage || 10;
+    this.currentPageProp = currentPage || 1;
+
+    this.hasNext = false;
+
+    this.response = [];
+    this.totalProp = false;
+
+    this.connection = connection;
+  }
+
+  /**
+   * Count all items in the current page.
+   *
+   * @returns {number}
+   */
+  async count() {
+    return this.response.length || (await this.executeQuery()).length;
+  }
+
+  /**
+   * Previous page
+   *
+   * @returns {boolean|number}
+   */
+  previousPage() {
+    if (this.currentPage() > 1) {
+      return this.currentPage() - 1;
+    }
+
+    return false;
+  }
+
+  /**
+   * The current page.
+   *
+   * @returns {*|number}
+   */
+  currentPage() {
+    return this.currentPageProp;
+  }
+
+  /**
+   * Next page
+   *
+   * @returns {Promise<boolean|*>}
+   */
+  async nextPage() {
+    if (this.response.length <= 0) {
+      await this.executeQuery();
+    }
+
+    if (this.hasNext) {
+      return this.currentPage() + 1;
+    }
+
+    return false;
+  }
+
+  /**
+   * First item in the current page.
+   *
+   * @returns {*}
+   */
+  async firstItem() {
+    if (this.response.length <= 0) {
+      await this.executeQuery();
+    }
+
+    return this.response[0];
+  }
+
+  /**
+   * Last item in the current page.
+   */
+  async lastItem() {
+    if (this.response.length <= 0) {
+      await this.executeQuery();
+    }
+
+    return this.response[this.response.length - 1];
+  }
+
+  /**
+   * Number of items per page.
+   *
+   * @returns {*}
+   */
+  perPage() {
+    return this.perPageProp;
+  }
+
+  /**
+   * Get the last page.
+   *
+   * @returns {Promise<number>}
+   */
+  async lastPage() {
+    return this.calculateTotalNumberOfPages();
+  }
+
+  /**
+   * Total items in all pages.
+   *
+   * @returns {null|number}
+   */
+  async total() {
+    return this.totalProp || this.countTotalItems();
+  }
+
+  /**
+   * All items in the current page.
+   *
+   * @returns {[]}
+   */
+  async items() {
+    if (this.response.length <= 0) {
+      await this.executeQuery();
+    }
+
+    return this.response;
+  }
+
+  /**
+   * Convert to object.
+   *
+   * @returns {Promise<{per_page: *, count: *, items: *, current_page: (*|number)}>}
+   */
+  async toObject() {
+    if (this.response.length <= 0) {
+      await this.executeQuery();
+    }
+
+    return {
+      count: await this.count(),
+      previous_page: this.previousPage(),
+      current_page: this.currentPage(),
+      next_page: await this.nextPage(),
+      last_page: await this.lastPage(),
+      per_page: this.perPage(),
+      total: await this.total(),
+      items: await this.items(),
+    };
+  }
+
+  // They act as protected methods.
+
+  getLimitAndOffsetByPageAndContentPerPage() {
+    const offset = this.currentPage() * this.perPage() - this.perPage();
+    const limit = this.perPage();
+
+    return {
+      offset,
+      limit,
+    };
+  }
+
+  generatePaginationSqlSnippet() {
+    const values = this.getLimitAndOffsetByPageAndContentPerPage();
+    const limitWithExtraData = values.limit + 1;
+    return this.sqlProp.concat(
+      ` LIMIT ${limitWithExtraData} OFFSET ${values.offset}`
+    );
+  }
+
+  async executeQuery() {
+    this.response = await this.dbProp.select(
+      this.generatePaginationSqlSnippet(),
+      this.sqlParamsProp,
+      this.connection
+    );
+
+    this.hasNext = this.response.length > this.perPage();
+    if (this.hasNext) {
+      this.response.pop();
+    }
+
+    return this.response;
+  }
+
+  /**
+   * Count total items with basic implementation.
+   *
+   * @returns {Promise<number>}
+   */
+  async countTotalItems() {
+    const resp = await this.dbProp.select(
+      this.sqlProp,
+      this.sqlParamsProp,
+      this.connection
+    );
+    this.totalProp = Object.keys(resp).length;
+
+    return this.totalProp;
+  }
+
+  async calculateTotalNumberOfPages() {
+    const total = await this.total();
+    return Math.ceil(total / this.perPage());
+  }
+}

package/src/utils/__mocks__/db.js

@@ -0,0 +1,109 @@
+export const mockData = {
+  index_0: 'data_0',
+  index_1: 'data_1',
+  index_2: 'data_2',
+  index_3: 'data_3',
+  index_4: 'data_4',
+};
+
+export const mockDataFirstItem = {
+  index_0: 'data_0_first_item',
+  index_1: 'data_1_first_item',
+  index_2: 'data_2_first_item',
+  index_3: 'data_3_first_item',
+  index_4: 'data_4_first_item',
+};
+
+export const mockDataLastItem = {
+  index_0: 'data_0_last_item',
+  index_1: 'data_1_last_item',
+  index_2: 'data_2_last_item',
+  index_3: 'data_3_last_item',
+  index_4: 'data_4_last_item',
+};
+
+export default {
+  // eslint-disable-next-line no-unused-vars
+  select: jest.fn().mockImplementation((sql, sqlParams) => {
+    if (sql.startsWith('SELECT * FROM tests LIMIT 6 OFFSET 10')) {
+      return Promise.resolve([
+        { ...mockDataFirstItem },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockDataLastItem },
+      ]);
+    }
+
+    if (
+      sql.startsWith('SELECT * FROM tests LIMIT 6') ||
+      sql.startsWith('SELECT * FROM total_tests LIMIT 6')
+    ) {
+      return Promise.resolve([
+        { ...mockDataFirstItem },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockDataLastItem },
+        { ...mockData },
+      ]);
+    }
+
+    if (sql.startsWith('SELECT * FROM total_tests')) {
+      return Promise.resolve([
+        { ...mockDataFirstItem },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockDataLastItem },
+      ]);
+    }
+
+    if (sql.startsWith('SELECT * FROM tests')) {
+      return Promise.resolve([
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+      ]);
+    }
+
+    return Promise.resolve({
+      mocked: {
+        sql,
+        sqlParams,
+      },
+    });
+  }),
+};

package/src/utils/__tests__/db.spec.js

@@ -1,5 +1,12 @@
 import config from 'Config/db'; // eslint-disable-line import/no-unresolved
-import db from '../db';
+
+let db;
+
+beforeEach(() => {
+  jest.isolateModules(() => {
+    db = require('../db').default; // eslint-disable-line global-require
+  });
+});
 
 describe('test db utils instantiate', () => {
   it('should not throw error on instantiating AuroraDbService', () => {
@@ -29,4 +36,36 @@ describe('test db utils instantiate', () => {
       },
     });
   });
+
+  it('should update AuroraDb credentials on connect based on dataApi config', () => {
+    config.default = 'dataApi';
+    let thisDb;
+    jest.isolateModules(() => {
+      thisDb = require('../db').default; // eslint-disable-line global-require
+    });
+
+    return expect(thisDb.client).toMatchObject({
+      mocked: {
+        database: config.connections.dataApi.database,
+        resourceArn: config.connections.dataApi.resourceArn,
+        secretArn: config.connections.dataApi.secretArn,
+      },
+    });
+  });
+
+  it('should update AuroraDb credentials on connect based on rdsProxy config', () => {
+    config.default = 'rdsProxy';
+    let thisDb;
+    jest.isolateModules(() => {
+      thisDb = require('../db').default; // eslint-disable-line global-require
+    });
+
+    return expect(thisDb.clientOpts).toMatchObject({
+      database: config.connections.rdsProxy.database,
+      host: config.connections.rdsProxy.host,
+      user: config.connections.rdsProxy.user,
+      password: config.connections.rdsProxy.password,
+      persists: config.connections.rdsProxy.persists,
+    });
+  });
 });

package/src/utils/__tests__/getJwtSubFromAuthHeader.spec.js

@@ -0,0 +1,20 @@
+import getJwtSubFromAuthHeader from '../getJwtSubFromAuthHeader';
+
+const authorizationHeader =
+  'eyJraWQiOiIzSHc3YmRuUHBIMnJSZWhjT3k5NFRLZm5ybzU0Y1RFUW1lcGtVYWc2bW1vPSIsImFsZyI6IlJTMjU2In0.eyJzdWIiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJhdWQiOiI0aHM0a2ZpNTAwZWtkajJhZTdiOWExazU4byIsImVtYWlsX3ZlcmlmaWVkIjpmYWxzZSwiZXZlbnRfaWQiOiJlNzdiZGZmYy0wYjFjLTQzMzMtYWUxZS1lM2QwNjZkNzAyZGMiLCJ0b2tlbl91c2UiOiJpZCIsImF1dGhfdGltZSI6MTYxNTYxMTc3NywiaXNzIjoiaHR0cHM6XC9cL2NvZ25pdG8taWRwLmFwLXNvdXRoZWFzdC0xLmFtYXpvbmF3cy5jb21cL2FwLXNvdXRoZWFzdC0xXzR3QjFuSmNvSyIsImNvZ25pdG86dXNlcm5hbWUiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJleHAiOjE2MTU2MTUzNzcsImlhdCI6MTYxNTYxMTc3NywiZW1haWwiOiJzdWZpeWFuK3Rlc3RAaW5jdWJlOC5zZyJ9.hbNYnVt6_fhX5KJEfn6Fi9cOZkQAldHGitVBWXSd0_YcWDU_BJ1OVu_VFEKzIvaRLR_zy2eW3dIJ27pn1_6U0sS8MZMsvtz0SKQP4M1hTEnhb5TOSIcOs9Y6ZPy1e1ShIqQmq2j_K1JFzEZH7u3eOmCTmFcs8X5vUk8O1sT2KqBP5UCBVB_4rCVEjbRGdyynqEKcdKkd7Nk6v9onpxRbG3FOg6vlsKSlfZ6RIz3jbjO4ZkCJiYAgrI7bsh2VGwE8pZq80GuQy9pocLkTcZiAFcni50-yvePQX8tkXhPzbp7DibAI6nU87Ol6TW4ZmB-0BZ56Nfeowoe7tT-7hvGkGA';
+
+describe('test Utils/getJwtSubFromAuthHeader util', () => {
+  it('should get sub from Authorization header', () => {
+    expect(getJwtSubFromAuthHeader(authorizationHeader)).toBe(
+      'f2b5349d-f5e3-44f5-9c08-ae6b01e95434'
+    );
+  });
+
+  it('should get sub as null from missing or empty header', () => {
+    expect(getJwtSubFromAuthHeader()).toBe(null);
+  });
+
+  it('should get sub as null from invalid Authorization header', () => {
+    expect(getJwtSubFromAuthHeader('some-invalid-token')).toBe(null);
+  });
+});

package/src/utils/__tests__/isDecimal.spec.js

@@ -0,0 +1,12 @@
+import isDecimal from '../isDecimal';
+
+describe('test Utils/isDecimal util', () => {
+  it('should return false for string', () => {
+    expect(isDecimal('1')).toBeFalsy();
+    expect(isDecimal('one')).toBeFalsy();
+  });
+
+  it('should return true for decimal number', () => {
+    return expect(isDecimal(1.5)).toBeTruthy();
+  });
+});

package/src/utils/__tests__/isEmail.spec.js

@@ -0,0 +1,28 @@
+import isEmail from '../isEmail';
+import LesgoException from '../../exceptions/LesgoException';
+
+describe('test isEmail util', () => {
+  test('isEmail should throws an Error when empty sting parameters were passed', () => {
+    expect(() => {
+      isEmail('');
+    }).toThrow(
+      new LesgoException('Empty parameter supplied', 'IS_EMAIL_EMPTY_PARAMETER')
+    );
+  });
+
+  test('isEmail should throws an Error when null parameters were passed', () => {
+    expect(() => {
+      isEmail(null);
+    }).toThrow(
+      new LesgoException('Empty parameter supplied', 'IS_EMAIL_EMPTY_PARAMETER')
+    );
+  });
+
+  it('isEmail should return false for invalid email ', () => {
+    return expect(isEmail('test@g')).toBeFalsy();
+  });
+
+  it('isEmail should return true for valid email', () => {
+    return expect(isEmail('test@gmail.com')).toBeTruthy();
+  });
+});

package/src/utils/__tests__/prepSQLInsertParams.spec.js

@@ -0,0 +1,46 @@
+import prepSQLInsertParams from '../prepSQLInsertParams';
+
+const columns = [
+  { key: 'uid', type: 'string', required: true },
+  {
+    key: 'type',
+    type: 'enum',
+    enumValues: ['photo', 'video'],
+    required: true,
+  },
+  { key: 'table_name', type: 'string', required: false },
+  { key: 'row_id', type: 'number', required: false },
+  { key: 'id', type: 'number', required: true },
+];
+
+describe('test prepSQLInsertParams util', () => {
+  test('should return all the fields if provided', () => {
+    const params = {
+      uid: 'sample-123123',
+      type: 'photo',
+      table_name: 'medias',
+      row_id: 123,
+      id: 123,
+    };
+
+    expect(prepSQLInsertParams(params, columns)).toMatchObject({
+      insertColumns: 'uid,type,table_name,row_id,id',
+      insertValues: ':uid,:type,:table_name,:row_id,:id',
+      insertFields: params,
+    });
+  });
+
+  test('should return only the given fields', () => {
+    const params = {
+      uid: 'sample-123123',
+      type: 'photo',
+      id: 123,
+    };
+
+    expect(prepSQLInsertParams(params, columns)).toMatchObject({
+      insertColumns: 'uid,type,id',
+      insertValues: ':uid,:type,:id',
+      insertFields: params,
+    });
+  });
+});

package/src/utils/__tests__/prepSQLUpdateParams.spec.js

@@ -0,0 +1,36 @@
+import prepSQLUpdateParams from '../prepSQLUpdateParams';
+
+const columns = [
+  { key: 'id', type: 'number', required: true },
+  { key: 'table_name', type: 'string', required: false },
+  { key: 'row_id', type: 'number', required: false },
+];
+
+describe('test prepSQLUpdateParams util', () => {
+  test('should return all the fields if provided', () => {
+    const params = {
+      id: 123,
+      table_name: 'users',
+      row_id: 123,
+    };
+
+    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
+      updateColumnValues: 'table_name=:table_name,row_id=:row_id',
+      wherePrimaryKey: 'id=:id',
+      updateFields: params,
+    });
+  });
+
+  test('should return only the provided fields', () => {
+    const params = {
+      id: 123,
+      row_id: 124,
+    };
+
+    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
+      updateColumnValues: 'row_id=:row_id',
+      wherePrimaryKey: 'id=:id',
+      updateFields: params,
+    });
+  });
+});