@mindhive/mock-aws/dist/givenTableCreated.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _isEqual = require('lodash/isEqual');

var _isEqual2 = _interopRequireDefault(_isEqual);

var _pick = require('lodash/pick');

var _pick2 = _interopRequireDefault(_pick);

var _fromPairs = require('lodash/fromPairs');

var _fromPairs2 = _interopRequireDefault(_fromPairs);

var _dynamodbClientInstance = require('./dynamodbClientInstance');

var _dynamodbClientInstance2 = _interopRequireDefault(_dynamodbClientInstance);

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

var matchProps = ['AttributeDefinitions', 'KeySchema'];

exports.default = function () {
  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(tableProperties) {
    var client, tableNameProp, existing, keyAttributesNames, expressionAttributeNames, scanParams, scanRequest, scanResponse, captureResponse, scan, createProps;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (tableProperties.TableName) {
              _context.next = 2;
              break;
            }

            throw new Error('If you are using a CloudFormation generated TableName you need to Output it and pass it in');

          case 2:
            _context.next = 4;
            return (0, _dynamodbClientInstance2.default)();

          case 4:
            client = _context.sent;
            tableNameProp = { TableName: tableProperties.TableName };
            existing = null;
            _context.prev = 7;
            _context.next = 10;
            return client.describeTable(tableNameProp).promise();

          case 10:
            existing = _context.sent;
            _context.next = 17;
            break;

          case 13:
            _context.prev = 13;
            _context.t0 = _context['catch'](7);

            if (!(_context.t0.code !== 'ResourceNotFoundException')) {
              _context.next = 17;
              break;
            }

            throw _context.t0;

          case 17:
            if (!existing) {
              _context.next = 44;
              break;
            }

            if (!(0, _isEqual2.default)((0, _pick2.default)(existing.Table, matchProps), (0, _pick2.default)(tableProperties, matchProps))) {
              _context.next = 39;
              break;
            }

            // Just empty it
            keyAttributesNames = existing.Table.KeySchema.map(function (s) {
              return s.AttributeName;
            });
            expressionAttributeNames = (0, _fromPairs2.default)(keyAttributesNames.map(function (a, i) {
              return ['#A' + i, a];
            }));
            scanParams = Object.assign({}, tableNameProp, {
              ExpressionAttributeNames: expressionAttributeNames,
              ProjectionExpression: Object.keys(expressionAttributeNames).join(', ')
            });
            _context.next = 24;
            return client.scan(scanParams);

          case 24:
            scanRequest = _context.sent;
            scanResponse = null;

            captureResponse = function captureResponse(response) {
              scanResponse = response;
            };

          case 27:
            scanRequest.on('success', captureResponse);
            _context.next = 30;
            return scanRequest.promise();

          case 30:
            scan = _context.sent;

            if (scan.Items.length) {
              _context.next = 33;
              break;
            }

            return _context.abrupt('return');

          case 33:
            _context.next = 35;
            return client.batchWriteItem({
              RequestItems: (0, _defineProperty3.default)({}, tableNameProp.TableName, scan.Items.map(function (k) {
                return {
                  DeleteRequest: { Key: k }
                };
              }))
            }).promise();

          case 35:
            scanRequest = scanResponse.nextPage();

          case 36:
            if (scanRequest) {
              _context.next = 27;
              break;
            }

          case 37:
            _context.next = 42;
            break;

          case 39:
            console.log('Reverting to delete as table properties have changed');
            // Have to delete, this can be slow with DynamoDB local
            _context.next = 42;
            return client.deleteTable(tableNameProp).promise();

          case 42:
            _context.next = 48;
            break;

          case 44:
            createProps = Object.assign({}, tableProperties);

            if (createProps.StreamSpecification && !('StreamEnabled' in createProps.StreamSpecification)) {
              // This is needed by the SDK, but not in CloudFormation
              createProps.StreamSpecification.StreamEnabled = true;
            }
            _context.next = 48;
            return client.createTable(createProps).promise();

          case 48:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined, [[7, 13]]);
  }));

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