Merge pull request #5920 from opsmill/pog-add-missing-relationship-types-IFC-1319

Add missing handling of secondary changelog relationships

Author: ogenstad

backend/infrahub/core/changelog/models.py

@@ -13,6 +13,8 @@
     from infrahub.core.manager import RelationshipSchema
     from infrahub.core.query.relationship import RelationshipPeerData
     from infrahub.core.relationship.model import Relationship
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
 
 
@@ -463,37 +465,198 @@ async def get_changelogs(self, primary_changelog: NodeChangelog) -> list[NodeCha
         These will typically include updates to relationships on other nodes.
         """
         schema_branch = self._db.schema.get_schema_branch(name=self._branch.name)
-        node_schema = schema_branch.get(name=primary_changelog.node_kind)
+        node_schema = schema_branch.get(name=primary_changelog.node_kind, duplicate=False)
         secondaries: list[NodeChangelog] = []
 
         for relationship in primary_changelog.relationships.values():
-            rel_schema = node_schema.get_relationship(name=relationship.name)
             if isinstance(relationship, RelationshipCardinalityOneChangelog):
-                # For now this code only looks at the scenario when a cardinality=one relationship
-                # is added to a node and it has a cardinality=many relationship coming back from
-                # another node, it will be expanded to include all variations.
-                if relationship.peer_status == DiffAction.ADDED:
-                    peer_schema = schema_branch.get(name=str(relationship.peer_kind))
-                    peer_relation = peer_schema.get_relationship_by_identifier(
-                        id=str(rel_schema.identifier), raise_on_error=False
+                secondaries.extend(
+                    self._parse_cardinality_one_relationship(
+                        relationship=relationship,
+                        node_schema=node_schema,
+                        primary_changelog=primary_changelog,
+                        schema_branch=schema_branch,
                     )
-                    if peer_relation:
-                        node_changelog = NodeChangelog(
-                            node_id=str(relationship.peer_id),
-                            node_kind=str(relationship.peer_kind),
-                            display_label="n/a",
+                )
+            elif isinstance(relationship, RelationshipCardinalityManyChangelog):
+                secondaries.extend(
+                    self._parse_cardinality_many_relationship(
+                        relationship=relationship,
+                        node_schema=node_schema,
+                        primary_changelog=primary_changelog,
+                        schema_branch=schema_branch,
+                    )
+                )
+
+        return secondaries
+
+    def _parse_cardinality_one_relationship(
+        self,
+        relationship: RelationshipCardinalityOneChangelog,
+        node_schema: MainSchemaTypes,
+        primary_changelog: NodeChangelog,
+        schema_branch: SchemaBranch,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        rel_schema = node_schema.get_relationship(name=relationship.name)
+
+        if relationship.peer_status == DiffAction.ADDED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind), duplicate=False)
+            secondaries.extend(
+                self._process_added_peers(
+                    peer_id=str(relationship.peer_id),
+                    peer_kind=str(relationship.peer_kind),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        elif relationship.peer_status == DiffAction.UPDATED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind), duplicate=False)
+            secondaries.extend(
+                self._process_added_peers(
+                    peer_id=str(relationship.peer_id),
+                    peer_kind=str(relationship.peer_kind),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+            secondaries.extend(
+                self._process_removed_peers(
+                    peer_schema=peer_schema,
+                    peer_id=str(relationship.peer_id_previous),
+                    peer_kind=str(relationship.peer_kind_previous),
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        elif relationship.peer_status == DiffAction.REMOVED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind_previous), duplicate=False)
+
+            secondaries.extend(
+                self._process_removed_peers(
+                    peer_id=str(relationship.peer_id_previous),
+                    peer_kind=str(relationship.peer_kind_previous),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        return secondaries
+
+    def _parse_cardinality_many_relationship(
+        self,
+        relationship: RelationshipCardinalityManyChangelog,
+        node_schema: MainSchemaTypes,
+        primary_changelog: NodeChangelog,
+        schema_branch: SchemaBranch,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        rel_schema = node_schema.get_relationship(name=relationship.name)
+
+        for peer in relationship.peers:
+            if peer.peer_status == DiffAction.ADDED:
+                peer_schema = schema_branch.get(name=peer.peer_kind)
+                secondaries.extend(
+                    self._process_added_peers(
+                        peer_id=peer.peer_id,
+                        peer_kind=peer.peer_kind,
+                        peer_schema=peer_schema,
+                        rel_schema=rel_schema,
+                        primary_changelog=primary_changelog,
+                    )
+                )
+
+            elif peer.peer_status == DiffAction.REMOVED:
+                peer_schema = schema_branch.get(name=peer.peer_kind)
+                secondaries.extend(
+                    self._process_removed_peers(
+                        peer_id=peer.peer_id,
+                        peer_kind=peer.peer_kind,
+                        peer_schema=peer_schema,
+                        rel_schema=rel_schema,
+                        primary_changelog=primary_changelog,
+                    )
+                )
+
+        return secondaries
+
+    def _process_added_peers(
+        self,
+        peer_id: str,
+        peer_kind: str,
+        peer_schema: MainSchemaTypes,
+        rel_schema: RelationshipSchema,
+        primary_changelog: NodeChangelog,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
+        if peer_relation:
+            node_changelog = NodeChangelog(
+                node_id=peer_id,
+                node_kind=peer_kind,
+                display_label="n/a",
+            )
+            if peer_relation.cardinality == RelationshipCardinality.ONE:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
+                    name=peer_relation.name,
+                    peer_id=primary_changelog.node_id,
+                    peer_kind=primary_changelog.node_kind,
+                )
+                secondaries.append(node_changelog)
+            elif peer_relation.cardinality == RelationshipCardinality.MANY:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
+                    name=peer_relation.name,
+                    peers=[
+                        RelationshipPeerChangelog(
+                            peer_id=primary_changelog.node_id,
+                            peer_kind=primary_changelog.node_kind,
+                            peer_status=DiffAction.ADDED,
+                        )
+                    ],
+                )
+                secondaries.append(node_changelog)
+
+        return secondaries
+
+    def _process_removed_peers(
+        self,
+        peer_id: str,
+        peer_kind: str,
+        peer_schema: MainSchemaTypes,
+        rel_schema: RelationshipSchema,
+        primary_changelog: NodeChangelog,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
+        if peer_relation:
+            node_changelog = NodeChangelog(
+                node_id=peer_id,
+                node_kind=peer_kind,
+                display_label="n/a",
+            )
+            if peer_relation.cardinality == RelationshipCardinality.ONE:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
+                    name=peer_relation.name,
+                    peer_id_previous=primary_changelog.node_id,
+                    peer_kind_previous=primary_changelog.node_kind,
+                )
+                secondaries.append(node_changelog)
+            elif peer_relation.cardinality == RelationshipCardinality.MANY:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
+                    name=peer_relation.name,
+                    peers=[
+                        RelationshipPeerChangelog(
+                            peer_id=primary_changelog.node_id,
+                            peer_kind=primary_changelog.node_kind,
+                            peer_status=DiffAction.REMOVED,
                         )
-                        if peer_relation.cardinality == RelationshipCardinality.MANY:
-                            node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
-                                name=peer_relation.name,
-                                peers=[
-                                    RelationshipPeerChangelog(
-                                        peer_id=primary_changelog.node_id,
-                                        peer_kind=primary_changelog.node_kind,
-                                        peer_status=DiffAction.ADDED,
-                                    )
-                                ],
-                            )
-                            secondaries.append(node_changelog)
+                    ],
+                )
+                secondaries.append(node_changelog)
 
         return secondaries

backend/infrahub/graphql/mutations/relationship.py

@@ -8,7 +8,7 @@
 
 from infrahub import config
 from infrahub.core.account import GlobalPermission, ObjectPermission
-from infrahub.core.changelog.models import NodeChangelog
+from infrahub.core.changelog.models import NodeChangelog, RelationshipChangelogGetter
 from infrahub.core.constants import (
     InfrahubKind,
     PermissionAction,
@@ -148,14 +148,33 @@ async def mutate(
                         graphql_context.background.add_task(graphql_context.active_service.event.send, group_add_event)
 
             else:
-                event = NodeUpdatedEvent(
+                main_event = NodeUpdatedEvent(
                     kind=source.get_schema().kind,
                     node_id=source.id,
                     changelog=node_changelog,
                     fields=[relationship_name],
                     meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
                 )
-                graphql_context.background.add_task(graphql_context.active_service.event.send, event)
+                relationship_changelogs = RelationshipChangelogGetter(
+                    db=graphql_context.db, branch=graphql_context.branch
+                )
+                node_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=node_changelog)
+
+                events = [main_event]
+
+                for node_changelog in node_changelogs:
+                    meta = EventMeta.from_parent(parent=main_event)
+                    event = NodeUpdatedEvent(
+                        kind=node_changelog.node_kind,
+                        node_id=node_changelog.node_id,
+                        changelog=node_changelog,
+                        fields=node_changelog.updated_fields,
+                        meta=meta,
+                    )
+                    events.append(event)
+
+                for event in events:
+                    graphql_context.background.add_task(graphql_context.active_service.event.send, event)
 
         return cls(ok=True)
 
@@ -243,14 +262,34 @@ async def mutate(
                             graphql_context.active_service.event.send, group_remove_event
                         )
             else:
-                event = NodeUpdatedEvent(
+                main_event = NodeUpdatedEvent(
                     kind=source.get_schema().kind,
                     node_id=source.id,
                     changelog=node_changelog,
                     fields=[relationship_name],
                     meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
                 )
-                graphql_context.background.add_task(graphql_context.active_service.event.send, event)
+
+                relationship_changelogs = RelationshipChangelogGetter(
+                    db=graphql_context.db, branch=graphql_context.branch
+                )
+                node_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=node_changelog)
+
+                events = [main_event]
+
+                for node_changelog in node_changelogs:
+                    meta = EventMeta.from_parent(parent=main_event)
+                    event = NodeUpdatedEvent(
+                        kind=node_changelog.node_kind,
+                        node_id=node_changelog.node_id,
+                        changelog=node_changelog,
+                        fields=node_changelog.updated_fields,
+                        meta=meta,
+                    )
+                    events.append(event)
+
+                for event in events:
+                    graphql_context.background.add_task(graphql_context.active_service.event.send, event)
 
         return cls(ok=True)
 

backend/tests/unit/core/changelog/test_models.py

@@ -206,6 +206,20 @@ async def test_node_changelog_update_with_cardinality_one_relationship(
     )
     assert not dog1_update.node_changelog.parent
 
+    relationship_changelogs = RelationshipChangelogGetter(db=db, branch=default_branch)
+    secondary_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=dog1_update.node_changelog)
+    assert len(secondary_changelogs) == 2
+
+    person1_secondary = [changelog for changelog in secondary_changelogs if changelog.node_id == person1.id][0]
+    person2_secondary = [changelog for changelog in secondary_changelogs if changelog.node_id == person2.id][0]
+
+    assert isinstance(person1_secondary.relationships["animals"], RelationshipCardinalityManyChangelog)
+    assert len(person1_secondary.relationships["animals"].peers) == 1
+    assert person1_secondary.relationships["animals"].peers[0].peer_status == DiffAction.REMOVED
+    assert isinstance(person2_secondary.relationships["animals"], RelationshipCardinalityManyChangelog)
+    assert len(person2_secondary.relationships["animals"].peers) == 1
+    assert person2_secondary.relationships["animals"].peers[0].peer_status == DiffAction.ADDED
+
 
 async def test_node_changelog_update_with_cardinality_many_relationship(
     db: InfrahubDatabase, default_branch, animal_person_schema, standard_group_schema
@@ -302,6 +316,15 @@ async def test_node_changelog_delete_with_cardinality_many_relationship(
     assert RelationshipPeerChangelog(peer_id=dog1.id, peer_kind="TestDog", peer_status=DiffAction.REMOVED) in animals
     assert RelationshipPeerChangelog(peer_id=dog2.id, peer_kind="TestDog", peer_status=DiffAction.REMOVED) in animals
 
+    relationship_changelogs = RelationshipChangelogGetter(db=db, branch=default_branch)
+    secondary_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=person1_update.node_changelog)
+
+    assert len(secondary_changelogs) == 2
+    for changelog in secondary_changelogs:
+        assert isinstance(changelog.relationships["owner"], RelationshipCardinalityOneChangelog)
+        assert changelog.relationships["owner"].peer_kind_previous == "TestPerson"
+        assert changelog.relationships["owner"].peer_status == DiffAction.REMOVED
+
 
 async def test_node_changelog_parent(db: InfrahubDatabase, default_branch, car_person_schema: None) -> None:
     """Validate that parents are registrered in the node_changelog for parent/component relationships."""

backend/tests/unit/graphql/test_mutation_update.py

@@ -4,7 +4,8 @@
 from infrahub.auth import AccountSession
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.changelog.models import RelationshipCardinalityOneChangelog
+from infrahub.core.changelog.models import RelationshipCardinalityManyChangelog, RelationshipCardinalityOneChangelog
+from infrahub.core.constants import DiffAction
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
 from infrahub.database import InfrahubDatabase
@@ -462,12 +463,27 @@ async def test_update_single_relationship(
     assert car_peer.id == person_jim_main.id
     assert gql_params.context.background
     await gql_params.context.background()
-    assert len(memory_event.events) == 1
-    event = memory_event.events[0]
-    assert isinstance(event, NodeMutatedEvent)
-    assert isinstance(event.changelog.relationships["owner"], RelationshipCardinalityOneChangelog)
-    assert event.changelog.relationships["owner"].peer_id == person_jim_main.id
-    assert event.changelog.relationships["owner"].peer_kind == "TestPerson"
+    assert len(memory_event.events) == 3
+    main_event = memory_event.events[0]
+    related_event_01 = memory_event.events[1]
+    related_event_02 = memory_event.events[2]
+    assert isinstance(main_event, NodeMutatedEvent)
+    assert isinstance(related_event_01, NodeMutatedEvent)
+    assert isinstance(related_event_02, NodeMutatedEvent)
+    assert isinstance(main_event.changelog.relationships["owner"], RelationshipCardinalityOneChangelog)
+    assert main_event.changelog.relationships["owner"].peer_id == person_jim_main.id
+    assert main_event.changelog.relationships["owner"].peer_kind == "TestPerson"
+    assert main_event.changelog.relationships["owner"].peer_status == DiffAction.UPDATED
+    johns_event = [event for event in [related_event_01, related_event_02] if event.node_id == person_john_main.id][0]
+    jims_event = [event for event in [related_event_01, related_event_02] if event.node_id == person_jim_main.id][0]
+    assert isinstance(johns_event.changelog.relationships["cars"], RelationshipCardinalityManyChangelog)
+    assert len(johns_event.changelog.relationships["cars"].peers) == 1
+    assert johns_event.changelog.relationships["cars"].peers[0].peer_id == car_accord_main.id
+    assert johns_event.changelog.relationships["cars"].peers[0].peer_status == DiffAction.REMOVED
+    assert isinstance(jims_event.changelog.relationships["cars"], RelationshipCardinalityManyChangelog)
+    assert len(jims_event.changelog.relationships["cars"].peers) == 1
+    assert jims_event.changelog.relationships["cars"].peers[0].peer_id == car_accord_main.id
+    assert jims_event.changelog.relationships["cars"].peers[0].peer_status == DiffAction.ADDED
 
 
 async def test_update_default_value(