lesgo 0.7.7 → 0.7.8

package/README.md

@@ -1,6 +1,6 @@
 # Lesgo!
 
-[![Build Status]](https://github.com/reflex-media/lesgo-framework/actions/workflows/release.yml/badge.svg)
+![Build Status](https://github.com/reflex-media/lesgo-framework/actions/workflows/release.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/reflex-media/lesgo-framework/badge.svg?branch=master)](https://coveralls.io/github/reflex-media/lesgo-framework?branch=master)
 
 Bootstrap your next microservice with a lightweight node.js serverless framework.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./src/index.js",
   "author": "Sufiyan Rahmat",
@@ -30,7 +30,7 @@
     "lesgo-scripts": "./bin/lesgo-scripts.sh"
   },
   "engines": {
-    "node": "12.x"
+    "node": ">=12.0.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.17.6",

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

@@ -0,0 +1,225 @@
+import basicAuthMiddleware, {
+  generateBasicAuthorizationHash,
+  verifyBasicAuthBeforeHandler,
+} from '../basicAuthMiddleware';
+import client from '../../../tests/__mocks__/config/client';
+
+describe('test basicAuthMiddleware middleware', () => {
+  test.each`
+    clientObj
+    ${undefined}
+    ${{}}
+    ${{
+  default: {
+    key: '1111-1111-1111-1111',
+    secret: '1111-1111-1111-1111',
+  },
+}}
+  `('should return object', ({ clientObj }) => {
+    const result = basicAuthMiddleware({
+      client: clientObj,
+    });
+
+    expect(result).toHaveProperty('before');
+    expect(result).toHaveProperty('onError');
+  });
+});
+
+// eslint-disable-next-line
+const next = () => {};
+
+describe('test verifyBasicAuthBeforeHandler error handling', () => {
+  const invalidClientKey = Buffer.from('client_key:secret_key').toString(
+    'base64'
+  );
+  const invalidSecretKey = Buffer.from(
+    `${client.platform_2.key}:secret_key`
+  ).toString('base64');
+
+  test.each`
+    headers                                           | errorName           | errorMessage                                  | errorStatusCode | errorCode                                                               | blacklistMode
+    ${{}}                                             | ${'LesgoException'} | ${'Authorization header not found'}           | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTHORIZATION_HEADER_NOT_FOUND'}    | ${undefined}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${undefined}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${undefined}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{}}                                             | ${'LesgoException'} | ${'Authorization header not found'}           | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTHORIZATION_HEADER_NOT_FOUND'}    | ${true}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${true}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${true}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${false}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${false}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
+  `(
+    'should throw $errorMessage when authorization header is $headers',
+    async ({
+      headers,
+      errorName,
+      errorMessage,
+      errorStatusCode,
+      errorCode,
+      blacklistMode,
+    }) => {
+      const handler = {
+        event: {
+          headers,
+          site: {
+            id: 'platform_1',
+          },
+        },
+      };
+
+      try {
+        expect(
+          verifyBasicAuthBeforeHandler(handler, next, {
+            blacklistMode,
+          })
+        ).toThrow();
+      } catch (error) {
+        expect(error.name).toBe(errorName);
+        expect(error.message).toBe(errorMessage);
+        expect(error.statusCode).toBe(errorStatusCode);
+        expect(error.code).toBe(errorCode);
+      }
+    }
+  );
+});
+
+describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
+  const validBasicAuth = Buffer.from(
+    generateBasicAuthorizationHash(
+      client.platform_2.key,
+      client.platform_2.secret
+    )
+  ).toString('base64');
+
+  test.each`
+    clientObj
+    ${undefined}
+    ${{}}
+    ${{
+  platform_2: {
+    key: '2222-2222-2222-2222',
+    secret: '2222-2222-2222-2222',
+  },
+}}
+  `('should return undefined when successful', ({ clientObj }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        site: {
+          id: 'platform_2',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      verifyBasicAuthBeforeHandler(handler, next, {
+        client: clientObj,
+      });
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBeFalsy();
+  });
+
+  test.each`
+    Authorization                | blacklistMode
+    ${undefined}                 | ${false}
+    ${`basic ${validBasicAuth}`} | ${false}
+    ${`Basic ${validBasicAuth}`} | ${false}
+    ${`basic ${validBasicAuth}`} | ${true}
+    ${`Basic ${validBasicAuth}`} | ${true}
+  `(
+    'test Exception with valid credentials',
+    ({ Authorization, blacklistMode }) => {
+      const handler = {
+        event: {
+          headers: {
+            Authorization,
+          },
+          site: {
+            id: 'platform_2',
+          },
+        },
+      };
+
+      let hasError = false;
+
+      try {
+        verifyBasicAuthBeforeHandler(handler, next, {
+          blacklistMode,
+        });
+      } catch (e) {
+        hasError = true;
+      }
+
+      expect(hasError).toBeFalsy();
+    }
+  );
+
+  test.each`
+    siteObjects
+    ${{}}
+    ${{ site: { id: undefined } }}
+    ${{ requestContext: { site: { id: undefined } } }}
+    ${{ platform: undefined }}
+  `('test Exception with no site ID', ({ siteObjects }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        ...siteObjects,
+      },
+    };
+
+    try {
+      expect(verifyBasicAuthBeforeHandler(handler, next)).toThrow();
+    } catch (error) {
+      expect(error.name).toBe('LesgoException');
+      expect(error.message).toBe('Site ID could not be found');
+      expect(error.statusCode).toBe(403);
+      expect(error.code).toBe(
+        'Middlewares/basicAuthMiddleware::SITE_ID_NOT_FOUND'
+      );
+    }
+  });
+
+  test.each`
+    siteObjects
+    ${{ site: { id: 'platform_2' } }}
+    ${{ requestContext: { site: { id: 'platform_2' } } }}
+    ${{ requestContext: { site: { id: undefined } }, platform: 'platform_2' }}
+    ${{ platform: 'platform_2' }}
+  `('valid site ids', ({ siteObjects }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        ...siteObjects,
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      verifyBasicAuthBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBeFalsy();
+  });
+});

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

@@ -0,0 +1,137 @@
+import clientAuthMiddleware, {
+  clientAuthMiddlewareBeforeHandler,
+} from '../clientAuthMiddleware';
+
+describe('test authMiddleware', () => {
+  test('should return object', async () => {
+    // eslint-disable-next-line no-unused-vars
+    const result = clientAuthMiddleware();
+    expect(result).toHaveProperty('before');
+    expect(result).toHaveProperty('onError');
+  });
+});
+
+const next = () => {};
+
+describe('test clientMiddlewareBeforeHandler', () => {
+  test('should throw LesgoException when invalid api key is provided', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'X-Api-Key': '123',
+        },
+      },
+    };
+
+    try {
+      expect(await clientAuthMiddlewareBeforeHandler(handler, next)).toThrow();
+    } catch (error) {
+      expect(error.name).toBe('LesgoException');
+      expect(error.message).toBe("Missing required 'x-client-id'");
+      expect(error.statusCode).toBe(403);
+      expect(error.code).toBe(
+        'Middlewares/clientAuthMiddleware::INVALID_AUTH_DATA'
+      );
+    }
+  });
+
+  test('should throw LesgoException when x-client-id is incorrect', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'x-client-id': 'notexisting',
+        },
+      },
+    };
+
+    try {
+      expect(await clientAuthMiddlewareBeforeHandler(handler, next)).toThrow();
+    } catch (error) {
+      expect(error.name).toBe('LesgoException');
+      expect(error.message).toBe('Invalid ClientId provided');
+      expect(error.statusCode).toBe(403);
+      expect(error.code).toBe(
+        'Middlewares/clientAuthMiddleware::INVALID_CLIENT_ID'
+      );
+    }
+  });
+
+  test('should return success with valid client id', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'x-client-id': '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should return success with valid client id on input', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should execute passed callback function', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next, h => {
+      // eslint-disable-next-line no-param-reassign
+      h.event.created_obj = 'created_obj';
+    });
+
+    expect(handler.event).toHaveProperty('created_obj');
+  });
+
+  test('should execute passed top object with callback function', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next, {
+      callback: h => {
+        // eslint-disable-next-line no-param-reassign
+        h.event.created_obj = 'created_obj';
+      },
+    });
+
+    expect(handler.event).toHaveProperty('created_obj');
+  });
+});

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

@@ -145,6 +145,36 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
 
     expect(end).toHaveBeenCalledTimes(1);
   });
+
+  it('should call cache.end() whenever a cache options is set', async () => {
+    const end = jest.fn().mockResolvedValue();
+    await errorHttpResponseHandler({
+      error: 'Test error message',
+      event: {
+        someEventKey: 'someEventValue',
+      },
+      cache: {
+        end,
+      },
+    });
+
+    expect(end).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call dbRead.end() whenever a dbRead options is set', async () => {
+    const end = jest.fn().mockResolvedValue();
+    await errorHttpResponseHandler({
+      error: 'Test error message',
+      event: {
+        someEventKey: 'someEventValue',
+      },
+      dbRead: {
+        end,
+      },
+    });
+
+    expect(end).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('MiddlewareGroup: test errorHttpResponseAfterHandler', () => {

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

@@ -0,0 +1,199 @@
+import app from 'Config/app'; // eslint-disable-line import/no-unresolved
+import {
+  successHttpNoOutputResponseAfterHandler,
+  errorHttpNoOutputResponseAfterHandler,
+} from '../httpNoOutputMiddleware';
+
+describe('MiddlewareGroup: test successHttpNoOutputResponseAfterHandler', () => {
+  it('should have no body without debug', async () => {
+    const handler = {
+      response: {},
+      event: {},
+    };
+
+    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      response: 'Some message',
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty('body', null);
+  });
+
+  it('should return the body when debug is enabled via query string parameters', async () => {
+    const handler = {
+      response: {},
+      event: {
+        queryStringParameters: {
+          debug: '1',
+        },
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      response: 'Some message',
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty(
+      'body',
+      JSON.stringify({
+        status: 'success',
+        data: 'Some message',
+        _meta: {},
+      })
+    );
+  });
+
+  it('should have null body even when enabled when configuration has is disabled', async () => {
+    app.debug = false;
+
+    const handler = {
+      response: {},
+      event: {
+        queryStringParameters: {
+          debug: '1',
+        },
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      response: 'Some message',
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty('body', null);
+    app.debug = true;
+  });
+
+  it('should return a response when allowResponse override is passed via options', async () => {
+    app.debug = false;
+
+    const handler = {
+      response: {},
+      event: {
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      response: 'Some message',
+      allowResponse: () => true,
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty(
+      'body',
+      JSON.stringify({
+        status: 'success',
+        data: 'Some message',
+        _meta: {},
+      })
+    );
+
+    app.debug = true;
+  });
+});
+
+describe('MiddlewareGroup: test errorHttpNoOutputResponseAfterHandler', () => {
+  it('should have no body without debug', async () => {
+    const handler = {
+      response: {},
+      event: {},
+    };
+
+    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      error: new Error('Test validation error'),
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty('body', null);
+  });
+
+  it('should return the body when debug is enabled via query string parameters', async () => {
+    const handler = {
+      response: {},
+      event: {
+        queryStringParameters: {
+          debug: '1',
+        },
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      error: new Error('Test validation error'),
+    });
+    expect(handler.response).toHaveProperty('statusCode', 500);
+    expect(handler.response).toHaveProperty(
+      'body',
+      JSON.stringify({
+        status: 'error',
+        data: null,
+        error: {
+          code: 'UNHANDLED_ERROR',
+          message: 'Error: Test validation error',
+          details: '',
+        },
+        _meta: {
+          queryStringParameters: {
+            debug: '1',
+          },
+          someEventKey: 'someEventValue',
+        },
+      })
+    );
+  });
+
+  it('should have null body even when enabled when configuration has is disabled', async () => {
+    app.debug = false;
+
+    const handler = {
+      response: {},
+      event: {
+        queryStringParameters: {
+          debug: '1',
+        },
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      error: new Error('Test validation error'),
+    });
+    expect(handler.response).toHaveProperty('statusCode', 200);
+    expect(handler.response).toHaveProperty('body', null);
+    app.debug = true;
+  });
+
+  it('should return a response when allowResponse override is passed via options', async () => {
+    app.debug = false;
+
+    const handler = {
+      response: {},
+      event: {
+        queryStringParameters: {
+          debug: '1',
+        },
+        someEventKey: 'someEventValue',
+      },
+    };
+
+    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
+      error: new Error('Test validation error'),
+      allowResponse: () => true,
+    });
+    expect(handler.response).toHaveProperty('statusCode', 500);
+    expect(handler.response).toHaveProperty(
+      'body',
+      JSON.stringify({
+        status: 'error',
+        data: null,
+        error: {
+          code: 'UNHANDLED_ERROR',
+          message: 'Error: Test validation error',
+          details: '',
+        },
+        _meta: {},
+      })
+    );
+
+    app.debug = false;
+  });
+});

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

@@ -59,6 +59,17 @@ describe('MiddlewareGroup: test disconnectConnections db middleware', () => {
 
     expect(end).toHaveBeenCalledTimes(1);
   });
+
+  it('should return exception if failure is detected', async () => {
+    const end = jest.fn().mockImplementationOnce(() => {
+      throw new Error('Test Error');
+    });
+    await disconnectConnections({
+      db: {
+        end,
+      },
+    });
+  });
 });
 
 describe('MiddlewareGroup: test disconnectConnections dbRead middleware', () => {
@@ -69,6 +80,13 @@ describe('MiddlewareGroup: test disconnectConnections dbRead middleware', () =>
     expect(end).toHaveBeenCalledTimes(0);
   });
 
+  it('should not call anything whenever no options is passed', async () => {
+    const end = jest.fn().mockResolvedValue();
+    await disconnectConnections();
+
+    expect(end).toHaveBeenCalledTimes(0);
+  });
+
   it('should call dbRead.end() whenever a dbRead options is set', async () => {
     const end = jest.fn().mockResolvedValue();
     await disconnectConnections({