@nypl/node-lambda-boilerplate/dist/index.js

An AWS node-lambda boilerplate written in ES7 via Babel that includes various configuration, testing, and deployment scripts

'use strict';

var _lambdaEnvVars = require('lambda-env-vars');

var _lambdaEnvVars2 = _interopRequireDefault(_lambdaEnvVars);

var _OAuthHelper = require('./src/helpers/OAuthHelper');

var _CacheFactory = require('./src/factories/CacheFactory');

var _CacheFactory2 = _interopRequireDefault(_CacheFactory);

var _ErrorHelper = require('./src/helpers/ErrorHelper');

var _ErrorHelper2 = _interopRequireDefault(_ErrorHelper);

var _Logger = require('./src/utilities/Logger');

var _Logger2 = _interopRequireDefault(_Logger);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } /* eslint-disable semi */


const lambdaEnvVarsClient = new _lambdaEnvVars2.default();

exports.handleKinesisAsyncProcessing = (() => {
  var _ref = _asyncToGenerator(function* (records, opts, context, callback) {
    try {
      const {
        oAuthProviderUrl,
        oAuthClientId,
        oAuthClientSecret,
        oAuthProviderScope
      } = opts;

      // Example of async/await promise handling
      const tokenResponse = yield (0, _OAuthHelper.handleAuthentication)(_CacheFactory2.default.getToken(), (0, _OAuthHelper.fetchAccessToken)(oAuthProviderUrl, oAuthClientId, oAuthClientSecret, oAuthProviderScope));

      if (tokenResponse.tokenType === 'new-token') {
        _Logger2.default.info('Obtained a new access token from the OAuth Service');
        _CacheFactory2.default.setToken(tokenResponse.token);
      } else {
        _Logger2.default.info('Using existing access token from Cache');
      }

      console.log(tokenResponse);
      return callback(null, 'The Lambda has successfully completed all operations; no fatal errors have occured');
    } catch (e) {
      if (typeof e === 'string' || e instanceof String) {
        _Logger2.default.error(`a fatal error occured, the lambda will NOT restart; ${e}`, { debugInfo: e });
        return false;
      }

      _Logger2.default.error('[handleKinesisAsyncProcessing function]: An unhandled error occured', { debugInfo: e });
      return callback(e);
    }
  });

  return function (_x, _x2, _x3, _x4) {
    return _ref.apply(this, arguments);
  };
})();

exports.kinesisHandler = (records, opts, context, callback) => {
  try {
    if (!opts || Object.keys(opts).length === 0) {
      throw new _ErrorHelper2.default('missing/undefined opts object configuration parameter', { type: 'function-parameter-error' });
    }

    if (!opts.oAuthProviderUrl || typeof opts.oAuthProviderUrl !== 'string' || opts.oAuthProviderUrl.trim() === '') {
      throw new _ErrorHelper2.default('missing/undefined oAuthProviderUrl configuration parameter', { type: 'function-parameter-error' });
    }

    if (!opts.oAuthClientId || typeof opts.oAuthClientId !== 'string' || opts.oAuthClientId.trim() === '') {
      throw new _ErrorHelper2.default('missing/undefined oAuthClientId configuration parameter', { type: 'function-parameter-error' });
    }

    if (!opts.oAuthClientSecret || typeof opts.oAuthClientSecret !== 'string' || opts.oAuthClientSecret.trim() === '') {
      throw new _ErrorHelper2.default('missing/undefined oAuthClientSecret configuration parameter', { type: 'function-parameter-error' });
    }

    if (!opts.oAuthProviderScope || typeof opts.oAuthProviderScope !== 'string' || opts.oAuthProviderScope.trim() === '') {
      throw new _ErrorHelper2.default('missing/undefined oAuthProviderScope configuration parameter', { type: 'function-parameter-error' });
    }

    return exports.handleKinesisAsyncProcessing(records, opts, context, callback);
  } catch (e) {
    _Logger2.default.error(`[kinesisHandler function error]: ${e.message}`, { debugInfo: e });
    return callback(e.message);
  }
};

exports.handler = (event, context, callback) => {
  if (event && Array.isArray(event.Records) && event.Records.length > 0) {
    const record = event.Records[0];
    // Handle Kinesis Stream
    if (record.kinesis && record.kinesis.data) {
      // Execute the handler in local development mode, without decryption
      if (!_CacheFactory2.default.isProductionEnv()) {
        _Logger2.default.info('executing kinesisHandler in local development mode');

        return exports.kinesisHandler(event.Records, {
          oAuthProviderUrl: process.env.OAUTH_PROVIDER_URL,
          oAuthClientId: process.env.OAUTH_CLIENT_ID,
          oAuthClientSecret: process.env.OAUTH_CLIENT_SECRET,
          oAuthProviderScope: process.env.OAUTH_PROVIDER_SCOPE
        }, context, callback);
      }

      // Handle Production decryption and execution of kinesisHandler
      return lambdaEnvVarsClient.getCustomDecryptedValueList(['OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET', 'OAUTH_PROVIDER_SCOPE'], { location: 'lambdaConfig' }).then(resultObject => {
        return exports.kinesisHandler(event.Records, {
          oAuthProviderUrl: process.env.OAUTH_PROVIDER_URL,
          oAuthClientId: resultObject.OAUTH_CLIENT_ID,
          oAuthClientSecret: resultObject.OAUTH_CLIENT_SECRET,
          oAuthProviderScope: resultObject.OAUTH_PROVIDER_SCOPE
        }, context, callback);
      }).catch(error => {
        _Logger2.default.error('[handler function error]: an error occured while decrypting the Lambda ENV variables via LambdaEnvVarsClient', { debugInfo: error });

        return callback(new Error('[handler function error]: an error occured while decrypting the Lambda ENV variables via LambdaEnvVarsClient'));
      });
    }

    _Logger2.default.error('[handler function error]: the event.Records array does not contain a kinesis stream of records to process');
    return callback(new Error('the event.Records array does not contain a kinesis stream of records to process'));
  }

  _Logger2.default.error('[handler function error]: the event.Records array is undefined');
  return callback(new Error('the event.Records array is undefined'));
};