lesgo 1.0.0 → 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,264 +0,0 @@
-import basicAuthMiddleware, {
-  generateBasicAuthorizationHash,
-  verifyBasicAuthBeforeHandler,
-} from '../basicAuthMiddleware';
-import client from '../../../tests/__mocks__/config/client';
-
-describe('test generateBasicAuthorizationHash', () => {
-  test('should return custom when overriden through opts', () => {
-    expect(
-      generateBasicAuthorizationHash(
-        'e5bb52b012ad4a4e9d862a3410e7013d',
-        '4cd19af8f7ca4448bcb2c427754095b5',
-        {
-          getPreHashString: key => {
-            return `=${key}=`;
-          },
-        }
-      )
-    ).toBe('PWU1YmI1MmIwMTJhZDRhNGU5ZDg2MmEzNDEwZTcwMTNkPQ==');
-  });
-
-  test('should return basic auth by default', () => {
-    const { getPreHashString } = client;
-    client.getPreHashString = null;
-
-    expect(
-      generateBasicAuthorizationHash(
-        'e5bb52b012ad4a4e9d862a3410e7013d',
-        '4cd19af8f7ca4448bcb2c427754095b5'
-      )
-    ).toBe(
-      'ZTViYjUyYjAxMmFkNGE0ZTlkODYyYTM0MTBlNzAxM2Q6NGNkMTlhZjhmN2NhNDQ0OGJjYjJjNDI3NzU0MDk1YjU='
-    );
-
-    client.getPreHashString = getPreHashString;
-  });
-});
-
-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');
-  });
-});
-
-// 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.clients.platform_2.key}:secret_key`
-  ).toString('base64');
-
-  test.each`
-    headers                                           | errorName           | errorMessage                                  | errorStatusCode | errorCode                                                               | platform
-    ${{}}                                             | ${'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'}    | ${'platform_1'}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'platform_1'}
-    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'platform_1'}
-    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
-    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
-    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'blacklist_platform'}
-    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'blacklist_platform'}
-    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
-    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
-    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'blacklist_platform_1'}
-    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'blacklist_platform_1'}
-    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
-    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
-    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
-  `(
-    'should throw $errorMessage when authorization header is $headers',
-    async ({
-      headers,
-      errorName,
-      errorMessage,
-      errorStatusCode,
-      errorCode,
-      platform,
-    }) => {
-      const handler = {
-        event: {
-          headers,
-          platform: {
-            id: platform,
-            ...client.clients[platform],
-          },
-        },
-      };
-
-      try {
-        expect(await verifyBasicAuthBeforeHandler(handler, next)).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 = generateBasicAuthorizationHash(
-    client.clients.platform_2.key,
-    client.clients.platform_2.secret
-  );
-
-  test.each`
-    clientObj
-    ${undefined}
-    ${{}}
-    ${{
-  platform_2: {
-    key: '2222-2222-2222-2222',
-    secret: '2222-2222-2222-2222',
-  },
-}}
-  `('should return undefined when successful', async ({ clientObj }) => {
-    const handler = {
-      event: {
-        headers: {
-          Authorization: `basic ${validBasicAuth}`,
-        },
-        site: {
-          id: 'platform_2',
-        },
-      },
-    };
-
-    let hasError = false;
-
-    try {
-      await verifyBasicAuthBeforeHandler(handler, next, {
-        client: clientObj,
-      });
-    } catch (e) {
-      hasError = true;
-    }
-
-    expect(hasError).toBeFalsy();
-  });
-
-  test.each`
-    clientObj
-    ${undefined}
-    ${{}}
-    ${{
-  platform_2: {
-    key: '2222-2222-2222-2222',
-    secret: '2222-2222-2222-2222',
-  },
-}}
-  `('should return undefined when successful', async ({ clientObj }) => {
-    const handler = {
-      event: {
-        headers: {
-          Authorization: `basic ${validBasicAuth}`,
-        },
-        site: {
-          id: 'platform_2',
-        },
-      },
-    };
-
-    let hasError = false;
-
-    try {
-      await verifyBasicAuthBeforeHandler(handler, next, {
-        client: clientObj,
-      });
-    } catch (e) {
-      hasError = true;
-    }
-
-    expect(hasError).toBeFalsy();
-  });
-
-  test.each`
-    Authorization                | platform
-    ${undefined}                 | ${'blacklist_platform'}
-    ${undefined}                 | ${'blacklist_platform_1'}
-    ${`basic ${validBasicAuth}`} | ${'platform_2'}
-    ${`Basic ${validBasicAuth}`} | ${'platform_2'}
-    ${`basic ${validBasicAuth}`} | ${'platform_2'}
-    ${`Basic ${validBasicAuth}`} | ${'platform_2'}
-  `(
-    'test Exception with valid credentials',
-    async ({ Authorization, platform }) => {
-      const handler = {
-        event: {
-          headers: {
-            Authorization,
-          },
-          platform: {
-            id: platform,
-            ...client.clients[platform],
-          },
-        },
-      };
-
-      let hasError = false;
-
-      try {
-        await verifyBasicAuthBeforeHandler(handler, next);
-      } catch (e) {
-        hasError = true;
-      }
-
-      expect(hasError).toBeFalsy();
-    }
-  );
-
-  test.each`
-    siteObjects
-    ${{ platform: {
-    id: 'platform_2',
-    ...client.clients.platform_2,
-  } }}
-    ${{}}
-  `('valid site ids', async ({ siteObjects }) => {
-    const handler = {
-      event: {
-        headers: {
-          Authorization: `basic ${validBasicAuth}`,
-        },
-        ...siteObjects,
-      },
-    };
-
-    let hasError = false;
-
-    try {
-      await verifyBasicAuthBeforeHandler(handler, next);
-    } catch (e) {
-      hasError = true;
-    }
-
-    expect(hasError).toBeFalsy();
-  });
-});

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

@@ -1,235 +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');
-  });
-});
-
-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 'clientKey'");
-      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 be able to validate from multiple header keys', async () => {
-    const handler = {
-      event: {
-        headers: {
-          'X-Client-Id': '1111-1111-1111-1111',
-        },
-      },
-    };
-
-    let hasError = false;
-
-    try {
-      await clientAuthMiddlewareBeforeHandler(handler, next);
-    } catch (e) {
-      hasError = e;
-    }
-
-    expect(hasError).toBe(false);
-  });
-
-  test('should allow getting from query string parameters', async () => {
-    const handler = {
-      event: {
-        queryStringParameters: {
-          'x-client-id': '1111-1111-1111-1111',
-        },
-      },
-    };
-
-    let hasError = false;
-
-    try {
-      await clientAuthMiddlewareBeforeHandler(handler, next);
-    } catch (e) {
-      hasError = e;
-    }
-
-    expect(hasError).toBe(false);
-  });
-
-  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 set handler.event.platform 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);
-    expect(handler.event.platform).toStrictEqual({
-      id: 'platform_1',
-      key: '1111-1111-1111-1111',
-      secret: '1111-1111-1111-1111',
-    });
-  });
-
-  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 with callback function from config', async () => {
-    const handler = {
-      event: {
-        headers: {},
-        input: {
-          clientid: '1111-1111-1111-1111',
-        },
-      },
-    };
-
-    await clientAuthMiddlewareBeforeHandler(handler, next);
-
-    expect(handler.event).toHaveProperty('created_obj');
-  });
-
-  test('should execute passed opt object with async callback function', async () => {
-    const handler = {
-      event: {
-        headers: {},
-        input: {
-          clientid: '1111-1111-1111-1111',
-        },
-      },
-    };
-
-    await clientAuthMiddlewareBeforeHandler(handler, next, {
-      callback: async h => {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        // eslint-disable-next-line no-param-reassign
-        h.event.created_obj_async = 'created_obj_async';
-      },
-    });
-
-    expect(handler.event).toHaveProperty('created_obj_async');
-  });
-
-  test('should not execute passed opt object with callback function if not a function', async () => {
-    const handler = {
-      event: {
-        headers: {},
-        input: {
-          clientid: '1111-1111-1111-1111',
-        },
-      },
-    };
-
-    await clientAuthMiddlewareBeforeHandler(handler, next, {
-      callback: 'not_function',
-    });
-
-    expect(handler.event).not.toHaveProperty('created_obj');
-  });
-});