infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/core/migrations/graph/m024_missing_hierarchy_backfill.py

@@ -39,8 +39,7 @@ class BackfillMissingHierarchyQuery(Query):
         MATCH (rel:Relationship {name: "parent__child"})-[e:IS_RELATED]-(n:Node)
         WHERE e.hierarchy IS NULL
         WITH DISTINCT rel, n, default_branch
-        CALL {
-            WITH rel, n, default_branch
+        CALL (rel, n, default_branch) {
             MATCH (rel)-[e:IS_RELATED {branch: default_branch}]-(n)
             RETURN e
             ORDER BY e.from DESC

infrahub/core/migrations/graph/m028_delete_diffs.py

@@ -33,6 +33,5 @@ class Migration028(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()

infrahub/core/migrations/graph/m029_duplicates_cleanup.py

@@ -58,15 +58,14 @@ class CleanUpDuplicatedUuidVertices(Query):
             r_arrow = ">"
 
         query = """
-    CALL {
+    CALL (vertex_to_keep, edge_type, branch, peer, earliest_active_time, latest_deleted_time, all_edges_deleted, edge_to_copy) {
         // ------------
         // get or create the active %(edge_type)s edge
         // ------------
-        WITH vertex_to_keep, edge_type, branch, peer, earliest_active_time, latest_deleted_time, all_edges_deleted, edge_to_copy
-        WITH vertex_to_keep, edge_type, branch, peer, earliest_active_time, latest_deleted_time, all_edges_deleted, edge_to_copy
+        WITH edge_type
         WHERE edge_type = "%(edge_type)s"
         MERGE (vertex_to_keep)%(l_arrow)s-[active_edge:%(edge_type)s {branch: branch, status: "active"}]-%(r_arrow)s(peer)
-        WITH active_edge, edge_to_copy, earliest_active_time, latest_deleted_time, all_edges_deleted
+        WITH active_edge
         LIMIT 1
         SET active_edge.to_delete = NULL
         SET active_edge.from = earliest_active_time
@@ -96,15 +95,14 @@ class CleanUpDuplicatedUuidVertices(Query):
             l_arrow = ""
             r_arrow = ">"
         subquery = """
-    CALL {
+    CALL (vertex_to_keep, edge_type, branch, peer, latest_deleted_time, edge_to_copy) {
         // ------------
         // create the deleted %(edge_type)s edge
         // ------------
-        WITH vertex_to_keep, edge_type, branch, peer, latest_deleted_time, edge_to_copy
-        WITH vertex_to_keep, edge_type, branch, peer, latest_deleted_time, edge_to_copy
+        WITH edge_type
         WHERE edge_type = "%(edge_type)s"
         MERGE (vertex_to_keep)%(l_arrow)s-[deleted_edge:%(edge_type)s {branch: branch, status: "deleted"}]-%(r_arrow)s(peer)
-        WITH deleted_edge, latest_deleted_time, edge_to_copy
+        WITH deleted_edge
         LIMIT 1
         SET deleted_edge.to_delete = NULL
         SET deleted_edge.from = latest_deleted_time
@@ -144,10 +142,8 @@ class CleanUpDuplicatedUuidVertices(Query):
 //------------
 // Get every %(direction)s branch, edge_type, peer element_id combinations touching vertices with this uuid/labels combination
 //------------
-CALL {
-    WITH n_uuid, vertex_element_ids, element_id_to_keep
-    CALL {
-        WITH n_uuid, vertex_element_ids
+CALL (n_uuid, vertex_element_ids, element_id_to_keep) {
+    CALL (n_uuid, vertex_element_ids) {
         MATCH (n:%(vertex_label)s {uuid: n_uuid})
         WHERE %(id_func_name)s(n) IN vertex_element_ids
         MATCH (n)%(l_arrow)s-[e]-%(r_arrow)s(peer)
@@ -157,8 +153,7 @@ CALL {
     //------------
     // Are all of the edges with these with this branch/edge_type/peer_element_id combination deleted?
     //------------
-    CALL {
-        WITH n_uuid, vertex_element_ids, branch, edge_type, peer_element_id
+    CALL (n_uuid, vertex_element_ids, branch, edge_type, peer_element_id) {
         // nodes with this edge_type/branch/peer combo
         MATCH (node_with_edge:%(vertex_label)s {uuid: n_uuid})%(l_arrow)s-[e {branch: branch}]-%(r_arrow)s(peer)
         WHERE %(id_func_name)s(node_with_edge) IN vertex_element_ids
@@ -181,8 +176,7 @@ CALL {
     //------------
     // What is the earliest active time for this branch/edge_type/peer_element_id/UUID/labels combination?
     //------------
-    CALL {
-        WITH n_uuid, vertex_element_ids, branch, edge_type, peer_element_id
+    CALL (n_uuid, vertex_element_ids, branch, edge_type, peer_element_id) {
         MATCH (n {uuid: n_uuid})%(l_arrow)s-[e {branch: branch, status: "active"}]-%(r_arrow)s(peer)
         WHERE %(id_func_name)s(n) IN vertex_element_ids
         AND type(e) = edge_type
@@ -194,8 +188,7 @@ CALL {
     //------------
     // What is the latest deleted time for this branch/edge_type/peer_element_id/UUID/labels combination?
     //------------
-    CALL {
-        WITH n_uuid, vertex_element_ids, branch, edge_type, peer_element_id, all_edges_deleted
+    CALL (n_uuid, vertex_element_ids, branch, edge_type, peer_element_id, all_edges_deleted) {
         OPTIONAL MATCH (n {uuid: n_uuid})%(l_arrow)s-[e {branch: branch}]-%(r_arrow)s(peer)
         WHERE all_edges_deleted = TRUE
         AND %(id_func_name)s(n) IN vertex_element_ids
@@ -211,9 +204,10 @@ CALL {
     // ------------
     // Add the %(direction)s edges to the node we are keeping, if necessary
     // ------------
-    CALL {
-        WITH n_uuid, vertex_element_ids, element_id_to_keep, branch, edge_type, peer_element_id, all_edges_deleted,
-            earliest_active_time, latest_deleted_time
+    CALL (
+        n_uuid, vertex_element_ids, element_id_to_keep, branch, edge_type, peer_element_id, all_edges_deleted,
+        earliest_active_time, latest_deleted_time
+    ) {
         // get the node we are keeping
         MATCH (vertex_to_keep {uuid: n_uuid})
         WHERE %(id_func_name)s(vertex_to_keep) = element_id_to_keep
@@ -221,25 +215,22 @@ CALL {
         MATCH (n {uuid: n_uuid})%(l_arrow)s-[]-%(r_arrow)s(peer)
         WHERE %(id_func_name)s(n) IN vertex_element_ids
         AND %(id_func_name)s(peer) = peer_element_id
-        WITH n_uuid, vertex_element_ids, element_id_to_keep, vertex_to_keep, branch, edge_type, peer, all_edges_deleted,
-            earliest_active_time, latest_deleted_time
+        WITH peer, vertex_to_keep
         LIMIT 1
         // ------------
         // mark all other edges for this branch/edge_type/peer combination as to be deleted
         // we will unmark any to keep later
         // ------------
-        CALL {
-            WITH n_uuid, branch, peer, vertex_element_ids, edge_type
+        CALL (n_uuid, branch, peer, vertex_element_ids, edge_type) {
             OPTIONAL MATCH (n {uuid: n_uuid})%(l_arrow)s-[edge_to_delete {branch: branch}]-%(r_arrow)s(peer)
             WHERE %(id_func_name)s(n) IN vertex_element_ids
             AND type(edge_to_delete) = edge_type
             SET edge_to_delete.to_delete = TRUE
         }
-        CALL {
+        CALL (n_uuid, branch, vertex_element_ids, edge_type, peer) {
             // ------------
             // get the edge to copy
             // ------------
-            WITH n_uuid, branch, vertex_element_ids, edge_type, peer
             MATCH (n {uuid: n_uuid})%(l_arrow)s-[e {branch: branch, status: "active"}]-%(r_arrow)s(peer)
             WHERE %(id_func_name)s(n) IN vertex_element_ids
             AND type(e) = edge_type
@@ -251,8 +242,7 @@ CALL {
         // ------------
         // conditionally create the deleted edges
         // ------------
-        WITH n_uuid, vertex_element_ids, vertex_to_keep, branch, edge_type, peer, all_edges_deleted,
-            latest_deleted_time, edge_to_copy
+        WITH vertex_to_keep, peer, edge_to_copy
         WHERE all_edges_deleted = TRUE
         %(deleted_edge_subqueries)s
     }
@@ -283,8 +273,7 @@ ORDER BY node_uuid ASC
 MATCH (n:%(vertex_label)s {uuid: node_uuid})
 WITH node_uuid, n, %(id_func_name)s(n) AS element_id
 ORDER BY node_uuid ASC, element_id ASC
-CALL {
-    WITH n
+CALL (n) {
     WITH labels(n) AS n_labels
     UNWIND n_labels AS n_label
     WITH n_label
@@ -309,8 +298,7 @@ LIMIT $limit
 //------------
 // Which node are we going to keep for this UUID/labels combination?
 //------------
-CALL {
-    WITH vertex_element_ids
+CALL (vertex_element_ids) {
     UNWIND vertex_element_ids AS element_id
     WITH element_id
     ORDER BY element_id ASC
@@ -377,11 +365,10 @@ WITH
 WITH node_with_dup_edges, edge_type, edge_status, edge_branch, peer, is_outbound, count(*) AS num_dup_edges
 WHERE num_dup_edges > 1
 WITH DISTINCT node_with_dup_edges, edge_type, edge_branch, peer, is_outbound
-CALL {
+CALL (node_with_dup_edges, edge_type, edge_branch, peer, is_outbound) {
     // ------------
     // Get the earliest active and deleted edges for this branch
     // ------------
-    WITH node_with_dup_edges, edge_type, edge_branch, peer, is_outbound
     OPTIONAL MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]-(peer)
     WHERE type(active_edge) = edge_type
     AND (%(id_func_name)s(startNode(active_edge)) = %(id_func_name)s(node_with_dup_edges) OR is_outbound = FALSE)
@@ -397,8 +384,7 @@ CALL {
     // ensure one active edge with correct from and to times
     // set the others to be deleted
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer, is_outbound, active_from, deleted_from
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer, is_outbound, active_from, deleted_from) {
         OPTIONAL MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]-(peer)
         WHERE type(active_e) = edge_type
         AND (%(id_func_name)s(startNode(active_e)) = %(id_func_name)s(node_with_dup_edges) OR is_outbound = FALSE)
@@ -414,8 +400,7 @@ CALL {
     // ensure one deleted edge with correct from time, if necessary
     // set the others to be deleted
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer, is_outbound, deleted_from
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer, is_outbound, deleted_from) {
         MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]-(peer)
         WHERE type(deleted_e) = edge_type
         AND (%(id_func_name)s(startNode(deleted_e)) = %(id_func_name)s(node_with_dup_edges) OR is_outbound = FALSE)
@@ -467,11 +452,9 @@ WITH DISTINCT default_branch, global_branch, r_uuid
 // Find any IS_RELATED edges on the duplicate Relationships that link to deleted Nodes,
 //   accounting for if the edge was added on a branch after the Node was deleted on main
 // ------------
-CALL {
-    WITH default_branch, global_branch, r_uuid
+CALL (default_branch, global_branch, r_uuid) {
     MATCH (:Relationship {uuid: r_uuid})-[is_related:IS_RELATED]-(n:Node)
-    CALL {
-        WITH is_related
+    CALL (is_related) {
         MATCH (b:Branch {name: is_related.branch})
         RETURN b.branched_from AS edge_branched_from_time
     }
@@ -483,7 +466,7 @@ CALL {
     // ------------
     // before the active IS_RELATED edge's from time, then delete the edge
     // ------------
-    WITH default_branch, global_branch, is_related, edge_branched_from_time, is_part_of, CASE
+    WITH is_related, edge_branched_from_time, is_part_of, CASE
         WHEN is_part_of.status = "deleted" THEN is_part_of.from
         ELSE is_part_of.to
     END AS node_deleted_time
@@ -492,8 +475,7 @@ CALL {
     DELETE is_related
 }
 MATCH (rel:Relationship {uuid: r_uuid})
-CALL {
-    WITH rel
+CALL (rel) {
     OPTIONAL MATCH (rel)-[:IS_RELATED]-(n:Node)
     WITH DISTINCT n
     RETURN count(*) AS num_peers
@@ -553,12 +535,12 @@ class PerformHardDeletes(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         query = """
-CALL {
+CALL () {
     MATCH (n)
     WHERE n.to_delete = TRUE
     DETACH DELETE n
 }
-CALL {
+CALL () {
     MATCH ()-[e]-()
     WHERE e.to_delete = TRUE
     DELETE e

infrahub/core/migrations/graph/m030_illegal_edges.py

@@ -42,8 +42,7 @@ WITH DISTINCT n, delete_branch, delete_time, added_e, peer
 // ------------
 // get the branched_from for the branch on which the node was deleted
 // ------------
-CALL {
-    WITH added_e
+CALL (added_e) {
     MATCH (b:Branch {name: added_e.branch})
     RETURN b.branched_from AS added_e_branched_from
 }

infrahub/core/migrations/query/attribute_add.py

@@ -61,8 +61,7 @@ class AttributeAddQuery(Query):
         MERGE (is_visible_value:Boolean { value: $is_visible_default })
         WITH av, is_protected_value, is_visible_value
         MATCH p = (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH (:Root)<-[r:IS_PART_OF]-(n)
             WHERE %(branch_filter)s
             WITH n, r AS is_part_of_e

infrahub/core/migrations/query/attribute_rename.py

@@ -38,7 +38,7 @@ class AttributeRenameQuery(Query):
     def render_match(self) -> str:
         query = """
         // Find all the active nodes
-        CALL {
+        CALL () {
             MATCH (node:%(node_kind)s)
             WHERE exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $prev_attr.name }))
             RETURN node
@@ -55,7 +55,6 @@ class AttributeRenameQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type_update_active(rel_type: str, rel_def: FieldInfo) -> str:
         subquery = [
-            "WITH peer_node, rb, active_attr",
             "WITH peer_node, rb, active_attr",
             f'WHERE type(rb) = "{rel_type}"',
         ]
@@ -72,7 +71,6 @@ class AttributeRenameQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type_create_new(rel_type: str, rel_def: FieldInfo) -> str:
         subquery = [
-            "WITH peer_node, rb, active_attr, new_attr",
             "WITH peer_node, rb, active_attr, new_attr",
             f'WHERE type(rb) = "{rel_type}"',
         ]
@@ -126,8 +124,7 @@ class AttributeRenameQuery(Query):
 
         add_uuid = db.render_uuid_generation(node_label="new_attr", node_attr="uuid")
         query = """
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -137,8 +134,7 @@ class AttributeRenameQuery(Query):
         WITH n1 as active_node, r1 as rb
         WHERE rb.status = "active"
         // Find all the attributes that need to be updated
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH (active_node)-[r:HAS_ATTRIBUTE]-(attr:Attribute { name: $prev_attr.name })
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as r1, attr as attr1
@@ -151,8 +147,7 @@ class AttributeRenameQuery(Query):
         %(add_uuid)s
         WITH active_attr, new_attr
         MATCH (active_attr)-[]-(peer)
-        CALL {
-            WITH active_attr, peer
+        CALL (active_attr, peer) {
             MATCH (active_attr)-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_attr as a1, r as r1, peer as p1
@@ -161,7 +156,7 @@ class AttributeRenameQuery(Query):
         }
         WITH a1 as active_attr, r1 as rb, p1 as peer_node, new_attr
         WHERE rb.status = "active"
-        CALL {
+        CALL (peer_node, rb, active_attr, new_attr){
             %(sub_query_create_all)s
         }
         WITH p2 as peer_node, rb, new_attr, active_attr
@@ -170,7 +165,7 @@ class AttributeRenameQuery(Query):
 
         if not (self.branch.is_default or self.branch.is_global):
             query = """
-            CALL {
+            CALL (peer_node, rb, active_attr) {
                 %(sub_query_update_all)s
             }
             WITH p2 as peer_node, rb, new_attr

infrahub/core/migrations/query/delete_element_in_schema.py

@@ -55,7 +55,6 @@ class DeleteElementInSchemaQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, direction: GraphRelDirection) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, element_to_delete",
             f"WITH peer_node, {rel_name}, element_to_delete",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -67,28 +66,32 @@ class DeleteElementInSchemaQuery(Query):
         return "\n".join(subquery)
 
     @classmethod
-    def _render_sub_query_out(cls) -> str:
+    def _render_sub_query_out(cls) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, element_to_delete"
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.OUTBOUND
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     @classmethod
-    def _render_sub_query_in(cls) -> str:
+    def _render_sub_query_in(cls) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, element_to_delete"
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, direction=GraphRelDirection.INBOUND
+                rel_name=rel_name, rel_type=rel_type, direction=GraphRelDirection.INBOUND
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
             if rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
@@ -108,16 +111,15 @@ class DeleteElementInSchemaQuery(Query):
             "from": self.at.to_string(),
         }
 
-        sub_query_out = self._render_sub_query_out()
-        sub_query_in = self._render_sub_query_in()
+        sub_query_out, sub_query_out_args = self._render_sub_query_out()
+        sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
         self.add_to_query(self.render_match())
         self.add_to_query(self.render_where())
 
         # ruff: noqa: E501
         query = """
-        CALL {
-            WITH attr_node
+        CALL (attr_node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(attr_node)
             WHERE %(branch_filter)s
             RETURN attr_node as n1, r as r1
@@ -130,8 +132,7 @@ class DeleteElementInSchemaQuery(Query):
 
         // Process Outbound Relationship
         MATCH (element_to_delete)-[]->(peer)
-        CALL {
-            WITH element_to_delete, peer
+        CALL (element_to_delete, peer) {
             MATCH (element_to_delete)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN element_to_delete as n1, r as rel_outband1, peer as p1
@@ -140,7 +141,7 @@ class DeleteElementInSchemaQuery(Query):
         }
         WITH n1 as element_to_delete, rel_outband1 as rel_outband, p1 as peer_node
         WHERE rel_outband.status = "active"
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, element_to_delete
@@ -150,8 +151,7 @@ class DeleteElementInSchemaQuery(Query):
         WITH DISTINCT(element_to_delete) AS element_to_delete
         // Process Inbound Relationship
         MATCH (element_to_delete)<-[]-(peer)
-        CALL {
-            WITH element_to_delete, peer
+        CALL (element_to_delete, peer) {
             MATCH (element_to_delete)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN element_to_delete as n1, r as rel_inband1, peer as p1
@@ -160,7 +160,7 @@ class DeleteElementInSchemaQuery(Query):
         }
         WITH n1 as element_to_delete, rel_inband1 as rel_inband, p1 as peer_node
         WHERE rel_inband.status = "active"
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, element_to_delete
@@ -172,5 +172,7 @@ class DeleteElementInSchemaQuery(Query):
             "branch_filter": branch_filter,
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_out_args": sub_query_out_args,
+            "sub_query_in_args": sub_query_in_args,
         }
         self.add_to_query(query)

infrahub/core/migrations/query/node_duplicate.py

@@ -47,7 +47,6 @@ class NodeDuplicateQuery(Query):
     @staticmethod
     def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, rel_dir: GraphRelDirection) -> str:
         subquery = [
-            f"WITH peer_node, {rel_name}, active_node, new_node",
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -81,28 +80,28 @@ class NodeDuplicateQuery(Query):
         return "\n".join(subquery)
 
     @classmethod
-    def _render_sub_query_out(cls) -> str:
+    def _render_sub_query_out(cls) -> tuple[str, str]:
+        rel_name = "rel_outband"
+        sub_query_out_args = f"peer_node, {rel_name}, active_node, new_node"
         sub_queries_out = [
-            cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND
-            )
+            cls._render_sub_query_per_rel_type(rel_name=rel_name, rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND)
             for rel_type, field_info in GraphNodeRelationships.model_fields.items()
             if field_info.default.direction in (GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
-        return sub_query_out
+        return sub_query_out, sub_query_out_args
 
     @classmethod
-    def _render_sub_query_in(cls) -> str:
+    def _render_sub_query_in(cls) -> tuple[str, str]:
+        rel_name = "rel_inband"
+        sub_query_in_args = f"peer_node, {rel_name}, active_node, new_node"
         sub_queries_in = [
-            cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND
-            )
+            cls._render_sub_query_per_rel_type(rel_name=rel_name, rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND)
             for rel_type, field_info in GraphNodeRelationships.model_fields.items()
             if field_info.default.direction in (GraphRelDirection.INBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
-        return sub_query_in
+        return sub_query_in, sub_query_in_args
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
@@ -126,15 +125,14 @@ class NodeDuplicateQuery(Query):
             "from": self.at.to_string(),
         }
 
-        sub_query_out = self._render_sub_query_out()
-        sub_query_in = self._render_sub_query_in()
+        sub_query_out, sub_query_out_args = self._render_sub_query_out()
+        sub_query_in, sub_query_in_args = self._render_sub_query_in()
 
         self.add_to_query(self.render_match())
 
         # ruff: noqa: E501
         query = """
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -147,8 +145,7 @@ class NodeDuplicateQuery(Query):
         WITH active_node, new_node
         // Process Outbound Relationship
         MATCH (active_node)-[]->(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_outband1, peer as p1
@@ -157,7 +154,7 @@ class NodeDuplicateQuery(Query):
         }
         WITH n1 as active_node, rel_outband1 as rel_outband, p1 as peer_node, new_node
         WHERE rel_outband.status = "active" AND rel_outband.to IS NULL
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, active_node, new_node
@@ -167,8 +164,7 @@ class NodeDuplicateQuery(Query):
         WITH DISTINCT active_node, new_node
         // Process Inbound Relationship
         MATCH (active_node)<-[]-(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_inband1, peer as p1
@@ -177,7 +173,7 @@ class NodeDuplicateQuery(Query):
         }
         WITH n1 as active_node, rel_inband1 as rel_inband, p1 as peer_node, new_node
         WHERE rel_inband.status = "active" AND rel_inband.to IS NULL
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, active_node, new_node
@@ -191,5 +187,7 @@ class NodeDuplicateQuery(Query):
             "labels": ":".join(self.new_node.labels),
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_out_args": sub_query_out_args,
+            "sub_query_in_args": sub_query_in_args,
         }
         self.add_to_query(query)