graphql-mocks/es/highlight/highlighter/field.js

Tools for setting up graphql test resolvers

import { isInputType } from 'graphql';
import { HIGHLIGHT_ALL, HIGHLIGHT_ROOT_QUERY, HIGHLIGHT_ROOT_MUTATION } from './constants.js';

function concat(a, b) {
  return [].concat(a, b);
}

class FieldHighlighter {
  constructor(targets) {
    if (targets.length === 0) {
      targets = [[HIGHLIGHT_ALL, HIGHLIGHT_ALL]];
    }

    this.targets = targets;
  }

  mark(schema) {
    return FieldHighlighter.expandTargets(schema, this.targets);
  }

  static expandTargets(schema, targets) {
    var fieldReferences = targets.map(target => {
      return FieldHighlighter.expandTarget(schema, target);
    }).reduce(concat, []);
    return fieldReferences;
  }

  static expandTarget(schema, _ref) {
    var _type;

    var [typeTarget, fieldTarget] = _ref;

    if (typeTarget === HIGHLIGHT_ALL) {
      var allTypes = Object.values(schema.getTypeMap());
      var expanded = allTypes.filter(type => !type.name.startsWith('__')).map(type => {
        var hasFields = type && 'getFields' in type && !isInputType(type);
        return hasFields ? this.expandTarget(schema, [type.name, fieldTarget]) : undefined;
      }).filter(Boolean).reduce(concat, []);
      return expanded;
    }

    var type = schema.getType(typeTarget);

    if (!type) {
      return [];
    }

    if (typeTarget === HIGHLIGHT_ROOT_QUERY) {
      var queryType = schema.getQueryType();

      if (!queryType) {
        return [];
      }

      type = queryType;
    }

    if (typeTarget === HIGHLIGHT_ROOT_MUTATION) {
      var mutationType = schema.getMutationType();

      if (!mutationType) {
        return [];
      }

      type = mutationType;
    }

    if (!type || !((_type = type) === null || _type === void 0 ? void 0 : _type.name) || !('getFields' in type)) {
      return [];
    }

    var fields = type.getFields();
    var fieldNames = fieldTarget === HIGHLIGHT_ALL ? Object.keys(fields) : [fieldTarget];
    var fieldReferences = fieldNames.filter(fieldName => Object.keys(fields).includes(fieldName)).map(fieldName => {
      var _type2;

      return ((_type2 = type) === null || _type2 === void 0 ? void 0 : _type2.name) && fieldName ? [type.name, fieldName] : undefined;
    }).filter(Boolean);
    return fieldReferences;
  }

}

var field = function type() {
  for (var _len = arguments.length, targetReferences = new Array(_len), _key = 0; _key < _len; _key++) {
    targetReferences[_key] = arguments[_key];
  }

  return new FieldHighlighter(targetReferences);
};

export { FieldHighlighter, field };
//# sourceMappingURL=field.js.map