graphql-compose-relay/lib/composeWithRelay.js

Plugin for `graphql-compose` which wraps graphql types with Relay specific logic.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.composeWithRelay = composeWithRelay;
exports.TypeMapForRelayNode = void 0;

var _graphqlCompose = require("graphql-compose");

var _wrapMutationResolver = _interopRequireDefault(require("./wrapMutationResolver"));

var _globalId = require("./globalId");

var _nodeInterface = require("./nodeInterface");

var _nodeFieldConfig = require("./nodeFieldConfig");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/* eslint-disable no-use-before-define */
// all wrapped typeComposers with Relay, stored in this variable
// for futher type resolving via NodeInterface.resolveType method
const TypeMapForRelayNode = {};
exports.TypeMapForRelayNode = TypeMapForRelayNode;

function composeWithRelay(tc) {
  if (!(tc instanceof _graphqlCompose.ObjectTypeComposer)) {
    throw new Error('You should provide ObjectTypeComposer instance to composeWithRelay method');
  }

  const nodeInterface = (0, _nodeInterface.getNodeInterface)(tc.schemaComposer);
  const nodeFieldConfig = (0, _nodeFieldConfig.getNodeFieldConfig)(TypeMapForRelayNode, nodeInterface);

  if (tc.getTypeName() === 'Query' || tc.getTypeName() === 'RootQuery') {
    tc.setField('node', nodeFieldConfig);
    return tc;
  }

  if (tc.getTypeName() === 'Mutation' || tc.getTypeName() === 'RootMutation') {
    // just skip
    return tc;
  }

  if (!tc.hasRecordIdFn()) {
    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. ` + 'This function returns ID from provided object.');
  }

  const findById = tc.getResolver('findById');

  if (!findById) {
    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay ` + 'should have findById resolver.');
  }

  TypeMapForRelayNode[tc.getTypeName()] = {
    resolver: findById,
    tc
  };
  tc.addFields({
    id: {
      type: 'ID!',
      description: 'The globally unique ID among all types',
      resolve: source => (0, _globalId.toGlobalId)(tc.getTypeName(), tc.getRecordId(source))
    }
  });
  tc.addInterface(nodeInterface);
  tc.getResolvers().forEach((resolver, resolverName) => {
    if (resolver.kind === 'mutation') {
      const wrappedResolver = (0, _wrapMutationResolver.default)(resolver, {
        resolverName,
        rootTypeName: tc.getTypeName()
      });
      tc.setResolver(resolverName, wrappedResolver);
    }
  });
  return tc;
}