如何在Java中使用片段检查请求的GraphQL字段？

Question

我有一个与此类似的GraphQL查询：

query {
  getPosts {    
      ...PostFragment
  }
}

fragment SpecificPostFragment on SpecificPost {
  owner {
    id
    name
  }
}

fragment PostFragment on Post {
  id
  object
  ... on SpecificPost {
    ...SpecificPostFragment 
  }
}

我尝试知道是否：

1. 请求字段对象
2. 要求字段所有者

我尝试应用这里写的内容：https://www.graphql-java.com/documentation/v11/fieldselection/

但是dataFetchingEnvironment.getSelectionSet().contains("XXX")似乎不适用于片段。怎么做？

Answer 1

我还没有找到任何内置的解决方案，所以我写了自己的解决方案。这是我的代码

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import graphql.execution.MergedField;
import graphql.language.Field;
import graphql.language.FragmentDefinition;
import graphql.language.FragmentSpread;
import graphql.language.InlineFragment;
import graphql.language.SelectionSet;
import graphql.schema.DataFetchingEnvironment;

public class GraphQLUtil {
    private static class PathElement {
        private final String name;
        private final String typeName;

        public PathElement(String name, String typeName) {
            this.name = name;
            this.typeName = typeName;
        }

        public String getName() {
            return name;
        }

        public String getTypeName() {
            return typeName;
        }
    }

    public static boolean containsIncludingFragments(DataFetchingEnvironment env, String path) {
        Objects.requireNonNull(env, "The data fetching environment must not be null");
        Objects.requireNonNull(path, "The field path must not be null");

        List<PathElement> elts = Stream.of(path.split("/")).map(p -> {
            String pt = p.trim();
            if (pt.isEmpty()) {
                throw new IllegalArgumentException("Empty path element found");
            }
            int sepIdx = pt.indexOf(":");
            String name = pt;
            String typeName = null;
            if (sepIdx >= 0) {
                typeName = pt.substring(0, sepIdx);
                name = pt.substring(sepIdx + 1, pt.length());
            }
            return new PathElement(name, typeName);
        }).collect(Collectors.toList());

        if (elts.isEmpty()) {
            return false;
        }

        MergedField mf = env.getMergedField();
        return searchPathElement(env, elts, 0, mf.getSingleField().getSelectionSet(), null);
    }

    private static boolean searchPathElement(
            DataFetchingEnvironment env,
            List<PathElement> elts,
            int eltIndex,
            SelectionSet selectionSet,
            String selectionTypeName) {
        if (eltIndex >= elts.size()) {
            return true;
        }

        PathElement currentElt = elts.get(eltIndex);
        String currentName = currentElt.getName();
        String currentTypeName = currentElt.getTypeName();
        List<Field> fields = selectionSet.getSelectionsOfType(Field.class);
        boolean found = false;
        for (Field f : fields) {
            if (f.getName().equals(currentName) && (currentTypeName == null
                    || selectionTypeName == null
                    || currentTypeName.equals(selectionTypeName))) {
                found = searchPathElement(env, elts, eltIndex + 1, f.getSelectionSet(), null);
                if (found) {
                    return true;
                }
            }
        }

        List<FragmentSpread> fragments = selectionSet.getSelectionsOfType(FragmentSpread.class);
        for (FragmentSpread f : fragments) {
            FragmentDefinition fDef = env.getFragmentsByName().get(f.getName());
            found = searchPathElement(env, elts, eltIndex, fDef.getSelectionSet(), fDef.getTypeCondition().getName());
            if (found) {
                return true;
            }
        }

        List<InlineFragment> inlineFragments = selectionSet.getSelectionsOfType(InlineFragment.class);
        for (InlineFragment f : inlineFragments) {
            found = searchPathElement(env, elts, eltIndex, f.getSelectionSet(), f.getTypeCondition().getName());
            if (found) {
                return true;
            }
        }

        return false;
    }
}

您这样称呼它：

  DataFetchingEnvironment dataEnv = ... // If like me you use GraphQL SPQR, you can get it with io.leangen.graphql.execution.ResolutionEnvironment
  boolean t1= GraphQLUtil.containsIncludingFragments(dataEnv, "id");
  boolean t2 = GraphQLUtil.containsIncludingFragments(dataEnv, "owner/id");
  boolean t3 = GraphQLUtil.containsIncludingFragments(dataEnv, "SpecificPost:owner/id"); // You may give the type of the field, if in some inheritance scenario, it is ambiguous

请注意，此解决方案不支持通配符（*或？）。而且我还没有测试主查询是否包含多个条目（例如，同一查询中的getPost + getPeople），但是在这种情况下可能不起作用。