lesgo 0.7.8 → 2.1.0

package/src/middlewares/__mocks__/ValidationErrorException.js

@@ -1,18 +0,0 @@
-export default class ValidationErrorException extends Error {
-  constructor(
-    message,
-    errorCode = 'VALIDATION_ERROR',
-    httpStatusCode = 400,
-    extra
-  ) {
-    super();
-    this.name = 'ValidationError';
-    this.message = message;
-    this.statusCode = httpStatusCode;
-    this.code = errorCode;
-
-    Error.captureStackTrace(this, this.constructor);
-
-    if (extra) this.extra = extra;
-  }
-}

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

@@ -1,225 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,190 +0,0 @@
-import {
-  errorHttpResponseHandler,
-  errorHttpResponseAfterHandler,
-} from '../errorHttpResponseMiddleware';
-import ValidationErrorException from '../__mocks__/ValidationErrorException';
-
-describe('MiddlewareGroup: test errorHandler middleware', () => {
-  it('test with thrown Error', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new Error('Test validation error'),
-    });
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(500);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'error');
-    expect(dataBody).toHaveProperty('data', null);
-    expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'Error: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with thrown custom Error with default parameters', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new ValidationErrorException('Test validation error'),
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(400);
-
-    expect(dataBody).toHaveProperty('error.code', 'VALIDATION_ERROR');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'ValidationError: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with thrown custom Error with given parameters', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new ValidationErrorException(
-        'Test validation error',
-        'VALIDATION_ERROR_SAMPLE',
-        401,
-        {
-          extraDataKey: 'extraDataValue',
-        }
-      ),
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(401);
-
-    expect(dataBody).toHaveProperty('error.code', 'VALIDATION_ERROR_SAMPLE');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'ValidationError: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', {
-      extraDataKey: 'extraDataValue',
-    });
-  });
-
-  it('test with error message', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty('error.message', 'Test error message');
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with error message with event', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      debugMode: true,
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-    expect(dataBody).toHaveProperty('_meta', {
-      someEventKey: 'someEventValue',
-    });
-  });
-
-  it('test with error message with event in non-debug mode', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('test with undefined opts', async () => {
-    const data = await errorHttpResponseHandler();
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(500);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'error');
-    expect(dataBody).toHaveProperty('data', null);
-    expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty('error.message', '');
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('should call db.end() whenever a db options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      db: {
-        end,
-      },
-    });
-
-    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', () => {
-  it('test with default parameters', async () => {
-    const handler = {
-      error: {},
-      event: {},
-    };
-
-    await errorHttpResponseAfterHandler(handler, () => {});
-    expect(handler.response).toHaveProperty('statusCode', 500);
-  });
-});