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

Tools for setting up graphql test resolvers

'use strict';

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

var graphql = require('graphql');

var constants = require('./constants.js');

var ramda = require('ramda');

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

function getResolvableAST(resolveString) {
  var _objectNode$fields;

  resolveString = resolveString.trim();
  let node;

  try {
    // https://astexplorer.net/#/gist/94dd07476cd3fdfa4a8ada395022b330/21faa076d9e4b626f114e39c79db8556cfb852ae
    node = graphql.parse(`
    type Noop {
      noop: ${resolveString}
    }
  `);
  } catch {
    return undefined;
  }

  const objectNode = node.definitions[0];
  const 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) {
  const aHasType = a && 'type' in a;
  const 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') {
    const removeLocsFromNamedTypeNode = ramda.evolve({
      loc: () => undefined,
      name: ramda.omit(['loc'])
    });
    return ramda.equals(removeLocsFromNamedTypeNode(a), removeLocsFromNamedTypeNode(b));
  } else {
    return false;
  }
}

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

    this.targets = targets;
  }

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

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

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

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

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

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

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

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

}

const resolvesTo = function type(...returnTargets) {
  return new ResolvesToHighlighter(returnTargets);
};

exports.ResolvesToHighlighter = ResolvesToHighlighter;
exports.resolvesTo = resolvesTo;
//# sourceMappingURL=resolves-to.js.map