graphql-mocks/graphql/handler.js

Tools for setting up graphql test resolvers

'use strict';

function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
var graphql = require('graphql');
var pack = require('../pack/pack.js');
require('../pack/utils/embed-pack-options-wrapper.js');
var attachScalarsToSchema = require('./utils/attach-scalars-to-schema.js');
var createSchema = require('./utils/create-schema.js');
var buildContext = require('./utils/build-context.js');
var normalizePackOptions = require('../pack/utils/normalize-pack-options.js');
var resolverRouter = require('./resolver-router.js');
class GraphQLHandler {
  constructor(options) {
    var _options$dependencies, _options$resolverMap, _options$state, _options$middlewares, _options$scalarMap;
    _defineProperty(this, "state", void 0);
    _defineProperty(this, "packed", false);
    _defineProperty(this, "packOptions", void 0);
    _defineProperty(this, "middlewares", void 0);
    _defineProperty(this, "graphqlSchema", void 0);
    _defineProperty(this, "initialContext", void 0);
    _defineProperty(this, "initialResolverMap", void 0);
    _defineProperty(this, "scalarMap", void 0);
    _defineProperty(this, "fieldResolverRouter", void 0);
    _defineProperty(this, "typeResolverRouter", void 0);
    const graphqlSchema = createSchema.createSchema((_options$dependencies = options.dependencies) === null || _options$dependencies === void 0 ? void 0 : _options$dependencies.graphqlSchema);
    const dependencies = _objectSpread(_objectSpread({}, options.dependencies), {}, {
      graphqlSchema
    });
    this.packOptions = normalizePackOptions.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;
    const 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
  async query(query, variableValues, queryContext, graphqlArgs) {
    var _variableValues, _queryContext;
    const {
      initialContext,
      packOptions,
      graphqlSchema: schema
    } = this;
    variableValues = (_variableValues = variableValues) !== null && _variableValues !== void 0 ? _variableValues : {};
    queryContext = (_queryContext = queryContext) !== null && _queryContext !== void 0 ? _queryContext : {};
    await this.pack();
    const {
      fieldResolverRouter,
      typeResolverRouter
    } = this;
    if (!fieldResolverRouter || !typeResolverRouter) {
      throw new Error('Run `pack` to ensure that field resolver and type resolvers are set');
    }
    const contextValue = buildContext.buildContext({
      initialContext,
      queryContext,
      packOptions
    });
    return graphql.graphql(_objectSpread(_objectSpread({}, graphqlArgs), {}, {
      source: query,
      schema,
      variableValues,
      contextValue,
      fieldResolver: fieldResolverRouter,
      typeResolver: typeResolverRouter
    }));
  }
  async pack() {
    const {
      initialResolverMap,
      middlewares,
      packOptions,
      graphqlSchema,
      scalarMap
    } = this;
    if (!this.packed) {
      const {
        resolverMap,
        state
      } = await pack.pack(initialResolverMap, middlewares, packOptions);
      this.state = state;
      this.fieldResolverRouter = resolverRouter.createFieldResolverRouter(resolverMap);
      this.typeResolverRouter = resolverRouter.createTypeResolverRouter(resolverMap);
      attachScalarsToSchema.attachScalarsToSchema(graphqlSchema, scalarMap);
    }
    this.packed = true;
  }
}
exports.GraphQLHandler = GraphQLHandler;
//# sourceMappingURL=handler.js.map