infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/diff/query/field_summary.py

@@ -45,8 +45,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         OPTIONAL MATCH (diff_root)-[:DIFF_HAS_NODE]->(n:DiffNode)
         WHERE n.action <> $unchanged_str
         WITH DISTINCT n.kind AS kind
-        CALL {
-            WITH kind
+        CALL (kind) {
             OPTIONAL MATCH (n:DiffNode {kind: kind})-[:DIFF_HAS_ATTRIBUTE]->(a:DiffAttribute)
             WHERE n.action <> $unchanged_str
             AND a.action <> $unchanged_str
@@ -54,8 +53,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
             RETURN collect(attr_name) AS attr_names
         }
         WITH kind, attr_names
-        CALL {
-            WITH kind
+        CALL (kind) {
             OPTIONAL MATCH (n:DiffNode {kind: kind})-[:DIFF_HAS_RELATIONSHIP]->(r:DiffRelationship)
             WHERE n.action <> $unchanged_str
             AND r.action <> $unchanged_str

infrahub/core/diff/query/merge.py

@@ -49,27 +49,24 @@ WITH node_diff_map, is_node_kind_migration, CASE
     WHEN is_node_kind_migration THEN $migrated_kinds_id_map[node_diff_map.uuid]
     ELSE NULL
 END AS node_db_id
-CALL {
-    WITH node_diff_map, node_db_id
+CALL (node_diff_map, node_db_id) {
     MATCH (n:Node {uuid: node_diff_map.uuid})
     WHERE node_db_id IS NULL
     OR %(id_func)s(n) = node_db_id
     RETURN n
 }
 WITH n, node_diff_map, is_node_kind_migration
-CALL {
-    WITH n, node_diff_map, is_node_kind_migration
-    WITH n, node_diff_map, is_node_kind_migration, CASE
+CALL (n, node_diff_map, is_node_kind_migration) {
+    WITH CASE
         WHEN node_diff_map.action = "ADDED" THEN "active"
         WHEN node_diff_map.action = "REMOVED" THEN "deleted"
         ELSE NULL
     END AS node_rel_status
-    CALL {
+    CALL (n, node_diff_map, is_node_kind_migration, node_rel_status) {
         // ------------------------------
         // only make IS_PART_OF updates if node is ADDED or REMOVED
         // ------------------------------
-        WITH n, node_diff_map, node_rel_status, is_node_kind_migration
-        WITH n, node_diff_map, node_rel_status, is_node_kind_migration
+        WITH node_rel_status
         WHERE node_rel_status IS NOT NULL
         // nodes with a migrated kind are handled in DiffMergeMigratedKindsQuery
         AND is_node_kind_migration = FALSE
@@ -78,8 +75,7 @@ CALL {
         // set IS_PART_OF.to, optionally, target branch
         // ------------------------------
         WITH root, n, node_rel_status
-        CALL {
-            WITH root, n, node_rel_status
+        CALL (root, n, node_rel_status) {
             OPTIONAL MATCH (root)<-[target_r_root:IS_PART_OF {branch: $target_branch, status: "active"}]-(n)
             WHERE node_rel_status = "deleted"
             AND target_r_root.from <= $at AND target_r_root.to IS NULL
@@ -89,13 +85,12 @@ CALL {
         // create new IS_PART_OF relationship on target_branch
         // ------------------------------
         WITH root, n, node_rel_status
-        CALL {
-            WITH root, n, node_rel_status
+        CALL (root, n, node_rel_status) {
             OPTIONAL MATCH (root)<-[r_root:IS_PART_OF {branch: $target_branch}]-(n)
             WHERE r_root.status = node_rel_status
             AND r_root.from <= $at
             AND (r_root.to >= $at OR r_root.to IS NULL)
-            WITH root, r_root, n, node_rel_status
+            WITH r_root
             WHERE r_root IS NULL
             CREATE (root)
                 <-[:IS_PART_OF { branch: $target_branch, branch_level: $branch_level, from: $at, status: node_rel_status }]
@@ -104,12 +99,10 @@ CALL {
         // ------------------------------
         // shortcut to delete all attributes and relationships for this node if the node is deleted
         // ------------------------------
-        CALL {
-            WITH n, node_rel_status
+        CALL (n, node_rel_status) {
             WITH n, node_rel_status
             WHERE node_rel_status = "deleted"
-            CALL {
-                WITH n
+            CALL (n) {
                 OPTIONAL MATCH (n)-[rel1:IS_RELATED]-(:Relationship)-[rel2]-(p)
                 WHERE (p.uuid IS NULL OR n.uuid <> p.uuid)
                 AND rel1.branch = $target_branch
@@ -118,7 +111,6 @@ CALL {
                 AND rel2.status = "active"
                 RETURN rel1, rel2
                 UNION
-                WITH n
                 OPTIONAL MATCH (n)-[rel1:HAS_ATTRIBUTE]->(:Attribute)-[rel2]->()
                 WHERE type(rel2) <> "HAS_ATTRIBUTE"
                 AND rel1.branch = $target_branch
@@ -127,7 +119,7 @@ CALL {
                 AND rel2.status = "active"
                 RETURN rel1, rel2
             }
-            WITH n, rel1, rel2
+            WITH rel1, rel2
             WHERE rel1.to IS NULL
             AND rel2.to IS NULL
             AND rel1.from <= $at
@@ -138,10 +130,8 @@ CALL {
             // and delete HAS_OWNER and HAS_SOURCE edges to this node if the node is deleted
             // ------------------------------
             WITH n
-            CALL {
-                WITH n
-                CALL {
-                    WITH n
+            CALL (n) {
+                CALL (n) {
                     MATCH (n)<-[rel:HAS_OWNER]-()
                     WHERE rel.branch = $target_branch
                     AND rel.status = "active"
@@ -161,9 +151,8 @@ CALL {
         }
     }
     WITH n, node_diff_map
-    CALL {
-        WITH n, node_diff_map
-        WITH n, CASE
+    CALL (n, node_diff_map) {
+        WITH CASE
             WHEN node_diff_map.attributes IS NULL OR node_diff_map.attributes = [] THEN [NULL]
             ELSE node_diff_map.attributes
         END AS attribute_maps
@@ -171,15 +160,13 @@ CALL {
         // ------------------------------
         // handle updates for attributes under this node
         // ------------------------------
-        CALL {
-            WITH n, attribute_diff_map
-            WITH n, attribute_diff_map.name AS attr_name, CASE
+        CALL (n, attribute_diff_map) {
+            WITH attribute_diff_map.name AS attr_name, CASE
                 WHEN attribute_diff_map.action = "ADDED" THEN "active"
                 WHEN attribute_diff_map.action = "REMOVED" THEN "deleted"
                 ELSE NULL
             END AS attr_rel_status
-            CALL {
-                WITH n, attr_name
+            CALL (n, attr_name) {
                 OPTIONAL MATCH (n)-[has_attr:HAS_ATTRIBUTE]->(a:Attribute {name: attr_name})
                 WHERE has_attr.branch IN [$source_branch, $target_branch]
                 RETURN a
@@ -190,8 +177,7 @@ CALL {
             // ------------------------------
             // set HAS_ATTRIBUTE.to on target branch if necessary
             // ------------------------------
-            CALL {
-                WITH n, attr_rel_status, a
+            CALL (n, attr_rel_status, a) {
                 OPTIONAL MATCH (n)
                     -[target_r_attr:HAS_ATTRIBUTE {branch: $target_branch, status: "active"}]
                     ->(a)
@@ -203,15 +189,14 @@ CALL {
             // ------------------------------
             // conditionally create new HAS_ATTRIBUTE relationship on target_branch, if necessary
             // ------------------------------
-            CALL {
-                WITH n, attr_rel_status, a
+            CALL (n, attr_rel_status, a) {
                 WITH n, attr_rel_status, a
                 WHERE a IS NOT NULL
                 OPTIONAL MATCH (n)-[r_attr:HAS_ATTRIBUTE {branch: $target_branch}]->(a)
                 WHERE r_attr.status = attr_rel_status
                 AND r_attr.from <= $at
                 AND (r_attr.to >= $at OR r_attr.to IS NULL)
-                WITH n, r_attr, attr_rel_status, a
+                WITH r_attr
                 WHERE r_attr IS NULL
                 CREATE (n)-[:HAS_ATTRIBUTE { branch: $target_branch, branch_level: $branch_level, from: $at, status: attr_rel_status }]->(a)
             }
@@ -220,16 +205,14 @@ CALL {
         RETURN 1 AS done
     }
     WITH n, node_diff_map
-    CALL {
-        WITH n,node_diff_map
+    CALL (n, node_diff_map) {
         UNWIND node_diff_map.relationships AS relationship_diff_map
         // ------------------------------
         // handle updates for relationships under this node
         // ------------------------------
-        CALL {
-            WITH n, relationship_diff_map
+        CALL (n, relationship_diff_map) {
             WITH
-                n, relationship_diff_map.peer_id AS rel_peer_id, relationship_diff_map.name AS rel_name,
+                relationship_diff_map.peer_id AS rel_peer_id, relationship_diff_map.name AS rel_name,
                 CASE
                     WHEN relationship_diff_map.action = "ADDED" THEN "active"
                     WHEN relationship_diff_map.action = "REMOVED" THEN "deleted"
@@ -243,8 +226,7 @@ CALL {
             // ------------------------------
             // determine the directions of each IS_RELATED
             // ------------------------------
-            CALL {
-                WITH n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
+            CALL (n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
                 MATCH (n)
                     -[source_r_rel_1:IS_RELATED]
                     -(r:Relationship {name: rel_name})
@@ -255,7 +237,7 @@ CALL {
                 AND source_r_rel_2.branch IN [$source_branch, $target_branch]
                 AND source_r_rel_1.from <= $at AND source_r_rel_1.to IS NULL
                 AND source_r_rel_2.from <= $at AND source_r_rel_2.to IS NULL
-                WITH n, rel_name, rel_peer_id, related_rel_status, r, source_r_rel_1, source_r_rel_2
+                WITH r, source_r_rel_1, source_r_rel_2
                 ORDER BY source_r_rel_1.branch_level DESC, source_r_rel_2.branch_level DESC, source_r_rel_1.from DESC, source_r_rel_2.from DESC
                 LIMIT 1
                 RETURN r, CASE
@@ -270,8 +252,7 @@ CALL {
                 source_r_rel_2.hierarchy AS r2_hierarchy
             }
             WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
-            CALL {
-                WITH n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
+            CALL (n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
                 OPTIONAL MATCH (n)
                     -[target_r_rel_1:IS_RELATED {branch: $target_branch, status: "active"}]
                     -(:Relationship {name: rel_name})
@@ -288,8 +269,7 @@ CALL {
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
-            CALL {
-                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
+            CALL (n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
                 MATCH (p:Node {uuid: rel_peer_id})
                 WHERE rel_peer_db_id IS NULL OR %(id_func)s(p) = rel_peer_db_id
                 OPTIONAL MATCH (n)
@@ -301,38 +281,34 @@ CALL {
                 AND (r_rel_1.to >= $at OR r_rel_1.to IS NULL)
                 AND r_rel_2.from <= $at
                 AND (r_rel_2.to >= $at OR r_rel_2.to IS NULL)
-                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, p, related_rel_status, r_rel_1, r_rel_2
+                WITH p, r_rel_1, r_rel_2
                 WHERE r_rel_1 IS NULL
                 AND r_rel_2 IS NULL
                 // ------------------------------
                 // create IS_RELATED relationships with directions maintained from source
                 // ------------------------------
-                CALL {
-                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                CALL (n, r, r1_dir, r1_hierarchy, related_rel_status) {
                     WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "r"
                     CREATE (n)
                         -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         ->(r)
                 }
-                CALL {
-                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                CALL (n, r, r1_dir, r1_hierarchy, related_rel_status) {
                     WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "l"
                     CREATE (n)
                         <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         -(r)
                 }
-                CALL {
-                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                CALL (r, p, r2_dir, r2_hierarchy, related_rel_status) {
                     WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "r"
                     CREATE (r)
                         -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         ->(p)
                 }
-                CALL {
-                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                CALL (r, p, r2_dir, r2_hierarchy, related_rel_status) {
                     WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "l"
                     CREATE (r)
@@ -390,13 +366,11 @@ CASE
     WHEN attr_rel_prop_diff.peer_uuid IN $migrated_kinds_uuids THEN $migrated_kinds_id_map[attr_rel_prop_diff.peer_uuid]
     ELSE NULL
 END AS peer_db_id
-CALL {
+CALL (attr_rel_prop_diff, node_db_id, peer_db_id) {
     // ------------------------------
     // find the Attribute node
     // ------------------------------
-    WITH attr_rel_prop_diff, node_db_id, peer_db_id
-    CALL {
-        WITH attr_rel_prop_diff, node_db_id
+    CALL (attr_rel_prop_diff, node_db_id) {
         OPTIONAL MATCH (n:Node {uuid: attr_rel_prop_diff.node_uuid})
             -[has_attr:HAS_ATTRIBUTE]
             ->(attr:Attribute {name: attr_rel_prop_diff.attribute_name})
@@ -407,8 +381,7 @@ CALL {
         ORDER BY has_attr.from DESC
         LIMIT 1
     }
-    CALL {
-        WITH attr_rel_prop_diff, node_db_id, peer_db_id
+    CALL (attr_rel_prop_diff, node_db_id, peer_db_id) {
         OPTIONAL MATCH (n:Node {uuid: attr_rel_prop_diff.node_uuid})
             -[r1:IS_RELATED]
             -(rel:Relationship {name: attr_rel_prop_diff.relationship_id})
@@ -429,13 +402,11 @@ CALL {
     // ------------------------------
     // handle updates for properties under this attribute/relationship
     // ------------------------------
-    CALL {
-        WITH attr_rel, property_diff, peer_db_id
+    CALL (attr_rel, property_diff, peer_db_id) {
         // ------------------------------
         // identify the correct property node to link
         // ------------------------------
-        CALL {
-            WITH attr_rel, property_diff, peer_db_id
+        CALL (attr_rel, property_diff, peer_db_id) {
             OPTIONAL MATCH (peer:Node {uuid: property_diff.value})
             WHERE property_diff.property_type IN ["HAS_SOURCE", "HAS_OWNER"]
             AND (peer_db_id IS NULL OR %(id_func)s(peer) = peer_db_id)
@@ -443,8 +414,7 @@ CALL {
             // the serialized diff might not include the values for IS_VISIBLE and IS_PROTECTED in
             // some cases, so we need to figure them out here
             // ------------------------------
-            CALL {
-                WITH attr_rel, property_diff
+            CALL (attr_rel, property_diff) {
                 OPTIONAL MATCH (attr_rel)-[r_vis_pro]->(bool:Boolean)
                 WHERE property_diff.property_type IN ["IS_VISIBLE", "IS_PROTECTED"]
                 AND r_vis_pro.branch IN [$source_branch, $target_branch]
@@ -454,12 +424,11 @@ CALL {
                 ORDER BY r_vis_pro.from DESC
                 LIMIT 1
             }
-            CALL {
+            CALL (attr_rel, property_diff) {
                 // ------------------------------
                 // get the latest linked AttributeValue on the source b/c there could be multiple
                 // with different is_default values
                 // ------------------------------
-                WITH attr_rel, property_diff
                 OPTIONAL MATCH (attr_rel)-[r_attr_val:HAS_VALUE]->(av:AttributeValue)
                 WHERE property_diff.property_type = "HAS_VALUE"
                 AND (
@@ -473,7 +442,7 @@ CALL {
             }
             RETURN COALESCE (peer, bool, av) AS prop_node
         }
-        WITH attr_rel, property_diff.property_type AS prop_type, prop_node, CASE
+        WITH attr_rel,property_diff.property_type AS prop_type, prop_node, CASE
             WHEN property_diff.action = "ADDED" THEN "active"
             WHEN property_diff.action = "REMOVED" THEN "deleted"
             ELSE NULL
@@ -481,8 +450,7 @@ CALL {
         // ------------------------------
         // set property edge.to, optionally, on target branch
         // ------------------------------
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type
+        CALL (attr_rel, prop_rel_status, prop_type) {
             OPTIONAL MATCH (attr_rel)
                 -[target_r_prop {branch: $target_branch}]
                 ->()
@@ -493,8 +461,7 @@ CALL {
         // ------------------------------
         // check for existing edge on target_branch
         // ------------------------------
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             OPTIONAL MATCH (attr_rel)-[r_prop {branch: $target_branch}]->(prop_node)
             WHERE type(r_prop) = prop_type
             AND r_prop.status = prop_rel_status
@@ -502,38 +469,33 @@ CALL {
             AND (r_prop.to > $at OR r_prop.to IS NULL)
             RETURN r_prop
         }
-        WITH attr_rel, prop_rel_status, prop_type, prop_node, r_prop
+        WITH attr_rel,prop_rel_status, prop_type, prop_node, r_prop
         WHERE r_prop IS NULL
         // ------------------------------
         // create new edge to prop_node on target_branch, if necessary
         // one subquery per possible edge type b/c edge type cannot be a variable
         // ------------------------------
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             WITH attr_rel, prop_rel_status, prop_type, prop_node
             WHERE prop_type = "HAS_VALUE"
             CREATE (attr_rel)-[:HAS_VALUE { branch: $target_branch, branch_level: $branch_level, from: $at, status: prop_rel_status }]->(prop_node)
         }
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             WITH attr_rel, prop_rel_status, prop_type, prop_node
             WHERE prop_type = "HAS_SOURCE"
             CREATE (attr_rel)-[:HAS_SOURCE { branch: $target_branch, branch_level: $branch_level, from: $at, status: prop_rel_status }]->(prop_node)
         }
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             WITH attr_rel, prop_rel_status, prop_type, prop_node
             WHERE prop_type = "HAS_OWNER"
             CREATE (attr_rel)-[:HAS_OWNER { branch: $target_branch, branch_level: $branch_level, from: $at, status: prop_rel_status }]->(prop_node)
         }
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             WITH attr_rel, prop_rel_status, prop_type, prop_node
             WHERE prop_type = "IS_VISIBLE"
             CREATE (attr_rel)-[:IS_VISIBLE { branch: $target_branch, branch_level: $branch_level, from: $at, status: prop_rel_status }]->(prop_node)
         }
-        CALL {
-            WITH attr_rel, prop_rel_status, prop_type, prop_node
+        CALL (attr_rel, prop_rel_status, prop_type, prop_node) {
             WITH attr_rel, prop_rel_status, prop_type, prop_node
             WHERE prop_type = "IS_PROTECTED"
             CREATE (attr_rel)-[:IS_PROTECTED { branch: $target_branch, branch_level: $branch_level, from: $at, status: prop_rel_status }]->(prop_node)
@@ -573,19 +535,17 @@ class DiffMergeMigratedKindsQuery(Query):
         query = """
 MATCH (n:Node)
 WHERE n.uuid IN $migrated_uuids
-CALL {
+CALL (n) {
     // --------------
     // for each migrated node (created or deleted), find its latest edges on the source branch,
     // check if they exist on the target, create them if not
     // --------------
-    WITH n
     MATCH (n)-[]-(peer)
     WITH DISTINCT n, peer
-    CALL {
+    CALL (n, peer) {
         // --------------
         // get the latest outbound edge for each type between n and peer
         // --------------
-        WITH n, peer
         MATCH (n)-[e {branch: $source_branch}]->(peer)
         WHERE e.from <= $at AND e.to IS NULL
         WITH e, type(e) AS edge_type
@@ -593,11 +553,10 @@ CALL {
         WITH edge_type, head(collect(e)) AS latest_source_edge
         RETURN edge_type, latest_source_edge
     }
-    CALL {
+    CALL (n, peer, edge_type) {
         // --------------
         // for each n, peer, edge_type, get the latest edge on target
         // --------------
-        WITH n, peer, edge_type
         OPTIONAL MATCH (n)-[e {branch: $target_branch}]->(peer)
         WHERE type(e) = edge_type AND e.from <= $at
         RETURN e AS latest_target_edge
@@ -610,13 +569,11 @@ CALL {
     WITH n, peer, edge_type, latest_source_edge, latest_target_edge
     WHERE (latest_target_edge IS NULL AND latest_source_edge.status = "active")
     OR latest_source_edge.status <> latest_target_edge.status
-    CALL {
+    CALL (latest_source_edge, latest_target_edge) {
         // --------------
         // set the to time on active target branch edges that we are setting to deleted
         // --------------
-        WITH latest_source_edge, latest_target_edge
-        WITH latest_source_edge, latest_target_edge
-        WHERE latest_target_edge IS NOT NULL
+        WITH latest_target_edge WHERE latest_target_edge IS NOT NULL
         AND latest_source_edge.status = "deleted"
         AND latest_target_edge.status = "active"
         AND latest_target_edge.to IS NULL
@@ -625,19 +582,16 @@ CALL {
     // --------------
     // create the outbound edges on the target branch, one subquery per possible type
     // --------------
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
-        WHERE edge_type = "IS_PART_OF"
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type WHERE edge_type = "IS_PART_OF"
         CREATE (n)-[new_edge:IS_PART_OF]->(peer)
         SET new_edge = properties(latest_source_edge)
         SET new_edge.from = $at
         SET new_edge.branch_level = $branch_level
         SET new_edge.branch = $target_branch
     }
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type
         WHERE edge_type = "IS_RELATED"
         CREATE (n)-[new_edge:IS_RELATED]->(peer)
         SET new_edge = properties(latest_source_edge)
@@ -645,9 +599,8 @@ CALL {
         SET new_edge.branch_level = $branch_level
         SET new_edge.branch = $target_branch
     }
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type
         WHERE edge_type = "HAS_ATTRIBUTE"
         CREATE (n)-[new_edge:HAS_ATTRIBUTE]->(peer)
         SET new_edge = properties(latest_source_edge)
@@ -659,11 +612,10 @@ CALL {
     // do all of this again for inbound edges
     // --------------
     WITH DISTINCT n, peer
-    CALL {
+    CALL (n, peer) {
         // --------------
         // get the latest inbound edge for each type between n and peer
         // --------------
-        WITH n, peer
         MATCH (n)<-[e {branch: $source_branch}]-(peer)
         WHERE e.from <= $at AND e.to IS NULL
         WITH e, type(e) AS edge_type
@@ -671,11 +623,10 @@ CALL {
         WITH edge_type, head(collect(e)) AS latest_source_edge
         RETURN edge_type, latest_source_edge
     }
-    CALL {
+    CALL (n, peer, edge_type) {
         // --------------
         // for each n, peer, edge_type, get the latest edge on target
         // --------------
-        WITH n, peer, edge_type
         OPTIONAL MATCH (n)<-[e {branch: $target_branch}]-(peer)
         WHERE type(e) = edge_type AND e.from <= $at
         RETURN e AS latest_target_edge
@@ -687,12 +638,11 @@ CALL {
     // --------------
     WITH n, peer, edge_type, latest_source_edge, latest_target_edge
     WHERE latest_target_edge IS NULL OR latest_source_edge.status <> latest_target_edge.status
-    CALL {
+    CALL (latest_source_edge, latest_target_edge) {
         // --------------
         // set the to time on active target branch edges that we are setting to deleted
         // --------------
-        WITH latest_source_edge, latest_target_edge
-        WITH latest_source_edge, latest_target_edge
+        WITH latest_target_edge
         WHERE latest_target_edge IS NOT NULL
         AND latest_source_edge.status = "deleted"
         AND latest_target_edge.status = "active"
@@ -702,9 +652,8 @@ CALL {
     // --------------
     // create the outbound edges on the target branch, one subquery per possible type
     // --------------
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type
         WHERE edge_type = "IS_RELATED"
         CREATE (n)<-[new_edge:IS_RELATED]-(peer)
         SET new_edge = properties(latest_source_edge)
@@ -712,9 +661,8 @@ CALL {
         SET new_edge.branch_level = $branch_level
         SET new_edge.branch = $target_branch
     }
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type
         WHERE edge_type = "HAS_OWNER"
         CREATE (n)<-[new_edge:HAS_OWNER]-(peer)
         SET new_edge = properties(latest_source_edge)
@@ -722,9 +670,8 @@ CALL {
         SET new_edge.branch_level = $branch_level
         SET new_edge.branch = $target_branch
     }
-    CALL {
-        WITH n, latest_source_edge, peer, edge_type
-        WITH n, latest_source_edge, peer, edge_type
+    CALL (n, latest_source_edge, peer, edge_type) {
+        WITH edge_type
         WHERE edge_type = "HAS_SOURCE"
         CREATE (n)<-[new_edge:HAS_SOURCE]-(peer)
         SET new_edge = properties(latest_source_edge)