infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b2__py3-none-any.whl

infrahub/dependencies/registry.py

@@ -3,6 +3,7 @@ from .builder.constraint.node.grouped_uniqueness import NodeGroupedUniquenessCon
 from .builder.constraint.node.uniqueness import NodeAttributeUniquenessConstraintDependency
 from .builder.constraint.relationship_manager.count import RelationshipCountConstraintDependency
 from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
 from .builder.constraint.schema.attribute_regex import SchemaAttributeRegexConstraintDependency
@@ -37,6 +38,7 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)
     component_registry.track_dependency(NodeConstraintRunnerDependency)
     component_registry.track_dependency(NodeDeleteValidatorDependency)
     component_registry.track_dependency(IpamKindsGetterDependency)

infrahub/events/models.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 from infrahub import __version__
 from infrahub.auth import AccountSession, AuthType
-from infrahub.context import InfrahubContext  # noqa: TC001
+from infrahub.context import InfrahubContext
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.message_bus import InfrahubMessage, Meta
 from infrahub.worker import WORKER_IDENTITY

infrahub/git/base.py

@@ -162,6 +162,11 @@ class InfrahubRepositoryBase(BaseModel, ABC):
     infrahub_branch_name: str | None = Field(None, description="Infrahub branch on which to sync the remote repository")
     model_config = ConfigDict(arbitrary_types_allowed=True, ignored_types=(Flow, Task))
 
+    def get_client(self) -> InfrahubClient:
+        if self.client is None:
+            raise ValueError("Client is not set")
+        return self.client
+
     @property
     def sdk(self) -> InfrahubClient:
         if self.client:
@@ -445,9 +450,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
         return [Worktree.init(response) for response in responses]
 
-    def get_client(self) -> InfrahubClient:
-        return self.sdk
-
     def get_location(self) -> str:
         if self.location:
             return self.location

infrahub/git/integrator.py

@@ -29,10 +29,12 @@ from infrahub_sdk.schema.repository import (
     InfrahubPythonTransformConfig,
     InfrahubRepositoryConfig,
 )
+from infrahub_sdk.spec.menu import MenuFile
+from infrahub_sdk.spec.object import ObjectFile
 from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.template.exceptions import JinjaTemplateError
 from infrahub_sdk.utils import compare_lists
-from infrahub_sdk.yaml import SchemaFile
+from infrahub_sdk.yaml import InfrahubFile, SchemaFile
 from prefect import flow, task
 from prefect.cache_policies import NONE
 from prefect.logging import get_run_logger
@@ -40,7 +42,7 @@ from pydantic import BaseModel, Field
 from pydantic import ValidationError as PydanticValidationError
 from typing_extensions import Self
 
-from infrahub.core.constants import ArtifactStatus, ContentType, InfrahubKind, RepositorySyncStatus
+from infrahub.core.constants import ArtifactStatus, ContentType, InfrahubKind, RepositoryObjects, RepositorySyncStatus
 from infrahub.core.registry import registry
 from infrahub.events.artifact_action import ArtifactCreatedEvent, ArtifactUpdatedEvent
 from infrahub.events.models import EventMeta
@@ -54,6 +56,7 @@ if TYPE_CHECKING:
     import types
 
     from infrahub_sdk.checks import InfrahubCheck
+    from infrahub_sdk.ctl.utils import YamlFileVar
     from infrahub_sdk.schema.repository import InfrahubRepositoryArtifactDefinitionConfig
     from infrahub_sdk.transforms import InfrahubTransform
 
@@ -159,7 +162,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     async def ensure_location_is_defined(self) -> None:
         if self.location:
             return
-        client = self.get_client()
+        client = self.sdk
         repo = await client.get(
             kind=CoreGenericRepository, name__value=self.name, exclude=["tags", "credential"], raise_when_missing=True
         )
@@ -179,6 +182,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         config_file = await self.get_repository_config(branch_name=infrahub_branch_name, commit=commit)  # type: ignore[misc]
         sync_status = RepositorySyncStatus.IN_SYNC if config_file else RepositorySyncStatus.ERROR_IMPORT
+
         error: Exception | None = None
 
         try:
@@ -189,6 +193,17 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )  # type: ignore[misc]
 
+                await self.import_objects(
+                    branch_name=infrahub_branch_name,
+                    commit=commit,
+                    config_file=config_file,
+                )  # type: ignore[misc]
+                await self.import_objects(
+                    branch_name=infrahub_branch_name,
+                    commit=commit,
+                    config_file=config_file,
+                )  # type: ignore[misc]
+
                 await self.import_all_python_files(  # type: ignore[call-overload]
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )  # type: ignore[misc]
@@ -815,6 +830,80 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             log.info(f"TransformPython {transform_name!r} not found locally, deleting")
             await transform_definition_in_graph[transform_name].delete()
 
+    async def _load_yamlfile_from_disk(self, paths: list[Path], file_type: type[YamlFileVar]) -> list[YamlFileVar]:
+        data_files = file_type.load_from_disk(paths=paths)
+
+        for data_file in data_files:
+            if not data_file.valid or not data_file.content:
+                raise ValueError(f"{data_file.error_message} ({data_file.location})")
+
+        return data_files
+
+    async def _load_objects(
+        self,
+        paths: list[Path],
+        branch: str,
+        file_type: type[InfrahubFile],
+    ) -> None:
+        """Load one or multiple objects files into Infrahub."""
+
+        log = get_run_logger()
+        files = await self._load_yamlfile_from_disk(paths=paths, file_type=file_type)
+
+        for file in files:
+            await file.validate_format(client=self.sdk, branch=branch)
+            schema = await self.sdk.schema.get(kind=file.spec.kind, branch=branch)
+            if not schema.human_friendly_id and not schema.default_filter:
+                raise ValueError(
+                    f"Schemas of objects or menus defined within {file.location} "
+                    "should have a `human_friendly_id` defined to avoid creating duplicated objects."
+                )
+
+        for file in files:
+            log.info(f"Loading objects defined in {file.location}")
+            await file.process(client=self.sdk, branch=branch)
+
+    async def _import_file_paths(
+        self, branch_name: str, commit: str, files_pathes: list[Path], object_type: RepositoryObjects
+    ) -> None:
+        branch_wt = self.get_worktree(identifier=commit or branch_name)
+        file_pathes = [branch_wt.directory / file_path for file_path in files_pathes]
+
+        # We currently assume there can't be concurrent imports, but if so, we might need to clone the client before tracking here.
+        async with self.sdk.start_tracking(
+            identifier=f"group-repo-{object_type.value}-{self.id}",
+            delete_unused_nodes=True,
+            branch=branch_name,
+            group_type="CoreRepositoryGroup",
+            group_params={"content": object_type.value, "repository": str(self.id)},
+        ):
+            file_type = repo_object_type_to_file_type(object_type)
+            await self._load_objects(
+                paths=file_pathes,
+                branch=branch_name,
+                file_type=file_type,
+            )
+
+    @task(name="import-objects", task_run_name="Import Objects", cache_policy=NONE)  # type: ignore[arg-type]
+    async def import_objects(
+        self,
+        branch_name: str,
+        commit: str,
+        config_file: InfrahubRepositoryConfig,
+    ) -> None:
+        await self._import_file_paths(
+            branch_name=branch_name,
+            commit=commit,
+            files_pathes=config_file.objects,
+            object_type=RepositoryObjects.OBJECT,
+        )
+        await self._import_file_paths(
+            branch_name=branch_name,
+            commit=commit,
+            files_pathes=config_file.menus,
+            object_type=RepositoryObjects.MENU,
+        )
+
     @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)  # type: ignore[arg-type]
     async def get_check_definition(
         self,
@@ -1342,3 +1431,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         await self.service.event.send(event=event)
         return ArtifactGenerateResult(changed=True, checksum=checksum, storage_id=storage_id, artifact_id=artifact.id)
+
+
+def repo_object_type_to_file_type(repo_object: RepositoryObjects) -> type[InfrahubFile]:
+    match repo_object:
+        case RepositoryObjects.OBJECT:
+            return ObjectFile
+        case RepositoryObjects.MENU:
+            return MenuFile
+        case _:
+            raise ValueError(f"Unknown repository object type: {repo_object}")

infrahub/graphql/mutations/main.py

@@ -382,7 +382,7 @@ class InfrahubMutationMixin:
         except HFIDViolatedError as exc:
             # Only the HFID constraint has been violated, it means the node exists and we can update without rerunning constraints
             if len(exc.matching_nodes_ids) > 1:
-                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid (database corrupted)") from exc
+                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid") from exc
             node_id = list(exc.matching_nodes_ids)[0]
             node = await NodeManager.get_one(db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True)
             updated_obj, mutation = await cls._call_mutate_update(

infrahub/graphql/mutations/resource_manager.py

@@ -6,15 +6,18 @@ from graphene import Boolean, Field, InputField, InputObjectType, Int, List, Mut
 from graphene.types.generic import GenericScalar
 from typing_extensions import Self
 
-from infrahub.core import registry
+from infrahub.core import protocols, registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.ipam.constants import PrefixMemberType
+from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.database import retry_db_transaction
 from infrahub.exceptions import QueryValidationError, SchemaNotFoundError, ValidationError
+from infrahub.pools.registration import get_branches_with_schema_number_pool
 
 from ..queries.resource_manager import PoolAllocatedNode
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -177,14 +180,16 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.schema.get(name=data["node"].value)
-            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+            schema_node = registry.schema.get(name=data["node"].value)
+            if not schema_node.is_generic_schema and not schema_node.is_node_schema:
                 raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc
 
-        attributes = [attribute for attribute in pool_node.attributes if attribute.name == data["node_attribute"].value]
+        attributes = [
+            attribute for attribute in schema_node.attributes if attribute.name == data["node_attribute"].value
+        ]
         if not attributes:
             raise ValidationError(input_value="The selected attribute doesn't exist in the selected model")
 
@@ -192,9 +197,22 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         if attribute.kind != "Number":
             raise ValidationError(input_value="The selected attribute is not of the kind Number")
 
-        if data["start_range"].value > data["end_range"].value:
+        start_range = data["start_range"].value
+        end_range = data["end_range"].value
+        if start_range > end_range:
             raise ValidationError(input_value="start_range can't be larger than end_range")
 
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            raise ValidationError(
+                input_value="The selected attribute parameters are not of the kind NumberAttributeParameters"
+            )
+
+        if attribute.parameters.min_value is not None and start_range < attribute.parameters.min_value:
+            raise ValidationError(input_value="start_range can't be less than min_value")
+
+        if attribute.parameters.max_value is not None and end_range > attribute.parameters.max_value:
+            raise ValidationError(input_value="end_range can't be larger than max_value")
+
         return await super().mutate_create(info=info, data=data, branch=branch)
 
     @classmethod
@@ -221,3 +239,33 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
                 raise ValidationError(input_value="start_range can't be larger than end_range")
 
         return number_pool, result
+
+    @classmethod
+    @retry_db_transaction(name="resource_manager_update")
+    async def mutate_delete(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+    ) -> DeleteResult:
+        graphql_context: GraphqlContext = info.context
+
+        number_pool = await NodeManager.find_object(
+            db=graphql_context.db,
+            kind=protocols.CoreNumberPool,
+            id=data.get("id"),
+            hfid=data.get("hfid"),
+            branch=branch,
+        )
+
+        violating_branches = get_branches_with_schema_number_pool(
+            kind=number_pool.node.value, attribute_name=number_pool.node_attribute.value
+        )
+
+        if violating_branches:
+            raise ValidationError(
+                input_value=f"Unable to delete number pool {number_pool.node.value}.{number_pool.node_attribute.value}"
+                f" is in use (branches: {','.join(violating_branches)})"
+            )
+
+        return await super().mutate_delete(info=info, data=data, branch=branch)

infrahub/graphql/queries/resource_manager.py

@@ -306,7 +306,13 @@ async def resolve_number_pool_allocation(
 async def resolve_number_pool_utilization(
     db: InfrahubDatabase, pool: CoreNode, at: Timestamp | str | None, branch: Branch
 ) -> dict:
-    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=at, branch=branch)
+    """
+    Returns a mapping containg utilization info of a number pool.
+    The utilization is calculated as the percentage of the total number of values in the pool that are not excluded for the corresponding attribute.
+    """
+
+    core_number_pool = await registry.manager.get_one_by_id_or_default_filter(db=db, id=pool.id, kind="CoreNumberPool")
+    number_pool = NumberUtilizationGetter(db=db, pool=core_number_pool, at=at, branch=branch)
     await number_pool.load_data()
 
     return {

infrahub/graphql/queries/task.py

@@ -32,6 +32,8 @@ class Tasks(ObjectType):
         workflow: list[str] | None = None,
         related_node__ids: list | None = None,
         q: str | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         related_nodes = related_node__ids or []
         ids = ids or []
@@ -45,6 +47,8 @@ class Tasks(ObjectType):
             statuses=state,
             workflows=workflow,
             related_nodes=related_nodes,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
 
     @staticmethod
@@ -71,6 +75,8 @@ class Tasks(ObjectType):
         branch: str | None = None,
         limit: int | None = None,
         offset: int | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         graphql_context: GraphqlContext = info.context
         fields = await extract_fields_first_node(info)
@@ -87,6 +93,8 @@ class Tasks(ObjectType):
             related_nodes=related_nodes,
             limit=limit,
             offset=offset,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
         prefect_count = prefect_tasks.get("count", None)
         return {
@@ -105,6 +113,8 @@ Task = Field(
     workflow=List(String),
     ids=List(String),
     q=String(required=False),
+    log_limit=Int(required=False),
+    log_offset=Int(required=False),
     resolver=Tasks.resolve,
     required=True,
 )

infrahub/graphql/resolvers/many_relationship.py

@@ -99,7 +99,7 @@ class ManyRelationshipResolver:
         filters = {
             f"{info.field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
 
         response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/resolver.py

@@ -99,7 +99,7 @@ async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     async with graphql_context.db.start_session(read_only=True) as db:
@@ -288,7 +288,7 @@ async def hierarchy_resolver(
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/single_relationship.py

@@ -107,7 +107,7 @@ class SingleRelationshipResolver:
         filters = {
             f"{field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
         async with db.start_session(read_only=True) as dbs:
             objs = await NodeManager.query_peers(

infrahub/graphql/types/task_log.py

@@ -1,4 +1,4 @@
-from graphene import Field, InputObjectType, List, ObjectType, String
+from graphene import Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene.types.uuid import UUID
 
 from .enums import Severity
@@ -26,4 +26,5 @@ class TaskLogNodes(ObjectType):
 
 
 class TaskLogEdge(ObjectType):
-    edges = List(TaskLogNodes)
+    edges = List(NonNull(TaskLogNodes), required=True)
+    count = Int(required=True)

infrahub/menu/menu.py

@@ -57,7 +57,7 @@ default_menu = [
                 name="IPPrefix",
                 label="IP Prefixes",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/prefixes",
+                path="/ipam",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPPREFIX)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -68,7 +68,7 @@ default_menu = [
                 name="IPAddress",
                 label="IP Addresses",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/addresses?ipam-tab=ip-details",
+                path="/ipam/ip_addresses",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPADDRESS)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -79,6 +79,7 @@ default_menu = [
                 name="Namespaces",
                 label="Namespaces",
                 kind=InfrahubKind.IPNAMESPACE,
+                path="/ipam/namespaces",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPNAMESPACE)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -249,16 +250,16 @@ default_menu = [
             MenuItemDefinition(
                 namespace="Builtin",
                 name="TriggerDefinition",
-                label="Triggers",
+                label="Events",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
                 protected=True,
                 section=MenuSection.INTERNAL,
                 order_weight=6000,
                 children=[
                     MenuItemDefinition(
-                        namespace="Core",
+                        namespace="Builtin",
                         name="TriggerRule",
-                        label="Trigger Rules",
+                        label="Rules",
                         kind=InfrahubKind.TRIGGERRULE,
                         icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
                         protected=True,
@@ -266,9 +267,9 @@ default_menu = [
                         order_weight=1000,
                     ),
                     MenuItemDefinition(
-                        namespace="Core",
+                        namespace="Builtin",
                         name="Action",
-                        label="Trigger Actions",
+                        label="Actions",
                         kind=InfrahubKind.ACTION,
                         icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.ACTION)),
                         protected=True,

infrahub/message_bus/operations/refresh/registry.py

@@ -26,6 +26,6 @@ async def rebased_branch(message: messages.RefreshRegistryRebasedBranch, service
 
     async with lock.registry.local_schema_lock():
         service.log.info("Refreshing rebased branch")
-        registry.branch[message.branch] = await registry.branch_object.get_by_name(
-            name=message.branch, db=service.database
-        )
+
+        async with service.database.start_session(read_only=True) as db:
+            registry.branch[message.branch] = await registry.branch_object.get_by_name(name=message.branch, db=db)

infrahub/patch/queries/delete_duplicated_edges.py

@@ -4,7 +4,7 @@ from .base import PatchQuery
 
 class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     """
-    Find duplicated or overlapping edges of the same status, type, and branch to update and delete
+    For all Node vertices, 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
@@ -17,9 +17,9 @@ class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     async def plan(self) -> PatchPlan:
         query = """
 // ------------
-// Find node pairs that have duplicate edges
+// Find vertex pairs that have duplicate edges
 // ------------
-MATCH (node_with_dup_edges:Node)-[edge]->(peer)
+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
@@ -27,12 +27,12 @@ CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
     // ------------
     // Get the earliest active and deleted edges for this branch
     // ------------
-    MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
+    OPTIONAL 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)
+    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
@@ -40,71 +40,82 @@ CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
     // Plan one active edge update with correct from and to times
     // ------------
     CALL (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)
+        OPTIONAL 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
+        RETURN CASE
+            WHEN active_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS active_edges_to_update
     }
     // ------------
     // Plan deletes for all the other active edges of this type on this branch
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
-        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+        OPTIONAL 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(
-            {
+        WITH CASE
+            WHEN active_e IS NOT NULL THEN {
                 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),
+                from_id: %(id_func_name)s(startNode(active_e)),
+                to_id: %(id_func_name)s(endNode(active_e)),
                 edge_type: type(active_e),
                 before_props: properties(active_e)
             }
-        ) AS active_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+        RETURN collect(serialized_edge) AS active_edges_to_delete
     }
     // ------------
     // Plan one deleted edge update with correct from time
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer, deleted_from) {
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        OPTIONAL 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
+        RETURN CASE
+            WHEN deleted_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS deleted_edges_to_update
     }
     // ------------
     // Plan deletes for all the other deleted edges of this type on this branch
     // ------------
     CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+        OPTIONAL 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(
-            {
+        WITH CASE
+            WHEN deleted_e IS NOT NULL THEN {
                 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),
+                from_id: %(id_func_name)s(startNode(deleted_e)),
+                to_id: %(id_func_name)s(endNode(deleted_e)),
                 edge_type: type(deleted_e),
                 before_props: properties(deleted_e)
             }
-        ) AS deleted_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+
+        RETURN collect(serialized_edge) AS deleted_edges_to_delete
     }
     RETURN
         active_edges_to_update + deleted_edges_to_update AS edges_to_update,