lesgo 0.7.8 → 2.1.0

package/src/middlewares/clientAuthMiddleware.js

@@ -1,82 +0,0 @@
-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/errorHttpResponseMiddleware.js

@@ -1,99 +0,0 @@
-import logger from '../utils/logger';
-import isEmpty from '../utils/isEmpty';
-
-const FILE = 'Lesgo/middlewares/errorHttpResponseMiddleware';
-
-export const errorHttpResponseHandler = async opts => {
-  const defaults = {
-    response: '',
-    statusCode: 500,
-    event: {},
-    debugMode: false,
-    headers: {
-      'Access-Control-Allow-Origin': '*',
-      'Cache-Control': 'no-cache',
-      'Content-Type': 'application/json',
-    },
-    error: '',
-  };
-
-  const optionsHeadersMerged =
-    opts === undefined
-      ? { ...defaults.headers }
-      : {
-          ...opts,
-          headers: { ...defaults.headers, ...opts.headers },
-        };
-
-  const options = { ...defaults, ...optionsHeadersMerged };
-
-  const jsonBody = {
-    status: 'error',
-    data: null,
-    error: {
-      code: options.error.code || 'UNHANDLED_ERROR',
-      message: options.error.name
-        ? `${options.error.name}: ${options.error.message}`
-        : options.error.message || options.error,
-      details: options.error.extra || '',
-    },
-    _meta: options.debugMode ? options.event : {},
-  };
-
-  const statusCode = options.error.statusCode || options.statusCode;
-
-  if (!isEmpty(options.error)) {
-    logger.log(statusCode === 500 ? 'error' : 'warn', options.error);
-  } else {
-    logger.log(statusCode === 500 ? 'error' : 'warn', jsonBody.error.message, {
-      error: jsonBody.error,
-    });
-  }
-
-  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,
-    body: JSON.stringify(jsonBody),
-  };
-};
-
-export const errorHttpResponseAfterHandler = async (handler, next, opts) => {
-  const defaults = {
-    error: handler.error,
-    event: handler.event,
-    logger: console.error, // eslint-disable-line no-console
-  };
-
-  const options = { ...defaults, ...opts };
-
-  // eslint-disable-next-line no-param-reassign
-  handler.response = await errorHttpResponseHandler(options);
-  /* istanbul ignore next */
-  next();
-};
-
-/**
- * Formats response for error responses
- */
-/* istanbul ignore next */
-const errorHttpResponseMiddleware = opts => {
-  return {
-    onError: (handler, next) =>
-      errorHttpResponseAfterHandler(handler, next, opts),
-  };
-};
-
-export default errorHttpResponseMiddleware;

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,87 +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 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/index.js

@@ -1,15 +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';
-
-export {
-  httpMiddleware,
-  normalizeHttpRequestMiddleware,
-  successHttpResponseMiddleware,
-  errorHttpResponseMiddleware,
-  normalizeSQSMessageMiddleware,
-  verifyJwtMiddleware,
-};

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

@@ -1,29 +0,0 @@
-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/successHttpResponseMiddleware.js

@@ -1,83 +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: 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;