graphql-mocks/highlight/highlight.js

Tools for setting up graphql test resolvers

'use strict';

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

var ramda = require('ramda');

var include = require('./operation/include.js');

var exclude = require('./operation/exclude.js');

var filter = require('./operation/filter.js');

var validate = require('./utils/validate.js');

var convertHighlighterOrReferenceToHighlighter = require('./utils/convert-highlighter-or-reference-to-highlighter.js');

var buildReferenceMap = require('./utils/build-reference-map.js');

var unique = require('./utils/unique.js');

var isFieldReference = require('./utils/is-field-reference.js');

var isTypeReference = require('./utils/is-type-reference.js');

const 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() {
    const schema = this.schema;
    const map = buildReferenceMap.buildReferenceMap(schema, this.references);
    return {
      types: map
    };
  }

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

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

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

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

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

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

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

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

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

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

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

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

    throw new validate.ValidationError(errors);
  }

}

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

exports.Highlight = Highlight;
exports.hi = hi;
//# sourceMappingURL=highlight.js.map