graphql-mocks/resolver/create-wrapper.js

Tools for setting up graphql test resolvers

'use strict';

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

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

var graphql = require('graphql');

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

function hasFieldResolverPackage(type, pkg) {
  return Boolean(graphql.isObjectType(type) && pkg);
}

function hasTypeResolverPackage(type, pkg) {
  return Boolean(graphql.isAbstractType(type) && pkg);
}

class InternalNamedWrapper {
  constructor(name, wrapperFor, wrapperFn) {
    if (typeof name !== 'string') {
      throw new Error('Specify a string for the name argument for createWrapper');
    }

    this.name = name;
    this.wrapper = wrapperFn;
    this.wrapperFor = wrapperFor;
  }

  async wrap(resolver, options) {
    const {
      type,
      field
    } = options;
    const wrapper = this.wrapper;
    const wrapperFor = this.wrapperFor; // for use with type guards `hasFieldResolverPackage` and `hasTypeResolverPackage`

    const wrapperPkg = {
      resolver,
      wrapper,
      options
    };

    if (hasFieldResolverPackage(type, wrapperPkg) && field && wrapperFor === constants.WrapperFor.FIELD) {
      const {
        wrapper,
        resolver,
        options
      } = wrapperPkg;

      const expandedOptions = _objectSpread(_objectSpread({}, options), {}, {
        type: options.type,
        field: options.field
      });

      return wrapper(resolver, expandedOptions);
    } else if (hasTypeResolverPackage(type, wrapperPkg) && !field && wrapperFor === constants.WrapperFor.TYPE) {
      const {
        wrapper,
        resolver,
        options
      } = wrapperPkg;

      const expandedOptions = _objectSpread(_objectSpread({}, options), {}, {
        type: type,
        field: undefined
      });

      return wrapper(resolver, expandedOptions);
    } else if (wrapperFor === constants.WrapperFor.ANY) {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      return wrapper(resolver, options);
    }

    return resolver;
  }

}

function createWrapper(name, wrapperFor, wrapperFn) {
  return new InternalNamedWrapper(name, wrapperFor, wrapperFn);
}

exports.createWrapper = createWrapper;
//# sourceMappingURL=create-wrapper.js.map