infrahub-server 1.2.8__py3-none-any.whl → 1.2.9__py3-none-any.whl

infrahub/core/query/branch.py

@@ -51,23 +51,33 @@ class DeleteBranchRelationshipsQuery(Query):
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        if config.SETTINGS.database.db_type == config.DatabaseType.MEMGRAPH:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE r.branch = $branch_name
-            DELETE r
-            """
-        else:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE r.branch = $branch_name
-            DELETE r
-            WITH *
-            UNWIND nodes(p) AS n
-            MATCH (n)
-            WHERE NOT exists((n)--())
-            DELETE n
-            """
+        query = """
+        MATCH (s)-[r1]-(d)
+        WHERE r1.branch = $branch_name
+        DELETE r1
+
+        WITH collect(DISTINCT s) + collect(DISTINCT d) AS nodes
+
+        // Collect node IDs for filtering
+        WITH nodes, [n in nodes | n.uuid] as nodes_uuids
+
+        // Also delete agnostic relationships that would not have been deleted above
+        MATCH (s2: Node)-[r2]-(d2)
+        WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
+        AND s2.uuid IN nodes_uuids
+        DELETE r2
+
+        WITH nodes, collect(DISTINCT s2) + collect(DISTINCT d2) as additional_nodes
+
+        WITH nodes + additional_nodes as nodes
+
+        // Delete nodes that are no longer connected to any other nodes
+        UNWIND nodes AS n
+        WITH DISTINCT n
+        MATCH (n)
+        WHERE NOT exists((n)--())
+        DELETE n
+        """
         self.params["branch_name"] = self.branch_name
         self.add_to_query(query)
 

infrahub/core/query/diff.py

@@ -9,6 +9,7 @@ from infrahub.core.timestamp import Timestamp
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.diff.model.field_specifiers_map import NodeFieldSpecifierMap
     from infrahub.database import InfrahubDatabase
 
 
@@ -106,8 +107,8 @@ class DiffCalculationQuery(DiffQuery):
         self,
         base_branch: Branch,
         diff_branch_from_time: Timestamp,
-        current_node_field_specifiers: dict[str, set[str]] | None = None,
-        new_node_field_specifiers: dict[str, set[str]] | None = None,
+        current_node_field_specifiers: NodeFieldSpecifierMap | None = None,
+        new_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         **kwargs: Any,
     ):
         self.base_branch = base_branch
@@ -231,10 +232,10 @@ class DiffNodePathsQuery(DiffCalculationQuery):
         self.params.update(params_dict)
         self.params.update(
             {
-                "new_node_ids_list": list(self.new_node_field_specifiers.keys())
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
                 if self.new_node_field_specifiers
                 else None,
-                "current_node_ids_list": list(self.current_node_field_specifiers.keys())
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
                 if self.current_node_field_specifiers
                 else None,
             }
@@ -371,15 +372,16 @@ class DiffFieldPathsQuery(DiffCalculationQuery):
 
         self.params.update(
             {
-                "current_node_field_specifiers_map": {
-                    node_uuid: list(field_names)
-                    for node_uuid, field_names in self.current_node_field_specifiers.items()
-                }
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
+                if self.current_node_field_specifiers
+                else None,
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
+                if self.new_node_field_specifiers
+                else None,
+                "current_node_field_specifiers_map": self.current_node_field_specifiers.get_uuid_field_names_map()
                 if self.current_node_field_specifiers is not None
                 else None,
-                "new_node_field_specifiers_map": {
-                    node_uuid: list(field_names) for node_uuid, field_names in self.new_node_field_specifiers.items()
-                }
+                "new_node_field_specifiers_map": self.new_node_field_specifiers.get_uuid_field_names_map()
                 if self.new_node_field_specifiers is not None
                 else None,
             }
@@ -400,16 +402,16 @@ AND (r_root.to IS NULL OR diff_rel.branch <> r_root.branch OR r_root.to >= diff_
 // node ID and field name filtering first pass
 AND (
     (
-        $current_node_field_specifiers_map IS NOT NULL
-        AND $current_node_field_specifiers_map[p.uuid] IS NOT NULL
+        $current_node_ids_list IS NOT NULL
+        AND p.uuid IN $current_node_ids_list
         AND q.name IN $current_node_field_specifiers_map[p.uuid]
     ) OR (
-        $new_node_field_specifiers_map IS NOT NULL
-        AND $new_node_field_specifiers_map[p.uuid] IS NOT NULL
+        $new_node_ids_list IS NOT NULL
+        AND p.uuid IN $new_node_ids_list
         AND q.name IN $new_node_field_specifiers_map[p.uuid]
     ) OR (
-        $current_node_field_specifiers_map IS NULL
-        AND $new_node_field_specifiers_map IS NULL
+        $new_node_ids_list IS NULL
+        AND $current_node_ids_list IS NULL
     )
 )
 // node ID and field name filtering second pass
@@ -417,8 +419,12 @@ AND (
     // time-based filters for nodes already included in the diff or fresh changes
     (
         (
-            ($current_node_field_specifiers_map IS NOT NULL AND q.name IN $current_node_field_specifiers_map[p.uuid])
-            OR ($current_node_field_specifiers_map IS NULL AND $new_node_field_specifiers_map IS NULL)
+            (
+                $current_node_ids_list IS NOT NULL
+                AND p.uuid IN $current_node_ids_list
+                AND q.name IN $current_node_field_specifiers_map[p.uuid]
+            )
+            OR ($current_node_ids_list IS NULL AND $new_node_ids_list IS NULL)
         )
         AND (r_root.from < $from_time OR p.branch_support = $branch_agnostic)
         AND (
@@ -428,7 +434,11 @@ AND (
     )
     // time-based filters for new nodes
     OR (
-        ($new_node_field_specifiers_map IS NOT NULL AND q.name IN $new_node_field_specifiers_map[p.uuid])
+        (
+            $new_node_ids_list IS NOT NULL
+            AND p.uuid IN $new_node_ids_list
+            AND q.name IN $new_node_field_specifiers_map[p.uuid]
+        )
         AND (r_root.from < $branch_from_time OR p.branch_support = $branch_agnostic)
         AND (
             ($branch_from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
@@ -454,7 +464,11 @@ WITH one_result[0] AS root, one_result[1] AS r_root, one_result[2] AS p, one_res
 // Add correct from_time for row
 // -------------------------------------
 WITH root, r_root, p, diff_rel, q, has_more_data, CASE
-    WHEN $new_node_field_specifiers_map IS NOT NULL AND q.name IN $new_node_field_specifiers_map[p.uuid] THEN $branch_from_time
+    WHEN
+        $new_node_ids_list IS NOT NULL
+        AND p.uuid IN $new_node_ids_list
+        AND q.name IN $new_node_field_specifiers_map[p.uuid]
+    THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
 // -------------------------------------
@@ -554,15 +568,16 @@ class DiffPropertyPathsQuery(DiffCalculationQuery):
 
         self.params.update(
             {
-                "current_node_field_specifiers_map": {
-                    node_uuid: list(field_names)
-                    for node_uuid, field_names in self.current_node_field_specifiers.items()
-                }
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
+                if self.current_node_field_specifiers
+                else None,
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
+                if self.new_node_field_specifiers
+                else None,
+                "current_node_field_specifiers_map": self.current_node_field_specifiers.get_uuid_field_names_map()
                 if self.current_node_field_specifiers is not None
                 else None,
-                "new_node_field_specifiers_map": {
-                    node_uuid: list(field_names) for node_uuid, field_names in self.new_node_field_specifiers.items()
-                }
+                "new_node_field_specifiers_map": self.new_node_field_specifiers.get_uuid_field_names_map()
                 if self.new_node_field_specifiers is not None
                 else None,
             }
@@ -580,16 +595,16 @@ AND type(r_node) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
 // node ID and field name filtering first pass
 AND (
     (
-        $current_node_field_specifiers_map IS NOT NULL
-        AND $current_node_field_specifiers_map[n.uuid] IS NOT NULL
+        $current_node_ids_list IS NOT NULL
+        AND n.uuid IN $current_node_ids_list
         AND p.name IN $current_node_field_specifiers_map[n.uuid]
     ) OR (
-        $new_node_field_specifiers_map IS NOT NULL
-        AND $new_node_field_specifiers_map[n.uuid] IS NOT NULL
+        $new_node_ids_list IS NOT NULL
+        AND n.uuid IN $new_node_ids_list
         AND p.name IN $new_node_field_specifiers_map[n.uuid]
     ) OR (
-        $current_node_field_specifiers_map IS NULL
-        AND $new_node_field_specifiers_map IS NULL
+        $new_node_ids_list IS NULL
+        AND $current_node_ids_list IS NULL
     )
 )
 // node ID and field name filtering second pass
@@ -597,8 +612,12 @@ AND (
     // time-based filters for nodes already included in the diff or fresh changes
     (
         (
-            ($current_node_field_specifiers_map IS NOT NULL AND p.name IN $current_node_field_specifiers_map[n.uuid])
-            OR ($current_node_field_specifiers_map IS NULL AND $new_node_field_specifiers_map IS NULL)
+            (
+                $current_node_ids_list IS NOT NULL
+                AND n.uuid IN $current_node_ids_list
+                AND p.name IN $current_node_field_specifiers_map[n.uuid]
+            )
+            OR ($current_node_ids_list IS NULL AND $new_node_ids_list IS NULL)
         )
         AND (
             ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
@@ -612,7 +631,11 @@ AND (
     )
     // time-based filters for new nodes
     OR (
-        ($new_node_field_specifiers_map IS NOT NULL AND p.name IN $new_node_field_specifiers_map[n.uuid])
+        (
+            $new_node_ids_list IS NOT NULL
+            AND n.uuid IN $new_node_ids_list
+            AND p.name IN $new_node_field_specifiers_map[n.uuid]
+        )
         AND (
             ($branch_from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
             OR ($branch_from_time <= diff_rel.to < $to_time)
@@ -667,7 +690,11 @@ WITH one_result[0] AS diff_rel_path, one_result[1] AS r_root, one_result[2] AS n
 // Add correct from_time for row
 // -------------------------------------
 WITH diff_rel_path, r_root, n, r_node, p, diff_rel, has_more_data, CASE
-    WHEN $new_node_field_specifiers_map IS NOT NULL AND p.name IN $new_node_field_specifiers_map[n.uuid] THEN $branch_from_time
+    WHEN
+        $new_node_ids_list IS NOT NULL
+        AND n.uuid IN $new_node_ids_list
+        AND p.name IN $new_node_field_specifiers_map[n.uuid]
+    THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
 WITH diff_rel_path, r_root, n, r_node, p, diff_rel, has_more_data, row_from_time

infrahub/core/query/node.py

@@ -92,6 +92,7 @@ class NodeAttributesFromDB:
 class PeerInfo:
     uuid: str
     kind: str
+    labels: frozenset[str]
 
 
 class NodeQuery(Query):
@@ -1405,7 +1406,7 @@ class NodeGetHierarchyQuery(Query):
 
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002,PLR0915
         hierarchy_schema = self.node_schema.get_hierarchy_schema(db=db, branch=self.branch)
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
@@ -1438,6 +1439,10 @@ class NodeGetHierarchyQuery(Query):
             UNWIND peers_with_duplicates AS pwd
             RETURN DISTINCT pwd AS peer
         }
+        """ % {"filter": filter_str, "branch_filter": branch_filter}
+
+        if not self.branch.is_default:
+            query += """
         CALL {
             WITH n, peer
             MATCH path = (n)%(filter)s(peer)
@@ -1448,10 +1453,14 @@ class NodeGetHierarchyQuery(Query):
             LIMIT 1
         }
         WITH peer1 as peer, is_active
-        """ % {"filter": filter_str, "branch_filter": branch_filter, "with_clause": with_clause}
+            """ % {"filter": filter_str, "branch_filter": branch_filter, "with_clause": with_clause}
+        else:
+            query += """
+        WITH peer
+            """
 
         self.add_to_query(query)
-        where_clause = ["is_active = TRUE"]
+        where_clause = ["is_active = TRUE"] if not self.branch.is_default else []
 
         clean_filters = extract_field_filters(field_name=self.direction.value, filters=self.filters)
 
@@ -1461,7 +1470,8 @@ class NodeGetHierarchyQuery(Query):
             if clean_filters.get("id", None):
                 self.params["peer_ids"].append(clean_filters.get("id"))
 
-        self.add_to_query("WHERE " + " AND ".join(where_clause))
+        if where_clause:
+            self.add_to_query("WHERE " + " AND ".join(where_clause))
 
         self.return_labels = ["peer"]
 
@@ -1544,4 +1554,5 @@ class NodeGetHierarchyQuery(Query):
             yield PeerInfo(
                 uuid=peer_node.get("uuid"),
                 kind=peer_node.get("kind"),
+                labels=peer_node.labels,
             )

infrahub/core/query/relationship.py

@@ -73,12 +73,21 @@ class RelationshipPeerData:
     source_id: UUID
     """UUID of the Source Node."""
 
+    source_kind: str
+    """Kind of the Source Node."""
+
+    source_labels: frozenset[str]
+    """Labels of the Source Node."""
+
     peer_id: UUID
     """UUID of the Peer Node."""
 
     peer_kind: str
     """Kind of the Peer Node."""
 
+    peer_labels: frozenset[str]
+    """Labels of the Peer Node."""
+
     properties: dict[str, FlagPropertyData | NodePropertyData]
     """UUID of the Relationship Node."""
 
@@ -752,10 +761,15 @@ class RelationshipGetPeerQuery(Query):
     def get_peers(self) -> Generator[RelationshipPeerData, None, None]:
         for result in self.get_results_group_by(("peer", "uuid"), ("source_node", "uuid")):
             rels = result.get("rels")
+            source_node = result.get_node("source_node")
+            peer_node = result.get_node("peer")
             data = RelationshipPeerData(
-                source_id=result.get_node("source_node").get("uuid"),
-                peer_id=result.get_node("peer").get("uuid"),
-                peer_kind=result.get_node("peer").get("kind"),
+                source_id=source_node.get("uuid"),
+                source_kind=source_node.get("kind"),
+                source_labels=source_node.labels,
+                peer_id=peer_node.get("uuid"),
+                peer_kind=peer_node.get("kind"),
+                peer_labels=peer_node.labels,
                 rel_node_db_id=result.get("rl").element_id,
                 rel_node_id=result.get("rl").get("uuid"),
                 updated_at=rels[0]["from"],

infrahub/core/query/subquery.py

@@ -57,7 +57,7 @@ async def build_subquery_filter(
     params.update(field_params)
 
     field_where.append("all(r IN relationships(path) WHERE (%s))" % branch_filter)
-    filter_str = f"({node_alias})" + "".join([str(item) for item in field_filter])
+    filter_str = f"({node_alias}:Node {{uuid: {node_alias}.uuid}})" + "".join([str(item) for item in field_filter])
     where_str = " AND ".join(field_where)
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
@@ -138,7 +138,7 @@ async def build_subquery_order(
     field_filter[-1].name = "last"
 
     field_where.append("all(r IN relationships(path) WHERE (%s))" % branch_filter)
-    filter_str = f"({node_alias})" + "".join([str(item) for item in field_filter])
+    filter_str = f"({node_alias}:Node {{uuid: {node_alias}.uuid}})" + "".join([str(item) for item in field_filter])
     where_str = " AND ".join(field_where)
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")

infrahub/core/schema/schema_branch.py

@@ -2050,6 +2050,9 @@ class SchemaBranch:
 
         identified.add(node_schema)
 
+        if node_schema.is_node_schema:
+            identified.update([self.get(name=kind, duplicate=False) for kind in node_schema.inherit_from])
+
         for relationship in node_schema.relationships:
             if (
                 relationship.peer in [InfrahubKind.GENERICGROUP, InfrahubKind.PROFILE]

infrahub/core/validators/uniqueness/query.py

@@ -30,7 +30,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
     def get_context(self) -> dict[str, str]:
         return {"kind": self.query_request.kind}
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002,PLR0915
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string(), is_isolated=False)
         self.params.update(branch_params)
         from_times = db.render_list_comprehension(items="relationships(potential_path)", item_name="from")
@@ -105,16 +105,28 @@ class NodeUniqueAttributeConstraintQuery(Query):
         attr_paths_subquery = """
         MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:AttributeValue)
         WHERE attr.name in $attribute_names
-            AND ([attr.name, type(r)] in $attr_paths
-            OR (attr_value.value in $attr_values AND [attr.name, type(r), attr_value.value] in $attr_paths_with_value))
+            AND [attr.name, type(r)] in $attr_paths
         RETURN start_node, attr_path as potential_path, NULL as rel_identifier, attr.name as potential_attr, attr_value.value as potential_attr_value
         """ % {"node_kind": self.query_request.kind}
 
-        relationship_attr_paths_with_value_subquery = """
+        attr_paths_with_value_subquery = """
+        MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:AttributeValue)
+        WHERE attr.name in $attribute_names AND attr_value.value in $attr_values
+            AND [attr.name, type(r), attr_value.value] in $attr_paths_with_value
+        RETURN start_node, attr_path as potential_path, NULL as rel_identifier, attr.name as potential_attr, attr_value.value as potential_attr_value
+        """ % {"node_kind": self.query_request.kind}
+
+        relationship_attr_paths_subquery = """
         MATCH rel_path = (start_node:%(node_kind)s)-[:IS_RELATED]-(relationship_node:Relationship)-[:IS_RELATED]-(related_n:Node)-[:HAS_ATTRIBUTE]->(rel_attr:Attribute)-[:HAS_VALUE]->(rel_attr_value:AttributeValue)
         WHERE relationship_node.name in $relationship_names
-            AND ([relationship_node.name, rel_attr.name] in $relationship_attr_paths
-            OR (rel_attr_value.value in $relationship_attr_values AND [relationship_node.name, rel_attr.name, rel_attr_value.value] in $relationship_attr_paths_with_value))
+            AND [relationship_node.name, rel_attr.name] in $relationship_attr_paths
+        RETURN start_node, rel_path as potential_path, relationship_node.name as rel_identifier, rel_attr.name as potential_attr, rel_attr_value.value as potential_attr_value
+        """ % {"node_kind": self.query_request.kind}
+
+        relationship_attr_paths_with_value_subquery = """
+        MATCH rel_path = (start_node:%(node_kind)s)-[:IS_RELATED]-(relationship_node:Relationship)-[:IS_RELATED]-(related_n:Node)-[:HAS_ATTRIBUTE]->(rel_attr:Attribute)-[:HAS_VALUE]->(rel_attr_value:AttributeValue)
+        WHERE relationship_node.name in $relationship_names AND rel_attr_value.value in $relationship_attr_values
+            AND [relationship_node.name, rel_attr.name, rel_attr_value.value] in $relationship_attr_paths_with_value
         RETURN start_node, rel_path as potential_path, relationship_node.name as rel_identifier, rel_attr.name as potential_attr, rel_attr_value.value as potential_attr_value
         """ % {"node_kind": self.query_request.kind}
 
@@ -130,9 +142,13 @@ class NodeUniqueAttributeConstraintQuery(Query):
         }
 
         select_subqueries = []
-        if attr_paths or attr_paths_with_value:
+        if attr_paths:
             select_subqueries.append(attr_paths_subquery)
-        if relationship_attr_paths_with_value or relationship_attr_paths:
+        if attr_paths_with_value:
+            select_subqueries.append(attr_paths_with_value_subquery)
+        if relationship_attr_paths:
+            select_subqueries.append(relationship_attr_paths_subquery)
+        if relationship_attr_paths_with_value:
             select_subqueries.append(relationship_attr_paths_with_value_subquery)
         if relationship_only_attr_paths:
             select_subqueries.append(relationship_only_attr_paths_subquery)

infrahub/database/__init__.py

@@ -33,9 +33,7 @@ from infrahub.exceptions import DatabaseError
 from infrahub.log import get_logger
 from infrahub.utils import InfrahubStringEnum
 
-from .memgraph import DatabaseManagerMemgraph
 from .metrics import CONNECTION_POOL_USAGE, QUERY_EXECUTION_METRICS, TRANSACTION_RETRIES
-from .neo4j import DatabaseManagerNeo4j
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -158,11 +156,6 @@ class InfrahubDatabase:
         else:
             self.db_type = config.SETTINGS.database.db_type
 
-        if self.db_type == DatabaseType.NEO4J:
-            self.manager = DatabaseManagerNeo4j(db=self)
-        elif self.db_type == DatabaseType.MEMGRAPH:
-            self.manager = DatabaseManagerMemgraph(db=self)
-
     def __del__(self) -> None:
         if not self._session or not self._is_session_local or self._session.closed():
             return

infrahub/database/memgraph.py

@@ -1,14 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from infrahub.constants.database import EntityType, IndexType
 
 from .index import IndexInfo, IndexItem, IndexManagerBase
-from .manager import DatabaseManager
-
-if TYPE_CHECKING:
-    from . import InfrahubDatabase
 
 
 class IndexNodeMemgraph(IndexItem):
@@ -52,9 +46,3 @@ class IndexManagerMemgraph(IndexManagerBase):
             )
 
         return results
-
-
-class DatabaseManagerMemgraph(DatabaseManager):
-    def __init__(self, db: InfrahubDatabase) -> None:
-        super().__init__(db=db)
-        self.index = IndexManagerMemgraph(db=db)

infrahub/database/neo4j.py

@@ -1,15 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from infrahub.constants.database import EntityType, IndexType
 from infrahub.core.query import QueryType
 
 from .index import IndexInfo, IndexItem, IndexManagerBase
-from .manager import DatabaseManager
-
-if TYPE_CHECKING:
-    from . import InfrahubDatabase
 
 
 class IndexRelNeo4j(IndexItem):
@@ -68,9 +62,3 @@ class IndexManagerNeo4j(IndexManagerBase):
             )
 
         return results
-
-
-class DatabaseManagerNeo4j(DatabaseManager):
-    def __init__(self, db: InfrahubDatabase) -> None:
-        super().__init__(db=db)
-        self.index = IndexManagerNeo4j(db=db)

infrahub/graphql/mutations/computed_attribute.py

@@ -71,7 +71,11 @@ class UpdateComputedAttribute(Mutation):
 
         if not (
             target_node := await NodeManager.get_one(
-                db=graphql_context.db, kind=node_schema.kind, id=str(data.id), branch=graphql_context.branch
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={target_attribute.name: None},
             )
         ):
             raise NodeNotFoundError(

infrahub/graphql/queries/diff/tree.py

@@ -10,6 +10,7 @@ from infrahub.core import registry
 from infrahub.core.constants import DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.diff.model.path import NameTrackingId
+from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
@@ -415,7 +416,7 @@ class DiffTreeResolver:
             diff_branch_names=[diff_branch.name],
             from_time=from_timestamp,
             to_time=to_timestamp,
-            filters=filters_dict,
+            filters=EnrichedDiffQueryFilters(**filters_dict),
             include_parents=include_parents,
             limit=limit,
             offset=offset,

infrahub/server.py

@@ -23,7 +23,6 @@ from infrahub import __version__, config
 from infrahub.api import router as api
 from infrahub.api.exception_handlers import generic_api_exception_handler
 from infrahub.components import ComponentType
-from infrahub.core.graph.index import attr_value_index, node_indexes, rel_indexes
 from infrahub.core.initialization import initialization
 from infrahub.database import InfrahubDatabase, InfrahubDatabaseMode, get_db
 from infrahub.dependencies.registry import build_component_registry
@@ -58,9 +57,6 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
 
     # Initialize database Driver and load local registry
     database = application.state.db = InfrahubDatabase(mode=InfrahubDatabaseMode.DRIVER, driver=await get_db())
-    if config.SETTINGS.experimental_features.value_db_index:
-        node_indexes.append(attr_value_index)
-    database.manager.index.init(nodes=node_indexes, rels=rel_indexes)
 
     build_component_registry()
 
@@ -85,7 +81,7 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
     initialize_lock(service=service)
     # We must initialize DB after initialize lock and initialize lock depends on cache initialization
     async with application.state.db.start_session() as db:
-        await initialization(db=db)
+        await initialization(db=db, add_database_indexes=True)
 
     application.state.service = service
     application.state.response_delay = config.SETTINGS.miscellaneous.response_delay

infrahub/trigger/models.py

@@ -5,8 +5,11 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from prefect.events.actions import RunDeployment
+from prefect.events.schemas.automations import (
+    Automation,  # noqa: TC002
+    Posture,
+)
 from prefect.events.schemas.automations import EventTrigger as PrefectEventTrigger
-from prefect.events.schemas.automations import Posture
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
@@ -19,6 +22,13 @@ if TYPE_CHECKING:
     from uuid import UUID
 
 
+class TriggerSetupReport(BaseModel):
+    created: list[TriggerDefinition] = Field(default_factory=list)
+    updated: list[TriggerDefinition] = Field(default_factory=list)
+    deleted: list[Automation] = Field(default_factory=list)
+    unchanged: list[TriggerDefinition] = Field(default_factory=list)
+
+
 class TriggerType(str, Enum):
     BUILTIN = "builtin"
     WEBHOOK = "webhook"