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

Tools for setting up graphql test resolvers

import { isAbstractType, isObjectType } from 'graphql';
import { getResolver } from './get-resolver.js';
import 'ramda';
import { isTypeReference } from '../highlight/utils/is-type-reference.js';
import { isFieldReference } from '../highlight/utils/is-field-reference.js';
import { isReference } from '../highlight/utils/is-reference.js';
import { getInstanceForReference } from '../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 : {};
  var {
    graphqlSchema
  } = options;
  var 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 ".concat(typeof resolver));
  }

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

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

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

  if (graphqlSchema) {
    var instance = getInstanceForReference(graphqlSchema, reference);

    if (!instance) {
      throw new Error("Expected to find reference ".concat(reference, " in schema"));
    }

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

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

  var existingResolver = getResolver(resolverMap, reference);

  if (existingResolver && !replace) {
    throw new Error("Cannot add resolver to resolver map at ".concat(reference, " because a resolver already exists ") + "and the replace is set to ".concat(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;
}

export { setResolver };
//# sourceMappingURL=set-resolver.js.map