Merge remote-tracking branch 'origin/stable' into dga-20250225-stable-to-release-1.2

Author: dgarros

.github/workflows/update-compose-file-and-chart.yml

@@ -1,5 +1,5 @@
 ---
-# yamllint disable rule:truthy
+# yamllint disable rule:truthy rule:line-length
 name: Update Docker Compose & helm chart on Pyproject update in Stable
 
 # This will bump the infrahub docker image in the docker-compose.yml
@@ -43,11 +43,20 @@ jobs:
       - name: "Install Package"
         run: "poetry install --all-extras"
 
+      - name: "Check prerelease type"
+        id: release
+        run: |
+          echo is_prerelease=$(poetry run python -c "from packaging.version import Version; print(int(Version('$(poetry version -s)').is_prerelease))") >> "$GITHUB_OUTPUT"
+          echo is_devrelease=$(poetry run python -c "from packaging.version import Version; print(int(Version('$(poetry version -s)').is_devrelease))") >> "$GITHUB_OUTPUT"
+
       - name: "Update Docker Env variable in docker-compose.yml file"
+        if: steps.release.outputs.is_prerelease == 0 && steps.release.outputs.is_devrelease == 0
         run: "poetry run invoke release.gen-config-env -u"
       - name: "Update Infrahub Image Version in docker-compose.yml file"
+        if: steps.release.outputs.is_prerelease == 0 && steps.release.outputs.is_devrelease == 0
         run: "poetry run invoke release.update-docker-compose"
       - name: "Update AppVersion in helm/chart.yaml file"
+        if: steps.release.outputs.is_prerelease == 0 && steps.release.outputs.is_devrelease == 0
         run: "poetry run invoke release.update-helm-chart"
       - name: "Update Versions in python_testcontainers/pyproject.toml"
         run: "poetry run invoke release.update-test-containers"

backend/infrahub/core/diff/model/path.py

@@ -409,8 +409,8 @@ class EnrichedDiffRootMetadata(BaseSummary):
     from_time: Timestamp
     to_time: Timestamp
     uuid: str
-    partner_uuid: str
     tracking_id: TrackingId
+    partner_uuid: str | None = field(default=None)
     exists_on_database: bool = field(default=False)
 
     def __hash__(self) -> int:

backend/infrahub/core/diff/query/save.py

@@ -42,6 +42,7 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa
 }
 WITH DISTINCT diff_root AS diff_root
 WITH collect(diff_root) AS diff_roots
+WHERE SIZE(diff_roots) = 2
 CALL {
     WITH diff_roots
     WITH diff_roots[0] AS base_diff_node, diff_roots[1] AS branch_diff_node

backend/infrahub/core/diff/repository/deserializer.py

@@ -164,6 +164,7 @@ def _deserialize_diff_root(self, root_node: Neo4jNode) -> EnrichedDiffRoot:
     def build_diff_root_metadata(cls, root_node: Neo4jNode) -> EnrichedDiffRootMetadata:
         from_time = Timestamp(str(root_node.get("from_time")))
         to_time = Timestamp(str(root_node.get("to_time")))
+        partner_uuid = cls._get_str_or_none_property_value(node=root_node, property_name="partner_uuid")
         tracking_id_str = str(root_node.get("tracking_id"))
         tracking_id = deserialize_tracking_id(tracking_id_str=tracking_id_str)
         return EnrichedDiffRootMetadata(
@@ -172,7 +173,7 @@ def build_diff_root_metadata(cls, root_node: Neo4jNode) -> EnrichedDiffRootMetad
             from_time=from_time,
             to_time=to_time,
             uuid=str(root_node.get("uuid")),
-            partner_uuid=str(root_node.get("partner_uuid")),
+            partner_uuid=partner_uuid,
             tracking_id=tracking_id,
             num_added=int(root_node.get("num_added", 0)),
             num_updated=int(root_node.get("num_updated", 0)),

backend/infrahub/core/diff/repository/repository.py

@@ -154,18 +154,23 @@ async def get_pairs(
             diff_branch_names=[base_branch_name],
             max_depth=max_depth,
             batch_size_limit=batch_size_limit,
-            diff_ids=[d.partner_uuid for d in diffs_by_uuid.values()],
+            diff_ids=[d.partner_uuid for d in diffs_by_uuid.values() if d.partner_uuid],
         )
         diffs_by_uuid.update({bbr.uuid: bbr for bbr in base_branch_roots})
-        return [
-            EnrichedDiffs(
-                base_branch_name=base_branch_name,
-                diff_branch_name=diff_branch_name,
-                base_branch_diff=diffs_by_uuid[dbr.partner_uuid],
-                diff_branch_diff=dbr,
+        diff_pairs = []
+        for dbr in diff_branch_roots:
+            if dbr.partner_uuid is None:
+                continue
+            base_branch_diff = diffs_by_uuid[dbr.partner_uuid]
+            diff_pairs.append(
+                EnrichedDiffs(
+                    base_branch_name=base_branch_name,
+                    diff_branch_name=diff_branch_name,
+                    base_branch_diff=base_branch_diff,
+                    diff_branch_diff=dbr,
+                )
             )
-            for dbr in diff_branch_roots
-        ]
+        return diff_pairs
 
     async def hydrate_diff_pair(
         self,
@@ -325,7 +330,7 @@ async def get_diff_pairs_metadata(
         roots_by_id = {root.uuid: root for root in empty_roots}
         pairs: list[EnrichedDiffsMetadata] = []
         for branch_root in empty_roots:
-            if branch_root.base_branch_name == branch_root.diff_branch_name:
+            if branch_root.base_branch_name == branch_root.diff_branch_name or branch_root.partner_uuid is None:
                 continue
             base_root = roots_by_id[branch_root.partner_uuid]
             pairs.append(

backend/infrahub/core/diff/tasks.py

@@ -11,14 +11,14 @@
 from infrahub.log import get_logger
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.catalogue import DIFF_REFRESH
-from infrahub.workflows.utils import add_branch_tag
+from infrahub.workflows.utils import add_tags
 
 log = get_logger()
 
 
 @flow(name="diff-update", flow_run_name="Update diff for branch {model.branch_name}")
 async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=model.branch_name)
+    await add_tags(branches=[model.branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()
@@ -38,7 +38,7 @@ async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> No
 
 @flow(name="diff-refresh", flow_run_name="Recreate diff for branch {branch_name}")
 async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=branch_name)
+    await add_tags(branches=[branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()
@@ -51,7 +51,7 @@ async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices
 
 @flow(name="diff-refresh-all", flow_run_name="Recreate all diffs for branch {branch_name}")
 async def refresh_diff_all(branch_name: str, context: InfrahubContext, service: InfrahubServices) -> None:
-    await add_branch_tag(branch_name=branch_name)
+    await add_tags(branches=[branch_name])
 
     async with service.database.start_session() as db:
         component_registry = get_component_registry()

backend/infrahub/core/query/relationship.py

@@ -581,6 +581,7 @@ async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG
         query = """
         MATCH (source_node:Node)%(arrow_left_start)s[:IS_RELATED]%(arrow_left_end)s(rl:Relationship { name: $rel_identifier })
         WHERE source_node.uuid IN $source_ids
+        WITH DISTINCT source_node, rl
         CALL {
             WITH rl, source_node
             MATCH path = (source_node)%(path)s(peer:Node)
@@ -657,10 +658,23 @@ async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG
         # QUERY Properties
         # ----------------------------------------------------------------------------
         query = """
-        MATCH (rl)-[rel_is_visible:IS_VISIBLE]-(is_visible)
-        MATCH (rl)-[rel_is_protected:IS_PROTECTED]-(is_protected)
-        WHERE all(r IN [ rel_is_visible, rel_is_protected] WHERE (%s))
-        """ % (branch_filter,)
+        CALL {
+            WITH rl
+            MATCH (rl)-[r:IS_VISIBLE]-(is_visible)
+            WHERE %(branch_filter)s
+            RETURN r AS rel_is_visible, is_visible
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        CALL {
+            WITH rl
+            MATCH (rl)-[r:IS_PROTECTED]-(is_protected)
+            WHERE %(branch_filter)s
+            RETURN r AS rel_is_protected, is_protected
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+        """ % {"branch_filter": branch_filter}
 
         self.add_to_query(query)
 
@@ -670,20 +684,24 @@ async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG
         # We must query them one by one otherwise the second one won't return
         for node_prop in ["source", "owner"]:
             query = """
-            WITH %s
-            OPTIONAL MATCH (rl)-[rel_%s:HAS_%s]-(%s)
-            WHERE all(r IN [ rel_%s ] WHERE (%s))
-            """ % (
-                ",".join(self.return_labels),
-                node_prop,
-                node_prop.upper(),
-                node_prop,
-                node_prop,
-                branch_filter,
-            )
+        CALL {
+            WITH rl
+            OPTIONAL MATCH (rl)-[r:HAS_%(node_prop_type)s]-(%(node_prop)s)
+            WHERE %(branch_filter)s
+            RETURN r AS rel_%(node_prop)s, %(node_prop)s
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+        }
+            """ % {
+                "node_prop": node_prop,
+                "node_prop_type": node_prop.upper(),
+                "branch_filter": branch_filter,
+            }
             self.add_to_query(query)
             self.update_return_labels([f"rel_{node_prop}", node_prop])
 
+        self.add_to_query("WITH " + ",".join(self.return_labels))
+
         # ----------------------------------------------------------------------------
         # ORDER Results
         # ----------------------------------------------------------------------------

backend/infrahub/graphql/mutations/diff.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from graphene import Boolean, DateTime, InputObjectType, Mutation, String
+from graphene import Boolean, DateTime, Field, InputObjectType, Mutation, String
 from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
@@ -14,6 +14,8 @@
 from infrahub.exceptions import ValidationError
 from infrahub.workflows.catalogue import DIFF_UPDATE
 
+from ..types.task import TaskInfo
+
 if TYPE_CHECKING:
     from ..initialization import GraphqlContext
 
@@ -23,14 +25,16 @@ class DiffUpdateInput(InputObjectType):
     name = String(required=False)
     from_time = DateTime(required=False)
     to_time = DateTime(required=False)
-    wait_for_completion = Boolean(required=False)
+    wait_for_completion = Boolean(required=False, deprecation_reason="Please use `wait_until_completion` instead")
 
 
 class DiffUpdateMutation(Mutation):
     class Arguments:
         data = DiffUpdateInput(required=True)
+        wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
+    task = Field(TaskInfo, required=False)
 
     @classmethod
     @retry_db_transaction(name="diff_update")
@@ -39,9 +43,13 @@ async def mutate(
         root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: DiffUpdateInput,
-    ) -> dict[str, bool]:
+        wait_until_completion: bool = False,
+    ) -> dict[str, bool | dict[str, str]]:
         graphql_context: GraphqlContext = info.context
 
+        if data.wait_for_completion is True:
+            wait_until_completion = True
+
         from_timestamp_str = DateTime.serialize(data.from_time) if data.from_time else None
         to_timestamp_str = DateTime.serialize(data.to_time) if data.to_time else None
         if (data.from_time or data.to_time) and not data.name:
@@ -55,11 +63,11 @@ async def mutate(
         )
 
         tracking_id = NameTrackingId(name=data.name)
-        existing_diffs_metatdatas = await diff_repository.get_roots_metadata(
+        existing_diffs_metadatas = await diff_repository.get_roots_metadata(
             diff_branch_names=[diff_branch.name], base_branch_names=[base_branch.name], tracking_id=tracking_id
         )
-        if existing_diffs_metatdatas:
-            metadata = existing_diffs_metatdatas[0]
+        if existing_diffs_metadatas:
+            metadata = existing_diffs_metadatas[0]
             from_time = Timestamp(from_timestamp_str) if from_timestamp_str else None
             to_time = Timestamp(to_timestamp_str) if to_timestamp_str else None
             branched_from_timestamp = Timestamp(diff_branch.get_branched_from())
@@ -70,7 +78,7 @@ async def mutate(
             if to_time and to_time < metadata.to_time:
                 raise ValidationError(f"to_time must be null or greater than or equal to {metadata.to_time}")
 
-        if data.wait_for_completion is True:
+        if wait_until_completion is True:
             diff_coordinator = await component_registry.get_component(
                 DiffCoordinator, db=graphql_context.db, branch=diff_branch
             )
@@ -91,8 +99,7 @@ async def mutate(
             to_time=to_timestamp_str,
         )
         if graphql_context.service:
-            await graphql_context.service.workflow.submit_workflow(
-                workflow=DIFF_UPDATE, context=graphql_context.get_context(), parameters={"model": model}
-            )
+            workflow = await graphql_context.service.workflow.submit_workflow(workflow=DIFF_UPDATE, parameters={"model": model})
+            return {"ok": True, "task": {"id": str(workflow.id)}}
 
         return {"ok": True}

backend/tests/integration/diff/test_diff_update.py

@@ -32,8 +32,8 @@
 BRANCH_NAME = "branch1"
 PROPOSED_CHANGE_NAME = "branch1-pc"
 DIFF_UPDATE_QUERY = """
-mutation DiffUpdate($branch_name: String!, $wait_for_completion: Boolean) {
-    DiffUpdate(data: { branch: $branch_name, wait_for_completion: $wait_for_completion }) {
+mutation DiffUpdate($branch_name: String!, $wait_for_completion: Boolean = true) {
+    DiffUpdate(data: { branch: $branch_name }, wait_until_completion: $wait_for_completion) {
         ok
     }
 }

backend/tests/unit/core/diff/test_coordinator.py

@@ -8,7 +8,7 @@
 from infrahub.core.diff.calculator import DiffCalculator
 from infrahub.core.diff.combiner import DiffCombiner
 from infrahub.core.diff.coordinator import DiffCoordinator
-from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRootMetadata
+from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRootMetadata, NameTrackingId
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.core.initialization import create_branch
 from infrahub.core.manager import NodeManager
@@ -240,3 +240,64 @@ async def test_unrelated_changes_skip_some_expensive_operations(
         )
         assert no_changes_diff.from_time == no_changes_diff_metadata.from_time == diff_with_data.from_time
         assert no_changes_diff.to_time == no_changes_diff_metadata.to_time
+
+    async def test_diff_on_default_branch_only(
+        self,
+        db: InfrahubDatabase,
+        default_branch: Branch,
+        person_john_main: Node,
+        person_jane_main: Node,
+        person_alfred_main: Node,
+        car_camry_main: Node,
+        car_accord_main: Node,
+    ) -> None:
+        branch = await create_branch(db=db, branch_name="branch1")
+
+        updated_person = await NodeManager.get_one(db=db, id=person_john_main.id)
+        updated_person.height.value = 200
+        await updated_person.save(db=db)
+
+        new_person = await Node.init(db=db, schema="TestPerson", branch=default_branch)
+        await new_person.new(db=db, name="Jeff", height=170)
+        await new_person.save(db=db)
+
+        deleted_person = await NodeManager.get_one(db=db, id=person_alfred_main.id)
+        await deleted_person.delete(db=db)
+
+        updated_car = await NodeManager.get_one(db=db, id=car_accord_main.id)
+        await updated_car.owner.update(db=db, data=new_person)
+        await updated_car.save(db=db)
+
+        from_time = Timestamp(branch.get_branched_from())
+        to_time = Timestamp()
+        name = str(uuid4())
+        diff_coordinator = await self.get_wrapped_diff_coordinator(db=db, branch=default_branch)
+        component_registry = get_component_registry()
+        diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
+        main_diff_metadata = await diff_coordinator.create_or_update_arbitrary_timeframe_diff(
+            base_branch=default_branch, diff_branch=default_branch, from_time=from_time, to_time=to_time, name=name
+        )
+        main_diff = await diff_repository.get_one(diff_branch_name=default_branch.name, diff_id=main_diff_metadata.uuid)
+
+        assert main_diff.base_branch_name == default_branch.name
+        assert main_diff.diff_branch_name == default_branch.name
+        assert main_diff.from_time == from_time
+        assert main_diff.to_time == to_time
+        assert main_diff.tracking_id == NameTrackingId(name=name)
+        assert len(main_diff.nodes) == 4
+        nodes_by_id = {n.uuid: n for n in main_diff.nodes}
+        assert set(nodes_by_id.keys()) == {updated_person.id, new_person.id, deleted_person.id, updated_car.id}
+        new_person_diff = nodes_by_id[new_person.id]
+        assert new_person_diff.action is DiffAction.ADDED
+        deleted_person_diff = nodes_by_id[deleted_person.id]
+        assert deleted_person_diff.action is DiffAction.REMOVED
+        updated_car_diff = nodes_by_id[updated_car.id]
+        assert updated_car_diff.action is DiffAction.UPDATED
+        assert updated_car_diff.attributes == set()
+        rel_diffs = {(r.name, r.action) for r in updated_car_diff.relationships}
+        assert rel_diffs == {("owner", DiffAction.UPDATED)}
+        updated_person_diff = nodes_by_id[updated_person.id]
+        rel_diffs = {(r.name, r.action) for r in updated_person_diff.relationships}
+        assert rel_diffs == {("cars", DiffAction.UPDATED)}
+        attr_diffs = {(a.name, a.action) for a in updated_person_diff.attributes}
+        assert attr_diffs == {("height", DiffAction.UPDATED)}