Add coordinate tree (#737)

* Add coordinate tree

* Update NadelCoordinatesTreeTest.kt

Author: gnawf

lib/src/main/java/graphql/nadel/definition/coordinates/NadelAppliedDirectiveArgumentCoordinates.kt

@@ -8,6 +8,7 @@ data class NadelAppliedDirectiveArgumentCoordinates(
     override val name: String,
 ) : NadelSchemaMemberCoordinates,
     NadelChildCoordinates {
+    override val kind = NadelCoordinateKind.AppliedDirectiveArgument
     override val level: Int = parent.level + 1
 
     override fun resolve(schema: GraphQLSchema): GraphQLAppliedDirectiveArgument {

lib/src/main/java/graphql/nadel/definition/coordinates/NadelAppliedDirectiveCoordinates.kt

@@ -8,6 +8,7 @@ data class NadelAppliedDirectiveCoordinates(
     override val name: String,
 ) : NadelSchemaMemberCoordinates,
     NadelChildCoordinates {
+    override val kind = NadelCoordinateKind.AppliedDirective
     override val level: Int = parent.level + 1
 
     override fun resolve(schema: GraphQLSchema): GraphQLAppliedDirective {

lib/src/main/java/graphql/nadel/definition/coordinates/NadelArgumentCoordinates.kt

@@ -10,6 +10,7 @@ data class NadelArgumentCoordinates(
     NadelChildCoordinates,
     NadelAppliedDirectiveParentCoordinates,
     NadelInputCoordinates {
+    override val kind = NadelCoordinateKind.Argument
     override val level: Int = parent.level + 1
 
     override fun resolve(schema: GraphQLSchema): GraphQLArgument? {

lib/src/main/java/graphql/nadel/definition/coordinates/NadelCoordinateKind.kt

@@ -0,0 +1,17 @@
+package graphql.nadel.definition.coordinates
+
+enum class NadelCoordinateKind {
+    AppliedDirective,
+    AppliedDirectiveArgument,
+    Argument,
+    Directive,
+    Enum,
+    EnumValue,
+    Field,
+    InputObject,
+    InputObjectField,
+    Interface,
+    Object,
+    Scalar,
+    Union,
+}

lib/src/main/java/graphql/nadel/definition/coordinates/NadelCoordinatesNode.kt

@@ -0,0 +1,7 @@
+package graphql.nadel.definition.coordinates
+
+data class NadelCoordinatesNode internal constructor(
+    val kind: NadelCoordinateKind,
+    val name: String,
+    val children: List<NadelCoordinatesNode>,
+)

lib/src/main/java/graphql/nadel/definition/coordinates/NadelCoordinatesTree.kt

@@ -0,0 +1,108 @@
+package graphql.nadel.definition.coordinates
+
+/**
+ * Converts a flat [Set] of [NadelSchemaMemberCoordinates] to and from an equivalent tree.
+ *
+ * Each coordinate carries its full parent chain, so serializing the flat [Set] repeats shared ancestors
+ * once per descendant. In the tree each coordinate appears once and parents are shared via nesting.
+ */
+object NadelCoordinatesTree {
+    fun toTree(coordinates: Set<NadelSchemaMemberCoordinates>): List<NadelCoordinatesNode> {
+        val builders = LinkedHashMap<NadelSchemaMemberCoordinates, MutableNode>()
+        val roots = mutableListOf<MutableNode>()
+
+        fun ensure(coordinate: NadelSchemaMemberCoordinates): MutableNode {
+            return builders.getOrPut(coordinate) {
+                val node = MutableNode(coordinate.kind, coordinate.name)
+                val parent = coordinate.parentOrNull
+                if (parent == null) {
+                    roots.add(node)
+                } else {
+                    ensure(parent).children.add(node)
+                }
+                node
+            }
+        }
+
+        coordinates
+            .asSequence()
+            .sorted()
+            .forEach(::ensure)
+
+        return roots.map { it.toNode() }
+    }
+
+    fun fromTree(nodes: List<NadelCoordinatesNode>): Set<NadelSchemaMemberCoordinates> {
+        val coordinates = LinkedHashSet<NadelSchemaMemberCoordinates>()
+
+        fun visit(node: NadelCoordinatesNode, parent: NadelSchemaMemberCoordinates?) {
+            val coordinate = if (parent == null) buildRoot(node) else buildChild(parent, node)
+            coordinates.add(coordinate)
+            node.children.forEach { child ->
+                visit(child, coordinate)
+            }
+        }
+
+        nodes.forEach { node ->
+            visit(node, parent = null)
+        }
+
+        return coordinates
+    }
+
+    private fun buildRoot(node: NadelCoordinatesNode): NadelSchemaMemberCoordinates {
+        return when (node.kind) {
+            NadelCoordinateKind.Object -> NadelObjectCoordinates(node.name)
+            NadelCoordinateKind.Interface -> NadelInterfaceCoordinates(node.name)
+            NadelCoordinateKind.Union -> NadelUnionCoordinates(node.name)
+            NadelCoordinateKind.Enum -> NadelEnumCoordinates(node.name)
+            NadelCoordinateKind.InputObject -> NadelInputObjectCoordinates(node.name)
+            NadelCoordinateKind.Scalar -> NadelScalarCoordinates(node.name)
+            NadelCoordinateKind.Directive -> NadelDirectiveCoordinates(node.name)
+            NadelCoordinateKind.Field,
+            NadelCoordinateKind.InputObjectField,
+            NadelCoordinateKind.Argument,
+            NadelCoordinateKind.EnumValue,
+            NadelCoordinateKind.AppliedDirective,
+            NadelCoordinateKind.AppliedDirectiveArgument,
+            -> error("${node.kind} cannot be a top level coordinate")
+        }
+    }
+
+    private fun buildChild(
+        parent: NadelSchemaMemberCoordinates,
+        node: NadelCoordinatesNode,
+    ): NadelSchemaMemberCoordinates {
+        return when (node.kind) {
+            NadelCoordinateKind.Field -> (parent as NadelFieldContainerCoordinates).field(node.name)
+            NadelCoordinateKind.Argument -> (parent as NadelArgumentParentCoordinates).argument(node.name)
+            NadelCoordinateKind.AppliedDirective -> (parent as NadelAppliedDirectiveParentCoordinates).appliedDirective(node.name)
+            NadelCoordinateKind.InputObjectField -> (parent as NadelInputObjectCoordinates).field(node.name)
+            NadelCoordinateKind.EnumValue -> (parent as NadelEnumCoordinates).enumValue(node.name)
+            NadelCoordinateKind.AppliedDirectiveArgument -> (parent as NadelAppliedDirectiveCoordinates).argument(node.name)
+            NadelCoordinateKind.Object,
+            NadelCoordinateKind.Interface,
+            NadelCoordinateKind.Union,
+            NadelCoordinateKind.Enum,
+            NadelCoordinateKind.InputObject,
+            NadelCoordinateKind.Scalar,
+            NadelCoordinateKind.Directive,
+            -> error("${node.kind} cannot be a child coordinate")
+        }
+    }
+
+    private class MutableNode(
+        private val kind: NadelCoordinateKind,
+        private val name: String,
+    ) {
+        val children = mutableListOf<MutableNode>()
+
+        fun toNode(): NadelCoordinatesNode {
+            return NadelCoordinatesNode(
+                kind = kind,
+                name = name,
+                children = children.map { it.toNode() },
+            )
+        }
+    }
+}

lib/src/main/java/graphql/nadel/definition/coordinates/NadelDirectiveCoordinates.kt

@@ -8,6 +8,8 @@ data class NadelDirectiveCoordinates(
 ) : NadelSchemaMemberCoordinates,
     NadelTopLevelDefinitionCoordinates,
     NadelArgumentParentCoordinates {
+    override val kind = NadelCoordinateKind.Directive
+
     override fun resolve(schema: GraphQLSchema): GraphQLDirective? {
         return schema.getDirective(name)
     }

lib/src/main/java/graphql/nadel/definition/coordinates/NadelEnumCoordinates.kt

@@ -8,6 +8,8 @@ data class NadelEnumCoordinates(
 ) : NadelSchemaMemberCoordinates,
     NadelTypeCoordinates,
     NadelAppliedDirectiveParentCoordinates {
+    override val kind = NadelCoordinateKind.Enum
+
     override fun resolve(schema: GraphQLSchema): GraphQLEnumType? {
         return schema.getType(name) as GraphQLEnumType?
     }

lib/src/main/java/graphql/nadel/definition/coordinates/NadelEnumValueCoordinates.kt

@@ -9,6 +9,7 @@ data class NadelEnumValueCoordinates(
 ) : NadelSchemaMemberCoordinates,
     NadelChildCoordinates,
     NadelAppliedDirectiveParentCoordinates {
+    override val kind = NadelCoordinateKind.EnumValue
     override val level: Int = parent.level + 1
 
     override fun resolve(schema: GraphQLSchema): GraphQLEnumValueDefinition? {

lib/src/main/java/graphql/nadel/definition/coordinates/NadelFieldCoordinates.kt

@@ -10,6 +10,7 @@ data class NadelFieldCoordinates(
     NadelChildCoordinates,
     NadelArgumentParentCoordinates,
     NadelAppliedDirectiveParentCoordinates {
+    override val kind = NadelCoordinateKind.Field
     override val level: Int = parent.level + 1
 
     override fun resolve(schema: GraphQLSchema): GraphQLFieldDefinition? {