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

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/definitions/core/builtin.py

@@ -1,6 +1,4 @@
-from infrahub.core.constants import (
-    BranchSupportType,
-)
+from infrahub.core.constants import BranchSupportType
 
 from ...attribute_schema import AttributeSchema as Attr
 from ...node_schema import NodeSchema
@@ -8,7 +6,7 @@ from ...node_schema import NodeSchema
 builtin_tag = NodeSchema(
     name="Tag",
     namespace="Builtin",
-    description="Standard Tag object to attached to other objects to provide some context.",
+    description="Standard Tag object to attach to other objects to provide some context.",
     include_in_menu=True,
     icon="mdi:tag-multiple",
     label="Tag",

infrahub/core/schema/definitions/core/transform.py

@@ -92,5 +92,6 @@ core_transform_python = NodeSchema(
     attributes=[
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
+        Attr(name="convert_query_response", kind="Boolean", optional=True, default_value=False),
     ],
 )

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/aggregated_checker.py

@@ -97,9 +97,9 @@ class AggregatedConstraintChecker:
                 error_detail_str += f"={data_path.value!r}"
                 error_detail_str_list.append(error_detail_str)
             if data_path.peer_id:
-                error_detail_str += f"{data_path.field_name}.id={data_path.peer_id}"
+                error_detail_str = f"{data_path.field_name}.id={data_path.peer_id}"
                 error_detail_str_list.append(error_detail_str)
-            if error_detail_str:
+            if error_detail_str_list:
                 error_str += " The error relates to field "
                 error_str += ",".join(error_detail_str_list)
                 error_str += "."

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")
@@ -39,7 +39,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         )
 
         attribute_names = set()
-        attr_paths, attr_paths_with_value = [], []
+        attr_paths, attr_paths_with_value, attr_values = [], [], []
         for attr_path in self.query_request.unique_attribute_paths:
             try:
                 property_rel_name = self.attribute_property_map[attr_path.property_name or "value"]
@@ -50,6 +50,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             attribute_names.add(attr_path.attribute_name)
             if attr_path.value:
                 attr_paths_with_value.append((attr_path.attribute_name, property_rel_name, attr_path.value))
+                attr_values.append(attr_path.value)
             else:
                 attr_paths.append((attr_path.attribute_name, property_rel_name))
 
@@ -57,6 +58,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
         relationship_attr_paths = []
         relationship_only_attr_paths = []
         relationship_only_attr_values = []
+        relationship_attr_values = []
         relationship_attr_paths_with_value = []
         for rel_path in self.query_request.relationship_attribute_paths:
             relationship_names.add(rel_path.identifier)
@@ -64,6 +66,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 relationship_attr_paths_with_value.append(
                     (rel_path.identifier, rel_path.attribute_name, rel_path.value)
                 )
+                relationship_attr_values.append(rel_path.value)
             elif rel_path.attribute_name:
                 relationship_attr_paths.append((rel_path.identifier, rel_path.attribute_name))
             else:
@@ -87,12 +90,14 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 "node_kind": self.query_request.kind,
                 "attr_paths": attr_paths,
                 "attr_paths_with_value": attr_paths_with_value,
+                "attr_values": attr_values,
                 "attribute_names": list(attribute_names),
                 "relationship_names": list(relationship_names),
                 "relationship_attr_paths": relationship_attr_paths,
                 "relationship_attr_paths_with_value": relationship_attr_paths_with_value,
                 "relationship_only_attr_paths": relationship_only_attr_paths,
                 "relationship_only_attr_values": relationship_only_attr_values,
+                "relationship_attr_values": relationship_attr_values,
                 "min_count_required": self.min_count_required,
             }
         )
@@ -100,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.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 [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}
 
@@ -125,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

@@ -26,16 +26,14 @@ from opentelemetry import trace
 from typing_extensions import Self
 
 from infrahub import config, lock
+from infrahub.constants.database import DatabaseType, Neo4jRuntime
 from infrahub.core import registry
 from infrahub.core.query import QueryType
 from infrahub.exceptions import DatabaseError
 from infrahub.log import get_logger
 from infrahub.utils import InfrahubStringEnum
 
-from .constants import DatabaseType, Neo4jRuntime
-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
@@ -44,8 +42,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
-    from .manager import DatabaseManager
-
 validated_database = {}
 R = TypeVar("R")
 
@@ -134,7 +130,6 @@ class InfrahubDatabase:
         mode: InfrahubDatabaseMode = InfrahubDatabaseMode.DRIVER,
         db_type: DatabaseType | None = None,
         default_neo4j_runtime: Neo4jRuntime = Neo4jRuntime.DEFAULT,
-        db_manager: DatabaseManager | None = None,
         schemas: list[SchemaBranch] | None = None,
         session: AsyncSession | None = None,
         session_mode: InfrahubDatabaseSessionMode = InfrahubDatabaseSessionMode.WRITE,
@@ -161,14 +156,6 @@ class InfrahubDatabase:
         else:
             self.db_type = config.SETTINGS.database.db_type
 
-        if db_manager:
-            self.manager = db_manager
-            self.manager.db = self
-        elif 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
@@ -228,7 +215,6 @@ class InfrahubDatabase:
             db_type=self.db_type,
             default_neo4j_runtime=self.default_neo4j_runtime,
             schemas=schemas or self._schemas.values(),
-            db_manager=self.manager,
             driver=self._driver,
             session_mode=session_mode,
             queries_names_to_config=self.queries_names_to_config,
@@ -243,7 +229,6 @@ class InfrahubDatabase:
             db_type=self.db_type,
             default_neo4j_runtime=self.default_neo4j_runtime,
             schemas=schemas or self._schemas.values(),
-            db_manager=self.manager,
             driver=self._driver,
             session=self._session,
             session_mode=self._session_mode,

infrahub/database/index.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from .constants import EntityType, IndexType  # noqa: TC001
+from infrahub.constants.database import EntityType, IndexType  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase

infrahub/database/memgraph.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from infrahub.constants.database import EntityType, IndexType
 
-from .constants import EntityType, IndexType
 from .index import IndexInfo, IndexItem, IndexManagerBase
-from .manager import DatabaseManager
-
-if TYPE_CHECKING:
-    from . import InfrahubDatabase
 
 
 class IndexNodeMemgraph(IndexItem):
@@ -51,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 .constants import EntityType, IndexType
 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/git/integrator.py

@@ -10,6 +10,7 @@ import ujson
 import yaml
 from infrahub_sdk import InfrahubClient  # noqa: TC002
 from infrahub_sdk.exceptions import ValidationError
+from infrahub_sdk.node import InfrahubNode
 from infrahub_sdk.protocols import (
     CoreArtifact,
     CoreArtifactDefinition,
@@ -53,7 +54,6 @@ if TYPE_CHECKING:
     import types
 
     from infrahub_sdk.checks import InfrahubCheck
-    from infrahub_sdk.node import InfrahubNode
     from infrahub_sdk.schema.repository import InfrahubRepositoryArtifactDefinitionConfig
     from infrahub_sdk.transforms import InfrahubTransform
 
@@ -123,6 +123,10 @@ class TransformPythonInformation(BaseModel):
     timeout: int
     """Timeout for the function."""
 
+    convert_query_response: bool = Field(
+        ..., description="Indicate if the transform should convert the query response to InfrahubNode objects"
+    )
+
 
 class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     """
@@ -874,6 +878,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     file_path=file_path,
                     query=str(graphql_query.id),
                     timeout=transform_class.timeout,
+                    convert_query_response=transform.convert_query_response,
                 )
             )
 
@@ -1005,6 +1010,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             "file_path": transform.file_path,
             "class_name": transform.class_name,
             "timeout": transform.timeout,
+            "convert_query_response": transform.convert_query_response,
         }
         create_payload = self.sdk.schema.generate_payload_create(
             schema=schema,
@@ -1028,6 +1034,9 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         if existing_transform.timeout.value != local_transform.timeout:
             existing_transform.timeout.value = local_transform.timeout
 
+        if existing_transform.convert_query_response.value != local_transform.convert_query_response:
+            existing_transform.convert_query_response.value = local_transform.convert_query_response
+
         await existing_transform.save()
 
     @classmethod
@@ -1038,6 +1047,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             existing_transform.query.id != local_transform.query
             or existing_transform.file_path.value != local_transform.file_path
             or existing_transform.timeout.value != local_transform.timeout
+            or existing_transform.convert_query_response.value != local_transform.convert_query_response
         ):
             return False
         return True
@@ -1129,7 +1139,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
     @task(name="python-transform-execute", task_run_name="Execute Python Transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_transform(
-        self, branch_name: str, commit: str, location: str, client: InfrahubClient, data: dict | None = None
+        self,
+        branch_name: str,
+        commit: str,
+        location: str,
+        client: InfrahubClient,
+        convert_query_response: bool,
+        data: dict | None = None,
     ) -> Any:
         """Execute A Python Transform stored in the repository."""
         log = get_run_logger()
@@ -1159,7 +1175,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
             transform_class: type[InfrahubTransform] = getattr(module, class_name)
 
-            transform = transform_class(root_directory=commit_worktree.directory, branch=branch_name, client=client)
+            transform = transform_class(
+                root_directory=commit_worktree.directory,
+                branch=branch_name,
+                client=client,
+                convert_query_response=convert_query_response,
+                infrahub_node=InfrahubNode,
+            )
             return await transform.run(data=data)
 
         except ModuleNotFoundError as exc:
@@ -1216,6 +1238,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=transformation_location,
                 data=response,
                 client=self.sdk,
+                convert_query_response=transformation.convert_query_response.value,
             )  # type: ignore[misc]
 
         if definition.content_type.value == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):
@@ -1275,6 +1298,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=message.transform_location,
                 data=response,
                 client=self.sdk,
+                convert_query_response=message.convert_query_response,
             )  # type: ignore[misc]
 
         if message.content_type == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):

infrahub/git/models.py

@@ -29,6 +29,10 @@ class RequestArtifactGenerate(BaseModel):
     repository_name: str = Field(..., description="The name of the Repository")
     repository_kind: str = Field(..., description="The kind of the Repository")
     branch_name: str = Field(..., description="The branch where the check is run")
+    convert_query_response: bool = Field(
+        default=False,
+        description="Indicate if the query response should be converted to InfrahubNode objects for Python transforms",
+    )
     target_id: str = Field(..., description="The ID of the target object for this artifact")
     target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")

infrahub/git/tasks.py

@@ -339,10 +339,12 @@ async def generate_request_artifact_definition(
         )
     transform_location = ""
 
+    convert_query_response = False
     if transform.typename == InfrahubKind.TRANSFORMJINJA2:
         transform_location = transform.template_path.value
     elif transform.typename == InfrahubKind.TRANSFORMPYTHON:
         transform_location = f"{transform.file_path.value}::{transform.class_name.value}"
+        convert_query_response = transform.convert_query_response.value
 
     for relationship in group.members.peers:
         member = relationship.peer
@@ -368,6 +370,7 @@ async def generate_request_artifact_definition(
             target_name=member.display_label,
             target_kind=member.get_kind(),
             timeout=transform.timeout.value,
+            convert_query_response=convert_query_response,
             context=context,
         )
 

infrahub/git_credential/helper.py

@@ -3,9 +3,9 @@ import sys
 
 import typer
 from infrahub_sdk import Config, InfrahubClientSync
+from infrahub_sdk.protocols import CoreGenericRepository
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind
 
 logging.getLogger("httpx").setLevel(logging.ERROR)
 app = typer.Typer()
@@ -51,7 +51,7 @@ def get(
         raise typer.Exit(1) from exc
 
     client = InfrahubClientSync(config=Config(address=config.SETTINGS.main.internal_address, insert_tracker=True))
-    repo = client.get(kind=InfrahubKind.GENERICREPOSITORY, location__value=location)
+    repo = client.get(kind=CoreGenericRepository.__name__, location__value=location)
 
     if not repo:
         print("Repository not found in the database.")

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/message_bus/operations/requests/proposed_change.py

@@ -319,6 +319,9 @@ query GatherArtifactDefinitions {
               file_path {
                 value
               }
+              convert_query_response {
+                value
+              }
             }
             repository {
               node {
@@ -526,6 +529,9 @@ def _parse_artifact_definitions(definitions: list[dict]) -> list[ProposedChangeA
         elif artifact_definition.transform_kind == InfrahubKind.TRANSFORMPYTHON:
             artifact_definition.class_name = definition["node"]["transformation"]["node"]["class_name"]["value"]
             artifact_definition.file_path = definition["node"]["transformation"]["node"]["file_path"]["value"]
+            artifact_definition.convert_query_response = definition["node"]["transformation"]["node"][
+                "convert_query_response"
+            ]["value"]
 
         parsed.append(artifact_definition)
 

infrahub/message_bus/types.py

@@ -96,6 +96,9 @@ class ProposedChangeArtifactDefinition(BaseModel):
     class_name: str = Field(default="")
     content_type: str
     file_path: str = Field(default="")
+    convert_query_response: bool = Field(
+        default=False, description="Convert query response to InfrahubNode objects for Python based transforms"
+    )
     timeout: int
 
     @property

infrahub/patch/queries/consolidate_duplicated_nodes.py

@@ -0,0 +1,109 @@
+from ..models import EdgeToAdd, EdgeToDelete, PatchPlan, VertexToDelete
+from .base import PatchQuery
+
+
+class ConsolidateDuplicatedNodesPatchQuery(PatchQuery):
+    """
+    Find any groups of nodes with the same labels and properties, move all the edges to one of the duplicated nodes,
+    then delete the other duplicated nodes
+    """
+
+    @property
+    def name(self) -> str:
+        return "consolidate-duplicated-nodes"
+
+    async def plan(self) -> PatchPlan:
+        query = """
+//------------
+// Find nodes with the same labels and UUID
+//------------
+MATCH (n:Node)
+WITH n.uuid AS node_uuid, count(*) as num_nodes_with_uuid
+WHERE num_nodes_with_uuid > 1
+WITH DISTINCT node_uuid
+MATCH (n:Node {uuid: node_uuid})
+CALL {
+    WITH n
+    WITH labels(n) AS n_labels
+    UNWIND n_labels AS n_label
+    WITH n_label
+    ORDER BY n_label ASC
+    RETURN collect(n_label) AS sorted_labels
+}
+WITH n.uuid AS n_uuid, sorted_labels, collect(n) AS duplicate_nodes
+WHERE size(duplicate_nodes) > 1
+WITH n_uuid, head(duplicate_nodes) AS node_to_keep, tail(duplicate_nodes) AS nodes_to_delete
+UNWIND nodes_to_delete AS node_to_delete
+//------------
+// Find the edges that we need to move to the selected node_to_keep
+//------------
+CALL {
+    WITH node_to_keep, node_to_delete
+    MATCH (node_to_delete)-[edge_to_delete]->(peer)
+    RETURN {
+        from_id: %(id_func_name)s(node_to_keep),
+        to_id: %(id_func_name)s(peer),
+        edge_type: type(edge_to_delete),
+        after_props: properties(edge_to_delete)
+    } AS edge_to_create
+    UNION
+    WITH node_to_keep, node_to_delete
+    MATCH (node_to_delete)<-[edge_to_delete]-(peer)
+    RETURN {
+        from_id: %(id_func_name)s(peer),
+        to_id: %(id_func_name)s(node_to_keep),
+        edge_type: type(edge_to_delete),
+        after_props: properties(edge_to_delete)
+    } AS edge_to_create
+}
+WITH node_to_delete, collect(edge_to_create) AS edges_to_create
+//------------
+// Find the edges that we need to remove from the duplicated nodes
+//------------
+CALL {
+    WITH node_to_delete
+    MATCH (node_to_delete)-[e]->(peer)
+    RETURN {
+        db_id: %(id_func_name)s(e),
+        from_id: %(id_func_name)s(node_to_delete),
+        to_id: %(id_func_name)s(peer),
+        edge_type: type(e),
+        before_props: properties(e)
+    } AS edge_to_delete
+    UNION
+    WITH node_to_delete
+    MATCH (node_to_delete)<-[e]-(peer)
+    RETURN {
+        db_id: %(id_func_name)s(e),
+        from_id: %(id_func_name)s(peer),
+        to_id: %(id_func_name)s(node_to_delete),
+        edge_type: type(e),
+        before_props: properties(e)
+    } AS edge_to_delete
+}
+WITH node_to_delete, edges_to_create, collect(edge_to_delete) AS edges_to_delete
+RETURN
+    {db_id: %(id_func_name)s(node_to_delete), labels: labels(node_to_delete), before_props: properties(node_to_delete)} AS vertex_to_delete,
+    edges_to_create,
+    edges_to_delete
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(query=query)
+        vertices_to_delete: list[VertexToDelete] = []
+        edges_to_delete: list[EdgeToDelete] = []
+        edges_to_add: list[EdgeToAdd] = []
+        for result in results:
+            serial_vertex_to_delete = result.get("vertex_to_delete")
+            if serial_vertex_to_delete:
+                vertex_to_delete = VertexToDelete(**serial_vertex_to_delete)
+                vertices_to_delete.append(vertex_to_delete)
+            for serial_edge_to_delete in result.get("edges_to_delete"):
+                edge_to_delete = EdgeToDelete(**serial_edge_to_delete)
+                edges_to_delete.append(edge_to_delete)
+            for serial_edge_to_create in result.get("edges_to_create"):
+                edges_to_add.append(EdgeToAdd(**serial_edge_to_create))
+        return PatchPlan(
+            name=self.name,
+            vertices_to_delete=vertices_to_delete,
+            edges_to_add=edges_to_add,
+            edges_to_delete=edges_to_delete,
+        )