graphql-compose/lib/toInputObjectType.js

GraphQL schema builder from different data sources with middleware extensions.

'use strict';

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = _assign2.default || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/* eslint-disable no-use-before-define, prefer-template */

exports.removeWrongFields = removeWrongFields;
exports.toInputObjectType = toInputObjectType;
exports.convertInputObjectField = convertInputObjectField;

var _graphql = require('graphql');

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _typeComposer = require('./typeComposer');

var _typeComposer2 = _interopRequireDefault(_typeComposer);

var _inputTypeComposer = require('./inputTypeComposer');

var _inputTypeComposer2 = _interopRequireDefault(_inputTypeComposer);

var _generic = require('./type/generic');

var _generic2 = _interopRequireDefault(_generic);

var _misc = require('./utils/misc');

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

function removeWrongFields(fields) {
  var result = {};
  (0, _keys2.default)(fields).forEach(function (key) {
    var field = fields[key];
    if (!(0, _graphql.isAbstractType)(field.type) // skip interface fields
    && !field._gqcResolver // skip fields that obtained via Resolver
    ) {
        result[key] = field;
      }
  });
  return result;
}

function toInputObjectType(typeComposer) {
  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var cache = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new _map2.default();

  if (typeComposer.hasInputTypeComposer()) {
    return typeComposer.getInputTypeComposer();
  }

  var prefix = opts.prefix || '';
  var postfix = opts.postfix || 'Input';

  var inputTypeName = '' + prefix + typeComposer.getTypeName() + postfix;
  if (cache.has(typeComposer.getType())) {
    // $FlowFixMe
    return cache.get(typeComposer.getType());
  }

  var inputTypeComposer = new _inputTypeComposer2.default(new _graphql.GraphQLInputObjectType({
    name: inputTypeName,
    fields: {}
  }));
  cache.set(typeComposer.getType(), inputTypeComposer);

  var outputFields = removeWrongFields(typeComposer.getFields());
  var inputFields = {};
  (0, _keys2.default)(outputFields).forEach(function (key) {
    var fieldOpts = _extends({}, opts, {
      fieldName: key,
      outputTypeName: typeComposer.getTypeName()
    });
    inputFields[key] = convertInputObjectField(outputFields[key], fieldOpts, cache);
  });
  inputTypeComposer.addFields(inputFields);

  return inputTypeComposer;
}

function convertInputObjectField(field, opts, cache) {
  var fieldType = field.type;

  var wrappers = [];
  while (fieldType instanceof _graphql.GraphQLList || fieldType instanceof _graphql.GraphQLNonNull) {
    wrappers.unshift(fieldType.constructor);
    fieldType = fieldType.ofType;
  }

  if (!(0, _graphql.isInputType)(fieldType)) {
    if (fieldType instanceof _graphql.GraphQLObjectType) {
      var typeOpts = {
        prefix: '' + (opts.prefix || '') + (0, _misc.upperFirst)(opts.outputTypeName || ''),
        postfix: opts.postfix || 'Input'
      };
      var typeComposer = new _typeComposer2.default(fieldType);
      fieldType = toInputObjectType(typeComposer, typeOpts, cache).getType();
    } else {
      // eslint-disable-next-line
      console.error('GQC: can not convert field \'' + (opts.outputTypeName || '') + '.' + (opts.fieldName || '') + '\' to InputType' + '\nIt should be GraphQLObjectType, but got \n' + _util2.default.inspect(fieldType, { depth: 2, colors: true }));
      fieldType = _generic2.default;
    }
  }

  // $FlowFixMe
  var inputFieldType = wrappers.reduce(function (type, Wrapper) {
    return new Wrapper(type);
  }, fieldType);

  return { type: inputFieldType, description: field.description };
}