jscrambler/dist/get-protection-default-fragments.js

'use strict';

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

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var getIntrospection = function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(client, typeName) {
    var _introspection;

    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _introspection = void 0;
            _context.prev = 1;
            _context.next = 4;
            return introspection.type(client, typeName);

          case 4:
            _introspection = _context.sent;
            _context.next = 9;
            break;

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

          case 9:
            return _context.abrupt('return', _introspection);

          case 10:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this, [[1, 7]]);
  }));

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

var _introspection2 = require('./introspection');

var introspection = _interopRequireWildcard(_introspection2);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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"); }); }; }

function fragmentToQL(fragment) {
  var iterate = function iterate(i) {
    return Object.keys(i).map(function (key) {
      var result;
      var value = i[key];
      if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
        result = key + ' { ' + iterate(value) + ' }';
      } else {
        result = key;
      }
      return result;
    }).join(',');
  };
  return iterate(fragment);
}

function getAvaliableFragments(a, b) {
  var fragment = {};
  Object.keys(b).forEach(function (field) {
    var _field = a.find(function (f) {
      return f.name === field;
    });
    if (_field) {
      if (_typeof(b[field]) === 'object' && _field.type.ofType.kind === 'OBJECT') {
        fragment[field] = b[field];
      } else {
        fragment[field] = 1;
      }
    }
  });
  return fragment;
}

var protectionFields = {
  _id: 1,
  state: 1,
  bail: 1,
  growthWarning: 1,
  errorMessage: 1,
  size: 1,
  transformedSize: 1
};

var deprecationFields = {
  type: 1,
  entity: 1
};

var sourceFields = {
  filename: 1
};

var errorMessageFields = {
  message: 1,
  line: 1,
  column: 1,
  fatal: 1
};

exports.default = function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(client) {
    var appProtection, deprecation, source, errorMessage, fragments;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return getIntrospection(client, 'ApplicationProtection');

          case 2:
            appProtection = _context2.sent;
            _context2.next = 5;
            return getIntrospection(client, 'Deprecation');

          case 5:
            deprecation = _context2.sent;
            _context2.next = 8;
            return getIntrospection(client, 'ApplicationSource');

          case 8:
            source = _context2.sent;
            _context2.next = 11;
            return getIntrospection(client, 'ErrorMessages');

          case 11:
            errorMessage = _context2.sent;
            fragments = {
              application: {
                name: 1
              },
              applicationProtection: {}
            };

            fragments.applicationProtection = appProtection && getAvaliableFragments(appProtection.fields, protectionFields);

            fragments.applicationProtection.deprecations = deprecation && getAvaliableFragments(deprecation.fields, deprecationFields);

            fragments.applicationProtection.sources = source && getAvaliableFragments(source.fields, sourceFields);

            fragments.applicationProtection.sources.errorMessages = errorMessage && getAvaliableFragments(errorMessage.fields, errorMessageFields);

            return _context2.abrupt('return', {
              application: fragmentToQL(fragments.application),
              applicationProtection: fragmentToQL(fragments.applicationProtection)
            });

          case 18:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  return function (_x3) {
    return _ref2.apply(this, arguments);
  };
}();