lesgo 0.7.8 → 2.1.0

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

@@ -1,170 +0,0 @@
-import serverAuthMiddleware, {
-  serverAuthBeforeHandler,
-} from '../serverAuthMiddleware';
-import { generateBasicAuthorizationHash } from '../basicAuthMiddleware';
-import client from '../../../tests/__mocks__/config/client';
-
-describe('test serverAuthMiddleware middleware', () => {
-  test.each`
-    clientObj
-    ${undefined}
-    ${{}}
-    ${{
-  default: {
-    key: '1111-1111-1111-1111',
-    secret: '1111-1111-1111-1111',
-  },
-}}
-  `('should return object', ({ clientObj }) => {
-    const result = serverAuthMiddleware({
-      client: clientObj,
-    });
-
-    expect(result).toHaveProperty('before');
-    expect(result).toHaveProperty('onError');
-  });
-});
-
-// eslint-disable-next-line
-const next = () => {};
-
-describe('test serverAuthBeforeHandler 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 {
-      serverAuthBeforeHandler(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 {
-        serverAuthBeforeHandler(handler, next, {
-          blacklistMode,
-        });
-      } catch (e) {
-        hasError = true;
-      }
-
-      expect(hasError).toBeFalsy();
-    }
-  );
-});
-
-describe('test serverAuthBeforeHandler 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 is required!'}        | ${403}          | ${'JWT_MISSING_AUTHORIZATION_HEADER'}                                   | ${undefined}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Missing Bearer token!'}                    | ${403}          | ${'JWT_MISSING_BEARER_TOKEN'}                                           | ${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 is required!'}        | ${403}          | ${'JWT_MISSING_AUTHORIZATION_HEADER'}                                   | ${true}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Missing Bearer token!'}                    | ${403}          | ${'JWT_MISSING_BEARER_TOKEN'}                                           | ${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'} | ${'Missing Bearer token!'}                    | ${403}          | ${'JWT_MISSING_BEARER_TOKEN'}                                           | ${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(
-          serverAuthBeforeHandler(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);
-      }
-    }
-  );
-});

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

@@ -1,159 +0,0 @@
-import {
-  successHttpResponseHandler,
-  successHttpResponseAfterHandler,
-} from '../successHttpResponseMiddleware';
-
-describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
-  it('test default without parameters', async () => {
-    const data = await successHttpResponseHandler();
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(200);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'success');
-    expect(dataBody).toHaveProperty('data', '');
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('test default', async () => {
-    const data = await successHttpResponseHandler({ response: 'Some message' });
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(200);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'success');
-    expect(dataBody).toHaveProperty('data', 'Some message');
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('test with status code and event', async () => {
-    const data = await successHttpResponseHandler({
-      response: 'Some message',
-      statusCode: 201,
-      event: {
-        someEventKey: 'someEventValue',
-      },
-    });
-
-    expect(data.statusCode).toBe(201);
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'success');
-    expect(dataBody).toHaveProperty('data', 'Some message');
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('test with status code and event in debug mode', async () => {
-    const data = await successHttpResponseHandler({
-      response: 'Some message',
-      statusCode: 201,
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      debugMode: true,
-    });
-
-    expect(data.statusCode).toBe(201);
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'success');
-    expect(dataBody).toHaveProperty('data', 'Some message');
-    expect(dataBody).toHaveProperty('_meta', {
-      someEventKey: 'someEventValue',
-    });
-  });
-
-  it('test with configurable header', async () => {
-    const data = await successHttpResponseHandler({
-      response: 'Some message',
-      headers: {
-        'Access-Control-Allow-Credentials': false,
-        'X-Token-Id': 'token',
-      },
-    });
-
-    expect(data.headers['Access-Control-Allow-Credentials']).toBe(false);
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-    expect(data.headers['X-Token-Id']).toBe('token');
-
-    expect(data.statusCode).toBe(200);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'success');
-    expect(dataBody).toHaveProperty('data', 'Some message');
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('should call db.end() whenever a db options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await successHttpResponseHandler({
-      response: 'Some message',
-      headers: {
-        'Access-Control-Allow-Credentials': false,
-        'X-Token-Id': 'token',
-      },
-      db: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call dbRead.end() whenever a dbRead options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await successHttpResponseHandler({
-      response: 'Some message',
-      headers: {
-        'Access-Control-Allow-Credentials': false,
-        'X-Token-Id': 'token',
-      },
-      dbRead: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call cache.end() whenever a cache options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await successHttpResponseHandler({
-      response: 'Some message',
-      headers: {
-        'Access-Control-Allow-Credentials': false,
-        'X-Token-Id': 'token',
-      },
-      cache: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('MiddlewareGroup: test successHttpResponseAfterHandler', () => {
-  it('test with default parameters', async () => {
-    const handler = {
-      response: {},
-      event: {},
-    };
-
-    await successHttpResponseAfterHandler(handler, () => {});
-    expect(handler.response).toHaveProperty('statusCode', 200);
-  });
-});

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

@@ -1,222 +0,0 @@
-import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import verifyJwtMiddleware, {
-  verifyJwtMiddlewareBeforeHandler,
-} from '../verifyJwtMiddleware';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
-  const handler = {
-    event: {
-      headers: {},
-      queryStringParameters: null,
-      body: null,
-    },
-  };
-
-  it('should return before object', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-    const result = verifyJwtMiddleware(newHandler, () => {});
-
-    expect(result).toHaveProperty('before');
-  });
-
-  it('test without authorization header', () => {
-    expect(() => verifyJwtMiddlewareBeforeHandler(handler, () => {})).toThrow(
-      new LesgoException(
-        'Authorization Header is required!',
-        'JWT_MISSING_AUTHORIZATION_HEADER',
-        403
-      )
-    );
-  });
-
-  it('test with missing bearer token', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: '',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        'Authorization Header is required!',
-        'JWT_MISSING_AUTHORIZATION_HEADER',
-        403
-      )
-    );
-  });
-
-  it('test with invalid token', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: 'asdasd',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        'Missing Bearer token!',
-        'JWT_MISSING_BEARER_TOKEN',
-        403
-      )
-    );
-  });
-
-  it('test with malformed token', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: 'Bearer sdawdasdawdawdsd',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('jwt malformed', 'JWT_ERROR', 403));
-  });
-
-  it('test with incorrect secret key', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('invalid signature', 'JWT_ERROR', 403));
-  });
-
-  it('test with invalid ISS', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.2r0UHtMWMcLH3VJVDtVGP2_MT8npWy-w2lsUiZSBFFI',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        "Token's [iss] is not valid!",
-        'JWT_ISS_NOT_VALID',
-        403
-      )
-    );
-  });
-
-  it('test with missing custom claim', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIn0.grz7RVA9XuOj4TUKLefvblt6bnSz0yfFpwee1MgMnN0',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        `Token's custom claim [${config.customClaims.data[0]}] not found!`,
-        'JWT_CUSTOM_CLAIM_NOT_FOUND',
-        403
-      )
-    );
-  });
-
-  it('test with expired token', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZXhwIjoxNTE2MjM5MDIyfQ.-S3Ym5HiC5GPiW1Zjjt4j6L-skqP4PVV5f4fIScgPTE',
-        },
-      },
-    };
-
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('jwt expired', 'JWT_EXPIRED', 403));
-  });
-
-  it('test with valid token', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-
-    verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
-    expect(newHandler.event.decodedJwt).toMatchObject({
-      sub: '1234567890',
-      iss: config.iss.data[0],
-    });
-  });
-
-  it('test with custom config', () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-
-    verifyJwtMiddlewareBeforeHandler(newHandler, () => {}, {
-      jwtConfig: {
-        secret:
-          'c4156b94c80b7f163feabd4ff268c99eb11ce8995df370a4fd872afb4377b273',
-        iss: {
-          validate: true,
-          data: ['domain.com'],
-        },
-        customClaims: {
-          validate: true,
-          data: ['department_id'],
-        },
-      },
-    });
-    expect(newHandler.event.decodedJwt).toMatchObject({
-      sub: '1234567890',
-      iss: config.iss.data[0],
-    });
-  });
-});

package/src/middlewares/basicAuthMiddleware.js

@@ -1,145 +0,0 @@
-import client from 'Config/client'; // eslint-disable-line import/no-unresolved
-import crypto from 'crypto';
-import LesgoException from '../exceptions/LesgoException';
-import { errorHttpResponseAfterHandler } from './errorHttpResponseMiddleware';
-
-const FILE = 'Middlewares/basicAuthMiddleware';
-
-const blacklistMode = opts => {
-  if (opts && typeof opts.blacklistMode !== 'undefined') {
-    return !!opts.blacklistMode;
-  }
-
-  return true;
-};
-
-export const generateBasicAuthorizationHash = (key, secret) => {
-  return crypto
-    .createHash('sha1')
-    .update(`${key}:${secret}`)
-    .digest('hex');
-};
-
-const getSiteId = event => {
-  let siteId;
-
-  if (event.site && event.site.id) {
-    siteId = event.site.id;
-  } else if (
-    event.requestContext &&
-    event.requestContext.site &&
-    event.requestContext.site.id
-  ) {
-    siteId = event.requestContext.site.id;
-  } else if (event.platform) {
-    siteId = event.platform;
-  }
-
-  if (typeof siteId === 'undefined') {
-    throw new LesgoException(
-      'Site ID could not be found',
-      `${FILE}::SITE_ID_NOT_FOUND`,
-      403,
-      'Ensure that clientAuthMiddleware() is called before this Middleware'
-    );
-  }
-
-  return siteId;
-};
-
-const getClient = opts => {
-  if (opts && opts.client && Object.keys(opts.client).length > 0) {
-    return opts.client;
-  }
-
-  return client;
-};
-
-const getHashFromHeaders = (headers, opts) => {
-  const basicAuth = headers.Authorization || headers.authorization;
-
-  if (typeof basicAuth === 'undefined') {
-    if (blacklistMode(opts)) {
-      throw new LesgoException(
-        'Authorization header not found',
-        `${FILE}::AUTHORIZATION_HEADER_NOT_FOUND`,
-        403,
-        'Ensure you are have provided the basic authentication code using Authorization header'
-      );
-    }
-
-    return '';
-  }
-
-  if (
-    typeof basicAuth !== 'undefined' &&
-    !basicAuth.startsWith('basic ') &&
-    !basicAuth.startsWith('Basic ')
-  ) {
-    throw new LesgoException(
-      'Invalid authorization type provided',
-      `${FILE}::AUTH_INVALID_AUTHORIZATION_TYPE`,
-      403,
-      'Use the basic authorization method'
-    );
-  }
-
-  const authEncoded = basicAuth.startsWith('basic ')
-    ? basicAuth.replace('basic ', '')
-    : basicAuth.replace('Basic ', '');
-
-  if (authEncoded.length <= 0) {
-    throw new LesgoException(
-      'Empty basic authentication hash provided',
-      `${FILE}::AUTH_EMPTY_BASIC_HASH`,
-      403,
-      'Ensure basic authentication has is provided along with the keyword "Basic"'
-    );
-  }
-
-  const buff = Buffer.from(authEncoded, 'base64');
-
-  return buff.toString('utf-8');
-};
-
-const validateBasicAuth = (hash, siteId, clientObject, opts) => {
-  const site = Object.keys(clientObject).find(clientCode => {
-    const hashIsEquals =
-      generateBasicAuthorizationHash(
-        clientObject[clientCode].key,
-        clientObject[clientCode].secret
-      ) === hash;
-
-    return siteId === clientCode && hashIsEquals;
-  });
-
-  if (!site && (hash.length > 0 || (hash.length <= 0 && blacklistMode(opts)))) {
-    throw new LesgoException(
-      'Invalid client key or secret provided',
-      `${FILE}::AUTH_INVALID_CLIENT_OR_SECRET_KEY`,
-      403,
-      'Ensure you are using the correct client key or secret key provided'
-    );
-  }
-};
-
-export const verifyBasicAuthBeforeHandler = (handler, next, opts) => {
-  const siteId = getSiteId(handler.event);
-  const finalClient = getClient(opts);
-  const hashFromHeader = getHashFromHeaders(handler.event.headers, opts);
-
-  validateBasicAuth(hashFromHeader, siteId, finalClient, opts);
-
-  next();
-};
-
-/* istanbul ignore next */
-const basicAuthMiddleware = opts => {
-  return {
-    before: (handler, next) =>
-      verifyBasicAuthBeforeHandler(handler, next, opts),
-    onError: (handler, next) => errorHttpResponseAfterHandler(handler, next),
-  };
-};
-
-export default basicAuthMiddleware;