graphql-compose/lib/typeByPath.js

GraphQL schema builder from different data sources with middleware extensions.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.typeByPath = typeByPath;
exports.typeByPathTC = typeByPathTC;
exports.typeByPathITC = typeByPathITC;
exports.processType = processType;

var _graphql = require('graphql');

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

var _typeComposer2 = _interopRequireDefault(_typeComposer);

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

var _inputTypeComposer2 = _interopRequireDefault(_inputTypeComposer);

var _resolver = require('./resolver');

var _resolver2 = _interopRequireDefault(_resolver);

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

/**
* fieldName
* @argName
* #resolver
*/

/* eslint-disable no-use-before-define */

function typeByPath(src, path) {
  var parts = Array.isArray(path) ? path : String(path).split('.');

  if (parts.length === 0) {
    return src;
  }

  if (src instanceof _typeComposer2.default) {
    return typeByPathTC(src, parts);
  } else if (src instanceof _inputTypeComposer2.default) {
    return typeByPathITC(src, parts);
  } else if (src instanceof _resolver2.default) {
    return typeByPathRSV(src, parts);
  }

  return src;
}

function typeByPathTC(tc, parts) {
  if (!tc) return undefined;
  if (parts.length === 0) return tc;

  var name = parts[0];
  if (!name) return undefined;
  var nextName = parts[1];

  if (name.startsWith('$')) {
    var restParts = parts.slice(1);
    var resolver = tc.getResolver(name.substring(1));
    if (resolver) {
      if (restParts.length > 0) {
        return typeByPathRSV(resolver, restParts);
      }
      return resolver;
    }
    return undefined;
  }

  if (nextName && nextName.startsWith('@')) {
    var arg = tc.getFieldArg(name, nextName.substring(1));
    return processType(arg && arg.type, parts.slice(2));
  }

  var fieldType = tc.getFieldType(name);
  return processType(fieldType, parts.slice(1));
}

function typeByPathITC(itc, parts) {
  if (!itc) return undefined;
  if (parts.length === 0) return itc;

  var fieldType = itc.getFieldType(parts[0]);
  return processType(fieldType, parts.slice(1));
}

function typeByPathRSV(rsv, parts) {
  if (!rsv) return undefined;
  if (parts.length === 0) return rsv;
  var name = parts[0];
  if (!name) return undefined;

  if (name.startsWith('@')) {
    var arg = rsv.getArg(name.substring(1));
    if (!arg) return undefined;
    return processType(arg.type, parts.slice(1));
  }

  return processType(rsv.getType(), parts);
}

function processType(type, restParts) {
  if (!type) return undefined;
  var unwrappedType = (0, _graphql.getNamedType)(type);

  if (unwrappedType instanceof _graphql.GraphQLObjectType) {
    var tc = new _typeComposer2.default(unwrappedType);
    if (restParts.length > 0) {
      return typeByPathTC(tc, restParts);
    }
    return tc;
  } else if (unwrappedType instanceof _graphql.GraphQLInputObjectType) {
    var itc = new _inputTypeComposer2.default(unwrappedType);
    if (restParts.length > 0) {
      return typeByPathITC(itc, restParts);
    }
    return itc;
  }

  if (restParts.length > 0) {
    return undefined;
  }
  return unwrappedType;
}