lesgo 1.0.0 → 2.1.1

package/src/middlewares/gzipHttpResponse.js

@@ -1,98 +0,0 @@
-import zlib from 'zlib';
-import LesgoException from '../exceptions/LesgoException';
-
-/**
- * Perform zipping and add neccessary header
- */
-export const gzip = async response => {
-  return new Promise((resolve, reject) => {
-    try {
-      zlib.gzip(response.body, (error, gzippedResponse) => {
-        if (error) {
-          reject(new LesgoException(error.message, 'GZIP_LIB_ERROR'));
-        } else {
-          response.body = gzippedResponse.toString('base64');
-          response.isBase64Encoded = true;
-          response.headers = {
-            ...response.headers,
-            'Content-Encoding': 'gzip',
-          };
-          resolve(response);
-        }
-      });
-    } catch (err) {
-      /* istanbul ignore next */
-      reject(new LesgoException(err.message, 'GZIP_UNKNOWN_ERROR', 500));
-    }
-  });
-};
-
-/**
- * Determine request origin
- */
-export const determineRequestOrigin = handler => {
-  const { requestContext = {} } = handler.event;
-  let requestFrom = 'APIGATEWAY';
-
-  if (requestContext.elb) {
-    requestFrom = 'ELB';
-  }
-
-  if (requestContext.apiId) {
-    requestFrom = 'APIGATEWAY';
-  }
-
-  return requestFrom;
-};
-
-/**
- * Determine headers Accept-Encoding exist
- */
-export const determineRequestAcceptEncoding = handler => {
-  const { headers } = handler.event;
-
-  let acceptEncoding =
-    headers['Accept-encoding'] ||
-    headers['accept-encoding'] ||
-    headers['Accept-Encoding'];
-
-  if (acceptEncoding) {
-    // normalise header
-    const re = / /g;
-    acceptEncoding = acceptEncoding
-      .replace(re, '')
-      .toLowerCase()
-      .split(',');
-
-    if (acceptEncoding.includes('gzip')) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-export const gzipHttpResponse = async (handler, options = {}) => {
-  /*
-   * By default we zip on ELB request only, but you also add APIGATEWAY
-   * Supported Request [ELB, APIGATEWAY]
-   */
-  let zipWhenRequest = ['ELB'];
-  if (options.zipWhenRequest) {
-    zipWhenRequest = options.zipWhenRequest;
-  }
-
-  const requestFrom = determineRequestOrigin(handler);
-
-  if (
-    zipWhenRequest.includes(requestFrom) &&
-    determineRequestAcceptEncoding(handler)
-  ) {
-    // eslint-disable-next-line no-param-reassign
-    handler.response = await gzip(handler.response);
-  }
-
-  return handler.response;
-};
-
-export default gzipHttpResponse;

package/src/middlewares/httpMiddleware.js

@@ -1,19 +0,0 @@
-import { normalizeHttpRequestBeforeHandler } from './normalizeHttpRequestMiddleware';
-import { successHttpResponseAfterHandler } from './successHttpResponseMiddleware';
-import { errorHttpResponseAfterHandler } from './errorHttpResponseMiddleware';
-
-/**
- * Combines all http middlewares into a single middleware
- */
-/* istanbul ignore next */
-const httpMiddleware = opts => {
-  return {
-    before: (handler, next) => normalizeHttpRequestBeforeHandler(handler, next),
-    after: (handler, next) =>
-      successHttpResponseAfterHandler(handler, next, opts),
-    onError: (handler, next) =>
-      errorHttpResponseAfterHandler(handler, next, opts),
-  };
-};
-
-export default httpMiddleware;

package/src/middlewares/httpNoOutputMiddleware.js

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

@@ -1,19 +0,0 @@
-import httpMiddleware from './httpMiddleware';
-import normalizeHttpRequestMiddleware from './normalizeHttpRequestMiddleware';
-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,
-  normalizeHttpRequestMiddleware,
-  successHttpResponseMiddleware,
-  errorHttpResponseMiddleware,
-  normalizeSQSMessageMiddleware,
-  verifyJwtMiddleware,
-  basicAuthMiddleware,
-  clientAuthMiddleware,
-};

package/src/middlewares/normalizeHttpRequestMiddleware.js

@@ -1,101 +0,0 @@
-import app from 'Config/app'; // eslint-disable-line import/no-unresolved
-import getJwtSubFromAuthHeader from '../utils/getJwtSubFromAuthHeader';
-import logger from '../utils/logger';
-
-export const normalizeRequest = opts => {
-  const { headers, body } = opts;
-  let { qs } = opts;
-  let input = null;
-
-  // to be consistent with api gateway, we convert empty object to null
-  if (JSON.stringify(qs) === '{}') qs = null;
-
-  if (!headers && qs === null) return input;
-
-  if (qs !== null) input = qs;
-
-  const contentType = headers['Content-Type'] || headers['content-type'];
-
-  if (!contentType) return input;
-
-  /* istanbul ignore else */
-  if (contentType.startsWith('application/json')) {
-    try {
-      input = { ...input, ...JSON.parse(body) };
-    } catch (err) {
-      throw new Error(
-        'Content type defined as JSON but an invalid JSON was provided'
-      );
-    }
-  }
-
-  return input;
-};
-
-export const normalizeHttpRequestBeforeHandler = (handler, next) => {
-  const options = {
-    headers: handler.event.headers,
-    qs: handler.event.queryStringParameters,
-    body: handler.event.body,
-  };
-
-  // eslint-disable-next-line no-param-reassign
-  handler.event.input = normalizeRequest(options);
-
-  const authHeader =
-    options.headers.Authorization || options.headers.authorization;
-
-  const auth = {};
-  if (authHeader) {
-    auth.sub = getJwtSubFromAuthHeader(authHeader);
-  }
-
-  // eslint-disable-next-line no-param-reassign
-  handler.event.auth = auth;
-
-  const tags = {};
-  switch (handler.event.version) {
-    case '2.0': {
-      if (handler.event.requestContext && handler.event.requestContext.http) {
-        tags.path = handler.event.requestContext.http.path;
-        tags.httpMethod = handler.event.requestContext.http.method;
-      }
-      break;
-    }
-    default:
-      tags.path = handler.event.path;
-      tags.httpMethod = handler.event.httpMethod;
-      break;
-  }
-
-  logger.addMeta({
-    requestId: handler.event.requestContext
-      ? handler.event.requestContext.requestId
-      : null,
-    tags,
-  });
-
-  if (app.debug) {
-    logger.addMeta({
-      auth: handler.event.auth,
-      queryStringParameters: options.qs,
-      body: options.body,
-    });
-  }
-
-  /* istanbul ignore next */
-  next();
-};
-
-/**
- * Normalizes handler.event.body and handler.event.queryStringParameters
- * as handler.event.input Object
- */
-/* istanbul ignore next */
-const normalizeHttpRequestMiddleware = () => {
-  return {
-    before: (handler, next) => normalizeHttpRequestBeforeHandler(handler, next),
-  };
-};
-
-export default normalizeHttpRequestMiddleware;

package/src/middlewares/normalizeSQSMessageMiddleware.js

@@ -1,67 +0,0 @@
-import logger from '../utils/logger';
-import isEmpty from '../utils/isEmpty';
-
-const FILE = 'Lesgo/middlewares/normalizeSQSMessageMiddleware';
-
-export const normalizeHandler = records => {
-  let recordCount = 0;
-
-  if (!records || records === null || Object.keys(records).length === 0) {
-    recordCount = null;
-  } else {
-    recordCount = Object.keys(records).length;
-  }
-
-  logger.addMeta({ recordCount });
-
-  if (recordCount === null) return null;
-
-  return Object.values(records).map(record => ({
-    messageId: record.messageId,
-    receiptHandle: record.receiptHandle,
-    ...JSON.parse(record.body),
-  }));
-};
-
-export const disconnectConnections = async opts => {
-  try {
-    const disconnect = [];
-    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);
-    }
-  } catch (err) {
-    logger.error(`${FILE}::Failed to end connection`, err);
-  }
-};
-
-/**
- * Normalizes handler.event.Records as handler.event.collections Object.
- * This type of request is received by SQS listeners
- */
-/* istanbul ignore next */
-const normalizeSQSMessageMiddleware /* istanbul ignore next */ = opts => {
-  return {
-    before: (handler, next) => {
-      const { Records } = handler.event;
-      // eslint-disable-next-line no-param-reassign
-      handler.event.collection = normalizeHandler(Records);
-      next();
-    },
-    after: async (handler, next) => {
-      await disconnectConnections(opts);
-      next();
-    },
-    onError: async (handler, next) => {
-      await disconnectConnections(opts);
-      next();
-    },
-  };
-};
-
-export default normalizeSQSMessageMiddleware;

package/src/middlewares/successHttpResponseMiddleware.js

@@ -1,85 +0,0 @@
-import gzipHttpResponse from './gzipHttpResponse';
-import isEmpty from '../utils/isEmpty';
-import logger from '../utils/logger';
-
-const FILE = 'Lesgo/middlewares/successHttpResponseMiddleware';
-
-export const successHttpResponseHandler = async opts => {
-  const defaults = {
-    response: '',
-    statusCode: 200,
-    event: {},
-    debugMode: false,
-    headers: {
-      'Access-Control-Allow-Origin': '*',
-      'Cache-Control': 'no-cache',
-      'Content-Type': 'application/json',
-    },
-  };
-
-  const optionsHeadersMerged =
-    opts === undefined
-      ? { ...defaults.headers }
-      : {
-          ...opts,
-          headers: { ...defaults.headers, ...opts.headers },
-        };
-
-  const options = { ...defaults, ...optionsHeadersMerged };
-
-  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 (disconnect.length > 0) {
-      await Promise.all(disconnect);
-    }
-  } catch (err) {
-    logger.error(`${FILE}::Failed to end connection`, err);
-  }
-
-  return {
-    headers: options.headers,
-    statusCode: options.statusCode,
-    body: options.formatSuccess
-      ? options.formatSuccess(options)
-      : JSON.stringify({
-          status: 'success',
-          data: options.response,
-          _meta: options.debugMode ? options.event : {},
-        }),
-  };
-};
-
-export const successHttpResponseAfterHandler = async (handler, next, opts) => {
-  const defaults = {
-    response: handler.response,
-    event: handler.event,
-  };
-
-  const options = { ...defaults, ...opts };
-
-  // eslint-disable-next-line no-param-reassign
-  handler.response = await successHttpResponseHandler(options);
-
-  // eslint-disable-next-line no-param-reassign
-  handler.response = await gzipHttpResponse(handler, opts);
-
-  /* istanbul ignore next */
-  next();
-};
-
-/**
- * Formats response for successful responses
- */
-/* istanbul ignore next */
-const successHttpResponseMiddleware = opts => {
-  return {
-    after: (handler, next) =>
-      successHttpResponseAfterHandler(handler, next, opts),
-  };
-};
-
-export default successHttpResponseMiddleware;

package/src/middlewares/verifyJwtMiddleware.js

@@ -1,73 +0,0 @@
-import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import JwtService from '../services/JwtService';
-import LesgoException from '../exceptions/LesgoException';
-
-export const token = headers => {
-  const authorizationHeader = headers.Authorization || headers.authorization;
-
-  if (!authorizationHeader) {
-    throw new LesgoException(
-      'Authorization Header is required!',
-      'JWT_MISSING_AUTHORIZATION_HEADER',
-      403
-    );
-  }
-
-  const parsed = authorizationHeader.split(' ');
-
-  if (!parsed[1]) {
-    throw new LesgoException(
-      'Missing Bearer token!',
-      'JWT_MISSING_BEARER_TOKEN',
-      403
-    );
-  }
-
-  return parsed[1];
-};
-
-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), {
-      ...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, err);
-    } else if (err.name === 'TokenExpiredError') {
-      throw new LesgoException(err.message, 'JWT_EXPIRED', 403, err);
-    } else {
-      throw err;
-    }
-  }
-};
-
-const verifyJwtMiddleware /* istanbul ignore next */ = opts => {
-  return {
-    before: (handler, next) =>
-      verifyJwtMiddlewareBeforeHandler(handler, next, opts),
-  };
-};
-
-export default verifyJwtMiddleware;