graphql-mocks/resolver-map/set-resolver.js

Tools for setting up graphql test resolvers

'use strict';

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

var graphql = require('graphql');

var getResolver = require('./get-resolver.js');

require('ramda');

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

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

var isReference = require('../highlight/utils/is-reference.js');

var getInstanceForReference = require('../highlight/utils/get-instance-for-reference.js');

function setResolver(resolverMap, reference, resolver, options) {
  var _options, _options$replace, _resolverMap$insertPo;

  options = (_options = options) !== null && _options !== void 0 ? _options : {};
  const {
    graphqlSchema
  } = options;
  const replace = (_options$replace = options.replace) !== null && _options$replace !== void 0 ? _options$replace : false;

  if (typeof resolver !== 'function') {
    throw new TypeError(`Expected resolver to be a function, got ${typeof resolver}`);
  }

  if (typeof resolverMap !== 'object') {
    throw new TypeError(`Expected resolverMap must be an object, got ${typeof resolverMap}`);
  }

  if (!isReference.isReference(reference)) {
    throw new TypeError(`Expected reference to be a type reference or field reference, got ${typeof reference}`);
  }

  const insertPosition = isFieldReference.isFieldReference(reference) ? {
    type: reference[0],
    field: reference[1]
  } : {
    type: reference,
    field: '__resolveType'
  }; // Do additional safety checks if a graphqlSchema is provided

  if (graphqlSchema) {
    const instance = getInstanceForReference.getInstanceForReference(graphqlSchema, reference);

    if (!instance) {
      throw new Error(`Expected to find reference ${reference} in schema`);
    }

    if (isTypeReference.isTypeReference(reference) && !graphql.isAbstractType(instance)) {
      throw new Error(`Expected reference ${reference} to be an Interface or Union type`);
    }

    if (isFieldReference.isFieldReference(reference) && Array.isArray(instance) && !graphql.isObjectType(instance[0])) {
      const [typename, fieldname] = reference;
      throw new Error(`Could not find reference [${typename}, ${fieldname}] ([type name, field name]) in the GraphQL Schema`);
    }
  }

  const existingResolver = getResolver.getResolver(resolverMap, reference);

  if (existingResolver && !replace) {
    throw new Error(`Cannot add resolver to resolver map at ${reference} because a resolver already exists ` + `and the replace is set to ${replace}`);
  }

  resolverMap[insertPosition.type] = (_resolverMap$insertPo = resolverMap[insertPosition.type]) !== null && _resolverMap$insertPo !== void 0 ? _resolverMap$insertPo : {}; // eslint-disable-next-line @typescript-eslint/no-explicit-any

  resolverMap[insertPosition.type][insertPosition.field] = resolver;
  return resolverMap;
}

exports.setResolver = setResolver;
//# sourceMappingURL=set-resolver.js.map