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

infrahub/core/migrations/graph/m030_illegal_edges.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class DeletePosthumousEdges(Query):
+    name = "delete_posthumous_edges_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL (added_e) {
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+DELETE added_e
+// --------------
+// the peer _should_ only be an Attribute, but I want to make sure we don't
+// inadvertently delete Root or an AttributeValue or a Boolean
+// --------------
+WITH peer
+WHERE "Attribute" IN labels(peer)
+DETACH DELETE peer
+        """
+        self.add_to_query(query)
+
+
+class Migration030(GraphMigration):
+    """
+    Edges could have been added to Nodes after the Node was deleted, so we need to hard-delete those illegal edges
+    """
+
+    name: str = "030_delete_illegal_edges"
+    minimum_version: int = 29
+    queries: Sequence[type[Query]] = [DeletePosthumousEdges]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/migrations/query/attribute_add.py

@@ -61,30 +61,33 @@ 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
-            MATCH (root:Root)<-[r1:IS_PART_OF]-(n)
-            OPTIONAL MATCH (n)-[r2:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
-            WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
-            RETURN n as n1, r1 as r11, r2 as r12
-            ORDER BY r2.branch_level DESC, r2.from ASC, r1.branch_level DESC, r1.from ASC
+        CALL (n) {
+            MATCH (:Root)<-[r:IS_PART_OF]-(n)
+            WHERE %(branch_filter)s
+            WITH n, r AS is_part_of_e
+            OPTIONAL MATCH (n)-[r:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
+            WHERE %(branch_filter)s
+            WITH is_part_of_e, r AS has_attr_e
+            RETURN is_part_of_e, has_attr_e
+            ORDER BY has_attr_e.branch_level DESC, has_attr_e.from ASC, is_part_of_e.branch_level DESC, is_part_of_e.from ASC
             LIMIT 1
         }
-        WITH n1 as n, r11 as r1, r12 as r2, av, is_protected_value, is_visible_value
-        WHERE r1.status = "active" AND (r2 IS NULL OR r2.status = "deleted")
+        WITH n, is_part_of_e, has_attr_e, av, is_protected_value, is_visible_value
+        WHERE is_part_of_e.status = "active" AND (has_attr_e IS NULL OR has_attr_e.status = "deleted")
         CREATE (a:Attribute { name: $attr_name, branch_support: $branch_support })
         CREATE (n)-[:HAS_ATTRIBUTE $rel_props ]->(a)
         CREATE (a)-[:HAS_VALUE $rel_props ]->(av)
         CREATE (a)-[:IS_PROTECTED $rel_props]->(is_protected_value)
         CREATE (a)-[:IS_VISIBLE $rel_props]->(is_visible_value)
         %(uuid_generation)s
-        FOREACH (i in CASE WHEN r2.status = "deleted" THEN [1] ELSE [] END |
-            SET r2.to = $current_time
+        FOREACH (i in CASE WHEN has_attr_e.status = "deleted" THEN [1] ELSE [] END |
+            SET has_attr_e.to = $current_time
         )
         """ % {
             "branch_filter": branch_filter,
             "node_kind": self.node_kind,
             "uuid_generation": db.render_uuid_generation(node_label="a", node_attr="uuid"),
         }
+
         self.add_to_query(query)
         self.return_labels = ["n.uuid", "a.uuid"]

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)

infrahub/core/migrations/query/relationship_duplicate.py

@@ -47,7 +47,6 @@ class RelationshipDuplicateQuery(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}, active_rel, new_rel",
             f"WITH peer_node, {rel_name}, active_rel, new_rel",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
@@ -61,28 +60,32 @@ class RelationshipDuplicateQuery(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_rel, new_rel"
         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 GraphRelationshipRelationships.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}, active_rel, new_rel"
         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 GraphRelationshipRelationships.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())
@@ -109,15 +112,13 @@ class RelationshipDuplicateQuery(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 source, rel, destination
+        CALL (source, rel, destination) {
             MATCH path = (source)-[r1:IS_RELATED]-(rel)-[r2:IS_RELATED]-(destination)
             WHERE all(r IN relationships(path) WHERE %(branch_filter)s)
             RETURN rel as rel1, r1 as r11, r2 as r12
@@ -130,8 +131,7 @@ class RelationshipDuplicateQuery(Query):
         WITH DISTINCT(active_rel) as active_rel, new_rel
         // Process Inbound Relationship
         MATCH (active_rel)<-[]-(peer)
-        CALL {
-            WITH active_rel, peer
+        CALL (active_rel, peer) {
             MATCH (active_rel)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_rel as n1, r as rel_inband1, peer as p1
@@ -140,7 +140,7 @@ class RelationshipDuplicateQuery(Query):
         }
         WITH n1 as active_rel, rel_inband1 as rel_inband, p1 as peer_node, new_rel
         WHERE rel_inband.status = "active"
-        CALL {
+        CALL (%(sub_query_in_args)s) {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, active_rel, new_rel
@@ -150,8 +150,7 @@ class RelationshipDuplicateQuery(Query):
         WITH DISTINCT(active_rel) as active_rel, new_rel
         // Process Outbound Relationship
         MATCH (active_rel)-[]->(peer)
-        CALL {
-            WITH active_rel, peer
+        CALL (active_rel, peer) {
             MATCH (active_rel)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_rel as n1, r as rel_outband1, peer as p1
@@ -160,7 +159,7 @@ class RelationshipDuplicateQuery(Query):
         }
         WITH n1 as active_rel, rel_outband1 as rel_outband, p1 as peer_node, new_rel
         WHERE rel_outband.status = "active"
-        CALL {
+        CALL (%(sub_query_out_args)s) {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, active_rel, new_rel
@@ -172,5 +171,7 @@ class RelationshipDuplicateQuery(Query):
             "branch_filter": branch_filter,
             "sub_query_out": sub_query_out,
             "sub_query_in": sub_query_in,
+            "sub_query_in_args": sub_query_in_args,
+            "sub_query_out_args": sub_query_out_args,
         }
         self.add_to_query(query)

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -50,7 +50,6 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
 
         def render_sub_query_per_rel_type(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}"',
             ]
@@ -75,8 +74,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         MATCH (node:%(node_kind)s)
         WHERE (size($kinds_to_ignore) = 0 OR NOT any(l IN labels(node) WHERE l IN $kinds_to_ignore))
         AND exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -86,8 +84,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         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: $attr_name })
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as r1, attr as attr1
@@ -98,8 +95,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         WHERE rb.status = "active"
         WITH active_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
@@ -108,7 +104,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         }
         WITH a1 as active_attr, r1 as rb, p1 as peer_node
         WHERE rb.status = "active"
-        CALL {
+        CALL (peer_node, rb, active_attr) {
             %(sub_query_all)s
         }
         WITH p2 as peer_node, rb, active_attr