lesgo 0.6.0 → 0.7.0

package/src/services/__tests__/AuroraDbService.spec.js

@@ -23,6 +23,16 @@ describe('test AuroraDbService instantiate', () => {
     expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
     expect(db.client.mocked).toMatchObject(auroraConfig);
   });
+
+  it('should not throw exception with custom region', () => {
+    const db = new AuroraDbService({
+      ...auroraConfig,
+      region: 'ap-southeast-1',
+    });
+
+    expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
+    expect(db.client.mocked).toMatchObject(auroraConfig);
+  });
 });
 
 describe('test AuroraDbService connect', () => {
@@ -106,6 +116,50 @@ describe('test AuroraDbService select', () => {
   });
 });
 
+describe('test AuroraDbService selectPaginate', () => {
+  it('should return paginated records when calling selectPaginate function', async () => {
+    const db = new AuroraDbService(auroraConfig);
+    return expect(db.selectPaginate('SELECT_QUERY', {})).resolves.toMatchObject(
+      {
+        count: 2,
+        previous_page: false,
+        current_page: 1,
+        next_page: false,
+        per_page: 10,
+        items: [
+          {
+            id: 1,
+            uid: 'some-uid-1',
+          },
+          {
+            id: 2,
+            uid: 'some-uid-2',
+          },
+        ],
+      }
+    );
+  });
+
+  it('should return paginated records when calling selectPaginate with defined total', async () => {
+    const db = new AuroraDbService(auroraConfig);
+    return expect(
+      db.selectPaginate('SELECT_QUERY', {}, 1, 2, 1)
+    ).resolves.toMatchObject({
+      count: 1,
+      previous_page: 1,
+      current_page: 2,
+      next_page: 3,
+      per_page: 1,
+      items: [
+        {
+          id: 1,
+          uid: 'some-uid-1',
+        },
+      ],
+    });
+  });
+});
+
 describe('test AuroraDbService selectFirst', () => {
   it('should only return the first record when calling selectFirst', async () => {
     const db = new AuroraDbService(auroraConfig);

package/src/services/__tests__/LengthAwarePaginator.spec.js

@@ -0,0 +1,180 @@
+import LengthAwarePaginator from '../pagination/LengthAwarePaginator';
+import {
+  mockData,
+  mockDataFirstItem,
+  mockDataLastItem,
+} from '../../utils/__mocks__/db';
+import db from '../../utils/db';
+
+jest.mock('../../utils/db');
+
+beforeEach(() => {
+  db.select.mockClear();
+});
+
+const FILE = 'Services/pagination/LengthAwarePaginator';
+
+describe('test LengthAwarePaginator instantiate', () => {
+  it('should not throw exception when instantiating', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        total: 30,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(5);
+    expect(paginator.currentPage()).toEqual(1);
+    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
+    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
+    expect(paginator.perPage()).toEqual(5);
+    expect(await paginator.total()).toEqual(30);
+  });
+  it('should not throw exception when instantiating with current page', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 2,
+        total: 30,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(5);
+    expect(paginator.currentPage()).toEqual(2);
+    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
+    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
+    expect(paginator.perPage()).toEqual(5);
+    expect(await paginator.total()).toEqual(30);
+  });
+  it('should default perPage to 10 when instantiating without perPage', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        total: 30,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(10);
+    expect(paginator.currentPage()).toEqual(1);
+    expect(paginator.perPage()).toEqual(10);
+    expect(await paginator.total()).toEqual(30);
+  });
+  it('should throw exception if total is not a number', async () => {
+    try {
+      expect(
+        new LengthAwarePaginator(
+          db,
+          'SELECT * FROM tests',
+          {},
+          {
+            perPage: 5,
+            currentPage: 1,
+            total: 'test',
+          }
+        )
+      ).toThrow();
+    } catch (err) {
+      expect(err.name).toEqual('LesgoException');
+      expect(err.message).toEqual(
+        "Invalid type for 'total', expecting 'number'"
+      );
+      expect(err.code).toEqual(`${FILE}::FIELD_VALIDATION_EXCEPTION`);
+      expect(err.statusCode).toEqual(500);
+    }
+  });
+  it('should return the object version of the paginator', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 5,
+        total: 30,
+      }
+    );
+    expect(await paginator.toObject()).toMatchObject({
+      count: 5,
+      previous_page: false,
+      current_page: 1,
+      next_page: 2,
+      per_page: 5,
+      last_page: 6,
+      total: 30,
+      items: [
+        { ...mockDataFirstItem },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockDataLastItem },
+      ],
+    });
+  });
+});
+
+describe('test total() usage', () => {
+  it('should get total number of data using supplied paramater', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 10,
+        currentPage: 1,
+        total: 30,
+      }
+    );
+
+    expect(await paginator.total()).toEqual(30);
+    expect(db.select).not.toHaveBeenCalled();
+  });
+});
+
+describe('test lastPage() usage', () => {
+  it('should get the last page using supplied paramater as total data', async () => {
+    const paginator1 = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 10,
+        currentPage: 1,
+        total: 30,
+      }
+    );
+    expect(await paginator1.lastPage()).toEqual(3);
+
+    const paginator2 = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 1,
+        total: 30,
+      }
+    );
+    expect(await paginator2.lastPage()).toEqual(6);
+
+    const paginator3 = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 7,
+        currentPage: 1,
+        total: 30,
+      }
+    );
+    expect(await paginator3.lastPage()).toEqual(5);
+
+    expect(db.select).not.toHaveBeenCalled();
+  });
+});

package/src/services/__tests__/Paginator.spec.js

@@ -0,0 +1,383 @@
+import Paginator from '../pagination/Paginator';
+import {
+  mockData,
+  mockDataFirstItem,
+  mockDataLastItem,
+} from '../../utils/__mocks__/db';
+import db from '../../utils/db';
+
+jest.mock('../../utils/db');
+
+beforeEach(() => {
+  db.select.mockClear();
+});
+
+const FILE = 'Services/pagination/Paginator';
+
+describe('test Paginator instantiate', () => {
+  it.each`
+    currentPage  | perPage      | expectedCount | firstItem            | lastItem
+    ${undefined} | ${undefined} | ${10}         | ${mockData}          | ${mockData}
+    ${undefined} | ${5}         | ${5}          | ${mockDataFirstItem} | ${mockDataLastItem}
+  `(
+    'should not throw exception if page is $page and perPage is $perPage',
+    async ({ currentPage, perPage, expectedCount, firstItem, lastItem }) => {
+      const paginator = new Paginator(
+        db,
+        'SELECT * FROM tests',
+        {},
+        {
+          perPage,
+          currentPage,
+        }
+      );
+
+      expect(await paginator.count()).toEqual(expectedCount);
+      expect(paginator.currentPage()).toEqual(1);
+      expect(await paginator.firstItem()).toMatchObject(firstItem);
+      expect(await paginator.lastItem()).toMatchObject(lastItem);
+      expect(paginator.perPage()).toEqual(expectedCount);
+      expect(await paginator.total()).toEqual(10);
+    }
+  );
+
+  it('should be instantiated without options', async () => {
+    const paginator = new Paginator(db, 'SELECT * FROM tests', {});
+
+    expect(await paginator.count()).toEqual(10);
+    expect(paginator.currentPage()).toEqual(1);
+    expect(await paginator.firstItem()).toMatchObject(mockData);
+    expect(await paginator.lastItem()).toMatchObject(mockData);
+    expect(paginator.perPage()).toEqual(10);
+    expect(await paginator.total()).toEqual(10);
+  });
+
+  it.each`
+    currentPage | perPage     | errorName           | errorMessage                                            | errorCode                                | errorStatusCode
+    ${'sample'} | ${10}       | ${'LesgoException'} | ${"Invalid type for 'currentPage', expecting 'number'"} | ${`${FILE}::FIELD_VALIDATION_EXCEPTION`} | ${500}
+    ${1}        | ${'sample'} | ${'LesgoException'} | ${"Invalid type for 'perPage', expecting 'number'"}     | ${`${FILE}::FIELD_VALIDATION_EXCEPTION`} | ${500}
+  `(
+    'should throw $errorMessage when page is $page and perPage is $perPage',
+    ({
+      currentPage,
+      perPage,
+      errorName,
+      errorMessage,
+      errorCode,
+      errorStatusCode,
+    }) => {
+      try {
+        const values = new Paginator(
+          db,
+          'SELECT * FROM tests',
+          {},
+          {
+            perPage,
+            currentPage,
+          }
+        );
+        expect(values).toThrow();
+      } catch (err) {
+        expect(err.name).toEqual(errorName);
+        expect(err.message).toEqual(errorMessage);
+        expect(err.code).toEqual(errorCode);
+        expect(err.statusCode).toEqual(errorStatusCode);
+      }
+    }
+  );
+
+  it('should return the first item of the result', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
+  });
+  it('should return the last item of the result', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
+  });
+  it('should return the defined per page', () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(paginator.perPage()).toEqual(5);
+  });
+  it('should return the previous page if exist', () => {
+    const paginator1 = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 2,
+      }
+    );
+    expect(paginator1.previousPage()).toEqual(1);
+
+    const paginator2 = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 1,
+      }
+    );
+    expect(paginator2.previousPage()).toEqual(false);
+  });
+  it('should return the next page if exist', async () => {
+    const paginator1 = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+    expect(await paginator1.nextPage()).toEqual(2);
+
+    const paginator2 = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 2,
+      }
+    );
+    expect(await paginator2.nextPage()).toEqual(3);
+
+    const paginator3 = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 3,
+      }
+    );
+    expect(await paginator3.nextPage()).toEqual(false);
+  });
+});
+
+describe('test count() usage', () => {
+  it('should count number of items of the current page', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(5);
+  });
+  it('should only run executeQuery once', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    await paginator.count();
+    await paginator.count();
+    await paginator.count();
+    await paginator.count();
+    await paginator.count();
+
+    expect(db.select).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('test currentPage() usage', () => {
+  it('should return 1 as current page if no currentPage is defined', () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(paginator.currentPage()).toEqual(1);
+  });
+  it('should return the defined current page on instantiation', () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 2,
+      }
+    );
+
+    expect(paginator.currentPage()).toEqual(2);
+  });
+});
+
+describe('test items() usage', () => {
+  it('should return all results from the current page', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(await paginator.items()).toMatchObject([
+      { ...mockDataFirstItem },
+      { ...mockData },
+      { ...mockData },
+      { ...mockData },
+      { ...mockDataLastItem },
+    ]);
+  });
+
+  it('should only run executeQuery once', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    await paginator.items();
+    await paginator.items();
+    await paginator.items();
+    await paginator.items();
+
+    expect(db.select).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('test toObject() usage', () => {
+  it('should return object version of the paginator', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    expect(await paginator.toObject()).toMatchObject({
+      count: 5,
+      previous_page: false,
+      current_page: 1,
+      next_page: 2,
+      last_page: 2,
+      per_page: 5,
+      total: 10,
+      items: [
+        { ...mockDataFirstItem },
+        { ...mockData },
+        { ...mockData },
+        { ...mockData },
+        { ...mockDataLastItem },
+      ],
+    });
+  });
+
+  it('should only run executeQuery twice', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+      }
+    );
+
+    await paginator.toObject();
+    await paginator.toObject();
+    await paginator.toObject();
+    await paginator.toObject();
+
+    expect(db.select).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('test total() usage', () => {
+  it('should get total number of data using default countTotalItems method', async () => {
+    const paginator = new Paginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        currentPage: 1,
+      }
+    );
+
+    expect(await paginator.total()).toEqual(30);
+    expect(db.select).toHaveBeenCalled();
+  });
+});
+
+describe('test lastPage() usage', () => {
+  it('should get the last page using default countTotalItems method when getting total data', async () => {
+    const paginator1 = new Paginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        currentPage: 1,
+      }
+    );
+    expect(await paginator1.lastPage()).toEqual(3);
+
+    const paginator2 = new Paginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 1,
+      }
+    );
+    expect(await paginator2.lastPage()).toEqual(6);
+
+    const paginator3 = new Paginator(
+      db,
+      'SELECT * FROM total_tests',
+      {},
+      {
+        perPage: 7,
+        currentPage: 1,
+      }
+    );
+    expect(await paginator3.lastPage()).toEqual(5);
+
+    expect(db.select).toHaveBeenCalled();
+  });
+});

package/src/services/pagination/LengthAwarePaginator.js

@@ -0,0 +1,49 @@
+import Paginator from './Paginator';
+import LesgoException from '../../exceptions/LesgoException';
+import validateFields from '../../utils/validateFields';
+
+const FILE = 'Services/pagination/LengthAwarePaginator';
+
+export default class LengthAwarePaginator extends Paginator {
+  /**
+   * Constructor
+   *
+   * @param db
+   * @param sql
+   * @param sqlParams
+   * @param options
+   * @param connection
+   */
+  constructor(db, sql, sqlParams, options, connection = {}) {
+    const validFields = [{ key: 'total', type: 'number', required: true }];
+
+    let validated = {};
+    try {
+      validated = validateFields(options, validFields);
+    } catch (error) {
+      throw new LesgoException(
+        error.message,
+        `${FILE}::FIELD_VALIDATION_EXCEPTION`,
+        500,
+        {
+          ...options,
+          error,
+        }
+      );
+    }
+
+    const { total } = validated;
+
+    super(db, sql, sqlParams, options, connection);
+    this.totalProp = total;
+  }
+
+  /**
+   * Total items in all pages.
+   *
+   * @returns {null|number}
+   */
+  async total() {
+    return this.totalProp;
+  }
+}