graphql-mocks/es/highlight/highlighter/resolves-to.js

Tools for setting up graphql test resolvers

import { isObjectType, parse } from 'graphql';
import { HIGHLIGHT_ALL } from './constants.js';
import { evolve, omit, equals } from 'ramda';

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

function getResolvableAST(resolveString) {
  var _objectNode$fields;

  resolveString = resolveString.trim();
  var node;

  try {
    // https://astexplorer.net/#/gist/94dd07476cd3fdfa4a8ada395022b330/21faa076d9e4b626f114e39c79db8556cfb852ae
    node = parse("\n    type Noop {\n      noop: ".concat(resolveString, "\n    }\n  "));
  } catch (_unused) {
    return undefined;
  }

  var objectNode = node.definitions[0];
  var fieldNode = objectNode === null || objectNode === void 0 ? void 0 : (_objectNode$fields = objectNode.fields) === null || _objectNode$fields === void 0 ? void 0 : _objectNode$fields[0];
  return fieldNode.type;
}

function compareTypeNodes(a, b) {
  var aHasType = a && 'type' in a;
  var bHasType = b && 'type' in b;

  if (aHasType && bHasType && a.kind === b.kind) {
    return compareTypeNodes(a.type, b.type);
  } else if (typeof a === 'object' && typeof b === 'object') {
    var removeLocsFromNamedTypeNode = evolve({
      loc: () => undefined,
      name: omit(['loc'])
    });
    return equals(removeLocsFromNamedTypeNode(a), removeLocsFromNamedTypeNode(b));
  } else {
    return false;
  }
}

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

    this.targets = targets;
  }

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

  static expandTargets(schema, targets) {
    if (targets.includes(HIGHLIGHT_ALL)) {
      return ResolvesToHighlighter.allFieldResolvables(schema);
    }

    var astTargets = targets.map(getResolvableAST).filter(Boolean);
    return astTargets.map(astTarget => ResolvesToHighlighter.expandTarget(schema, astTarget)).reduce(concat, []);
  }

  static expandTarget(schema, targetAST) {
    var types = Object.values(schema.getTypeMap());
    var fieldReferences = types.filter(isObjectType).map(type => {
      var fields = Object.values(type.getFields());
      var fieldReferences = fields.reduce((fieldReferences, field) => {
        var _field$astNode;

        var fieldReturnAST = (_field$astNode = field.astNode) === null || _field$astNode === void 0 ? void 0 : _field$astNode.type;
        var typeNodesEqual = compareTypeNodes(targetAST, fieldReturnAST);

        if (typeNodesEqual) {
          fieldReferences.push([type.name, field.name]);
        }

        return fieldReferences;
      }, []);
      return fieldReferences;
    }).reduce(concat, []);
    return fieldReferences;
  }

  static allFieldResolvables(schema) {
    var allResolvableFieldReferences = Object.values(schema.getTypeMap()).filter(isObjectType).filter(type => !type.name.startsWith('__')).map(type => {
      var fields = Object.values(type.getFields());
      return fields.map(field => 'resolve' in field && [type.name, field.name]);
    }).reduce(concat, []).filter(Boolean);
    return allResolvableFieldReferences;
  }

}

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

  return new ResolvesToHighlighter(returnTargets);
};

export { ResolvesToHighlighter, resolvesTo };
//# sourceMappingURL=resolves-to.js.map