Fix filters parameter

Author: LucasG0

infrahub_sdk/client.py

@@ -539,7 +539,6 @@ async def _process_nodes_and_relationships(
         response: dict[str, Any],
         schema_kind: str,
         branch: str,
-        prefetch_relationships: bool,
         timeout: int | None = None,
     ) -> ProcessRelationsNode:
         """Processes InfrahubNode and their Relationships from the GraphQL query response.
@@ -548,7 +547,6 @@ async def _process_nodes_and_relationships(
             response (dict[str, Any]): The response from the GraphQL query.
             schema_kind (str): The kind of schema being queried.
             branch (str): The branch name.
-            prefetch_relationships (bool): Flag to indicate whether to prefetch relationship data.
             timeout (int, optional): Overrides default timeout used when querying the graphql API. Specified in seconds.
 
         Returns:
@@ -564,10 +562,9 @@ async def _process_nodes_and_relationships(
             node = await InfrahubNode.from_graphql(client=self, branch=branch, data=item, timeout=timeout)
             nodes.append(node)
 
-            if prefetch_relationships:
-                await node._process_relationships(
-                    node_data=item, branch=branch, related_nodes=related_nodes, timeout=timeout
-                )
+            await node._process_relationships(
+                node_data=item, branch=branch, related_nodes=related_nodes, timeout=timeout
+            )
 
         return ProcessRelationsNode(nodes=nodes, related_nodes=related_nodes)
 
@@ -814,7 +811,6 @@ async def process_page(page_offset: int, page_number: int) -> tuple[dict, Proces
                 response=response,
                 schema_kind=schema.kind,
                 branch=branch,
-                prefetch_relationships=prefetch_relationships,
                 timeout=timeout,
             )
             return response, process_result

infrahub_sdk/node/node.py

@@ -730,19 +730,20 @@ async def generate_query_data_node(
                 continue
 
             rel_schema = self._schema.get_relationship(name=rel_name)
-
             if not rel_schema or (not inherited and rel_schema.inherited):
                 continue
 
+            # Don't fetch many attribute/parent relationships unless they are specified in `include`
+            # TODO Why wouldn't we we fetch them if prefetch_relationships is True?
             if (
                 rel_schema.cardinality == RelationshipCardinality.MANY  # type: ignore[union-attr]
                 and rel_schema.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.PARENT]  # type: ignore[union-attr]
                 and not (include and rel_name in include)
             ):
                 continue
 
-            peer_data: dict[str, Any] = {}
-            if rel_schema and prefetch_relationships:
+            should_fetch_relationship = prefetch_relationships or (include is not None and rel_name in include)
+            if rel_schema and should_fetch_relationship:
                 peer_schema = await self._client.schema.get(kind=rel_schema.peer, branch=self._branch)
                 peer_node = InfrahubNode(client=self._client, schema=peer_schema, branch=self._branch)
                 peer_data = await peer_node.generate_query_data_node(
@@ -751,23 +752,26 @@ async def generate_query_data_node(
                     property=property,
                 )
 
-            if rel_schema and rel_schema.cardinality == "one":
-                rel_data = RelatedNode._generate_query_data(peer_data=peer_data, property=property)
-                # Nodes involved in a hierarchy are required to inherit from a common ancestor node, and graphql
-                # tries to resolve attributes in this ancestor instead of actual node. To avoid
-                # invalid queries issues when attribute is missing in the common ancestor, we use a fragment
-                # to explicit actual node kind we are querying.
-                if rel_schema.kind == RelationshipKind.HIERARCHY:
-                    data_node = rel_data["node"]
-                    rel_data["node"] = {}
-                    rel_data["node"][f"...on {rel_schema.peer}"] = data_node
-            elif rel_schema and rel_schema.cardinality == "many":
-                rel_data = RelationshipManager._generate_query_data(peer_data=peer_data, property=property)
+                # TODO is there a reason why we fetch here even with prefetch_relationships == False?
+                if rel_schema.cardinality == "one":
+                    rel_data = RelatedNode._generate_query_data(peer_data=peer_data, property=property)
+                    # Nodes involved in a hierarchy are required to inherit from a common ancestor node, and graphql
+                    # tries to resolve attributes in this ancestor instead of actual node. To avoid
+                    # invalid queries issues when attribute is missing in the common ancestor, we use a fragment
+                    # to explicit actual node kind we are querying.
+                    if rel_schema.kind == RelationshipKind.HIERARCHY:
+                        data_node = rel_data["node"]
+                        rel_data["node"] = {}
+                        rel_data["node"][f"...on {rel_schema.peer}"] = data_node
+                elif rel_schema.cardinality == "many":
+                    rel_data = RelationshipManager._generate_query_data(peer_data=peer_data, property=property)
+                else:
+                    raise ValueError(f"Unknown relationship cardinality {rel_schema.cardinality}")
 
-            data[rel_name] = rel_data
+                data[rel_name] = rel_data
 
-            if insert_alias:
-                data[rel_name]["@alias"] = f"__alias__{self._schema.kind}__{rel_name}"
+                if insert_alias:
+                    data[rel_name]["@alias"] = f"__alias__{self._schema.kind}__{rel_name}"
 
         return data
 

tests/integration/test_node.py

@@ -85,6 +85,39 @@ async def test_node_create_with_relationships_using_related_node(
         assert node_after.owner.peer.id == person_joe.id
         assert node_after.owner.peer.typename == "TestingPerson"
 
+    async def test_node_filters_include(
+        self,
+        default_branch: str,
+        client: InfrahubClient,
+        initial_schema: None,
+        manufacturer_mercedes,
+        person_joe,
+        tag_red,
+    ) -> None:
+        car = await client.create(
+            kind=TESTING_CAR,
+            name="Tiguan2",
+            color="Black",
+            manufacturer=manufacturer_mercedes,
+            owner=person_joe,
+            tags=[tag_red],
+        )
+        await car.save(allow_upsert=True)
+        assert car.id is not None
+
+        node_after = await client.get(kind=TESTING_CAR, id=car.id)
+
+        with pytest.raises(ValueError):
+            # match=r"Node must have at least one identifier (ID or HFID) to query it."
+            _ = node_after.owner.peer
+
+        assert len(node_after.tags.peers) == 0
+
+        # Test both one and many relationships
+        node_after = await client.get(kind=TESTING_CAR, id=car.id, include=["tags", "owner"])
+        assert [tag.id for tag in node_after.tags.peers] == [tag_red.id]
+        assert node_after.owner.peer.id == person_joe.id, f"{person_joe.id=}"
+
     async def test_node_update_with_original_data(
         self,
         default_branch: str,