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

Tools for setting up graphql test resolvers

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

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

import { pack } from '../pack/pack.js';
import '../pack/utils/embed-pack-options-wrapper.js';
import { mergeDeepRight } from 'ramda';
import { hi } from '../highlight/highlight.js';
import 'graphql';
import { fromResolverMap } from '../highlight/highlighter/from-resolver-map.js';
import { walk } from '../highlight/utils/walk.js';
import { getResolver } from './get-resolver.js';
import { setResolver } from './set-resolver.js';
import { applyWrappers } from '../resolver/apply-wrappers.js';

function layer(partials, options) {
  options = _objectSpread({
    replace: false,
    wrappers: []
  }, options);
  var layerMiddlewares = partials.map(resolverMap => previous => {
    return mergeDeepRight(previous, resolverMap);
  });

  var middleware = /*#__PURE__*/function () {
    var _layerMiddleware = _asyncToGenerator(function* (resolverMap, packOptions) {
      var {
        graphqlSchema
      } = packOptions.dependencies;
      if (!graphqlSchema) throw new Error('`graphqlSchema` is a required dependency');
      var packed = yield pack({}, layerMiddlewares, packOptions);
      var layeredResolverMap = packed.resolverMap;
      var resolverMapReferences = hi(graphqlSchema).include(fromResolverMap(layeredResolverMap)).references; // walk references from the resulting layeredResolverMap and apply them to
      // the final resolverMap for this middlware with any provided wrappers

      yield walk(graphqlSchema, resolverMapReferences, /*#__PURE__*/function () {
        var _ref2 = _asyncToGenerator(function* (_ref) {
          var _options, _options$wrappers;

          var {
            reference,
            type,
            field
          } = _ref;
          var resolver = getResolver(layeredResolverMap, reference);

          if (resolver && ((_options = options) === null || _options === void 0 ? void 0 : (_options$wrappers = _options.wrappers) === null || _options$wrappers === void 0 ? void 0 : _options$wrappers.length)) {
            resolver = yield applyWrappers(resolver, options.wrappers, {
              schema: graphqlSchema,
              resolverMap,
              packOptions,
              type: type,
              field: field
            });
          }

          if (resolver) {
            var _options2;

            setResolver(resolverMap, reference, resolver, {
              replace: (_options2 = options) === null || _options2 === void 0 ? void 0 : _options2.replace
            });
          }
        });

        return function (_x3) {
          return _ref2.apply(this, arguments);
        };
      }());
      return resolverMap;
    });

    function layerMiddleware(_x, _x2) {
      return _layerMiddleware.apply(this, arguments);
    }

    return layerMiddleware;
  }();

  return middleware;
}

export { layer };
//# sourceMappingURL=layer.js.map