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

infrahub/cli/db.py

@@ -54,12 +54,14 @@ from infrahub.services.adapters.message_bus.local import BusSimulator
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
+from .patch import patch_app
 
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
     from infrahub.database import InfrahubDatabase
 
 app = AsyncTyper()
+app.add_typer(patch_app, name="patch")
 
 PERMISSIONS_AVAILABLE = ["read", "write", "admin"]
 

infrahub/cli/patch.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+from infrahub_sdk.async_typer import AsyncTyper
+from rich import print as rprint
+
+from infrahub import config
+from infrahub.patch.edge_adder import PatchPlanEdgeAdder
+from infrahub.patch.edge_deleter import PatchPlanEdgeDeleter
+from infrahub.patch.edge_updater import PatchPlanEdgeUpdater
+from infrahub.patch.plan_reader import PatchPlanReader
+from infrahub.patch.plan_writer import PatchPlanWriter
+from infrahub.patch.queries.base import PatchQuery
+from infrahub.patch.runner import (
+    PatchPlanEdgeDbIdTranslator,
+    PatchRunner,
+)
+from infrahub.patch.vertex_adder import PatchPlanVertexAdder
+from infrahub.patch.vertex_deleter import PatchPlanVertexDeleter
+from infrahub.patch.vertex_updater import PatchPlanVertexUpdater
+
+from .constants import ERROR_BADGE, SUCCESS_BADGE
+
+if TYPE_CHECKING:
+    from infrahub.cli.context import CliContext
+    from infrahub.database import InfrahubDatabase
+
+
+patch_app = AsyncTyper(help="Commands for planning, applying, and reverting database patches")
+
+
+def get_patch_runner(db: InfrahubDatabase) -> PatchRunner:
+    return PatchRunner(
+        plan_writer=PatchPlanWriter(),
+        plan_reader=PatchPlanReader(),
+        edge_db_id_translator=PatchPlanEdgeDbIdTranslator(),
+        vertex_adder=PatchPlanVertexAdder(db=db),
+        vertex_deleter=PatchPlanVertexDeleter(db=db),
+        vertex_updater=PatchPlanVertexUpdater(db=db),
+        edge_adder=PatchPlanEdgeAdder(db=db),
+        edge_deleter=PatchPlanEdgeDeleter(db=db),
+        edge_updater=PatchPlanEdgeUpdater(db=db),
+    )
+
+
+@patch_app.command(name="plan")
+async def plan_patch_cmd(
+    ctx: typer.Context,
+    patch_path: str = typer.Argument(
+        help="Path to the file containing the PatchQuery instance to run. Use Python-style dot paths, such as infrahub.cli.patch.queries.base"
+    ),
+    patch_plans_dir: Path = typer.Option(Path("infrahub-patches"), help="Path to patch plans directory"),  # noqa: B008
+    apply: bool = typer.Option(False, help="Apply the patch immediately after creating it"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Create a plan for a given patch and save it in the patch plans directory to be applied/reverted"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    patch_module = importlib.import_module(patch_path)
+    patch_query_class = None
+    patch_query_class_count = 0
+    for _, cls in inspect.getmembers(patch_module, inspect.isclass):
+        if issubclass(cls, PatchQuery) and cls is not PatchQuery:
+            patch_query_class = cls
+            patch_query_class_count += 1
+
+    patch_query_path = f"{PatchQuery.__module__}.{PatchQuery.__name__}"
+    if patch_query_class is None:
+        rprint(f"{ERROR_BADGE} No subclass of {patch_query_path} found in {patch_path}")
+        raise typer.Exit(1)
+    if patch_query_class_count > 1:
+        rprint(
+            f"{ERROR_BADGE} Multiple subclasses of {patch_query_path} found in {patch_path}. Please only define one per file."
+        )
+        raise typer.Exit(1)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    patch_query_instance = patch_query_class(db=dbdriver)
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        patch_plan_dir = await patch_runner.prepare_plan(patch_query_instance, directory=Path(patch_plans_dir))
+        rprint(f"{SUCCESS_BADGE} Patch plan created at {patch_plan_dir}")
+        if apply:
+            await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+            rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="apply")
+async def apply_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Apply a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+        rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="revert")
+async def revert_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Revert a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    db = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    patch_runner = get_patch_runner(db=db)
+    await patch_runner.revert(patch_plan_directory=patch_plan_dir)
+    rprint(f"{SUCCESS_BADGE} Patch plan successfully reverted")
+
+    await db.close()

infrahub/computed_attribute/models.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from infrahub_sdk.graphql import Query
 from prefect.events.schemas.automations import Automation  # noqa: TC002
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 from typing_extensions import Self
 
 from infrahub.core import registry
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.schema import AttributeSchema, NodeSchema  # noqa: TC001
 from infrahub.core.schema.schema_branch_computed import (  # noqa: TC001
     ComputedAttributeTarget,
     ComputedAttributeTriggerNode,
@@ -309,3 +312,80 @@ class ComputedAttrPythonQueryTriggerDefinition(TriggerBranchDefinition):
         )
 
         return definition
+
+
+class ComputedAttrJinja2GraphQLResponse(BaseModel):
+    node_id: str
+    computed_attribute_value: str | None
+    variables: dict[str, Any] = Field(default_factory=dict)
+
+
+class ComputedAttrJinja2GraphQL(BaseModel):
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    attribute_schema: AttributeSchema = Field(..., description="The computed attribute")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, query_filter: str, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields[self.attribute_schema.name] = {"value": None}
+        query = Query(
+            name="ComputedAttributeFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {query_filter: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[ComputedAttrJinja2GraphQLResponse]:
+        rendered_response: list[ComputedAttrJinja2GraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> ComputedAttrJinja2GraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        computed_attribute = node.get(self.attribute_schema.name, {}).get("value")
+        response = ComputedAttrJinja2GraphQLResponse(node_id=node_id, computed_attribute_value=computed_attribute)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = field_content.get(remainder)
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = related_attribute_content.get(related_value)
+
+        return response

infrahub/computed_attribute/tasks.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from infrahub_sdk.protocols import (
-    CoreNode,  # noqa: TC002
-    CoreTransformPython,
-)
+from infrahub_sdk.protocols import CoreTransformPython
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.client.orchestration import get_client
@@ -28,9 +25,7 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
 
 from .gather import gather_trigger_computed_attribute_jinja2, gather_trigger_computed_attribute_python
-from .models import (
-    PythonTransformTarget,
-)
+from .models import ComputedAttrJinja2GraphQL, ComputedAttrJinja2GraphQLResponse, PythonTransformTarget
 
 if TYPE_CHECKING:
     from infrahub.core.schema.computed_attribute import ComputedAttribute
@@ -167,49 +162,33 @@ async def trigger_update_python_computed_attributes(
     flow_run_name="Update value for computed attribute {attribute_name}",
 )
 async def update_computed_attribute_value_jinja2(
-    branch_name: str, obj: CoreNode, attribute_name: str, template_value: str, service: InfrahubServices
+    branch_name: str,
+    obj: ComputedAttrJinja2GraphQLResponse,
+    node_kind: str,
+    attribute_name: str,
+    template: Jinja2Template,
+    service: InfrahubServices,
 ) -> None:
     log = get_run_logger()
 
-    await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
-
-    jinja_template = Jinja2Template(template=template_value)
-    variables = {}
-    for variable in jinja_template.get_variables():
-        components = variable.split("__")
-        if len(components) == 2:
-            property_name = components[0]
-            property_value = components[1]
-            attribute_property = getattr(obj, property_name)
-            variables[variable] = getattr(attribute_property, property_value)
-        elif len(components) == 3:
-            relationship_name = components[0]
-            property_name = components[1]
-            property_value = components[2]
-            relationship = getattr(obj, relationship_name)
-            try:
-                attribute_property = getattr(relationship.peer, property_name)
-                variables[variable] = getattr(attribute_property, property_value)
-            except ValueError:
-                variables[variable] = ""
-
-    value = await jinja_template.render(variables=variables)
-    existing_value = getattr(obj, attribute_name).value
-    if value == existing_value:
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    value = await template.render(variables=obj.variables)
+    if value == obj.computed_attribute_value:
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")
         return
 
     await service.client.execute_graphql(
         query=UPDATE_ATTRIBUTE,
         variables={
-            "id": obj.id,
-            "kind": obj.get_kind(),
+            "id": obj.node_id,
+            "kind": node_kind,
             "attribute": attribute_name,
             "value": value,
         },
         branch_name=branch_name,
     )
-    log.info(f"Updating computed attribute {obj.get_kind()}.{attribute_name}='{value}' ({obj.id})")
+    log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
 
 
 @flow(
@@ -235,41 +214,43 @@ async def process_jinja2(
         branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
     )
     schema_branch = registry.schema.get_schema_branch(name=target_branch_schema)
-    await service.client.schema.all(branch=branch_name, refresh=True, schema_hash=schema_branch.get_hash())
-
+    node_schema = schema_branch.get_node(name=computed_attribute_kind, duplicate=False)
     computed_macros = [
         attrib
         for attrib in schema_branch.computed_attributes.get_impacted_jinja2_targets(kind=node_kind, updates=updates)
         if attrib.kind == computed_attribute_kind and attrib.attribute.name == computed_attribute_name
     ]
     for computed_macro in computed_macros:
-        found: list[CoreNode] = []
+        found: list[ComputedAttrJinja2GraphQLResponse] = []
+        template_string = "n/a"
+        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
+            template_string = computed_macro.attribute.computed_attribute.jinja2_template
+
+        jinja_template = Jinja2Template(template=template_string)
+        variables = jinja_template.get_variables()
+
+        attribute_graphql = ComputedAttrJinja2GraphQL(
+            node_schema=node_schema, attribute_schema=computed_macro.attribute, variables=variables
+        )
+
         for id_filter in computed_macro.node_filters:
-            filters = {id_filter: object_id}
-            nodes: list[CoreNode] = await service.client.filters(
-                kind=computed_macro.kind,
-                branch=branch_name,
-                prefetch_relationships=True,
-                populate_store=True,
-                **filters,
-            )
-            found.extend(nodes)
+            query = attribute_graphql.render_graphql_query(query_filter=id_filter, filter_id=object_id)
+            response = await service.client.execute_graphql(query=query, branch_name=branch_name)
+            output = attribute_graphql.parse_response(response=response)
+            found.extend(output)
 
         if not found:
             log.debug("No nodes found that requires updates")
 
-        template_string = "n/a"
-        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
-            template_string = computed_macro.attribute.computed_attribute.jinja2_template
-
         batch = await service.client.create_batch()
         for node in found:
             batch.add(
                 task=update_computed_attribute_value_jinja2,
                 branch_name=branch_name,
                 obj=node,
+                node_kind=node_schema.kind,
                 attribute_name=computed_macro.attribute.name,
-                template_value=template_string,
+                template=jinja_template,
                 service=service,
             )
 

infrahub/core/node/__init__.py

@@ -29,6 +29,7 @@ from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
+from ...log import get_logger
 from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
@@ -53,6 +54,8 @@ SchemaProtocol = TypeVar("SchemaProtocol")
 #  -
 # ---------------------------------------------------------------------------------------
 
+log = get_logger()
+
 
 class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
@@ -348,7 +351,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             fields.pop("updated_at")
         for field_name in fields.keys():
             if field_name not in self._schema.valid_input_names:
-                errors.append(ValidationError({field_name: f"{field_name} is not a valid input for {self.get_kind()}"}))
+                log.error(f"{field_name} is not a valid input for {self.get_kind()}")
 
         # Backfill fields with the ones from the template if there's one
         await self.handle_object_template(fields=fields, db=db, errors=errors)

infrahub/core/query/ipam.py

@@ -367,9 +367,11 @@ class IPPrefixReconcileQuery(Query):
             possible_prefix = tmp_prefix.ljust(self.ip_value.max_prefixlen, "0")
             if possible_prefix not in possible_prefix_map:
                 possible_prefix_map[possible_prefix] = max_prefix_len
-        self.params["possible_prefix_and_length_list"] = [
-            [possible_prefix, max_length] for possible_prefix, max_length in possible_prefix_map.items()
-        ]
+        self.params["possible_prefix_and_length_list"] = []
+        self.params["possible_prefix_list"] = []
+        for possible_prefix, max_length in possible_prefix_map.items():
+            self.params["possible_prefix_and_length_list"].append([possible_prefix, max_length])
+            self.params["possible_prefix_list"].append(possible_prefix)
 
         namespace_query = """
         // ------------------
@@ -386,8 +388,7 @@ class IPPrefixReconcileQuery(Query):
             // ------------------
             // Get IP Prefix node by UUID
             // ------------------
-            MATCH (ip_node {uuid: $node_uuid})
-            WHERE "%(ip_kind)s" IN labels(ip_node)
+            MATCH (ip_node:%(ip_kind)s {uuid: $node_uuid})
             """ % {
                 "ip_kind": InfrahubKind.IPADDRESS
                 if isinstance(self.ip_value, IPAddressType)
@@ -487,6 +488,7 @@ class IPPrefixReconcileQuery(Query):
             -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
             WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
             AND av.version = $ip_version
+            AND av.binary_address IN $possible_prefix_list
             AND any(prefix_and_length IN $possible_prefix_and_length_list WHERE av.binary_address = prefix_and_length[0] AND av.prefixlen <= prefix_and_length[1])
             WITH
                 maybe_new_parent,

infrahub/patch/constants.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class PatchPlanFilename(str, Enum):
+    VERTICES_TO_ADD = "vertices_to_add.json"
+    VERTICES_TO_UPDATE = "vertices_to_update.json"
+    VERTICES_TO_DELETE = "vertices_to_delete.json"
+    EDGES_TO_ADD = "edges_to_add.json"
+    EDGES_TO_UPDATE = "edges_to_update.json"
+    EDGES_TO_DELETE = "edges_to_delete.json"
+    ADDED_DB_IDS = "added_db_ids.json"
+    DELETED_DB_IDS = "deleted_db_ids.json"
+    REVERTED_DELETED_DB_IDS = "reverted_deleted_db_ids.json"

infrahub/patch/edge_adder.py

@@ -0,0 +1,64 @@
+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 EdgeToAdd
+
+
+class PatchPlanEdgeAdder:
+    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, edge_type: str, edges_to_add: list[EdgeToAdd]) -> dict[str, str]:
+        query = """
+UNWIND $edges_to_add AS edge_to_add
+MATCH (a) WHERE %(id_func_name)s(a) = edge_to_add.from_id
+MATCH (b) WHERE %(id_func_name)s(b) = edge_to_add.to_id
+CREATE (a)-[e:%(edge_type)s]->(b)
+SET e = edge_to_add.after_props
+RETURN edge_to_add.identifier AS abstract_id, %(id_func_name)s(e) AS db_id
+        """ % {
+            "edge_type": edge_type,
+            "id_func_name": self.db.get_id_function_name(),
+        }
+        edges_to_add_dicts = [asdict(v) for v in edges_to_add]
+        # 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={"edges_to_add": edges_to_add_dicts}, 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,
+        edges_to_add: list[EdgeToAdd],
+    ) -> AsyncGenerator[dict[str, str], None]:
+        """
+        Create edges_to_add on the database.
+        Returns a generator that yields dictionaries mapping EdgeToAdd.identifier to the database-level ID of the newly created edge.
+        """
+        edges_map_queue: dict[str, list[EdgeToAdd]] = defaultdict(list)
+        for edge_to_add in edges_to_add:
+            edges_map_queue[edge_to_add.edge_type].append(edge_to_add)
+            if len(edges_map_queue[edge_to_add.edge_type]) > self.batch_size_limit:
+                yield await self._run_add_query(
+                    edge_type=edge_to_add.edge_type,
+                    edges_to_add=edges_map_queue[edge_to_add.edge_type],
+                )
+                edges_map_queue[edge_to_add.edge_type] = []
+
+        for edge_type, edges_group in edges_map_queue.items():
+            yield await self._run_add_query(edge_type=edge_type, edges_to_add=edges_group)

infrahub/patch/edge_deleter.py

@@ -0,0 +1,33 @@
+from typing import AsyncGenerator
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import EdgeToDelete
+
+
+class PatchPlanEdgeDeleter:
+    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 ()-[e]-()
+WHERE %(id_func_name)s(e) IN $ids_to_delete
+DELETE e
+RETURN %(id_func_name)s(e) 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, edges_to_delete: list[EdgeToDelete]) -> AsyncGenerator[set[str], None]:
+        for i in range(0, len(edges_to_delete), self.batch_size_limit):
+            ids_to_delete = [e.db_id for e in edges_to_delete[i : i + self.batch_size_limit]]
+            yield await self._run_delete_query(ids_to_delete=ids_to_delete)

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)