Add check point

Author: marcelldls

src/fastcs/backends/graphQL/graphQL.py

@@ -25,21 +25,17 @@ class GraphQLServerOptions:
 class GraphQLServer:
     def __init__(self, mapping: Mapping):
         self._mapping = mapping
-        self._field_dict: dict[str, list[StrawberryField]] = {
-            "Query": [],
-            "Mutation": [],
-        }
+        self._fields_tree: FieldsTree = FieldsTree("")
         self._app = self._create_app()
 
     def _create_app(self) -> FastAPI:
-        _add_dev_attributes(self._field_dict, self._mapping)
-        _add_dev_commands(self._field_dict, self._mapping)
+        _add_dev_attributes(self._fields_tree, self._mapping)
+        _add_dev_commands(self._fields_tree, self._mapping)
 
         schema_kwargs = {}
-        for key, value in self._field_dict.items():
-            if self._field_dict[key]:
-                # Strawberry types map to graphql object
-                schema_kwargs[key.lower()] = create_type(key, value)
+        for key in ["query", "mutation"]:
+            if s_type := self._fields_tree.create_type(key):
+                schema_kwargs[key] = s_type
         schema = strawberry.Schema(**schema_kwargs)  # type: ignore
         graphql_app: GraphQL = GraphQL(schema)
 
@@ -90,36 +86,94 @@ async def _dynamic_f() -> Any:
     return _dynamic_f
 
 
-def _add_dev_attributes(
-    field_dict: dict[str, list[StrawberryField]], mapping: Mapping
-) -> None:
-    for single_mapping in mapping.get_controller_mappings():
-        path = single_mapping.controller.path
-        # nest for each controller
-        # if path:
+def _wrap_as_field(
+    field_name: str,
+    strawberry_type: type,
+) -> StrawberryField:
+    def _dynamic_field():
+        return strawberry_type()
 
-        for attr_name, attribute in single_mapping.attributes.items():
-            attr_name = attr_name.title().replace("_", "")
-            d_attr_name = f"{'/'.join(path)}/{attr_name}" if path else attr_name
+    _dynamic_field.__name__ = field_name
+    _dynamic_field.__annotations__["return"] = strawberry_type
 
-            match attribute:
-                case AttrRW():
-                    field_dict["Query"].append(
-                        strawberry.field(_wrap_attr_get(d_attr_name, attribute))
-                    )
-                    field_dict["Mutation"].append(
-                        strawberry.mutation(_wrap_attr_set(d_attr_name, attribute))
-                    )  # mutation for server changes https://graphql.org/learn/queries/
+    return strawberry.field(_dynamic_field)
 
-                case AttrR():
-                    field_dict["Query"].append(
-                        strawberry.field(_wrap_attr_get(d_attr_name, attribute))
-                    )
 
-                case AttrW():
-                    field_dict["Mutation"].append(
-                        strawberry.mutation(_wrap_attr_set(d_attr_name, attribute))
-                    )
+class FieldsTree:
+    def __init__(self, name: str):
+        self.name = name
+        self.children: list[FieldsTree] = []
+        self.fields_dict: dict[str, list[StrawberryField]] = {
+            "query": [],
+            "mutation": [],
+        }
+
+    def insert(self, path: list[str]):
+        # Create child if not exist
+        name = path.pop(0)
+        if not (child := self.get_child(name)):
+            child = FieldsTree(name)
+            self.children.append(child)
+        else:
+            child = self.get_child(name)
+
+        # Recurse if needed
+        if path:
+            return child.insert(path)  # type: ignore
+        else:
+            return child
+
+    def get_child(self, name: str):
+        for child in self.children:
+            if child.name == name:
+                return child
+        return None
+
+    def create_type(self, strawberry_type: str):
+        for child in self.children:
+            child_field = _wrap_as_field(
+                child.name,
+                child.create_type(strawberry_type),
+            )
+            self.fields_dict[strawberry_type].append(child_field)
+
+        return create_type(
+            f"{self.name}{strawberry_type}", self.fields_dict[strawberry_type]
+        )
+
+
+def _add_dev_attributes(
+    fields_tree: FieldsTree,
+    mapping: Mapping,
+) -> None:
+    for single_mapping in mapping.get_controller_mappings():
+        path = single_mapping.controller.path
+        if path:
+            node = fields_tree.insert(path)
+        else:
+            node = fields_tree
+
+        if node is not None:
+            for attr_name, attribute in single_mapping.attributes.items():
+                attr_name = attr_name.title().replace("_", "")
+
+                match attribute:
+                    # mutation for server changes https://graphql.org/learn/queries/
+                    case AttrRW():
+                        node.fields_dict["query"].append(
+                            strawberry.field(_wrap_attr_get(attr_name, attribute))
+                        )
+                        node.fields_dict["mutation"].append(
+                            strawberry.mutation(_wrap_attr_set(attr_name, attribute))
+                        )
+                    case AttrR():
+                        node.fields_dict["query"].append(
+                            strawberry.field(_wrap_attr_get(attr_name, attribute))
+                        )
+                    case AttrW():
+                        node.fields_dict["mutation"].append(
+                            strawberry.mutation(_wrap_attr_set(attr_name, attribute))
+                        )
 
 
 def _wrap_command(
@@ -135,20 +189,25 @@ async def _dynamic_f() -> bool:
 
 
 def _add_dev_commands(
-    field_dict: dict[str, list[StrawberryField]], mapping: Mapping
+    fields_tree: FieldsTree,
+    mapping: Mapping,
 ) -> None:
     for single_mapping in mapping.get_controller_mappings():
         path = single_mapping.controller.path
-
-        for name, method in single_mapping.command_methods.items():
-            cmd_name = name.title().replace("_", "")
-            d_cmd_name = f"{'/'.join(path)}/{cmd_name}" if path else cmd_name
-            field_dict["Mutation"].append(
-                strawberry.mutation(
-                    _wrap_command(
-                        d_cmd_name,
-                        method.fn,
-                        single_mapping.controller,
+        if path:
+            node = fields_tree.insert(path)
+        else:
+            node = fields_tree
+
+        if node is not None:
+            for name, method in single_mapping.command_methods.items():
+                cmd_name = name.title().replace("_", "")
+                node.fields_dict["mutation"].append(
+                    strawberry.mutation(
+                        _wrap_command(
+                            cmd_name,
+                            method.fn,
+                            single_mapping.controller,
+                        )
                     )
                 )
-            )

tests/backends/graphQL/test_graphQL.py

@@ -27,6 +27,7 @@ def client_exec(self, field: str):
         mutation = f"mutation {{{field}}}"
         response = self._client.post("/graphql", json={"query": mutation})
         assert response.status_code == 200
+        assert response.json()["data"] == {field: True}
 
     def test_read_int(self):
         self.client_read("ReadInt", AttrR(Int())._value)
@@ -55,3 +56,19 @@ def test_big_enum(self):
 
     def test_go(self):
         self.client_exec("Go")
+
+    def test_read_child1(self):
+        query = "query { SubController01 { ReadWriteInt }}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {
+            "SubController01": {"ReadWriteInt": AttrR(Int())._value}
+        }
+
+    def test_read_child2(self):
+        query = "query { SubController02 { ReadWriteInt }}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {
+            "SubController02": {"ReadWriteInt": AttrR(Int())._value}
+        }

tests/conftest.py

@@ -12,7 +12,7 @@
 
 from fastcs.attributes import AttrR, AttrRW, AttrW, Handler, Sender, Updater
 from fastcs.backends.graphQL.backend import GraphQLBackend
-from fastcs.controller import Controller
+from fastcs.controller import Controller, SubController
 from fastcs.datatypes import Bool, Float, Int, String
 from fastcs.mapping import Mapping
 from fastcs.wrappers import command, scan
@@ -51,7 +51,27 @@ class TestHandler(Handler, TestUpdater, TestSender):
     pass
 
 
+class TestSubController(SubController):
+    read_write_int: AttrRW = AttrRW(Int(), handler=TestHandler())
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @command()
+    async def go(self):
+        pass
+
+
 class TestController(Controller):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._sub_controllers: list[TestSubController] = []
+        for index in range(1, 3):
+            controller = TestSubController()
+            self._sub_controllers.append(controller)
+            self.register_sub_controller(f"SubController{index:02d}", controller)
+
     read_int: AttrR = AttrR(Int(), handler=TestUpdater())
     read_write_int: AttrRW = AttrRW(Int(), handler=TestHandler())
     read_write_float: AttrRW = AttrRW(Float())