lesgo 0.7.7 → 1.0.0

package/src/middlewares/basicAuthMiddleware.js

@@ -0,0 +1,125 @@
+import client from 'Config/client'; // eslint-disable-line import/no-unresolved
+import LesgoException from '../exceptions/LesgoException';
+
+const FILE = 'Middlewares/basicAuthMiddleware';
+
+export const generateBasicAuthorizationHash = (key, secret, opts = {}) => {
+  const { getPreHashString } = {
+    ...client,
+    ...opts,
+  };
+  const preHashString =
+    typeof getPreHashString === 'function'
+      ? getPreHashString(key, secret)
+      : `${key}:${secret}`;
+
+  return Buffer.from(preHashString).toString('base64');
+};
+
+const getClient = opts => {
+  if (opts && opts.client && Object.keys(opts.client).length > 0) {
+    return opts.client;
+  }
+
+  return client.clients;
+};
+
+const getHashFromHeaders = headers => {
+  const basicAuth = headers.Authorization || headers.authorization;
+
+  if (typeof basicAuth === 'undefined') {
+    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"'
+    );
+  }
+
+  return authEncoded;
+};
+
+const validateBasicAuth = (hash, clientObject, opts, siteId = undefined) => {
+  const site = Object.keys(clientObject).find(clientCode => {
+    const hashIsEquals =
+      generateBasicAuthorizationHash(
+        clientObject[clientCode].key,
+        clientObject[clientCode].secret,
+        opts
+      ) === hash;
+
+    return siteId ? siteId === clientCode && hashIsEquals : hashIsEquals;
+  });
+
+  if (!site) {
+    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 = async (handler, next, opts) => {
+  const { headers, platform } = handler.event;
+  const finalClient = getClient(opts);
+  const hashFromHeader = getHashFromHeaders(headers);
+  let isAuthOptional = platform ? platform.isAuthOptional : false;
+  if (isAuthOptional && typeof isAuthOptional.then === 'function') {
+    isAuthOptional = await isAuthOptional;
+  }
+
+  if (hashFromHeader) {
+    validateBasicAuth(
+      hashFromHeader,
+      finalClient,
+      opts,
+      platform ? platform.id : undefined
+    );
+  } else if (!platform || !isAuthOptional) {
+    /**
+     * An error will occur only when either the platform could not be determined, assuming a basic auth is needed.
+     * Or whenever the platform could be determined, but `isAuthOptional` is not true for that platform
+     */
+    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'
+    );
+  }
+
+  next();
+};
+
+/* istanbul ignore next */
+const basicAuthMiddleware = opts => {
+  return {
+    before: (handler, next) =>
+      verifyBasicAuthBeforeHandler(handler, next, opts),
+  };
+};
+
+export default basicAuthMiddleware;

package/src/middlewares/clientAuthMiddleware.js

@@ -0,0 +1,103 @@
+import client from 'Config/client'; // eslint-disable-line import/no-unresolved
+import validateFields from '../utils/validateFields';
+import { LesgoException } from '../exceptions';
+
+const FILE = 'Middlewares/clientAuthMiddleware';
+
+const validateParams = params => {
+  const validFields = [
+    { key: 'clientKey', 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 => {
+  const foundExistingKey = client.headerKeys.find(headerKey => {
+    if (event.headers && typeof event.headers[headerKey] === 'string') {
+      return true;
+    }
+
+    if (
+      event.queryStringParameters &&
+      typeof event.queryStringParameters[headerKey] === 'string'
+    ) {
+      return true;
+    }
+
+    return false;
+  });
+
+  if (foundExistingKey) {
+    if (event.headers && event.headers[foundExistingKey]) {
+      return event.headers[foundExistingKey];
+    }
+
+    // There will always be one where this is found existing
+    return event.queryStringParameters[foundExistingKey];
+  }
+
+  if (event.input && typeof event.input.clientid === 'string') {
+    return event.input.clientid;
+  }
+
+  return undefined;
+};
+
+export const clientAuthMiddlewareBeforeHandler = async (
+  handler,
+  next,
+  opt = {}
+) => {
+  const { clients, callback } = {
+    ...client,
+    ...(typeof opt === 'function' ? { callback: opt } : opt),
+  };
+
+  const { client: validatedClient, clientKey } = validateParams({
+    clientKey: getClientKey(handler.event),
+    client: clients,
+  });
+
+  const platform = Object.keys(validatedClient).filter(clientPlatform => {
+    return validatedClient[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 = {
+    id: platform[0],
+    ...client.clients[platform[0]],
+  };
+
+  if (typeof callback === 'function') {
+    await callback(handler);
+  }
+
+  next();
+};
+
+/* istanbul ignore next */
+const clientAuthMiddleware = opt => {
+  return {
+    before: (handler, next) =>
+      clientAuthMiddlewareBeforeHandler(handler, next, opt),
+  };
+};
+
+export default clientAuthMiddleware;

package/src/middlewares/errorHttpResponseMiddleware.js

@@ -66,7 +66,9 @@ export const errorHttpResponseHandler = async opts => {
   return {
     headers: options.headers,
     statusCode,
-    body: JSON.stringify(jsonBody),
+    body: options.formatError
+      ? options.formatError(options)
+      : JSON.stringify(jsonBody),
   };
 };
 

package/src/middlewares/httpNoOutputMiddleware.js

@@ -0,0 +1,91 @@
+import app from 'Config/app'; // eslint-disable-line import/no-unresolved
+import { normalizeHttpRequestBeforeHandler } from './normalizeHttpRequestMiddleware';
+import { successHttpResponseHandler } from './successHttpResponseMiddleware';
+import { errorHttpResponseHandler } from './errorHttpResponseMiddleware';
+
+const allowResponse = () => {
+  return app.debug;
+};
+
+const successHttpNoOutputResponseHandler = async opts => {
+  const { queryStringParameters } = opts.event;
+  const debug = queryStringParameters && queryStringParameters.debug;
+  const response = await successHttpResponseHandler(opts);
+  const shouldAllowResponse = opts.allowResponse || allowResponse;
+
+  /* istanbul ignore next */
+  if (!debug || !shouldAllowResponse(opts)) {
+    response.body = '';
+  }
+
+  return response;
+};
+
+export const successHttpNoOutputResponseAfterHandler = async (
+  handler,
+  next,
+  opts
+) => {
+  const defaults = {
+    response: handler.response,
+    event: handler.event,
+    allowResponse,
+  };
+  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;
+  const response = await errorHttpResponseHandler({
+    ...opts,
+    debugMode: opts.debugMode || debug,
+  });
+  const shouldAllowResponse = opts.allowResponse || allowResponse;
+
+  if (!debug || !shouldAllowResponse(opts)) {
+    response.statusCode = 200;
+    response.body = '';
+  }
+
+  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,
+  };
+
+  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/index.js

@@ -4,6 +4,8 @@ import successHttpResponseMiddleware from './successHttpResponseMiddleware';
 import errorHttpResponseMiddleware from './errorHttpResponseMiddleware';
 import normalizeSQSMessageMiddleware from './normalizeSQSMessageMiddleware';
 import verifyJwtMiddleware from './verifyJwtMiddleware';
+import basicAuthMiddleware from './basicAuthMiddleware';
+import clientAuthMiddleware from './clientAuthMiddleware';
 
 export {
   httpMiddleware,
@@ -12,4 +14,6 @@ export {
   errorHttpResponseMiddleware,
   normalizeSQSMessageMiddleware,
   verifyJwtMiddleware,
+  basicAuthMiddleware,
+  clientAuthMiddleware,
 };

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

@@ -43,11 +43,13 @@ export const successHttpResponseHandler = async opts => {
   return {
     headers: options.headers,
     statusCode: options.statusCode,
-    body: JSON.stringify({
-      status: 'success',
-      data: options.response,
-      _meta: options.debugMode ? options.event : {},
-    }),
+    body: options.formatSuccess
+      ? options.formatSuccess(options)
+      : JSON.stringify({
+          status: 'success',
+          data: options.response,
+          _meta: options.debugMode ? options.event : {},
+        }),
   };
 };
 

package/src/middlewares/verifyJwtMiddleware.js

@@ -26,31 +26,47 @@ export const token = headers => {
   return parsed[1];
 };
 
-export const verifyJwtMiddlewareBeforeHandler = (handler, next) => {
+export const verifyJwtMiddlewareBeforeHandler = async (handler, next, opts) => {
   const { headers } = handler.event;
 
+  const finalConfig =
+    typeof opts !== 'undefined' && 'jwtConfig' in opts
+      ? opts.jwtConfig
+      : config;
+
+  const { secret, callback } = finalConfig;
+
   try {
-    const service = new JwtService(token(headers), config);
+    const service = new JwtService(token(headers), {
+      ...finalConfig,
+      ...{
+        secret: typeof secret === 'function' ? secret(handler) : secret,
+      },
+    });
 
     // eslint-disable-next-line no-param-reassign
     handler.event.decodedJwt = service.validate().decoded;
 
+    if (typeof callback === 'function') {
+      await callback(handler);
+    }
+
     next();
   } catch (err) {
     if (err.name === 'JsonWebTokenError') {
-      throw new LesgoException(err.message, 'JWT_ERROR', 403);
+      throw new LesgoException(err.message, 'JWT_ERROR', 403, err);
     } else if (err.name === 'TokenExpiredError') {
-      throw new LesgoException(err.message, 'JWT_EXPIRED', 403);
+      throw new LesgoException(err.message, 'JWT_EXPIRED', 403, err);
     } else {
       throw err;
     }
   }
 };
 
-/* 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),
   };
 };
 

package/src/services/LoggerService.js

@@ -30,8 +30,9 @@ export default class LoggerService {
     this.logLevels = {
       error: 0,
       warn: 1,
-      info: 2,
-      debug: 3,
+      notice: 2,
+      info: 3,
+      debug: 4,
     };
   }
 
@@ -63,6 +64,10 @@ export default class LoggerService {
     this.log('debug', message, extra);
   }
 
+  notice(message, extra = {}) {
+    this.log('notice', message, extra);
+  }
+
   addMeta(meta = {}) {
     this.meta = {
       ...this.meta,
@@ -73,7 +78,9 @@ export default class LoggerService {
   consoleLogger(level, message) {
     if (!this.checkIsLogRequired('console', level)) return null;
     const refinedMessage = this.refineMessagePerTransport('console', message);
-    return console[level](JSON.stringify(refinedMessage)); // eslint-disable-line no-console
+    const consoleFunc = level === 'notice' ? 'log' : level;
+
+    return console[consoleFunc](JSON.stringify(refinedMessage)); // eslint-disable-line no-console
   }
 
   checkIsLogRequired(transportName, level) {

package/src/services/__tests__/LoggerService.spec.js

@@ -13,8 +13,9 @@ describe('ServicesGroup: test LoggerService instantiation', () => {
     expect(logger.logLevels).toMatchObject({
       error: 0,
       warn: 1,
-      info: 2,
-      debug: 3,
+      notice: 2,
+      info: 3,
+      debug: 4,
     });
   });
 
@@ -146,6 +147,20 @@ describe('ServicesGroup: test log LoggerService with console transport', () => {
     );
   });
 
+  it('test log with notice level', () => {
+    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
+    logger.notice('some notice log');
+
+    expect(console.log).toHaveBeenCalledWith(
+      JSON.stringify({
+        level: 'notice',
+        message: 'some notice log',
+        logger: 'lesgo-logger',
+        extra: {},
+      })
+    );
+  });
+
   it('test log with error level', () => {
     const logger = new LoggerService({ transports: [{ logType: 'console' }] });
     logger.error('some error log');