graphql-mocks/es/graphql/handler.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 { graphql } from 'graphql';
import { pack } from '../pack/pack.js';
import '../pack/utils/embed-pack-options-wrapper.js';
import { attachResolversToSchema } from './utils/attach-resolvers-to-schema.js';
import { attachScalarsToSchema } from './utils/attach-scalars-to-schema.js';
import { createSchema } from './utils/create-schema.js';
import { buildContext } from './utils/build-context.js';
import { normalizePackOptions } from '../pack/utils/normalize-pack-options.js';

class GraphQLHandler {
  constructor(options) {
    var _options$dependencies, _options$resolverMap, _options$state, _options$middlewares, _options$scalarMap;

    this.packed = false;
    var graphqlSchema = createSchema((_options$dependencies = options.dependencies) === null || _options$dependencies === void 0 ? void 0 : _options$dependencies.graphqlSchema);

    var dependencies = _objectSpread(_objectSpread({}, options.dependencies), {}, {
      graphqlSchema
    });

    this.packOptions = normalizePackOptions({
      dependencies,
      state: options.state
    });
    this.graphqlSchema = graphqlSchema;
    this.initialContext = options.initialContext;
    this.initialResolverMap = (_options$resolverMap = options.resolverMap) !== null && _options$resolverMap !== void 0 ? _options$resolverMap : {};
    this.state = (_options$state = options.state) !== null && _options$state !== void 0 ? _options$state : {};
    this.middlewares = (_options$middlewares = options.middlewares) !== null && _options$middlewares !== void 0 ? _options$middlewares : [];
    this.scalarMap = (_options$scalarMap = options.scalarMap) !== null && _options$scalarMap !== void 0 ? _options$scalarMap : {};
  }

  applyMiddlewares(middlewares, options) {
    var _options$reset;

    var reset = (_options$reset = options === null || options === void 0 ? void 0 : options.reset) !== null && _options$reset !== void 0 ? _options$reset : false;

    if (!reset) {
      middlewares = [...this.middlewares, ...middlewares];
    }

    this.middlewares = middlewares;
    this.packed = false;
  } // eslint-disable-next-line @typescript-eslint/no-explicit-any


  query(query, variableValues, queryContext, graphqlArgs) {
    var _this = this;

    return _asyncToGenerator(function* () {
      var _variableValues, _queryContext;

      var initialContext = _this.initialContext;
      var packOptions = _this.packOptions;
      var schema = _this.graphqlSchema;
      variableValues = (_variableValues = variableValues) !== null && _variableValues !== void 0 ? _variableValues : {};
      queryContext = (_queryContext = queryContext) !== null && _queryContext !== void 0 ? _queryContext : {};
      yield _this.pack();
      var contextValue = buildContext({
        initialContext,
        queryContext,
        packOptions
      });
      return graphql(_objectSpread(_objectSpread({}, graphqlArgs), {}, {
        source: query,
        schema,
        variableValues,
        contextValue
      }));
    })();
  }

  pack() {
    var _this2 = this;

    return _asyncToGenerator(function* () {
      var {
        initialResolverMap,
        middlewares,
        packOptions,
        graphqlSchema,
        scalarMap
      } = _this2;

      if (!_this2.packed) {
        var {
          resolverMap,
          state
        } = yield pack(initialResolverMap, middlewares, packOptions);
        _this2.state = state;
        attachResolversToSchema(graphqlSchema, resolverMap);
        attachScalarsToSchema(graphqlSchema, scalarMap);
      }

      _this2.packed = true;
    })();
  }

}

export { GraphQLHandler };
//# sourceMappingURL=handler.js.map