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

infrahub/patch/edge_updater.py

@@ -0,0 +1,28 @@
+from dataclasses import asdict
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import EdgeToUpdate
+
+
+class PatchPlanEdgeUpdater:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_update_query(self, edges_to_update: list[EdgeToUpdate]) -> None:
+        query = """
+UNWIND $edges_to_update AS edge_to_update
+MATCH ()-[e]-()
+WHERE %(id_func_name)s(e) = edge_to_update.db_id
+SET e = edge_to_update.after_props
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        await self.db.execute_query(
+            query=query, params={"edges_to_update": [asdict(e) for e in edges_to_update]}, type=QueryType.WRITE
+        )
+
+    async def execute(self, edges_to_update: list[EdgeToUpdate]) -> None:
+        for i in range(0, len(edges_to_update), self.batch_size_limit):
+            vertices_slice = edges_to_update[i : i + self.batch_size_limit]
+            await self._run_update_query(edges_to_update=vertices_slice)

infrahub/patch/models.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass, field
+from uuid import uuid4
+
+PropertyPrimitives = str | bool | int | float | None
+
+
+def str_uuid() -> str:
+    return str(uuid4())
+
+
+@dataclass
+class VertexToAdd:
+    labels: list[str]
+    after_props: dict[str, PropertyPrimitives]
+    identifier: str = field(default_factory=str_uuid)
+
+
+@dataclass
+class VertexToUpdate:
+    db_id: str
+    before_props: dict[str, PropertyPrimitives]
+    after_props: dict[str, PropertyPrimitives]
+
+
+@dataclass
+class VertexToDelete:
+    db_id: str
+    labels: list[str]
+    before_props: dict[str, PropertyPrimitives]
+
+
+@dataclass
+class EdgeToAdd:
+    from_id: str
+    to_id: str
+    edge_type: str
+    after_props: dict[str, PropertyPrimitives]
+    identifier: str = field(default_factory=str_uuid)
+
+
+@dataclass
+class EdgeToUpdate:
+    db_id: str
+    before_props: dict[str, PropertyPrimitives]
+    after_props: dict[str, PropertyPrimitives]
+
+
+@dataclass
+class EdgeToDelete:
+    db_id: str
+    from_id: str
+    to_id: str
+    edge_type: str
+    before_props: dict[str, PropertyPrimitives]
+
+
+@dataclass
+class PatchPlan:
+    name: str
+    vertices_to_add: list[VertexToAdd] = field(default_factory=list)
+    vertices_to_update: list[VertexToUpdate] = field(default_factory=list)
+    vertices_to_delete: list[VertexToDelete] = field(default_factory=list)
+    edges_to_add: list[EdgeToAdd] = field(default_factory=list)
+    edges_to_update: list[EdgeToUpdate] = field(default_factory=list)
+    edges_to_delete: list[EdgeToDelete] = field(default_factory=list)
+    added_element_db_id_map: dict[str, str] = field(default_factory=dict)
+    deleted_db_ids: set[str] = field(default_factory=set)
+    reverted_deleted_db_id_map: dict[str, str] = field(default_factory=dict)
+
+    def get_database_id_for_added_element(self, abstract_id: str) -> str:
+        return self.added_element_db_id_map.get(abstract_id, abstract_id)
+
+    def has_element_been_added(self, identifier: str) -> bool:
+        return identifier in self.added_element_db_id_map
+
+    @property
+    def added_vertices(self) -> list[VertexToAdd]:
+        return [v for v in self.vertices_to_add if self.has_element_been_added(v.identifier)]
+
+    @property
+    def added_edges(self) -> list[EdgeToAdd]:
+        return [e for e in self.edges_to_add if self.has_element_been_added(e.identifier)]
+
+    @property
+    def deleted_vertices(self) -> list[VertexToDelete]:
+        return [v for v in self.vertices_to_delete if v.db_id in self.deleted_db_ids]
+
+    @property
+    def deleted_edges(self) -> list[EdgeToDelete]:
+        return [e for e in self.edges_to_delete if e.db_id in self.deleted_db_ids]
+
+    def drop_added_db_ids(self, db_ids_to_drop: set[str]) -> None:
+        self.added_element_db_id_map = {
+            k: v for k, v in self.added_element_db_id_map.items() if v not in db_ids_to_drop
+        }
+
+    def drop_deleted_db_ids(self, db_ids_to_drop: set[str]) -> None:
+        self.deleted_db_ids -= db_ids_to_drop

infrahub/patch/plan_reader.py

@@ -0,0 +1,107 @@
+import json
+from pathlib import Path
+from typing import Generator
+
+from .constants import PatchPlanFilename
+from .models import EdgeToAdd, EdgeToDelete, EdgeToUpdate, PatchPlan, VertexToAdd, VertexToDelete, VertexToUpdate
+
+
+class PatchPlanReader:
+    def read(self, patch_plan_directory: Path) -> PatchPlan:
+        vertices_to_add = self._read_vertices_to_add(patch_plan_directory=patch_plan_directory)
+        vertices_to_delete = self._read_vertices_to_delete(patch_plan_directory=patch_plan_directory)
+        vertices_to_update = self._read_vertices_to_update(patch_plan_directory=patch_plan_directory)
+        edges_to_add = self._read_edges_to_add(patch_plan_directory=patch_plan_directory)
+        edges_to_delete = self._read_edges_to_delete(patch_plan_directory=patch_plan_directory)
+        edges_to_update = self._read_edges_to_update(patch_plan_directory=patch_plan_directory)
+        added_node_db_id_map = self._read_added_node_db_id_map(patch_plan_directory=patch_plan_directory)
+        deleted_db_ids = self._read_deleted_db_ids(patch_plan_directory=patch_plan_directory)
+        reverted_deleted_db_id_map = self._read_reverted_deleted_db_id_map(patch_plan_directory=patch_plan_directory)
+
+        return PatchPlan(
+            name="none",
+            vertices_to_add=vertices_to_add,
+            vertices_to_delete=vertices_to_delete,
+            vertices_to_update=vertices_to_update,
+            edges_to_add=edges_to_add,
+            edges_to_delete=edges_to_delete,
+            edges_to_update=edges_to_update,
+            added_element_db_id_map=added_node_db_id_map or {},
+            deleted_db_ids=deleted_db_ids or set(),
+            reverted_deleted_db_id_map=reverted_deleted_db_id_map or {},
+        )
+
+    def _read_file_lines(self, patch_file: Path) -> Generator[str | None, None, None]:
+        if not patch_file.exists():
+            return
+        with patch_file.open() as f:
+            yield from f
+
+    def _read_vertices_to_add(self, patch_plan_directory: Path) -> list[VertexToAdd]:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_ADD.value)
+        vertices_to_add: list[VertexToAdd] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                vertices_to_add.append(VertexToAdd(**json.loads(raw_line)))
+        return vertices_to_add
+
+    def _read_vertices_to_update(self, patch_plan_directory: Path) -> list[VertexToUpdate]:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_UPDATE.value)
+        vertices_to_update: list[VertexToUpdate] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                vertices_to_update.append(VertexToUpdate(**json.loads(raw_line)))
+        return vertices_to_update
+
+    def _read_vertices_to_delete(self, patch_plan_directory: Path) -> list[VertexToDelete]:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_DELETE.value)
+        vertices_to_delete: list[VertexToDelete] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                vertices_to_delete.append(VertexToDelete(**json.loads(raw_line)))
+        return vertices_to_delete
+
+    def _read_edges_to_add(self, patch_plan_directory: Path) -> list[EdgeToAdd]:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_ADD.value)
+        edges_to_add: list[EdgeToAdd] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                edges_to_add.append(EdgeToAdd(**json.loads(raw_line)))
+        return edges_to_add
+
+    def _read_edges_to_delete(self, patch_plan_directory: Path) -> list[EdgeToDelete]:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_DELETE.value)
+        edges_to_delete: list[EdgeToDelete] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                edges_to_delete.append(EdgeToDelete(**json.loads(raw_line)))
+        return edges_to_delete
+
+    def _read_edges_to_update(self, patch_plan_directory: Path) -> list[EdgeToUpdate]:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_UPDATE.value)
+        edges_to_update: list[EdgeToUpdate] = []
+        for raw_line in self._read_file_lines(patch_file=file):
+            if raw_line:
+                edges_to_update.append(EdgeToUpdate(**json.loads(raw_line)))
+        return edges_to_update
+
+    def _read_added_node_db_id_map(self, patch_plan_directory: Path) -> dict[str, str] | None:
+        file = patch_plan_directory / Path(PatchPlanFilename.ADDED_DB_IDS.value)
+        if not file.exists():
+            return None
+        added_db_id_json = file.read_text()
+        return json.loads(added_db_id_json)
+
+    def _read_deleted_db_ids(self, patch_plan_directory: Path) -> set[str] | None:
+        file = patch_plan_directory / Path(PatchPlanFilename.DELETED_DB_IDS.value)
+        if not file.exists():
+            return None
+        deleted_db_ids_json = file.read_text()
+        return set(json.loads(deleted_db_ids_json))
+
+    def _read_reverted_deleted_db_id_map(self, patch_plan_directory: Path) -> dict[str, str] | None:
+        file = patch_plan_directory / Path(PatchPlanFilename.REVERTED_DELETED_DB_IDS.value)
+        if not file.exists():
+            return None
+        reverted_deleted_db_id_json = file.read_text()
+        return json.loads(reverted_deleted_db_id_json)

infrahub/patch/plan_writer.py

@@ -0,0 +1,92 @@
+import json
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .constants import PatchPlanFilename
+from .models import EdgeToAdd, EdgeToDelete, EdgeToUpdate, PatchPlan, VertexToAdd, VertexToDelete, VertexToUpdate
+
+
+class PatchPlanWriter:
+    def write(self, patches_directory: Path, patch_plan: PatchPlan) -> Path:
+        timestamp_str = datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+        patch_name = f"patch-{patch_plan.name}-{timestamp_str}"
+        patch_plan_directory = patches_directory / Path(patch_name)
+        if not patch_plan_directory.exists():
+            patch_plan_directory.mkdir(parents=True)
+        if patch_plan.vertices_to_add:
+            self._write_vertices_to_add(
+                patch_plan_directory=patch_plan_directory, vertices_to_add=patch_plan.vertices_to_add
+            )
+        if patch_plan.vertices_to_delete:
+            self._write_vertices_to_delete(
+                patch_plan_directory=patch_plan_directory, vertices_to_delete=patch_plan.vertices_to_delete
+            )
+        if patch_plan.vertices_to_update:
+            self._write_vertices_to_update(
+                patch_plan_directory=patch_plan_directory, vertices_to_update=patch_plan.vertices_to_update
+            )
+        if patch_plan.edges_to_add:
+            self._write_edges_to_add(patch_plan_directory=patch_plan_directory, edges_to_add=patch_plan.edges_to_add)
+        if patch_plan.edges_to_delete:
+            self._write_edges_to_delete(
+                patch_plan_directory=patch_plan_directory, edges_to_delete=patch_plan.edges_to_delete
+            )
+        if patch_plan.edges_to_update:
+            self._write_edges_to_update(
+                patch_plan_directory=patch_plan_directory, edges_to_update=patch_plan.edges_to_update
+            )
+
+        return patch_plan_directory
+
+    def write_added_db_id_map(self, patch_plan_directory: Path, db_id_map: dict[str, str]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.ADDED_DB_IDS.value)
+        file.touch(exist_ok=True)
+        with file.open(mode="w") as f:
+            f.write(json.dumps(db_id_map) + "\n")
+
+    def write_deleted_db_ids(self, patch_plan_directory: Path, deleted_ids: set[str]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.DELETED_DB_IDS.value)
+        file.touch(exist_ok=True)
+        with file.open(mode="w") as f:
+            f.write(json.dumps(list(deleted_ids)) + "\n")
+
+    def write_reverted_deleted_db_id_map(self, patch_plan_directory: Path, db_id_map: dict[str, str]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.REVERTED_DELETED_DB_IDS.value)
+        file.touch(exist_ok=True)
+        with file.open(mode="w") as f:
+            f.write(json.dumps(db_id_map) + "\n")
+
+    def _dataclass_to_json_line(self, dataclass_instance: Any) -> str:
+        return json.dumps(asdict(dataclass_instance)) + "\n"
+
+    def _write_to_file(self, file_path: Path, objects: list[Any]) -> None:
+        file_path.touch(exist_ok=True)
+        with file_path.open(mode="w") as f:
+            for obj in objects:
+                f.write(self._dataclass_to_json_line(obj))
+
+    def _write_vertices_to_add(self, patch_plan_directory: Path, vertices_to_add: list[VertexToAdd]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_ADD.value)
+        self._write_to_file(file_path=file, objects=vertices_to_add)
+
+    def _write_vertices_to_delete(self, patch_plan_directory: Path, vertices_to_delete: list[VertexToDelete]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_DELETE.value)
+        self._write_to_file(file_path=file, objects=vertices_to_delete)
+
+    def _write_vertices_to_update(self, patch_plan_directory: Path, vertices_to_update: list[VertexToUpdate]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.VERTICES_TO_UPDATE.value)
+        self._write_to_file(file_path=file, objects=vertices_to_update)
+
+    def _write_edges_to_add(self, patch_plan_directory: Path, edges_to_add: list[EdgeToAdd]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_ADD.value)
+        self._write_to_file(file_path=file, objects=edges_to_add)
+
+    def _write_edges_to_delete(self, patch_plan_directory: Path, edges_to_delete: list[EdgeToDelete]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_DELETE.value)
+        self._write_to_file(file_path=file, objects=edges_to_delete)
+
+    def _write_edges_to_update(self, patch_plan_directory: Path, edges_to_update: list[EdgeToUpdate]) -> None:
+        file = patch_plan_directory / Path(PatchPlanFilename.EDGES_TO_UPDATE.value)
+        self._write_to_file(file_path=file, objects=edges_to_update)

infrahub/patch/queries/base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from infrahub.database import InfrahubDatabase
+
+from ..models import PatchPlan
+
+
+class PatchQuery(ABC):
+    def __init__(self, db: InfrahubDatabase):
+        self.db = db
+
+    @abstractmethod
+    async def plan(self) -> PatchPlan: ...
+
+    @property
+    @abstractmethod
+    def name(self) -> str: ...

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,
+        )

infrahub/patch/queries/delete_duplicated_edges.py

@@ -0,0 +1,138 @@
+from ..models import EdgeToDelete, EdgeToUpdate, PatchPlan
+from .base import PatchQuery
+
+
+class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
+    """
+    Find duplicated or overlapping edges of the same status, type, and branch to update and delete
+    - one edge will be kept for each pair of nodes and a given status, type, and branch. it will be
+        updated to have the earliest "from" and "to" times in this group
+    - all the other duplicate/overlapping edges will be deleted
+    """
+
+    @property
+    def name(self) -> str:
+        return "delete-duplicated-edges"
+
+    async def plan(self) -> PatchPlan:
+        query = """
+// ------------
+// Find node pairs that have duplicate edges
+// ------------
+MATCH (node_with_dup_edges:Node)-[edge]->(peer)
+WITH node_with_dup_edges, type(edge) AS edge_type, edge.status AS edge_status, edge.branch AS edge_branch, peer, count(*) AS num_dup_edges
+WHERE num_dup_edges > 1
+WITH DISTINCT node_with_dup_edges, edge_type, edge_branch, peer
+CALL {
+    // ------------
+    // Get the earliest active and deleted edges for this branch
+    // ------------
+    WITH node_with_dup_edges, edge_type, edge_branch, peer
+    MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
+    WHERE type(active_edge) = edge_type
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_edge
+    ORDER BY active_edge.from ASC
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, head(collect(active_edge.from)) AS active_from
+    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]->(peer)
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_edge
+    ORDER BY deleted_edge.from ASC
+    WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, head(collect(deleted_edge.from)) AS deleted_from
+    // ------------
+    // Plan one active edge update with correct from and to times
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from
+        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        WHERE type(active_e) = edge_type
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from, active_e
+        ORDER BY %(id_func_name)s(active_e)
+        LIMIT 1
+        WITH active_e, properties(active_e) AS before_props, {from: active_from, to: deleted_from} AS prop_updates
+        RETURN [
+            {
+                db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
+            }
+        ] AS active_edges_to_update
+    }
+    // ------------
+    // Plan deletes for all the other active edges of this type on this branch
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer
+        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        WHERE type(active_e) = edge_type
+        WITH node_with_dup_edges, peer, active_e
+        ORDER BY %(id_func_name)s(active_e)
+        SKIP 1
+        RETURN collect(
+            {
+                db_id: %(id_func_name)s(active_e),
+                from_id: %(id_func_name)s(node_with_dup_edges),
+                to_id: %(id_func_name)s(peer),
+                edge_type: type(active_e),
+                before_props: properties(active_e)
+            }
+        ) AS active_edges_to_delete
+    }
+    // ------------
+    // Plan one deleted edge update with correct from time
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from
+        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        WHERE type(deleted_e) = edge_type
+        WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from, deleted_e
+        ORDER BY %(id_func_name)s(deleted_e)
+        LIMIT 1
+        WITH deleted_e, properties(deleted_e) AS before_props, {from: deleted_from} AS prop_updates
+        RETURN [
+            {
+                db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
+            }
+        ] AS deleted_edges_to_update
+    }
+    // ------------
+    // Plan deletes for all the other deleted edges of this type on this branch
+    // ------------
+    CALL {
+        WITH node_with_dup_edges, edge_type, edge_branch, peer
+        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        WHERE type(deleted_e) = edge_type
+        WITH node_with_dup_edges, peer, deleted_e
+        ORDER BY %(id_func_name)s(deleted_e)
+        SKIP 1
+        RETURN collect(
+            {
+                db_id: %(id_func_name)s(deleted_e),
+                from_id: %(id_func_name)s(node_with_dup_edges),
+                to_id: %(id_func_name)s(peer),
+                edge_type: type(deleted_e),
+                before_props: properties(deleted_e)
+            }
+        ) AS deleted_edges_to_delete
+    }
+    RETURN
+        active_edges_to_update + deleted_edges_to_update AS edges_to_update,
+        active_edges_to_delete + deleted_edges_to_delete AS edges_to_delete
+}
+RETURN edges_to_update, edges_to_delete
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(query=query)
+        edges_to_delete: list[EdgeToDelete] = []
+        edges_to_update: list[EdgeToUpdate] = []
+        for result in results:
+            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_update in result.get("edges_to_update"):
+                prop_updates = serial_edge_to_update["prop_updates"]
+                if prop_updates:
+                    serial_edge_to_update["after_props"] = serial_edge_to_update["before_props"] | prop_updates
+                    del serial_edge_to_update["prop_updates"]
+                edge_to_update = EdgeToUpdate(**serial_edge_to_update)
+                edges_to_update.append(edge_to_update)
+        return PatchPlan(
+            name=self.name,
+            edges_to_delete=edges_to_delete,
+            edges_to_update=edges_to_update,
+        )