graphql-mocks/es/highlight/highlight.js

Tools for setting up graphql test resolvers

import { clone } from 'ramda';
import { include } from './operation/include.js';
import { exclude } from './operation/exclude.js';
import { filter } from './operation/filter.js';
import { validate, ValidationError } from './utils/validate.js';
import { convertHighlighterOrReferenceToHighlighter } from './utils/convert-highlighter-or-reference-to-highlighter.js';
import { buildReferenceMap } from './utils/build-reference-map.js';
import { unique } from './utils/unique.js';
import { isFieldReference } from './utils/is-field-reference.js';
import { isTypeReference } from './utils/is-type-reference.js';
var INTERNAL_SCALARS = ['Int', 'Float', 'String', 'Boolean', 'ID'];

class Highlight {
  constructor(schema, references) {
    var _references;

    this.schema = schema;
    references = (_references = references) !== null && _references !== void 0 ? _references : [];
    this.validate(references);
    this.references = references;
  }

  get instances() {
    var schema = this.schema;
    var map = buildReferenceMap(schema, this.references);
    return {
      types: map
    };
  }

  include() {
    var operation = include;

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

    var highlighters = highlightersOrReferences.map(convertHighlighterOrReferenceToHighlighter).filter(Boolean);
    var newReferences = this.applyHighlighters(operation, highlighters);
    this.validate(newReferences);
    return this.clone(newReferences);
  }

  exclude() {
    var operation = exclude;

    for (var _len2 = arguments.length, highlightersOrReferences = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      highlightersOrReferences[_key2] = arguments[_key2];
    }

    var highlighters = highlightersOrReferences.map(convertHighlighterOrReferenceToHighlighter).filter(Boolean);
    var newReferences = this.applyHighlighters(operation, highlighters);
    this.validate(newReferences);
    return this.clone(newReferences);
  }

  filter() {
    var operation = filter;

    for (var _len3 = arguments.length, highlightersOrReferences = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      highlightersOrReferences[_key3] = arguments[_key3];
    }

    var highlighters = highlightersOrReferences.map(convertHighlighterOrReferenceToHighlighter).filter(Boolean);
    var newReferences = this.applyHighlighters(operation, highlighters);
    this.validate(newReferences);
    return this.clone(newReferences);
  }

  clone(references) {
    return new Highlight(this.schema, references);
  }

  applyHighlighters(operation, highlighters) {
    var schema = this.schema; // all changes are implemented with a fresh copy of data

    var references = clone(this.references);
    var updated = highlighters.reduce((references, highlighter) => {
      var highlightedReferences = highlighter.mark(schema);
      return operation(references, highlightedReferences);
    }, references).filter(function filterInternalGraphQLTypes(reference) {
      var type;

      if (isFieldReference(reference)) {
        type = reference[0];
      }

      if (isTypeReference(reference)) {
        type = reference;
      }

      if (type) {
        return !type.startsWith('__') && !INTERNAL_SCALARS.includes(type);
      }

      return true;
    });
    updated = unique(updated);
    return updated;
  }

  validate(references) {
    var errors = references.map(reference => validate(this.schema, reference)).filter(Boolean);

    if (errors.length === 0) {
      return;
    }

    throw new ValidationError(errors);
  }

}

function hi(schema, references) {
  return new Highlight(schema, references);
}

export { Highlight, hi };
//# sourceMappingURL=highlight.js.map