lesgo 0.7.7 → 0.7.8

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

@@ -0,0 +1,170 @@
+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__/verifyJwtMiddleware.spec.js

@@ -1,5 +1,7 @@
 import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import { verifyJwtMiddlewareBeforeHandler } from '../verifyJwtMiddleware';
+import verifyJwtMiddleware, {
+  verifyJwtMiddlewareBeforeHandler,
+} from '../verifyJwtMiddleware';
 import LesgoException from '../../exceptions/LesgoException';
 
 describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
@@ -11,6 +13,21 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
     },
   };
 
+  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(
@@ -171,4 +188,35 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       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

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

package/src/middlewares/clientAuthMiddleware.js

@@ -0,0 +1,82 @@
+import client from 'Config/client'; // eslint-disable-line import/no-unresolved
+import { errorHttpResponseAfterHandler } from './errorHttpResponseMiddleware';
+import validateFields from '../utils/validateFields';
+import { LesgoException } from '../exceptions';
+
+const FILE = 'Middlewares/clientAuthMiddleware';
+
+const validateParams = params => {
+  const validFields = [
+    { key: 'x-client-id', type: 'string', required: true },
+    { key: 'client', type: 'object', required: true },
+  ];
+
+  try {
+    return validateFields(params, validFields);
+  } catch (error) {
+    throw new LesgoException(error.message, `${FILE}::INVALID_AUTH_DATA`, 403, {
+      error,
+    });
+  }
+};
+
+const getClientKey = event => {
+  if (typeof event.headers['x-client-id'] === 'string') {
+    return event.headers['x-client-id'];
+  }
+
+  if (event.input && typeof event.input.clientid === 'string') {
+    return event.input.clientid;
+  }
+
+  return undefined;
+};
+
+export const clientAuthMiddlewareBeforeHandler = (
+  handler,
+  next,
+  opt = undefined
+) => {
+  const validated = validateParams({
+    'x-client-id': getClientKey(handler.event),
+    client,
+  });
+
+  const clientKey = validated['x-client-id'];
+
+  const platform = Object.keys(validated.client).filter(clientPlatform => {
+    return validated.client[clientPlatform].key === clientKey;
+  });
+
+  if (platform.length === 0) {
+    throw new LesgoException(
+      'Invalid ClientId provided',
+      `${FILE}::INVALID_CLIENT_ID`,
+      403,
+      'Ensure you are using the correct Client Id provided'
+    );
+  }
+
+  // eslint-disable-next-line no-param-reassign,prefer-destructuring
+  handler.event.platform = platform[0];
+
+  if (typeof opt === 'function') {
+    opt(handler);
+  } else if (typeof opt === 'object') {
+    const { callback } = opt;
+    if (typeof callback === 'function') callback(handler);
+  }
+
+  next();
+};
+
+/* istanbul ignore next */
+const clientAuthMiddleware = opt => {
+  return {
+    before: (handler, next) =>
+      clientAuthMiddlewareBeforeHandler(handler, next, opt),
+    onError: (handler, next) => errorHttpResponseAfterHandler(handler, next),
+  };
+};
+
+export default clientAuthMiddleware;

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/normalizeSQSMessageMiddleware.js

@@ -26,9 +26,11 @@ export const normalizeHandler = records => {
 export const disconnectConnections = async opts => {
   try {
     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 (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);

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/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,10 +52,10 @@ export const verifyJwtMiddlewareBeforeHandler = (handler, next) => {
   }
 };
 
-/* istanbul ignore next */
-const verifyJwtMiddleware = () => {
+const verifyJwtMiddleware /* istanbul ignore next */ = opts => {
   return {
-    before: (handler, next) => verifyJwtMiddlewareBeforeHandler(handler, next),
+    before: (handler, next) =>
+      verifyJwtMiddlewareBeforeHandler(handler, next, opts),
   };
 };