dep graph experiment

andimarek · Jul 1, 2019 · Jul 1, 2019 · Jul 2, 2019 · Jul 2, 2019 · Jul 2, 2019
commit c38f50ca34b0a40a5bbb7f9b7889124deaeb9ba3
diff --git a/src/main/java/graphql/execution/nextgen/depgraph/DependencyGraph.java b/src/main/java/graphql/execution/nextgen/depgraph/DependencyGraph.java
@@ -15,7 +15,9 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Function;
 
 import static graphql.util.FpKit.map;
@@ -36,32 +38,73 @@ public DependencyGraph createDependencyGraph(GraphQLSchema graphQLSchema, Operat
         };
 
         Traverser<MergedFieldWTC> traverser = Traverser.depthFirst(getChildren);
+        FieldVertex rootVertex = new FieldVertex(null, null, null, null, null);
+        traverser.rootVar(FieldVertex.class, rootVertex);
         List<MergedFieldWTC> roots = fieldCollector.collectFromOperation(parameters, operationDefinition, graphQLSchema.getQueryType());
         traverser.traverse(roots, new TraverserVisitorStub<MergedFieldWTC>() {
             @Override
             public TraversalControl enter(TraverserContext<MergedFieldWTC> context) {
-                List<MergedFieldWTC> parentNodes = context.getParentNodes();
-                Collections.reverse(parentNodes);
-
-                List<String> keys = map(parentNodes, parentNode -> {
-                    return parentNode.getResultKey() + getPossibleObjectTypesString(parentNode, graphQLSchema);
-                });
-                String queryPath = String.join("/", keys);
                 MergedFieldWTC mergedFieldWTC = context.thisNode();
-                queryPath = "/" + queryPath + "/" + mergedFieldWTC.getResultKey() + getPossibleObjectTypesString(mergedFieldWTC, graphQLSchema);
-//                System.out.println("-----------");
-//                System.out.println("visited key:" + context.thisNode().getResultKey());
-                System.out.println("query path: " + queryPath + " field type: " + context.thisNode().getFieldDefinition().getType() + " container: " + context.thisNode().getFieldsContainer().getName());
+//                List<MergedFieldWTC> parentNodes = context.getParentNodes();
+//                Collections.reverse(parentNodes);
+
+//                List<String> keys = map(parentNodes, parentNode -> {
+//                    return parentNode.getResultKey() + getPossibleObjectTypesString(parentNode, graphQLSchema);
+//                });
+//                String queryPath = String.join("/", keys);
+//                queryPath = "/" + queryPath + "/" + mergedFieldWTC.getResultKey() + getPossibleObjectTypesString(mergedFieldWTC, graphQLSchema);
+////                System.out.println("-----------");
+////                System.out.println("visited key:" + context.thisNode().getResultKey());
+//                System.out.println("query path: " + queryPath + " field type: " + context.thisNode().getFieldDefinition().getType() + " container: " + context.thisNode().getFieldsContainer().getName());
 //                System.out.println("visited: " + context.thisNode());
 
+
+                Set<GraphQLObjectType> possibleObjectTypes = new LinkedHashSet<>(getPossibleObjectTypes(mergedFieldWTC, graphQLSchema));
+                FieldVertex parentVertex = context.getVarFromParents(FieldVertex.class);
+//                List<FieldVertex> newChildren = new ArrayList<>();
+//                for (FieldVertex child : parentVertex.getChildren()) {
+//                    if (!child.getResultKey().equals(mergedFieldWTC.getResultKey())) {
+//                        newChildren.add(child);
+//                        continue;
+//                    }
+//                    possibleObjectTypes.addAll(child.getPossibleObjectTypes());
+//                }
+
+                FieldVertex fieldVertex = createFieldVertex(mergedFieldWTC, graphQLSchema, new ArrayList<>(possibleObjectTypes));
+//                newChildren.add(fieldVertex);
+//                parentVertex.setChildren(newChildren);
+                context.setVar(FieldVertex.class, fieldVertex);
+                parentVertex.addChild(fieldVertex);
+
                 return TraversalControl.CONTINUE;
             }
 
         });
 
+
+        Traverser<FieldVertex> traverserVertex = Traverser.depthFirst(FieldVertex::getChildren);
+
+        traverserVertex.traverse(rootVertex, new TraverserVisitorStub<FieldVertex>() {
+            @Override
+            public TraversalControl enter(TraverserContext<FieldVertex> context) {
+                FieldVertex fieldVertex = context.thisNode();
+                System.out.println(fieldVertex);
+                return TraversalControl.CONTINUE;
+            }
+        });
+
         return null;
     }
 
+    private FieldVertex createFieldVertex(MergedFieldWTC mergedFieldWTC, GraphQLSchema graphQLSchema, List<GraphQLObjectType> possibleObjectTypes) {
+        return new FieldVertex(mergedFieldWTC.getFields(),
+                mergedFieldWTC.getFieldDefinition(),
+                mergedFieldWTC.getFieldsContainer(),
+                mergedFieldWTC.getParentType(),
+                possibleObjectTypes);
+
+    }
+
     private List<String> getPossibleObjectTypesString(MergedFieldWTC mergedFieldWTC, GraphQLSchema graphQLSchema) {
         return map(getPossibleObjectTypes(mergedFieldWTC, graphQLSchema), GraphQLObjectType::getName);
     }

diff --git a/src/main/java/graphql/execution/nextgen/depgraph/FieldVertex.java b/src/main/java/graphql/execution/nextgen/depgraph/FieldVertex.java
@@ -1,6 +1,90 @@
 package graphql.execution.nextgen.depgraph;
 
+import graphql.language.Field;
+import graphql.schema.GraphQLFieldDefinition;
+import graphql.schema.GraphQLFieldsContainer;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLOutputType;
+import graphql.util.FpKit;
+
+import java.util.ArrayList;
+import java.util.List;
+
 public class FieldVertex {
-    private String key;
-    private MergedFieldWTC mergedFieldWTC;
+    private final List<Field> fields;
+    private final GraphQLFieldDefinition fieldDefinition;
+    private final GraphQLFieldsContainer fieldsContainer;
+    private final GraphQLOutputType parentType;
+    private final List<GraphQLObjectType> possibleObjectTypes;
+
+    private List<FieldVertex> children = new ArrayList<>();
+
+    public FieldVertex(List<Field> fields,
+                       GraphQLFieldDefinition fieldDefinition,
+                       GraphQLFieldsContainer fieldsContainer,
+                       GraphQLOutputType parentType,
+                       List<GraphQLObjectType> possibleObjectTypes) {
+        this.fields = fields;
+        this.fieldDefinition = fieldDefinition;
+        this.fieldsContainer = fieldsContainer;
+        this.parentType = parentType;
+        this.possibleObjectTypes = possibleObjectTypes;
+    }
+
+    public void addChild(FieldVertex fieldVertex) {
+        this.children.add(fieldVertex);
+    }
+
+    public void setChildren(List<FieldVertex> children) {
+        this.children = new ArrayList<>(children);
+    }
+
+
+    public List<Field> getFields() {
+        return fields;
+    }
+
+    public GraphQLFieldDefinition getFieldDefinition() {
+        return fieldDefinition;
+    }
+
+    public GraphQLFieldsContainer getFieldsContainer() {
+        return fieldsContainer;
+    }
+
+    public GraphQLOutputType getParentType() {
+        return parentType;
+    }
+
+    public List<GraphQLObjectType> getPossibleObjectTypes() {
+        return possibleObjectTypes;
+    }
+
+    public List<FieldVertex> getChildren() {
+        return children;
+    }
+
+    public String getName() {
+        return fields.get(0).getName();
+    }
+
+    public Field getSingleField() {
+        return fields.get(0);
+    }
+
+    public String getResultKey() {
+        Field singleField = getSingleField();
+        if (singleField.getAlias() != null) {
+            return singleField.getAlias();
+        }
+        return singleField.getName();
+    }
+
+    @Override
+    public String toString() {
+        if (fields == null) {
+            return "ROOT VERTEX";
+        }
+        return fields.get(0).getName() + FpKit.map(getPossibleObjectTypes(), GraphQLObjectType::getName);
+    }
 }
diff --git a/src/main/java/graphql/execution/nextgen/depgraph/Vertex.java b/src/main/java/graphql/execution/nextgen/depgraph/Vertex.java
diff --git a/src/test/groovy/graphql/execution/nextgen/depgraph/DependencyGraphTest.groovy b/src/test/groovy/graphql/execution/nextgen/depgraph/DependencyGraphTest.groovy
@@ -241,7 +241,7 @@ type Dog implements Animal{
             pets {
                 ... on Dog {
                     ... on CatOrDog {
-                    ... on Dog{
+                    ... on Cat{
                             name
                             }
                     }