add support for merging relationship properties (#4593)

* support relationship properties in merge queries

* more tests and finish support for relationship properties

Author: ajtmccarty

backend/infrahub/core/diff/merger/serializer.py

@@ -104,7 +104,8 @@ async def serialize_diff(
                 attribute_diff, attribute_property_diff = self._serialize_attribute(
                     attribute_diff=attr_diff, node_uuid=node.uuid, node_kind=node.kind
                 )
-                attribute_diffs.append(attribute_diff)
+                if attribute_diff:
+                    attribute_diffs.append(attribute_diff)
                 serialized_property_diffs.append(attribute_property_diff)
             relationship_diffs = []
             for rel_diff in node.relationships:
@@ -113,7 +114,9 @@ async def serialize_diff(
                 )
                 for relationship_element_diff in rel_diff.relationships:
                     element_diffs, relationship_property_diffs = self._serialize_relationship_element(
-                        relationship_diff=relationship_element_diff, relationship_identifier=relationship_identifier
+                        relationship_diff=relationship_element_diff,
+                        relationship_identifier=relationship_identifier,
+                        node_uuid=node.uuid,
                     )
                     relationship_diffs.extend(element_diffs)
                     serialized_property_diffs.extend(relationship_property_diffs)
@@ -153,13 +156,13 @@ def _get_property_actions_and_values(
             final_value = self._convert_property_value(
                 property_type=property_diff.property_type, raw_value=raw_value, value_type=python_value_type
             )
-            if final_value:
+            if final_value is not None:
                 actions_and_values.append((action, final_value))
         return actions_and_values
 
     def _serialize_attribute(
         self, attribute_diff: EnrichedDiffAttribute, node_uuid: str, node_kind: str
-    ) -> tuple[AttributeMergeDict, AttributePropertyMergeDict]:
+    ) -> tuple[AttributeMergeDict | None, AttributePropertyMergeDict]:
         prop_dicts: list[PropertyMergeDict] = []
         python_type = self._get_property_type_for_attribute_value(
             schema_kind=node_kind, attribute_name=attribute_diff.name
@@ -169,38 +172,105 @@ def _serialize_attribute(
                 property_diff=property_diff, python_value_type=python_type
             )
             for action, value in actions_and_values:
+                # we only delete attributes when the whole attribute is deleted
+                if action is DiffAction.REMOVED and attribute_diff.action is not DiffAction.REMOVED:
+                    continue
                 prop_dicts.append(
                     PropertyMergeDict(
                         property_type=property_diff.property_type.value,
                         action=self._to_action_str(action=action),
                         value=value,
                     )
                 )
-        attr_dict = AttributeMergeDict(
-            name=attribute_diff.name,
-            action=self._to_action_str(action=attribute_diff.action),
-        )
+        attr_dict = None
+        if attribute_diff.action in (DiffAction.ADDED, DiffAction.REMOVED):
+            attr_dict = AttributeMergeDict(
+                name=attribute_diff.name,
+                action=self._to_action_str(action=attribute_diff.action),
+            )
         attr_prop_dict = AttributePropertyMergeDict(
             node_uuid=node_uuid, attribute_name=attribute_diff.name, properties=prop_dicts
         )
         return attr_dict, attr_prop_dict
 
     def _serialize_relationship_element(
-        self, relationship_diff: EnrichedDiffSingleRelationship, relationship_identifier: str
+        self, relationship_diff: EnrichedDiffSingleRelationship, relationship_identifier: str, node_uuid: str
     ) -> tuple[list[RelationshipMergeDict], list[RelationshipPropertyMergeDict]]:
         relationship_dicts = []
+        # start with default values for IS_VISIBLE and IS_PROTECTED b/c we always want to update them during a merge
+        added_property_dicts: dict[DatabaseEdgeType, PropertyMergeDict] = {
+            DatabaseEdgeType.IS_VISIBLE: PropertyMergeDict(
+                property_type=DatabaseEdgeType.IS_VISIBLE.value,
+                action=self._to_action_str(DiffAction.ADDED),
+                value=None,
+            ),
+            DatabaseEdgeType.IS_PROTECTED: PropertyMergeDict(
+                property_type=DatabaseEdgeType.IS_PROTECTED.value,
+                action=self._to_action_str(DiffAction.ADDED),
+                value=None,
+            ),
+        }
+        removed_property_dicts: dict[DatabaseEdgeType, PropertyMergeDict] = {
+            DatabaseEdgeType.IS_VISIBLE: PropertyMergeDict(
+                property_type=DatabaseEdgeType.IS_VISIBLE.value,
+                action=self._to_action_str(DiffAction.REMOVED),
+                value=None,
+            ),
+            DatabaseEdgeType.IS_PROTECTED: PropertyMergeDict(
+                property_type=DatabaseEdgeType.IS_PROTECTED.value,
+                action=self._to_action_str(DiffAction.REMOVED),
+                value=None,
+            ),
+        }
+        added_peer_id: str | None = None
+        removed_peer_id: str | None = None
         for property_diff in relationship_diff.properties:
-            if property_diff.property_type is not DatabaseEdgeType.IS_RELATED:
-                continue
-            # TODO: next PR will add properties to this method
+            python_value_type: type = str
+            if property_diff.property_type in (DatabaseEdgeType.IS_VISIBLE, DatabaseEdgeType.IS_PROTECTED):
+                python_value_type = bool
             actions_and_values = self._get_property_actions_and_values(
-                property_diff=property_diff, python_value_type=str
+                property_diff=property_diff, python_value_type=python_value_type
             )
-
-            for action, value in actions_and_values:
-                relationship_dicts.append(
-                    RelationshipMergeDict(
-                        peer_id=str(value), name=relationship_identifier, action=self._to_action_str(action=action)
+            if property_diff.property_type is DatabaseEdgeType.IS_RELATED:
+                for action, value in actions_and_values:
+                    peer_id = str(value)
+                    if action is DiffAction.ADDED:
+                        added_peer_id = peer_id
+                    elif action is DiffAction.REMOVED:
+                        removed_peer_id = peer_id
+                    relationship_dicts.append(
+                        RelationshipMergeDict(
+                            peer_id=peer_id, name=relationship_identifier, action=self._to_action_str(action=action)
+                        )
                     )
+            else:
+                for action, value in actions_and_values:
+                    property_dict = PropertyMergeDict(
+                        property_type=property_diff.property_type.value,
+                        action=self._to_action_str(action=action),
+                        value=value,
+                    )
+                    if action is DiffAction.ADDED:
+                        added_property_dicts[property_diff.property_type] = property_dict
+                    elif action is DiffAction.REMOVED:
+                        removed_property_dicts[property_diff.property_type] = property_dict
+        relationship_property_dicts = []
+        if added_peer_id and added_property_dicts:
+            relationship_property_dicts.append(
+                RelationshipPropertyMergeDict(
+                    node_uuid=node_uuid,
+                    relationship_id=relationship_identifier,
+                    peer_uuid=added_peer_id,
+                    properties=list(added_property_dicts.values()),
                 )
-        return relationship_dicts, []
+            )
+        if removed_peer_id and removed_property_dicts:
+            relationship_property_dicts.append(
+                RelationshipPropertyMergeDict(
+                    node_uuid=node_uuid,
+                    relationship_id=relationship_identifier,
+                    peer_uuid=removed_peer_id,
+                    properties=list(removed_property_dicts.values()),
+                )
+            )
+        return relationship_dicts, relationship_property_dicts