lesgo 0.7.6 → 0.7.8

package/src/middlewares/httpNoOutputMiddleware.js

@@ -0,0 +1,87 @@
+import app from 'Config/app'; // eslint-disable-line import/no-unresolved
+import { normalizeHttpRequestBeforeHandler } from './normalizeHttpRequestMiddleware';
+import { successHttpResponseHandler } from './successHttpResponseMiddleware';
+import { errorHttpResponseHandler } from './errorHttpResponseMiddleware';
+
+const successHttpNoOutputResponseHandler = async opts => {
+  const { queryStringParameters } = opts.event;
+  const debug =
+    queryStringParameters && queryStringParameters.debug && app.debug;
+  const response = await successHttpResponseHandler(opts);
+
+  /* istanbul ignore next */
+  if (!debug && !opts.allowResponse(opts)) {
+    response.body = null;
+  }
+
+  return response;
+};
+
+export const successHttpNoOutputResponseAfterHandler = async (
+  handler,
+  next,
+  opts
+) => {
+  const defaults = {
+    response: handler.response,
+    event: handler.event,
+    allowResponse: () => false,
+  };
+  const options = { ...defaults, ...opts };
+
+  // eslint-disable-next-line no-param-reassign
+  handler.response = await successHttpNoOutputResponseHandler(options);
+
+  /* istanbul ignore next */
+  next();
+};
+
+const errorHttpResponseNoOutputHandler = async opts => {
+  const { queryStringParameters } = opts.event;
+  const debug =
+    queryStringParameters && queryStringParameters.debug && app.debug;
+  const response = await errorHttpResponseHandler({
+    ...opts,
+    debugMode: opts.debugMode || debug,
+  });
+
+  if (!debug && !opts.allowResponse(opts)) {
+    response.statusCode = 200;
+    response.body = null;
+  }
+
+  return response;
+};
+
+export const errorHttpNoOutputResponseAfterHandler = async (
+  handler,
+  next,
+  opts
+) => {
+  const defaults = {
+    error: handler.error,
+    event: handler.event,
+    logger: console.error, // eslint-disable-line no-console
+    allowResponse: () => false,
+  };
+
+  const options = { ...defaults, ...opts };
+
+  // eslint-disable-next-line no-param-reassign
+  handler.response = await errorHttpResponseNoOutputHandler(options);
+  /* istanbul ignore next */
+  next();
+};
+
+/* istanbul ignore next */
+const httpNoOutputMiddleware = opts => {
+  return {
+    before: (handler, next) => normalizeHttpRequestBeforeHandler(handler, next),
+    after: (handler, next) =>
+      successHttpNoOutputResponseAfterHandler(handler, next, opts),
+    onError: (handler, next) =>
+      errorHttpNoOutputResponseAfterHandler(handler, next, opts),
+  };
+};
+
+export default httpNoOutputMiddleware;

package/src/middlewares/normalizeHttpRequestMiddleware.js

@@ -91,7 +91,8 @@ export const normalizeHttpRequestBeforeHandler = (handler, next) => {
  * Normalizes handler.event.body and handler.event.queryStringParameters
  * as handler.event.input Object
  */
-const normalizeHttpRequestMiddleware /* istanbul ignore next */ = () => {
+/* istanbul ignore next */
+const normalizeHttpRequestMiddleware = () => {
   return {
     before: (handler, next) => normalizeHttpRequestBeforeHandler(handler, next),
   };

package/src/middlewares/normalizeSQSMessageMiddleware.js

@@ -1,4 +1,7 @@
 import logger from '../utils/logger';
+import isEmpty from '../utils/isEmpty';
+
+const FILE = 'Lesgo/middlewares/normalizeSQSMessageMiddleware';
 
 export const normalizeHandler = records => {
   let recordCount = 0;
@@ -20,11 +23,29 @@ export const normalizeHandler = records => {
   }));
 };
 
+export const disconnectConnections = async opts => {
+  try {
+    const disconnect = [];
+    if (opts) {
+      if (!isEmpty(opts.cache)) disconnect.push(opts.cache.end());
+      if (!isEmpty(opts.db)) disconnect.push(opts.db.end());
+      if (!isEmpty(opts.dbRead)) disconnect.push(opts.dbRead.end());
+    }
+
+    if (disconnect.length > 0) {
+      await Promise.all(disconnect);
+    }
+  } catch (err) {
+    logger.error(`${FILE}::Failed to end connection`, err);
+  }
+};
+
 /**
  * Normalizes handler.event.Records as handler.event.collections Object.
  * This type of request is received by SQS listeners
  */
-const normalizeSQSMessageMiddleware /* istanbul ignore next */ = () => {
+/* istanbul ignore next */
+const normalizeSQSMessageMiddleware /* istanbul ignore next */ = opts => {
   return {
     before: (handler, next) => {
       const { Records } = handler.event;
@@ -32,6 +53,14 @@ const normalizeSQSMessageMiddleware /* istanbul ignore next */ = () => {
       handler.event.collection = normalizeHandler(Records);
       next();
     },
+    after: async (handler, next) => {
+      await disconnectConnections(opts);
+      next();
+    },
+    onError: async (handler, next) => {
+      await disconnectConnections(opts);
+      next();
+    },
   };
 };
 

package/src/middlewares/serverAuthMiddleware.js

@@ -0,0 +1,29 @@
+import { verifyBasicAuthBeforeHandler } from './basicAuthMiddleware';
+import { verifyJwtMiddlewareBeforeHandler } from './verifyJwtMiddleware';
+import { errorHttpResponseAfterHandler } from './errorHttpResponseMiddleware';
+
+export const serverAuthBeforeHandler = (handler, next, opts) => {
+  try {
+    return verifyBasicAuthBeforeHandler(handler, next, opts);
+  } catch (e) {
+    if (
+      e.code !==
+        `Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE` &&
+      e.code !==
+        `Middlewares/basicAuthMiddleware::AUTHORIZATION_HEADER_NOT_FOUND`
+    )
+      throw e;
+  }
+
+  return verifyJwtMiddlewareBeforeHandler(handler, next, opts);
+};
+
+/* istanbul ignore next */
+const serverAuthMiddleware = opts => {
+  return {
+    before: (handler, next) => serverAuthBeforeHandler(handler, next, opts),
+    onError: (handler, next) => errorHttpResponseAfterHandler(handler, next),
+  };
+};
+
+export default serverAuthMiddleware;

package/src/middlewares/successHttpResponseMiddleware.js

@@ -1,5 +1,8 @@
 import gzipHttpResponse from './gzipHttpResponse';
 import isEmpty from '../utils/isEmpty';
+import logger from '../utils/logger';
+
+const FILE = 'Lesgo/middlewares/successHttpResponseMiddleware';
 
 export const successHttpResponseHandler = async opts => {
   const defaults = {
@@ -25,9 +28,16 @@ export const successHttpResponseHandler = async opts => {
   const options = { ...defaults, ...optionsHeadersMerged };
 
   try {
-    if (!isEmpty(opts.db)) await opts.db.end();
+    const disconnect = [];
+    if (!isEmpty(opts.cache)) disconnect.push(opts.cache.end());
+    if (!isEmpty(opts.db)) disconnect.push(opts.db.end());
+    if (!isEmpty(opts.dbRead)) disconnect.push(opts.dbRead.end());
+
+    if (disconnect.length > 0) {
+      await Promise.all(disconnect);
+    }
   } catch (err) {
-    // do nothing
+    logger.error(`${FILE}::Failed to end connection`, err);
   }
 
   return {

package/src/middlewares/verifyJwtMiddleware.js

@@ -26,11 +26,16 @@ export const token = headers => {
   return parsed[1];
 };
 
-export const verifyJwtMiddlewareBeforeHandler = (handler, next) => {
+export const verifyJwtMiddlewareBeforeHandler = (handler, next, opts) => {
   const { headers } = handler.event;
 
+  const finalConfig =
+    typeof opts !== 'undefined' && 'jwtConfig' in opts
+      ? opts.jwtConfig
+      : config;
+
   try {
-    const service = new JwtService(token(headers), config);
+    const service = new JwtService(token(headers), finalConfig);
 
     // eslint-disable-next-line no-param-reassign
     handler.event.decodedJwt = service.validate().decoded;
@@ -47,9 +52,10 @@ export const verifyJwtMiddlewareBeforeHandler = (handler, next) => {
   }
 };
 
-const verifyJwtMiddleware /* istanbul ignore next */ = () => {
+const verifyJwtMiddleware /* istanbul ignore next */ = opts => {
   return {
-    before: (handler, next) => verifyJwtMiddlewareBeforeHandler(handler, next),
+    before: (handler, next) =>
+      verifyJwtMiddlewareBeforeHandler(handler, next, opts),
   };
 };
 

package/src/services/AuroraDbRDSProxyService.js

@@ -13,14 +13,13 @@ const FILE = 'Lesgo/services/AuroraDbRDSProxyService';
  */
 export default class AuroraDbRDSProxyService {
   constructor(opts = {}) {
-    const { host, user, password, database, persists } = opts;
+    const { host, user, password, database } = opts;
 
     this.clientOpts = {
       host,
       user,
       password,
       database,
-      persists,
     };
 
     this.conn = {};
@@ -48,7 +47,7 @@ export default class AuroraDbRDSProxyService {
         : this.clientOpts.database,
     };
 
-    const persistentConn = connectionOpts.persists || this.clientOpts.persists;
+    const persistentConn = connectionOpts.persists;
 
     logger.debug(`${FILE}::PREPARING DB CONNECTION`, {
       clientOpts,

package/src/services/ElastiCacheService.js

@@ -1,12 +1,12 @@
-import Memcached from 'memcached-elasticache';
+import MemcachePlus from 'memcache-plus';
 
 export default class ElastiCacheService {
-  constructor({ url, options }) {
+  constructor(options) {
     // @TODO:
     // - determine the driver used 'memcached' or 'redis'
     // - add switch-case that will set the driver
 
-    this.setDriver(new Memcached(url, options));
+    this.setDriver(new MemcachePlus(options));
   }
 
   setDriver(driver) {

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

@@ -28,6 +28,39 @@ describe('ServicesGroup: test ElasticsearchService', () => {
     });
   });
 
+  it('test msearch', () => {
+    const es = new ElasticsearchService(config.adapters.aws);
+    const params = [
+      { index: config.adapters.aws.index },
+      {
+        query: {
+          bool: {
+            must: { id: 123 },
+            must_not: { is_deleted: 1 },
+          },
+        },
+      },
+    ];
+
+    return expect(es.msearch(params)).resolves.toMatchObject({
+      mocked: {
+        params: {
+          body: [
+            { index: config.adapters.aws.index },
+            {
+              query: {
+                bool: {
+                  must: { id: 123 },
+                  must_not: { is_deleted: 1 },
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+  });
+
   it('test get', () => {
     const es = new ElasticsearchService(config.adapters.aws);
     return expect(es.get(1)).resolves.toMatchObject({

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

@@ -1,59 +1,85 @@
+import config from 'Config/cache'; // eslint-disable-line import/no-unresolved
+
 import cache from '../cache';
+import isEmpty from '../isEmpty';
 
-describe('UtilsGroup: test cache utils', () => {
-  const cacheKey = 'cacheKey';
-  const cacheTime = 10;
-  const cacheData = {
-    someData: [
-      {
-        someDataKey1: 'someDataValue1',
-      },
-      {
-        someDataKey2: 'someDataValue2',
-      },
-    ],
-  };
+export const cacheKey = 'cacheKey';
+export const cacheKey2 = 'cacheKey2';
+export const cacheTime = 10;
+export const cacheData = {
+  someData: [
+    {
+      someDataKey1: 'someDataValue1',
+    },
+    {
+      someDataKey2: 'someDataValue2',
+    },
+  ],
+};
+export const cacheData2 = 'someValue2';
 
+describe('UtilsGroup: test cache utils', () => {
   it('test cache utils', async () => {
-    await expect(cache.set(cacheKey, cacheData, cacheTime)).resolves.toEqual(
-      true
-    );
+    await expect(cache.set(cacheKey, cacheData, cacheTime)).resolves.toBe();
+    await expect(cache.set(cacheKey2, cacheData2, cacheTime)).resolves.toBe();
 
-    await expect(cache.get(cacheKey)).resolves.toMatchObject({
-      data: cacheData,
-      lifetime: cacheTime,
-    });
+    await expect(cache.get(cacheKey)).resolves.toMatchObject(cacheData);
+    await expect(cache.getMulti([cacheKey, cacheKey2])).resolves.toMatchObject([
+      cacheData,
+      cacheData2,
+    ]);
+
+    await expect(cache.del(cacheKey)).resolves.toBe();
+    await expect(cache.delMulti([cacheKey, cacheKey2])).resolves.toBe();
 
-    await expect(cache.del(cacheKey)).resolves.toEqual(true);
+    await expect(cache.end()).resolves.toBe();
+    await expect(cache.disconnect()).resolves.toBe();
   });
 
-  it('test setting cache with error', async () => {
-    await expect(
-      cache.set('mockError', cacheData, cacheTime)
-    ).rejects.toMatchObject({
-      code: 'CACHE_SET_ERROR',
-      message: 'mockedError',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
+  it('test connect using legacy config', async () => {
+    config.connections.memcached = {
+      ...config.connections.memcached,
+      url: 'localhost',
+    };
+
+    await cache.pConnect('memcached');
+    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
   });
 
-  it('test getting cache with error', async () => {
-    await expect(cache.get('mockError')).rejects.toMatchObject({
-      code: 'CACHE_GET_ERROR',
-      message: 'mockedError',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
+  it('test pConnect', async () => {
+    await cache.pConnect('memcached');
+    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
   });
 
-  it('test deleting cache with error', async () => {
-    await expect(cache.del('mockError')).rejects.toMatchObject({
-      code: 'CACHE_DEL_ERROR',
-      message: 'mockedError',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
+  it('test pConnect without connectionName to default', async () => {
+    await cache.pConnect();
+    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
+  });
+
+  it('test disconnecting with pConnect', async () => {
+    await cache.pConnect('memcached');
+
+    await expect(cache.end()).resolves.toBe();
+    expect(isEmpty(Object.keys(cache.singleton))).toEqual(true);
+  });
+
+  it('test cache utils with pConnect', async () => {
+    await cache.pConnect('memcached');
+
+    await expect(cache.set(cacheKey, cacheData, cacheTime)).resolves.toBe();
+    await expect(cache.set(cacheKey2, cacheData2, cacheTime)).resolves.toBe();
+
+    await expect(cache.get(cacheKey)).resolves.toMatchObject(cacheData);
+    await expect(cache.getMulti([cacheKey, cacheKey2])).resolves.toMatchObject([
+      cacheData,
+      cacheData2,
+    ]);
+
+    await expect(cache.del(cacheKey)).resolves.toBe();
+    await expect(cache.delMulti([cacheKey, cacheKey2])).resolves.toBe();
+
+    await expect(cache.end()).resolves.toBe();
+    await expect(cache.disconnect()).resolves.toBe();
   });
 
   it('test setting cache with exception', async () => {
@@ -76,6 +102,15 @@ describe('UtilsGroup: test cache utils', () => {
     });
   });
 
+  it('test getting multiple cache with exception', async () => {
+    await expect(cache.getMulti(['mockException'])).rejects.toMatchObject({
+      code: 'CACHE_GET_MULTI_EXCEPTION',
+      message: 'mockedException',
+      name: 'LesgoException',
+      statusCode: 500,
+    });
+  });
+
   it('test deleting cache with exception', async () => {
     await expect(cache.del('mockException')).rejects.toMatchObject({
       code: 'CACHE_DEL_EXCEPTION',
@@ -84,4 +119,13 @@ describe('UtilsGroup: test cache utils', () => {
       statusCode: 500,
     });
   });
+
+  it('test deleting multiple cache with exception', async () => {
+    await expect(cache.delMulti(['mockException'])).rejects.toMatchObject({
+      code: 'CACHE_DEL_MULTI_EXCEPTION',
+      message: 'mockedException',
+      name: 'LesgoException',
+      statusCode: 500,
+    });
+  });
 });

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

@@ -65,7 +65,6 @@ describe('test db utils instantiate', () => {
       host: config.connections.rdsProxy.host,
       user: config.connections.rdsProxy.user,
       password: config.connections.rdsProxy.password,
-      persists: config.connections.rdsProxy.persists,
     });
   });
 });