lesgo 0.7.1 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "0.7.1",
+  "version": "0.7.5",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./src/index.js",
   "author": "Sufiyan Rahmat",
@@ -51,7 +51,7 @@
     "prettier": "^1.18.2"
   },
   "dependencies": {
-    "@elastic/elasticsearch": "^7.4.0",
+    "@elastic/elasticsearch": "^7.16.0",
     "@firebase/app": "^0.6.12",
     "data-api-client": "^1.1.0",
     "firebase-admin": "^9.3.0",

package/src/middlewares/__tests__/errorHttpResponseMiddleware.spec.js

@@ -21,7 +21,7 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('status', 'error');
     expect(dataBody).toHaveProperty('data', null);
     expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNKNOWN_ERROR');
+    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
     expect(dataBody).toHaveProperty(
       'error.message',
       'Error: Test validation error'
@@ -78,7 +78,7 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
 
     expect(data.statusCode).toBe(500);
 
-    expect(dataBody).toHaveProperty('error.code', 'UNKNOWN_ERROR');
+    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
     expect(dataBody).toHaveProperty('error.message', 'Test error message');
     expect(dataBody).toHaveProperty('error.details', '');
   });
@@ -126,7 +126,7 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('status', 'error');
     expect(dataBody).toHaveProperty('data', null);
     expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNKNOWN_ERROR');
+    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
     expect(dataBody).toHaveProperty('error.message', '');
     expect(dataBody).toHaveProperty('error.details', '');
   });

package/src/middlewares/__tests__/normalizeHttpRequestMiddleware.spec.js

@@ -102,7 +102,6 @@ describe('MiddlewareGroup: test normalizeHttpRequestBeforeHandler', () => {
     };
 
     normalizeHttpRequestBeforeHandler(handler, () => {});
-    expect(handler.event.requestContext.requestId).toBe('requestId');
   });
 
   it('should return auth.sub if Authorization exists', () => {
@@ -119,6 +118,44 @@ describe('MiddlewareGroup: test normalizeHttpRequestBeforeHandler', () => {
     expect(handler.event.auth.sub).toBe('f2b5349d-f5e3-44f5-9c08-ae6b01e95434');
   });
 
+  it.each`
+    version  | tags
+    ${'1.0'} | ${{ path: '/v1/path', httpMethod: 'GET' }}
+    ${'2.0'} | ${{ path: '/v2/path', httpMethod: 'POST' }}
+    ${'3.0'} | ${{ path: '/v2/path', httpMethod: 'POST' }}
+  `(
+    'should identify path and httpMethod based on version',
+    ({ version, tags }) => {
+      const handler = {
+        event: {
+          version,
+          headers: {},
+          ...tags,
+          requestContext: {
+            http: {
+              ...tags,
+              method: tags.httpMethod,
+            },
+          },
+        },
+      };
+      normalizeHttpRequestBeforeHandler(handler, () => {});
+      expect(logger.meta.tags).toStrictEqual(tags);
+    }
+  );
+
+  it('should not set tags when using API Gateway v2 and requestContext is empty', () => {
+    const handler = {
+      event: {
+        version: '2.0',
+        headers: {},
+      },
+    };
+
+    normalizeHttpRequestBeforeHandler(handler, () => {});
+    expect(logger.meta.tags).toStrictEqual({});
+  });
+
   it('should not set meta on debug', () => {
     app.debug = true;
     const handler = {
@@ -133,6 +170,7 @@ describe('MiddlewareGroup: test normalizeHttpRequestBeforeHandler', () => {
         },
       },
     };
+
     normalizeHttpRequestBeforeHandler(handler, () => {});
     expect(logger.meta.auth).toBe(handler.event.auth);
     expect(logger.meta.queryStringParameters).toStrictEqual(

package/src/middlewares/errorHttpResponseMiddleware.js

@@ -1,6 +1,8 @@
 import logger from '../utils/logger';
 import isEmpty from '../utils/isEmpty';
 
+const FILE = 'Lesgo/middlewares/errorHttpResponseMiddleware';
+
 export const errorHttpResponseHandler = async opts => {
   const defaults = {
     response: '',
@@ -29,7 +31,7 @@ export const errorHttpResponseHandler = async opts => {
     status: 'error',
     data: null,
     error: {
-      code: options.error.code || 'UNKNOWN_ERROR',
+      code: options.error.code || 'UNHANDLED_ERROR',
       message: options.error.name
         ? `${options.error.name}: ${options.error.message}`
         : options.error.message || options.error,
@@ -40,18 +42,18 @@ export const errorHttpResponseHandler = async opts => {
 
   const statusCode = options.error.statusCode || options.statusCode;
 
-  /* istanbul ignore next */
-  if (statusCode === 500) {
-    // this is likely an unhandled exception, log it
-    logger.error(options.error);
+  if (!isEmpty(options.error)) {
+    logger.log(statusCode === 500 ? 'error' : 'warn', options.error);
   } else {
-    logger.warn(options.error);
+    logger.log(statusCode === 500 ? 'error' : 'warn', jsonBody.error.message, {
+      error: jsonBody.error,
+    });
   }
 
   try {
     if (!isEmpty(opts.db)) await opts.db.end();
   } catch (err) {
-    // do nothing
+    logger.error(`${FILE}::Failed to end db connection`, err);
   }
 
   return {

package/src/middlewares/normalizeHttpRequestMiddleware.js

@@ -53,14 +53,26 @@ export const normalizeHttpRequestBeforeHandler = (handler, next) => {
   // eslint-disable-next-line no-param-reassign
   handler.event.auth = auth;
 
+  const tags = {};
+  switch (handler.event.version) {
+    case '2.0': {
+      if (handler.event.requestContext && handler.event.requestContext.http) {
+        tags.path = handler.event.requestContext.http.path;
+        tags.httpMethod = handler.event.requestContext.http.method;
+      }
+      break;
+    }
+    default:
+      tags.path = handler.event.path;
+      tags.httpMethod = handler.event.httpMethod;
+      break;
+  }
+
   logger.addMeta({
     requestId: handler.event.requestContext
       ? handler.event.requestContext.requestId
       : null,
-    tags: {
-      path: handler.event.path,
-      httpMethod: handler.event.httpMethod,
-    },
+    tags,
   });
 
   if (app.debug) {

package/src/services/ElasticsearchService.js

@@ -38,24 +38,18 @@ class ElasticsearchService {
     return this.client;
   }
 
-  search(body) {
-    return new Promise((resolve, reject) => {
-      const param = {
-        index: this.index,
-        type: this.type,
-        body,
-      };
-      this.client.search(param, (err, response) => {
-        /* istanbul ignore next */
-        if (err) {
-          reject(err);
-        }
-
-        this.result = response;
-
-        resolve(response);
-      });
-    });
+  async search(body) {
+    const param = {
+      index: this.index,
+      type: this.type,
+      body,
+    };
+
+    const response = await this.client.search(param);
+
+    this.result = response;
+
+    return response;
   }
 
   /**
@@ -75,12 +69,7 @@ class ElasticsearchService {
       body: settings,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.indices.create(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.indices.create(params);
   }
 
   deleteIndices(index, options = {}) {
@@ -89,32 +78,20 @@ class ElasticsearchService {
       ...options,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.indices.delete(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.indices.delete(params);
   }
 
-  existIndices(index, options = {}) {
+  async existIndices(index, options = {}) {
     const params = { index, ...options };
-    return new Promise((resolve, reject) => {
-      this.client.indices.exists(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response.body);
-      });
-    });
+
+    const response = await this.client.indices.exists(params);
+    return response.body;
   }
 
   putMapping(index, type, body) {
     const params = { index, type, body: { properties: body } };
-    return new Promise((resolve, reject) => {
-      this.client.indices.putMapping(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+
+    return this.client.indices.putMapping(params);
   }
 
   get(id) {
@@ -124,12 +101,7 @@ class ElasticsearchService {
       id,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.get(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.get(params);
   }
 
   indexOrCreateById(body, refresh = false) {
@@ -141,24 +113,11 @@ class ElasticsearchService {
       refresh,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.index(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.index(params);
   }
 
   bulkIndex(bodies) {
-    return new Promise((resolve, reject) => {
-      this.client.bulk(
-        { body: this.constructBulkIndex(bodies) },
-        (err, response) => {
-          // eslint-disable-next-line no-unused-expressions
-          err ? /* istanbul ignore next */ reject(err) : resolve(response);
-        }
-      );
-    });
+    return this.client.bulk({ body: this.constructBulkIndex(bodies) });
   }
 
   create(id, body) {
@@ -169,12 +128,7 @@ class ElasticsearchService {
       body,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.index(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.index(params);
   }
 
   updateById(id) {
@@ -184,12 +138,7 @@ class ElasticsearchService {
       id,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.get(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
-    });
+    return this.client.get(params);
   }
 
   /**

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

@@ -32,6 +32,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
     expect(paginator.perPage()).toEqual(5);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should not throw exception when instantiating with current page', async () => {
     const paginator = new LengthAwarePaginator(
@@ -51,6 +53,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
     expect(paginator.perPage()).toEqual(5);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should default perPage to 10 when instantiating without perPage', async () => {
     const paginator = new LengthAwarePaginator(
@@ -66,6 +70,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(paginator.currentPage()).toEqual(1);
     expect(paginator.perPage()).toEqual(10);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should throw exception if total is not a number', async () => {
     try {
@@ -116,6 +122,43 @@ describe('test LengthAwarePaginator instantiate', () => {
         { ...mockDataLastItem },
       ],
     });
+
+    expect(db.select).toHaveBeenCalled();
+  });
+
+  it('should simply return an empty paginator object if total is explicitly zero', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 1,
+        total: 0,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(0);
+    expect(await paginator.previousPage()).toEqual(false);
+    expect(paginator.currentPage()).toEqual(1);
+    expect(await paginator.nextPage()).toEqual(false);
+    expect(await paginator.firstItem()).toBe(undefined);
+    expect(await paginator.lastItem()).toBe(undefined);
+    expect(paginator.perPage()).toEqual(5);
+    expect(await paginator.total()).toEqual(0);
+
+    expect(await paginator.toObject()).toMatchObject({
+      count: 0,
+      previous_page: false,
+      current_page: 1,
+      next_page: false,
+      per_page: 5,
+      last_page: 0,
+      total: 0,
+      items: [],
+    });
+
+    expect(db.select).not.toHaveBeenCalled();
   });
 });
 
@@ -138,7 +181,7 @@ describe('test total() usage', () => {
 });
 
 describe('test lastPage() usage', () => {
-  it('should get the last page using supplied paramater as total data', async () => {
+  it('should get the last page using supplied parameter as total data', async () => {
     const paginator1 = new LengthAwarePaginator(
       db,
       'SELECT * FROM total_tests',

package/src/services/pagination/Paginator.js

@@ -217,11 +217,17 @@ export default class Paginator {
   }
 
   async executeQuery() {
-    this.response = await this.dbProp.select(
-      this.generatePaginationSqlSnippet(),
-      this.sqlParamsProp,
-      this.connection
-    );
+    const total = this.totalProp;
+    if (
+      (typeof total === 'number' && total > 0) ||
+      (typeof total !== 'number' && !total)
+    ) {
+      this.response = await this.dbProp.select(
+        this.generatePaginationSqlSnippet(),
+        this.sqlParamsProp,
+        this.connection
+      );
+    }
 
     this.hasNext = this.response.length > this.perPage();
     if (this.hasNext) {