lesgo 1.0.0 → 2.1.1

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

@@ -1,297 +0,0 @@
-import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import verifyJwtMiddleware, {
-  verifyJwtMiddlewareBeforeHandler,
-} from '../verifyJwtMiddleware';
-
-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', async () => {
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(handler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('Authorization Header is required!');
-      expect(e.code).toEqual('JWT_MISSING_AUTHORIZATION_HEADER');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with missing bearer token', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: '',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('Authorization Header is required!');
-      expect(e.code).toEqual('JWT_MISSING_AUTHORIZATION_HEADER');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with invalid token', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: 'asdasd',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('Missing Bearer token!');
-      expect(e.code).toEqual('JWT_MISSING_BEARER_TOKEN');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with malformed token', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization: 'Bearer sdawdasdawdawdsd',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('jwt malformed');
-      expect(e.code).toEqual('JWT_ERROR');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with incorrect secret key', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('invalid signature');
-      expect(e.code).toEqual('JWT_ERROR');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with invalid ISS', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.2r0UHtMWMcLH3VJVDtVGP2_MT8npWy-w2lsUiZSBFFI',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual("Token's [iss] is not valid!");
-      expect(e.code).toEqual('JWT_ISS_NOT_VALID');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with missing custom claim', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIn0.grz7RVA9XuOj4TUKLefvblt6bnSz0yfFpwee1MgMnN0',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Token's custom claim [${config.customClaims.data[0]}] not found!`
-      );
-      expect(e.code).toEqual('JWT_CUSTOM_CLAIM_NOT_FOUND');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with expired token', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZXhwIjoxNTE2MjM5MDIyfQ.-S3Ym5HiC5GPiW1Zjjt4j6L-skqP4PVV5f4fIScgPTE',
-        },
-      },
-    };
-
-    try {
-      expect(
-        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-      ).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual('jwt expired');
-      expect(e.code).toEqual('JWT_EXPIRED');
-      expect(e.statusCode).toEqual(403);
-    }
-  });
-
-  it('test with valid token', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-
-    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
-    expect(newHandler.event.decodedJwt).toMatchObject({
-      sub: '1234567890',
-      iss: config.iss.data[0],
-    });
-  });
-
-  it('test with secret as a function argument', async () => {
-    const { secret } = config;
-    config.secret = secretHandler => {
-      return `111${secretHandler.key}`;
-    };
-    const newHandler = {
-      key: '1',
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.7RdbXJhzrn_yV7CPqkuX0Yvtms0xaIw1q4LPe8O0BDY',
-        },
-      },
-    };
-
-    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
-    expect(newHandler.event.decodedJwt).toMatchObject({
-      sub: '1234567890',
-      iss: config.iss.data[0],
-    });
-
-    config.secret = secret;
-  });
-
-  it('test with callback argument', async () => {
-    const callback = jest.fn();
-    config.callback = callback;
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-
-    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
-    expect(newHandler.event.decodedJwt).toMatchObject({
-      sub: '1234567890',
-      iss: config.iss.data[0],
-    });
-    expect(callback).toHaveBeenCalledWith(newHandler);
-  });
-
-  it('test with custom config', async () => {
-    const newHandler = {
-      event: {
-        ...handler.event,
-        headers: {
-          Authorization:
-            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-        },
-      },
-    };
-
-    await 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,125 +0,0 @@
-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

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

@@ -1,101 +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: options.formatError
-      ? options.formatError(options)
-      : 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;