graphql-mocks/es/resolver/create-wrapper.js

Tools for setting up graphql test resolvers

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; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

import { isObjectType, isAbstractType } from 'graphql';
import { WrapperFor } from './constants.js';

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

function hasTypeResolverPackage(type, pkg) {
  return Boolean(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;
  }

  wrap(resolver, options) {
    var _this = this;

    return _asyncToGenerator(function* () {
      var {
        type,
        field
      } = options;
      var wrapper = _this.wrapper;
      var wrapperFor = _this.wrapperFor; // for use with type guards `hasFieldResolverPackage` and `hasTypeResolverPackage`

      var wrapperPkg = {
        resolver,
        wrapper,
        options
      };

      if (hasFieldResolverPackage(type, wrapperPkg) && field && wrapperFor === WrapperFor.FIELD) {
        var {
          wrapper: _wrapper,
          resolver: _resolver,
          options: _options
        } = wrapperPkg;

        var expandedOptions = _objectSpread(_objectSpread({}, _options), {}, {
          type: _options.type,
          field: _options.field
        });

        return _wrapper(_resolver, expandedOptions);
      } else if (hasTypeResolverPackage(type, wrapperPkg) && !field && wrapperFor === WrapperFor.TYPE) {
        var {
          wrapper: _wrapper2,
          resolver: _resolver2,
          options: _options2
        } = wrapperPkg;

        var _expandedOptions = _objectSpread(_objectSpread({}, _options2), {}, {
          type: type,
          field: undefined
        });

        return _wrapper2(_resolver2, _expandedOptions);
      } else if (wrapperFor === 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);
}

export { createWrapper };
//# sourceMappingURL=create-wrapper.js.map