Add ast_to_dict utility function (#136)

This function existed in the legacy version 2 and may be sometimes useful.

Author: Cito

docs/modules/utilities.rst

@@ -54,6 +54,10 @@ Create a GraphQLType from a GraphQL language AST:
 
 .. autofunction:: type_from_ast
 
+Convert a language AST to a dictionary:
+
+.. autofunction:: ast_to_dict
+
 Create a Python value from a GraphQL language AST with a type:
 
 .. autofunction:: value_from_ast

src/graphql/__init__.py

@@ -189,6 +189,8 @@
     print_introspection_schema,
     # Create a GraphQLType from a GraphQL language AST.
     type_from_ast,
+    # Convert a language AST to a dictionary.
+    ast_to_dict,
     # Create a Python value from a GraphQL language AST with a Type.
     value_from_ast,
     # Create a Python value from a GraphQL language AST without a Type.
@@ -744,6 +746,7 @@
     "value_from_ast",
     "value_from_ast_untyped",
     "ast_from_value",
+    "ast_to_dict",
     "TypeInfo",
     "coerce_input_value",
     "concat_ast",

src/graphql/language/ast.py

@@ -321,7 +321,7 @@ class Node:
     loc: Optional[Location]
 
     kind: str = "ast"  # the kind of the node as a snake_case string
-    keys = ["loc"]  # the names of the attributes of this node
+    keys: Tuple[str, ...] = ("loc",)  # the names of the attributes of this node
 
     def __init__(self, **kwargs: Any) -> None:
         """Initialize the node with the given keyword arguments."""
@@ -349,6 +349,7 @@ def __hash__(self) -> int:
         # Caching the hash values improves the performance of AST validators
         hashed = getattr(self, "_hash", None)
         if hashed is None:
+            self._hash = id(self)  # avoid recursion
             hashed = hash(tuple(getattr(self, key) for key in self.keys))
             self._hash = hashed
         return hashed
@@ -386,7 +387,12 @@ def __init_subclass__(cls) -> None:
             # noinspection PyUnresolvedReferences
             keys.extend(base.keys)  # type: ignore
         keys.extend(cls.__slots__)
-        cls.keys = keys
+        cls.keys = tuple(keys)
+
+    def to_dict(self, locations: bool = False) -> Dict:
+        from ..utilities import ast_to_dict
+
+        return ast_to_dict(self, locations)
 
 
 # Name

src/graphql/utilities/__init__.py

@@ -39,6 +39,9 @@
 # Create a GraphQLType from a GraphQL language AST.
 from .type_from_ast import type_from_ast
 
+# Convert a language AST to a dictionary.
+from .ast_to_dict import ast_to_dict
+
 # Create a Python value from a GraphQL language AST with a type.
 from .value_from_ast import value_from_ast
 
@@ -91,6 +94,7 @@
     "TypeInfoVisitor",
     "assert_valid_name",
     "ast_from_value",
+    "ast_to_dict",
     "build_ast_schema",
     "build_client_schema",
     "build_schema",

src/graphql/utilities/ast_to_dict.py

@@ -0,0 +1,65 @@
+from typing import Any, Collection, Dict, List, Optional, overload
+
+from ..language import Node, OperationType
+from ..pyutils import is_iterable
+
+
+__all__ = ["ast_to_dict"]
+
+
+@overload
+def ast_to_dict(
+    node: Node, locations: bool = False, cache: Optional[Dict[Node, Any]] = None
+) -> Dict:
+    ...
+
+
+@overload
+def ast_to_dict(
+    node: Collection[Node],
+    locations: bool = False,
+    cache: Optional[Dict[Node, Any]] = None,
+) -> List[Node]:
+    ...
+
+
+@overload
+def ast_to_dict(
+    node: OperationType,
+    locations: bool = False,
+    cache: Optional[Dict[Node, Any]] = None,
+) -> str:
+    ...
+
+
+def ast_to_dict(
+    node: Any, locations: bool = False, cache: Optional[Dict[Node, Any]] = None
+) -> Any:
+    """Convert a language AST to a nested Python dictionary.
+
+    Set `location` to True in order to get the locations as well.
+    """
+
+    """Convert a node to a nested Python dictionary."""
+    if isinstance(node, Node):
+        if cache is None:
+            cache = {}
+        elif node in cache:
+            return cache[node]
+        cache[node] = res = {}
+        res.update(
+            {
+                key: ast_to_dict(getattr(node, key), locations, cache)
+                for key in ("kind",) + node.keys[1:]
+            }
+        )
+        if locations:
+            loc = node.loc
+            if loc:
+                res["loc"] = dict(start=loc.start, end=loc.end)
+        return res
+    if is_iterable(node):
+        return [ast_to_dict(sub_node, locations, cache) for sub_node in node]
+    if isinstance(node, OperationType):
+        return node.value
+    return node

tests/language/test_ast.py

@@ -240,4 +240,32 @@ class Foo(Node):
         assert Foo.kind == "foo"
 
     def provides_keys_as_class_attribute():
-        assert SampleTestNode.keys == ["loc", "alpha", "beta"]
+        assert SampleTestNode.keys == ("loc", "alpha", "beta")
+
+    def can_can_convert_to_dict():
+        node = SampleTestNode(alpha=1, beta=2)
+        res = node.to_dict()
+        assert node.to_dict(locations=True) == res
+        assert res == {"kind": "sample_test", "alpha": 1, "beta": 2}
+        assert list(res) == ["kind", "alpha", "beta"]
+
+    def can_can_convert_to_dict_with_locations():
+        token = Token(
+            kind=TokenKind.NAME,
+            start=1,
+            end=3,
+            line=1,
+            column=1,
+            value="foo",
+        )
+        loc = Location(token, token, Source("foo"))
+        node = SampleTestNode(alpha=1, beta=2, loc=loc)
+        res = node.to_dict(locations=True)
+        assert res == {
+            "kind": "sample_test",
+            "alpha": 1,
+            "beta": 2,
+            "loc": {"start": 1, "end": 3},
+        }
+        assert list(res) == ["kind", "alpha", "beta", "loc"]
+        assert list(res["loc"]) == ["start", "end"]