graphql-compose/es/typeByPath.js

GraphQL schema builder from different data sources with middleware extensions.

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

import { GraphQLObjectType, GraphQLInputObjectType, getNamedType } from 'graphql';
import TypeComposer from './typeComposer';
import InputTypeComposer from './inputTypeComposer';
import Resolver from './resolver';

/**
* fieldName
* @argName
* #resolver
*/
export function typeByPath(src, path) {
  var parts = Array.isArray(path) ? path : String(path).split('.');

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

  if (src instanceof TypeComposer) {
    return typeByPathTC(src, parts);
  } else if (src instanceof InputTypeComposer) {
    return typeByPathITC(src, parts);
  } else if (src instanceof Resolver) {
    return typeByPathRSV(src, parts);
  }

  return src;
}

export 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));
}

export 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);
}

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

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

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