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

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

@@ -0,0 +1,254 @@
+from pathlib import Path
+
+from .edge_adder import PatchPlanEdgeAdder
+from .edge_deleter import PatchPlanEdgeDeleter
+from .edge_updater import PatchPlanEdgeUpdater
+from .models import EdgeToAdd, EdgeToDelete, EdgeToUpdate, PatchPlan, VertexToAdd, VertexToDelete, VertexToUpdate
+from .plan_reader import PatchPlanReader
+from .plan_writer import PatchPlanWriter
+from .queries.base import PatchQuery
+from .vertex_adder import PatchPlanVertexAdder
+from .vertex_deleter import PatchPlanVertexDeleter
+from .vertex_updater import PatchPlanVertexUpdater
+
+
+class PatchPlanEdgeDbIdTranslator:
+    def translate_to_db_ids(self, patch_plan: PatchPlan) -> None:
+        for edge_to_add in patch_plan.edges_to_add:
+            translated_from_id = patch_plan.get_database_id_for_added_element(abstract_id=edge_to_add.from_id)
+            edge_to_add.from_id = translated_from_id
+            translated_to_id = patch_plan.get_database_id_for_added_element(abstract_id=edge_to_add.to_id)
+            edge_to_add.to_id = translated_to_id
+
+
+class PatchRunner:
+    def __init__(
+        self,
+        plan_writer: PatchPlanWriter,
+        plan_reader: PatchPlanReader,
+        edge_db_id_translator: PatchPlanEdgeDbIdTranslator,
+        vertex_adder: PatchPlanVertexAdder,
+        vertex_updater: PatchPlanVertexUpdater,
+        vertex_deleter: PatchPlanVertexDeleter,
+        edge_adder: PatchPlanEdgeAdder,
+        edge_updater: PatchPlanEdgeUpdater,
+        edge_deleter: PatchPlanEdgeDeleter,
+    ) -> None:
+        self.plan_writer = plan_writer
+        self.plan_reader = plan_reader
+        self.edge_db_id_translator = edge_db_id_translator
+        self.vertex_adder = vertex_adder
+        self.vertex_updater = vertex_updater
+        self.vertex_deleter = vertex_deleter
+        self.edge_adder = edge_adder
+        self.edge_updater = edge_updater
+        self.edge_deleter = edge_deleter
+
+    async def prepare_plan(self, patch_query: PatchQuery, directory: Path) -> Path:
+        patch_plan = await patch_query.plan()
+        return self.plan_writer.write(patches_directory=directory, patch_plan=patch_plan)
+
+    async def apply(self, patch_plan_directory: Path) -> PatchPlan:
+        patch_plan = self.plan_reader.read(patch_plan_directory)
+        await self._apply_vertices_to_add(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._apply_edges_to_add(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        if patch_plan.vertices_to_update:
+            await self.vertex_updater.execute(vertices_to_update=patch_plan.vertices_to_update)
+        await self._apply_edges_to_delete(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._apply_vertices_to_delete(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        if patch_plan.edges_to_update:
+            await self.edge_updater.execute(edges_to_update=patch_plan.edges_to_update)
+        return patch_plan
+
+    async def _apply_vertices_to_add(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.vertices_to_add:
+            return
+        unadded_vertices = [
+            v for v in patch_plan.vertices_to_add if not patch_plan.has_element_been_added(v.identifier)
+        ]
+        try:
+            async for added_element_id_map in self.vertex_adder.execute(vertices_to_add=unadded_vertices):
+                patch_plan.added_element_db_id_map.update(added_element_id_map)
+        finally:
+            # record the added elements so that we do not double-add them if the patch is run again
+            self.plan_writer.write_added_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+            )
+
+    async def _apply_edges_to_add(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.edges_to_add:
+            return
+        self.edge_db_id_translator.translate_to_db_ids(patch_plan=patch_plan)
+        unadded_edges = [e for e in patch_plan.edges_to_add if not patch_plan.has_element_been_added(e.identifier)]
+        try:
+            async for added_element_id_map in self.edge_adder.execute(edges_to_add=unadded_edges):
+                patch_plan.added_element_db_id_map.update(added_element_id_map)
+        finally:
+            # record the added elements so that we do not double-add them if the patch is run again
+            self.plan_writer.write_added_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+            )
+
+    async def _apply_vertices_to_delete(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.vertices_to_delete:
+            return
+        try:
+            async for deleted_ids in self.vertex_deleter.execute(vertices_to_delete=patch_plan.vertices_to_delete):
+                patch_plan.deleted_db_ids |= deleted_ids
+        finally:
+            # record the deleted elements so that we know what to add if the patch is reverted
+            self.plan_writer.write_deleted_db_ids(
+                patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+            )
+
+    async def _apply_edges_to_delete(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.edges_to_delete:
+            return
+        try:
+            async for deleted_ids in self.edge_deleter.execute(edges_to_delete=patch_plan.edges_to_delete):
+                patch_plan.deleted_db_ids |= deleted_ids
+        finally:
+            # record the deleted elements so that we know what to add if the patch is reverted
+            self.plan_writer.write_deleted_db_ids(
+                patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+            )
+
+    async def revert(self, patch_plan_directory: Path) -> PatchPlan:
+        """Invert the PatchPlan to create the complement of every added/updated/deleted element and undo them"""
+        patch_plan = self.plan_reader.read(patch_plan_directory)
+        await self._revert_deleted_vertices(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._revert_deleted_edges(
+            patch_plan=patch_plan,
+            patch_plan_directory=patch_plan_directory,
+        )
+        await self._revert_added_edges(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._revert_added_vertices(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        vertices_to_update = [
+            VertexToUpdate(
+                db_id=vertex_update_to_revert.db_id,
+                before_props=vertex_update_to_revert.after_props,
+                after_props=vertex_update_to_revert.before_props,
+            )
+            for vertex_update_to_revert in patch_plan.vertices_to_update
+        ]
+        if vertices_to_update:
+            await self.vertex_updater.execute(vertices_to_update=vertices_to_update)
+
+        edges_to_update = [
+            EdgeToUpdate(
+                db_id=edge_update_to_revert.db_id,
+                before_props=edge_update_to_revert.after_props,
+                after_props=edge_update_to_revert.before_props,
+            )
+            for edge_update_to_revert in patch_plan.edges_to_update
+        ]
+        if edges_to_update:
+            await self.edge_updater.execute(edges_to_update=edges_to_update)
+        if patch_plan.reverted_deleted_db_id_map:
+            patch_plan.reverted_deleted_db_id_map = {}
+            self.plan_writer.write_reverted_deleted_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.reverted_deleted_db_id_map
+            )
+        return patch_plan
+
+    async def _revert_added_vertices(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        vertices_to_delete = [
+            VertexToDelete(
+                db_id=patch_plan.get_database_id_for_added_element(abstract_id=vertex_add_to_revert.identifier),
+                labels=vertex_add_to_revert.labels,
+                before_props=vertex_add_to_revert.after_props,
+            )
+            for vertex_add_to_revert in patch_plan.added_vertices
+        ]
+        if not vertices_to_delete:
+            return
+        all_deleted_ids: set[str] = set()
+        try:
+            async for deleted_ids in self.vertex_deleter.execute(vertices_to_delete=vertices_to_delete):
+                all_deleted_ids |= deleted_ids
+        finally:
+            if all_deleted_ids:
+                patch_plan.drop_added_db_ids(db_ids_to_drop=all_deleted_ids)
+                self.plan_writer.write_added_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+                )
+
+    async def _revert_deleted_vertices(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        vertices_to_add = [
+            VertexToAdd(
+                labels=vertex_delete_to_revert.labels,
+                after_props=vertex_delete_to_revert.before_props,
+                identifier=vertex_delete_to_revert.db_id,
+            )
+            for vertex_delete_to_revert in patch_plan.deleted_vertices
+        ]
+        if not vertices_to_add:
+            return
+
+        deleted_to_undeleted_db_id_map: dict[str, str] = {}
+        try:
+            async for added_db_id_map in self.vertex_adder.execute(vertices_to_add=vertices_to_add):
+                deleted_to_undeleted_db_id_map.update(added_db_id_map)
+        finally:
+            if deleted_to_undeleted_db_id_map:
+                patch_plan.drop_deleted_db_ids(db_ids_to_drop=set(deleted_to_undeleted_db_id_map.keys()))
+                self.plan_writer.write_deleted_db_ids(
+                    patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+                )
+                patch_plan.reverted_deleted_db_id_map.update(deleted_to_undeleted_db_id_map)
+                self.plan_writer.write_reverted_deleted_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.reverted_deleted_db_id_map
+                )
+
+    async def _revert_added_edges(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        edges_to_delete = [
+            EdgeToDelete(
+                db_id=patch_plan.get_database_id_for_added_element(abstract_id=edge_add_to_revert.identifier),
+                from_id=edge_add_to_revert.from_id,
+                to_id=edge_add_to_revert.to_id,
+                edge_type=edge_add_to_revert.edge_type,
+                before_props=edge_add_to_revert.after_props,
+            )
+            for edge_add_to_revert in patch_plan.added_edges
+        ]
+        if not edges_to_delete:
+            return
+        all_deleted_ids: set[str] = set()
+        try:
+            async for deleted_ids in self.edge_deleter.execute(edges_to_delete=edges_to_delete):
+                all_deleted_ids |= deleted_ids
+        finally:
+            if all_deleted_ids:
+                patch_plan.drop_added_db_ids(db_ids_to_drop=all_deleted_ids)
+                self.plan_writer.write_added_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+                )
+
+    async def _revert_deleted_edges(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        edges_to_add = [
+            EdgeToAdd(
+                identifier=edge_delete_to_revert.db_id,
+                from_id=patch_plan.reverted_deleted_db_id_map.get(
+                    edge_delete_to_revert.from_id, edge_delete_to_revert.from_id
+                ),
+                to_id=patch_plan.reverted_deleted_db_id_map.get(
+                    edge_delete_to_revert.to_id, edge_delete_to_revert.to_id
+                ),
+                edge_type=edge_delete_to_revert.edge_type,
+                after_props=edge_delete_to_revert.before_props,
+            )
+            for edge_delete_to_revert in patch_plan.deleted_edges
+        ]
+        if not edges_to_add:
+            return
+
+        undeleted_ids: set[str] = set()
+        try:
+            async for added_db_id_map in self.edge_adder.execute(edges_to_add=edges_to_add):
+                undeleted_ids |= set(added_db_id_map.keys())
+        finally:
+            if undeleted_ids:
+                patch_plan.drop_deleted_db_ids(db_ids_to_drop=undeleted_ids)
+                self.plan_writer.write_deleted_db_ids(
+                    patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+                )

infrahub/patch/vertex_adder.py

@@ -0,0 +1,61 @@
+from collections import defaultdict
+from dataclasses import asdict
+from typing import AsyncGenerator
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import VertexToAdd
+
+
+class PatchPlanVertexAdder:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_add_query(self, labels: list[str], vertices_to_add: list[VertexToAdd]) -> dict[str, str]:
+        labels_str = ":".join(labels)
+        serial_vertices_to_add: list[dict[str, str | int | bool]] = [asdict(v) for v in vertices_to_add]
+        query = """
+UNWIND $vertices_to_add AS vertex_to_add
+CREATE (v:%(labels)s)
+SET v = vertex_to_add.after_props
+RETURN vertex_to_add.identifier AS abstract_id, %(id_func_name)s(v) AS db_id
+        """ % {
+            "labels": labels_str,
+            "id_func_name": self.db.get_id_function_name(),
+        }
+        # use transaction to make sure we record the results before committing them
+        try:
+            txn_db = self.db.start_transaction()
+            async with txn_db as txn:
+                results = await txn.execute_query(
+                    query=query, params={"vertices_to_add": serial_vertices_to_add}, type=QueryType.WRITE
+                )
+                abstract_to_concrete_id_map: dict[str, str] = {}
+                for result in results:
+                    abstract_id = result.get("abstract_id")
+                    concrete_id = result.get("db_id")
+                    abstract_to_concrete_id_map[abstract_id] = concrete_id
+        finally:
+            await txn_db.close()
+        return abstract_to_concrete_id_map
+
+    async def execute(self, vertices_to_add: list[VertexToAdd]) -> AsyncGenerator[dict[str, str], None]:
+        """
+        Create vertices_to_add on the database.
+        Returns a generator that yields dictionaries mapping VertexToAdd.identifier to the database-level ID of the newly created vertex.
+        """
+        vertices_map_queue: dict[frozenset[str], list[VertexToAdd]] = defaultdict(list)
+        for vertex_to_add in vertices_to_add:
+            frozen_labels = frozenset(vertex_to_add.labels)
+            vertices_map_queue[frozen_labels].append(vertex_to_add)
+            if len(vertices_map_queue[frozen_labels]) > self.batch_size_limit:
+                yield await self._run_add_query(
+                    labels=list(frozen_labels),
+                    vertices_to_add=vertices_map_queue[frozen_labels],
+                )
+                vertices_map_queue[frozen_labels] = []
+
+        for frozen_labels, vertices_group in vertices_map_queue.items():
+            yield await self._run_add_query(labels=list(frozen_labels), vertices_to_add=vertices_group)

infrahub/patch/vertex_deleter.py

@@ -0,0 +1,33 @@
+from typing import AsyncGenerator
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import VertexToDelete
+
+
+class PatchPlanVertexDeleter:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_delete_query(self, ids_to_delete: list[str]) -> set[str]:
+        query = """
+MATCH (n)
+WHERE %(id_func_name)s(n) IN $ids_to_delete
+DETACH DELETE n
+RETURN %(id_func_name)s(n) AS deleted_id
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(
+            query=query, params={"ids_to_delete": ids_to_delete}, type=QueryType.WRITE
+        )
+        deleted_ids: set[str] = set()
+        for result in results:
+            deleted_id = result.get("deleted_id")
+            deleted_ids.add(deleted_id)
+        return deleted_ids
+
+    async def execute(self, vertices_to_delete: list[VertexToDelete]) -> AsyncGenerator[set[str], None]:
+        for i in range(0, len(vertices_to_delete), self.batch_size_limit):
+            ids_to_delete = [v.db_id for v in vertices_to_delete[i : i + self.batch_size_limit]]
+            yield await self._run_delete_query(ids_to_delete=ids_to_delete)