infrahub-server 1.1.4__tar.gz → 1.1.5__tar.gz

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.1.4
+Version: 1.1.5
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/api/artifact.py

@@ -85,7 +85,10 @@ async def generate_artifact(
 
     service = request.app.state.service
     model = RequestArtifactDefinitionGenerate(
-        artifact_definition=artifact_definition.id, branch=branch_params.branch.name, limit=payload.nodes
+        artifact_definition_id=artifact_definition.id,
+        artifact_definition_name=artifact_definition.name.value,
+        branch=branch_params.branch.name,
+        limit=payload.nodes,
     )
 
     await service.workflow.submit_workflow(workflow=REQUEST_ARTIFACT_DEFINITION_GENERATE, parameters={"model": model})

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/api/oidc.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urljoin
 
+import jwt
 import ujson
 from authlib.integrations.httpx_client import AsyncOAuth2Client
 from fastapi import APIRouter, Depends, Request, Response
@@ -138,7 +139,7 @@ async def token(
 
     with trace.get_tracer(__name__).start_as_current_span("sso_token_request") as span:
         span.set_attribute("token_request_data", ujson.dumps(token_response.json()))
-        payload = token_response.json()
+        payload: dict[str, Any] = token_response.json()
 
     headers = {"Authorization": f"{payload.get('token_type')} {payload.get('access_token')}"}
 
@@ -148,8 +149,10 @@ async def token(
         userinfo_response = await service.http.post(str(oidc_config.userinfo_endpoint), headers=headers)
 
     _validate_response(response=userinfo_response)
-    user_info = userinfo_response.json()
-    sso_groups = user_info.get("groups", [])
+    user_info: dict[str, Any] = userinfo_response.json()
+    sso_groups = user_info.get("groups") or await _get_id_token_groups(
+        oidc_config=oidc_config, service=service, payload=payload, client_id=provider.client_id
+    )
 
     if not sso_groups and config.SETTINGS.security.sso_user_default_group:
         sso_groups = [config.SETTINGS.security.sso_user_default_group]
@@ -185,3 +188,28 @@ def _validate_response(response: httpx.Response) -> None:
         body=response.json(),
     )
     raise GatewayError(message="Invalid response from Authentication provider")
+
+
+async def _get_id_token_groups(
+    oidc_config: OIDCDiscoveryConfig, service: InfrahubServices, payload: dict[str, Any], client_id: str
+) -> list[str]:
+    id_token = payload.get("id_token")
+    if not id_token:
+        return []
+    jwks = await service.http.get(url=str(oidc_config.jwks_uri))
+
+    jwk_client = jwt.PyJWKClient(uri=str(oidc_config.jwks_uri), cache_jwk_set=True)
+    if jwk_client.jwk_set_cache:
+        jwk_client.jwk_set_cache.put(jwks.json())
+
+    signing_key = jwk_client.get_signing_key_from_jwt(id_token)
+
+    decoded_token: dict[str, Any] = jwt.decode(
+        jwt=id_token,
+        key=signing_key.key,
+        algorithms=oidc_config.id_token_signing_alg_values_supported,
+        audience=client_id,
+        issuer=str(oidc_config.issuer),
+    )
+
+    return decoded_token.get("groups", [])

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/api/transformation.py

@@ -83,6 +83,7 @@ async def transform_python(
         commit=repository.commit.value,  # type: ignore[attr-defined]
         branch=branch_params.branch.name,
         transform_location=f"{transform.file_path.value}::{transform.class_name.value}",
+        timeout=transform.timeout.value,
         data=data,
     )
 
@@ -140,6 +141,7 @@ async def transform_jinja2(
         commit=repository.commit.value,  # type: ignore[attr-defined]
         branch=branch_params.branch.name,
         template_location=transform.template_path.value,
+        timeout=transform.timeout.value,
         data=data,
     )
 

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/computed_attribute/tasks.py

@@ -4,7 +4,10 @@ from datetime import timedelta
 from typing import TYPE_CHECKING, Any
 
 import ujson
-from infrahub_sdk.protocols import CoreNode  # noqa: TC002
+from infrahub_sdk.protocols import (
+    CoreNode,  # noqa: TC002
+    CoreTransformPython,
+)
 from prefect import flow
 from prefect.automations import AutomationCore
 from prefect.client.orchestration import get_client
@@ -88,17 +91,18 @@ async def process_transform(
 
     for attribute_name, transform_attribute in transform_attributes.items():
         transform = await service.client.get(
-            kind="CoreTransformPython",
+            kind=CoreTransformPython,
             branch=branch_name,
             id=transform_attribute.transform,
             prefetch_relationships=True,
             populate_store=True,
         )
+
         if not transform:
             continue
 
         repo_node = await service.client.get(
-            kind=transform.repository.peer.typename,
+            kind=str(transform.repository.peer.typename),
             branch=branch_name,
             id=transform.repository.peer.id,
             raise_when_missing=True,
@@ -108,7 +112,7 @@ async def process_transform(
             repository_id=transform.repository.peer.id,
             name=transform.repository.peer.name.value,
             service=service,
-            repository_kind=transform.repository.peer.typename,
+            repository_kind=str(transform.repository.peer.typename),
             commit=repo_node.commit.value,
         )
 
@@ -120,7 +124,7 @@ async def process_transform(
             subscribers=[object_id],
         )
 
-        transformed_data = await repo.execute_python_transform(
+        transformed_data = await repo.execute_python_transform.with_options(timeout_seconds=transform.timeout.value)(
             branch_name=branch_name,
             commit=repo_node.commit.value,
             location=f"{transform.file_path.value}::{transform.class_name.value}",

infrahub_server-1.1.5/backend/infrahub/core/diff/calculator.py

@@ -0,0 +1,197 @@
+from dataclasses import dataclass, field
+
+from infrahub import config
+from infrahub.core import registry
+from infrahub.core.branch import Branch
+from infrahub.core.diff.query_parser import DiffQueryParser
+from infrahub.core.query.diff import DiffAllPathsQuery, DiffCalculationQuery, DiffFieldPathsQuery, DiffNodePathsQuery
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
+
+from .model.path import CalculatedDiffs
+
+log = get_logger()
+
+
+@dataclass
+class DiffCalculationRequest:
+    base_branch: Branch
+    diff_branch: Branch
+    branch_from_time: Timestamp
+    from_time: Timestamp
+    to_time: Timestamp
+    current_node_field_specifiers: dict[str, set[str]] | None = field(default=None)
+    new_node_field_specifiers: dict[str, set[str]] | None = field(default=None)
+
+
+class DiffCalculator:
+    def __init__(self, db: InfrahubDatabase) -> None:
+        self.db = db
+
+    async def _run_diff_calculation_query(
+        self,
+        diff_parser: DiffQueryParser,
+        query_class: type[DiffCalculationQuery],
+        calculation_request: DiffCalculationRequest,
+        limit: int,
+    ) -> None:
+        has_more_data = True
+        offset = 0
+        while has_more_data:
+            diff_query = await query_class.init(
+                db=self.db,
+                branch=calculation_request.diff_branch,
+                base_branch=calculation_request.base_branch,
+                diff_branch_from_time=calculation_request.branch_from_time,
+                diff_from=calculation_request.from_time,
+                diff_to=calculation_request.to_time,
+                current_node_field_specifiers=calculation_request.current_node_field_specifiers,
+                new_node_field_specifiers=calculation_request.new_node_field_specifiers,
+                limit=limit,
+                offset=offset,
+            )
+            log.info(f"Beginning one diff calculation query {limit=}, {offset=}")
+            await diff_query.execute(db=self.db)
+            log.info("Diff calculation query complete")
+            last_result = None
+            for query_result in diff_query.get_results():
+                diff_parser.read_result(query_result=query_result)
+                last_result = query_result
+            has_more_data = False
+            if last_result:
+                has_more_data = last_result.get_as_type("has_more_data", bool)
+            offset += limit
+
+    async def calculate_diff(
+        self,
+        base_branch: Branch,
+        diff_branch: Branch,
+        from_time: Timestamp,
+        to_time: Timestamp,
+        include_unchanged: bool = True,
+        previous_node_specifiers: dict[str, set[str]] | None = None,
+    ) -> CalculatedDiffs:
+        if diff_branch.name == registry.default_branch:
+            diff_branch_from_time = from_time
+        else:
+            diff_branch_from_time = Timestamp(diff_branch.get_branched_from())
+        diff_parser = DiffQueryParser(
+            base_branch=base_branch,
+            diff_branch=diff_branch,
+            schema_manager=registry.schema,
+            from_time=from_time,
+            to_time=to_time,
+            previous_node_field_specifiers=previous_node_specifiers,
+        )
+        node_limit = int(config.SETTINGS.database.query_size_limit / 10)
+        fields_limit = int(config.SETTINGS.database.query_size_limit / 3)
+
+        calculation_request = DiffCalculationRequest(
+            base_branch=base_branch,
+            diff_branch=diff_branch,
+            branch_from_time=diff_branch_from_time,
+            from_time=from_time,
+            to_time=to_time,
+        )
+
+        log.info("Beginning diff node-level calculation queries for branch")
+        await self._run_diff_calculation_query(
+            diff_parser=diff_parser,
+            query_class=DiffNodePathsQuery,
+            calculation_request=calculation_request,
+            limit=node_limit,
+        )
+        log.info("Diff node-level calculation queries for branch complete")
+
+        log.info("Beginning diff field-level calculation queries for branch")
+        await self._run_diff_calculation_query(
+            diff_parser=diff_parser,
+            query_class=DiffFieldPathsQuery,
+            calculation_request=calculation_request,
+            limit=fields_limit,
+        )
+        log.info("Diff field-level calculation queries for branch complete")
+
+        branch_diff_query = await DiffAllPathsQuery.init(
+            db=self.db,
+            branch=diff_branch,
+            base_branch=base_branch,
+            diff_branch_from_time=diff_branch_from_time,
+            diff_from=from_time,
+            diff_to=to_time,
+        )
+        log.info("Beginning diff calculation query for branch")
+        await branch_diff_query.execute(db=self.db)
+        log.info("Diff calculation query for branch complete")
+        log.info("Reading results of query for branch")
+        for query_result in branch_diff_query.get_results():
+            diff_parser.read_result(query_result=query_result)
+        log.info("Results of query for branch read")
+
+        if base_branch.name != diff_branch.name:
+            current_node_field_specifiers = diff_parser.get_current_node_field_specifiers()
+            new_node_field_specifiers = diff_parser.get_new_node_field_specifiers()
+            calculation_request = DiffCalculationRequest(
+                base_branch=base_branch,
+                diff_branch=base_branch,
+                branch_from_time=diff_branch_from_time,
+                from_time=from_time,
+                to_time=to_time,
+                current_node_field_specifiers=current_node_field_specifiers,
+                new_node_field_specifiers=new_node_field_specifiers,
+            )
+
+            log.info("Beginning diff node-level calculation queries for base")
+            await self._run_diff_calculation_query(
+                diff_parser=diff_parser,
+                query_class=DiffNodePathsQuery,
+                calculation_request=calculation_request,
+                limit=node_limit,
+            )
+            log.info("Diff node-level calculation queries for base complete")
+
+            log.info("Beginning diff field-level calculation queries for base")
+            await self._run_diff_calculation_query(
+                diff_parser=diff_parser,
+                query_class=DiffFieldPathsQuery,
+                calculation_request=calculation_request,
+                limit=fields_limit,
+            )
+            log.info("Diff field-level calculation queries for base complete")
+
+            # Temporary until next change
+            current_node_field_specifier_tuples: list[tuple[str, str]] = []
+            new_node_field_specifier_tuples: list[tuple[str, str]] = []
+            for node_uuid, field_names in current_node_field_specifiers.items():
+                current_node_field_specifier_tuples.extend((node_uuid, field_name) for field_name in field_names)
+            for node_uuid, field_names in new_node_field_specifiers.items():
+                new_node_field_specifier_tuples.extend((node_uuid, field_name) for field_name in field_names)
+
+            base_diff_query = await DiffAllPathsQuery.init(
+                db=self.db,
+                branch=base_branch,
+                base_branch=base_branch,
+                diff_branch_from_time=diff_branch_from_time,
+                diff_from=from_time,
+                diff_to=to_time,
+                current_node_field_specifiers=current_node_field_specifier_tuples,
+                new_node_field_specifiers=new_node_field_specifier_tuples,
+            )
+
+            log.info("Beginning diff calculation query for base")
+            await base_diff_query.execute(db=self.db)
+            log.info("Diff calculation query for base complete")
+            log.info("Reading results of query for base")
+            for query_result in base_diff_query.get_results():
+                diff_parser.read_result(query_result=query_result)
+            log.info("Results of query for branch read")
+        log.info("Parsing calculated diff")
+        diff_parser.parse(include_unchanged=include_unchanged)
+        log.info("Calculated diff parsed")
+        return CalculatedDiffs(
+            base_branch_name=base_branch.name,
+            diff_branch_name=diff_branch.name,
+            base_branch_diff=diff_parser.get_diff_root_for_branch(branch=base_branch.name),
+            diff_branch_diff=diff_parser.get_diff_root_for_branch(branch=diff_branch.name),
+        )

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/core/diff/coordinator.py

@@ -15,7 +15,6 @@ from .model.path import (
     EnrichedDiffs,
     EnrichedDiffsMetadata,
     NameTrackingId,
-    NodeFieldSpecifier,
     TrackingId,
 )
 
@@ -44,7 +43,7 @@ class EnrichedDiffRequest:
     from_time: Timestamp
     to_time: Timestamp
     tracking_id: TrackingId | None = field(default=None)
-    node_field_specifiers: set[NodeFieldSpecifier] = field(default_factory=set)
+    node_field_specifiers: dict[str, set[str]] = field(default_factory=dict)
 
     def __repr__(self) -> str:
         return (

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/core/diff/model/path.py

@@ -82,15 +82,6 @@ def deserialize_tracking_id(tracking_id_str: str) -> TrackingId:
     raise ValueError(f"{tracking_id_str} is not a valid TrackingId")
 
 
-@dataclass
-class NodeFieldSpecifier:
-    node_uuid: str
-    field_name: str
-
-    def __hash__(self) -> int:
-        return hash(f"{self.node_uuid}:{self.field_name}")
-
-
 @dataclass
 class NodeDiffFieldSummary:
     kind: str

infrahub_server-1.1.5/backend/infrahub/core/diff/query/all_conflicts.py

@@ -0,0 +1,64 @@
+from typing import Any, Generator
+
+from neo4j.graph import Node as Neo4jNode
+
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+from ..model.path import TrackingId
+
+
+class EnrichedDiffAllConflictsQuery(Query):
+    name = "enriched_diff_all_conflicts"
+    type = QueryType.READ
+
+    def __init__(
+        self, diff_branch_name: str, tracking_id: TrackingId | None = None, diff_id: str | None = None, **kwargs: Any
+    ) -> None:
+        super().__init__(**kwargs)
+        if (diff_id is None and tracking_id is None) or (diff_id and tracking_id):
+            raise ValueError("EnrichedDiffAllConflictsQuery requires one and only one of `tracking_id` or `diff_id`")
+        self.diff_branch_name = diff_branch_name
+        self.tracking_id = tracking_id
+        self.diff_id = diff_id
+        if self.tracking_id is None and self.diff_id is None:
+            raise RuntimeError("tracking_id or diff_id is required")
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+        self.params = {
+            "diff_branch_name": self.diff_branch_name,
+            "diff_id": self.diff_id,
+            "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
+        }
+        query = """
+MATCH (root:DiffRoot)
+WHERE ($diff_id IS NOT NULL AND root.uuid = $diff_id)
+OR ($tracking_id IS NOT NULL AND root.tracking_id = $tracking_id AND root.diff_branch = $diff_branch_name)
+CALL {
+    WITH root
+    MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_CONFLICT]->(node_conflict:DiffConflict)
+    RETURN node.path_identifier AS path_identifier, node_conflict AS conflict
+    UNION
+    WITH root
+    MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_ATTRIBUTE]->(:DiffAttribute)
+        -[:DIFF_HAS_PROPERTY]->(property:DiffProperty)-[:DIFF_HAS_CONFLICT]->(attr_property_conflict:DiffConflict)
+    RETURN property.path_identifier AS path_identifier, attr_property_conflict AS conflict
+    UNION
+    WITH root
+    MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(:DiffRelationship)
+        -[:DIFF_HAS_ELEMENT]->(element:DiffRelationshipElement)-[:DIFF_HAS_CONFLICT]->(rel_element_conflict:DiffConflict)
+    RETURN element.path_identifier AS path_identifier, rel_element_conflict AS conflict
+    UNION
+    WITH root
+    MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(:DiffRelationship)
+        -[:DIFF_HAS_ELEMENT]->(:DiffRelationshipElement)-[:DIFF_HAS_PROPERTY]->(property:DiffProperty)
+        -[:DIFF_HAS_CONFLICT]->(rel_property_conflict:DiffConflict)
+    RETURN property.path_identifier AS path_identifier, rel_property_conflict AS conflict
+}
+"""
+        self.return_labels = ["path_identifier", "conflict"]
+        self.add_to_query(query=query)
+
+    def get_conflict_paths_and_nodes(self) -> Generator[tuple[str, Neo4jNode], None, None]:
+        for result in self.get_results():
+            yield (result.get_as_type("path_identifier", str), result.get_node("conflict"))

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/core/diff/query_parser.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional
 from uuid import uuid4
@@ -22,7 +23,6 @@ from .model.path import (
     DiffRelationship,
     DiffRoot,
     DiffSingleRelationship,
-    NodeFieldSpecifier,
 )
 
 if TYPE_CHECKING:
@@ -459,7 +459,7 @@ class DiffQueryParser:
         schema_manager: SchemaManager,
         from_time: Timestamp,
         to_time: Optional[Timestamp] = None,
-        previous_node_field_specifiers: set[NodeFieldSpecifier] | None = None,
+        previous_node_field_specifiers: dict[str, set[str]] | None = None,
     ) -> None:
         self.base_branch_name = base_branch.name
         self.diff_branch_name = diff_branch.name
@@ -473,7 +473,9 @@ class DiffQueryParser:
             self.diff_branched_from_time = Timestamp(diff_branch.get_branched_from())
         self._diff_root_by_branch: dict[str, DiffRootIntermediate] = {}
         self._final_diff_root_by_branch: dict[str, DiffRoot] = {}
-        self._previous_node_field_specifiers = previous_node_field_specifiers or set()
+        self._previous_node_field_specifiers = previous_node_field_specifiers or {}
+        self._new_node_field_specifiers: dict[str, set[str]] | None = None
+        self._current_node_field_specifiers: dict[str, set[str]] | None = None
 
     def get_branches(self) -> set[str]:
         return set(self._final_diff_root_by_branch.keys())
@@ -485,38 +487,59 @@ class DiffQueryParser:
             return self._final_diff_root_by_branch[branch]
         return DiffRoot(from_time=self.from_time, to_time=self.to_time, uuid=str(uuid4()), branch=branch, nodes=[])
 
-    def get_diff_node_field_specifiers(self) -> set[NodeFieldSpecifier]:
+    def get_diff_node_field_specifiers(self) -> dict[str, set[str]]:
         if self.diff_branch_name not in self._diff_root_by_branch:
-            return set()
-        node_field_specifiers: set[NodeFieldSpecifier] = set()
+            return {}
+        node_field_specifiers_map: dict[str, set[str]] = defaultdict(set)
         diff_root = self._diff_root_by_branch[self.diff_branch_name]
         for node in diff_root.nodes_by_id.values():
-            node_field_specifiers.update(
-                NodeFieldSpecifier(node_uuid=node.uuid, field_name=attribute_name)
-                for attribute_name in node.attributes_by_name
-            )
-            node_field_specifiers.update(
-                NodeFieldSpecifier(node_uuid=node.uuid, field_name=relationship_diff.identifier)
-                for relationship_diff in node.relationships_by_name.values()
-            )
-        return node_field_specifiers
-
-    def get_new_node_field_specifiers(self) -> set[NodeFieldSpecifier]:
+            for attribute_name in node.attributes_by_name:
+                node_field_specifiers_map[node.uuid].add(attribute_name)
+            for relationship_diff in node.relationships_by_name.values():
+                node_field_specifiers_map[node.uuid].add(relationship_diff.identifier)
+        return node_field_specifiers_map
+
+    def _remove_node_specifiers(
+        self, node_specifiers: dict[str, set[str]], node_specifiers_to_remove: dict[str, set[str]]
+    ) -> dict[str, set[str]]:
+        final_node_specifiers: dict[str, set[str]] = defaultdict(set)
+        for node_uuid, field_names_set in node_specifiers.items():
+            specifiers_to_remove = node_specifiers_to_remove.get(node_uuid, set())
+            final_specifiers = field_names_set - specifiers_to_remove
+            if final_specifiers:
+                final_node_specifiers[node_uuid] = final_specifiers
+        return final_node_specifiers
+
+    def get_new_node_field_specifiers(self) -> dict[str, set[str]]:
+        if self._new_node_field_specifiers is not None:
+            return self._new_node_field_specifiers
         branch_node_specifiers = self.get_diff_node_field_specifiers()
-        new_node_field_specifiers = branch_node_specifiers - self._previous_node_field_specifiers
+        new_node_field_specifiers = self._remove_node_specifiers(
+            branch_node_specifiers, self._previous_node_field_specifiers
+        )
+        self._new_node_field_specifiers = new_node_field_specifiers
         return new_node_field_specifiers
 
-    def get_current_node_field_specifiers(self) -> set[NodeFieldSpecifier]:
+    def get_current_node_field_specifiers(self) -> dict[str, set[str]]:
+        if self._current_node_field_specifiers is not None:
+            return self._current_node_field_specifiers
         new_node_field_specifiers = self.get_new_node_field_specifiers()
-        current_node_field_specifiers = self._previous_node_field_specifiers - new_node_field_specifiers
+        current_node_field_specifiers = self._remove_node_specifiers(
+            self._previous_node_field_specifiers, new_node_field_specifiers
+        )
+        self._current_node_field_specifiers = current_node_field_specifiers
         return current_node_field_specifiers
 
     def read_result(self, query_result: QueryResult) -> None:
         path = query_result.get_path(label="diff_path")
         database_path = DatabasePath.from_cypher_path(cypher_path=path)
         self._parse_path(database_path=database_path)
+        self._current_node_field_specifiers = None
+        self._new_node_field_specifiers = None
 
     def parse(self, include_unchanged: bool = False) -> None:
+        self._new_node_field_specifiers = None
+        self._current_node_field_specifiers = None
         if len(self._diff_root_by_branch) > 1:
             self._apply_base_branch_previous_values()
             self._remove_empty_base_diff_root()
@@ -586,11 +609,12 @@ class DiffQueryParser:
         self, database_path: DatabasePath, diff_node: DiffNodeIntermediate
     ) -> DiffAttributeIntermediate:
         attribute_name = database_path.attribute_name
-        node_field_specifier = NodeFieldSpecifier(node_uuid=diff_node.uuid, field_name=attribute_name)
         branch_name = database_path.deepest_branch
         from_time = self.from_time
-        if branch_name == self.base_branch_name and node_field_specifier in self.get_new_node_field_specifiers():
-            from_time = self.diff_branched_from_time
+        if branch_name == self.base_branch_name:
+            new_node_field_specifiers = self.get_new_node_field_specifiers()
+            if attribute_name in new_node_field_specifiers.get(diff_node.uuid, set()):
+                from_time = self.diff_branched_from_time
         if attribute_name not in diff_node.attributes_by_name:
             diff_node.attributes_by_name[attribute_name] = DiffAttributeIntermediate(
                 uuid=database_path.attribute_id,
@@ -627,13 +651,12 @@ class DiffQueryParser:
     ) -> DiffRelationshipIntermediate:
         diff_relationship = diff_node.relationships_by_name.get(relationship_schema.name)
         if not diff_relationship:
-            node_field_specifier = NodeFieldSpecifier(
-                node_uuid=diff_node.uuid, field_name=relationship_schema.get_identifier()
-            )
             branch_name = database_path.deepest_branch
             from_time = self.from_time
-            if branch_name == self.base_branch_name and node_field_specifier in self.get_new_node_field_specifiers():
-                from_time = self.diff_branched_from_time
+            if branch_name == self.base_branch_name:
+                new_node_field_specifiers = self.get_new_node_field_specifiers()
+                if relationship_schema.get_identifier() in new_node_field_specifiers.get(diff_node.uuid, set()):
+                    from_time = self.diff_branched_from_time
             diff_relationship = DiffRelationshipIntermediate(
                 name=relationship_schema.name,
                 cardinality=relationship_schema.cardinality,

{infrahub_server-1.1.4 → infrahub_server-1.1.5}/backend/infrahub/core/diff/repository/repository.py

@@ -1,4 +1,5 @@
-from typing import Generator
+from collections import defaultdict
+from typing import AsyncGenerator, Generator
 
 from infrahub import config
 from infrahub.core import registry
@@ -18,10 +19,10 @@ from ..model.path import (
     EnrichedDiffsMetadata,
     EnrichedNodeCreateRequest,
     NodeDiffFieldSummary,
-    NodeFieldSpecifier,
     TimeRange,
     TrackingId,
 )
+from ..query.all_conflicts import EnrichedDiffAllConflictsQuery
 from ..query.delete_query import EnrichedDiffDeleteQuery
 from ..query.diff_get import EnrichedDiffGetQuery
 from ..query.diff_summary import DiffSummaryCounters, DiffSummaryQuery
@@ -318,6 +319,19 @@ class DiffRepository:
             raise ResourceNotFoundError(f"No conflict with id {conflict_id}")
         return self.deserializer.deserialize_conflict(diff_conflict_node=conflict_node)
 
+    async def get_all_conflicts_for_diff(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+    ) -> AsyncGenerator[tuple[str, EnrichedDiffConflict], None]:
+        query = await EnrichedDiffAllConflictsQuery.init(
+            db=self.db, diff_branch_name=diff_branch_name, tracking_id=tracking_id, diff_id=diff_id
+        )
+        await query.execute(db=self.db)
+        for conflict_path, conflict_node in query.get_conflict_paths_and_nodes():
+            yield (conflict_path, self.deserializer.deserialize_conflict(diff_conflict_node=conflict_node))
+
     async def get_node_field_summaries(
         self, diff_branch_name: str, tracking_id: TrackingId | None = None, diff_id: str | None = None
     ) -> list[NodeDiffFieldSummary]:
@@ -338,23 +352,18 @@ class DiffRepository:
         await query.execute(db=self.db)
         return query.get_num_changes_by_branch()
 
-    async def get_node_field_specifiers(self, diff_id: str) -> set[NodeFieldSpecifier]:
+    async def get_node_field_specifiers(self, diff_id: str) -> dict[str, set[str]]:
         limit = config.SETTINGS.database.query_size_limit
         offset = 0
-        specifiers: set[NodeFieldSpecifier] = set()
+        specifiers: dict[str, set[str]] = defaultdict(set)
         while True:
             query = await EnrichedDiffFieldSpecifiersQuery.init(db=self.db, diff_id=diff_id, offset=offset, limit=limit)
             await query.execute(db=self.db)
-
-            new_specifiers = {
-                NodeFieldSpecifier(
-                    node_uuid=field_specifier_tuple[0],
-                    field_name=field_specifier_tuple[1],
-                )
-                for field_specifier_tuple in query.get_node_field_specifier_tuples()
-            }
-            if not new_specifiers:
+            has_data = False
+            for field_specifier_tuple in query.get_node_field_specifier_tuples():
+                specifiers[field_specifier_tuple[0]].add(field_specifier_tuple[1])
+                has_data = True
+            if not has_data:
                 break
-            specifiers |= new_specifiers
             offset += limit
         return specifiers