infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/changelog/models.py

@@ -13,6 +13,8 @@ if TYPE_CHECKING:
     from infrahub.core.manager import RelationshipSchema
     from infrahub.core.query.relationship import RelationshipPeerData
     from infrahub.core.relationship.model import Relationship
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
 
 
@@ -463,37 +465,198 @@ class RelationshipChangelogGetter:
         These will typically include updates to relationships on other nodes.
         """
         schema_branch = self._db.schema.get_schema_branch(name=self._branch.name)
-        node_schema = schema_branch.get(name=primary_changelog.node_kind)
+        node_schema = schema_branch.get(name=primary_changelog.node_kind, duplicate=False)
         secondaries: list[NodeChangelog] = []
 
         for relationship in primary_changelog.relationships.values():
-            rel_schema = node_schema.get_relationship(name=relationship.name)
             if isinstance(relationship, RelationshipCardinalityOneChangelog):
-                # For now this code only looks at the scenario when a cardinality=one relationship
-                # is added to a node and it has a cardinality=many relationship coming back from
-                # another node, it will be expanded to include all variations.
-                if relationship.peer_status == DiffAction.ADDED:
-                    peer_schema = schema_branch.get(name=str(relationship.peer_kind))
-                    peer_relation = peer_schema.get_relationship_by_identifier(
-                        id=str(rel_schema.identifier), raise_on_error=False
+                secondaries.extend(
+                    self._parse_cardinality_one_relationship(
+                        relationship=relationship,
+                        node_schema=node_schema,
+                        primary_changelog=primary_changelog,
+                        schema_branch=schema_branch,
                     )
-                    if peer_relation:
-                        node_changelog = NodeChangelog(
-                            node_id=str(relationship.peer_id),
-                            node_kind=str(relationship.peer_kind),
-                            display_label="n/a",
+                )
+            elif isinstance(relationship, RelationshipCardinalityManyChangelog):
+                secondaries.extend(
+                    self._parse_cardinality_many_relationship(
+                        relationship=relationship,
+                        node_schema=node_schema,
+                        primary_changelog=primary_changelog,
+                        schema_branch=schema_branch,
+                    )
+                )
+
+        return secondaries
+
+    def _parse_cardinality_one_relationship(
+        self,
+        relationship: RelationshipCardinalityOneChangelog,
+        node_schema: MainSchemaTypes,
+        primary_changelog: NodeChangelog,
+        schema_branch: SchemaBranch,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        rel_schema = node_schema.get_relationship(name=relationship.name)
+
+        if relationship.peer_status == DiffAction.ADDED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind), duplicate=False)
+            secondaries.extend(
+                self._process_added_peers(
+                    peer_id=str(relationship.peer_id),
+                    peer_kind=str(relationship.peer_kind),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        elif relationship.peer_status == DiffAction.UPDATED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind), duplicate=False)
+            secondaries.extend(
+                self._process_added_peers(
+                    peer_id=str(relationship.peer_id),
+                    peer_kind=str(relationship.peer_kind),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+            secondaries.extend(
+                self._process_removed_peers(
+                    peer_schema=peer_schema,
+                    peer_id=str(relationship.peer_id_previous),
+                    peer_kind=str(relationship.peer_kind_previous),
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        elif relationship.peer_status == DiffAction.REMOVED:
+            peer_schema = schema_branch.get(name=str(relationship.peer_kind_previous), duplicate=False)
+
+            secondaries.extend(
+                self._process_removed_peers(
+                    peer_id=str(relationship.peer_id_previous),
+                    peer_kind=str(relationship.peer_kind_previous),
+                    peer_schema=peer_schema,
+                    rel_schema=rel_schema,
+                    primary_changelog=primary_changelog,
+                )
+            )
+
+        return secondaries
+
+    def _parse_cardinality_many_relationship(
+        self,
+        relationship: RelationshipCardinalityManyChangelog,
+        node_schema: MainSchemaTypes,
+        primary_changelog: NodeChangelog,
+        schema_branch: SchemaBranch,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        rel_schema = node_schema.get_relationship(name=relationship.name)
+
+        for peer in relationship.peers:
+            if peer.peer_status == DiffAction.ADDED:
+                peer_schema = schema_branch.get(name=peer.peer_kind)
+                secondaries.extend(
+                    self._process_added_peers(
+                        peer_id=peer.peer_id,
+                        peer_kind=peer.peer_kind,
+                        peer_schema=peer_schema,
+                        rel_schema=rel_schema,
+                        primary_changelog=primary_changelog,
+                    )
+                )
+
+            elif peer.peer_status == DiffAction.REMOVED:
+                peer_schema = schema_branch.get(name=peer.peer_kind)
+                secondaries.extend(
+                    self._process_removed_peers(
+                        peer_id=peer.peer_id,
+                        peer_kind=peer.peer_kind,
+                        peer_schema=peer_schema,
+                        rel_schema=rel_schema,
+                        primary_changelog=primary_changelog,
+                    )
+                )
+
+        return secondaries
+
+    def _process_added_peers(
+        self,
+        peer_id: str,
+        peer_kind: str,
+        peer_schema: MainSchemaTypes,
+        rel_schema: RelationshipSchema,
+        primary_changelog: NodeChangelog,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
+        if peer_relation:
+            node_changelog = NodeChangelog(
+                node_id=peer_id,
+                node_kind=peer_kind,
+                display_label="n/a",
+            )
+            if peer_relation.cardinality == RelationshipCardinality.ONE:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
+                    name=peer_relation.name,
+                    peer_id=primary_changelog.node_id,
+                    peer_kind=primary_changelog.node_kind,
+                )
+                secondaries.append(node_changelog)
+            elif peer_relation.cardinality == RelationshipCardinality.MANY:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
+                    name=peer_relation.name,
+                    peers=[
+                        RelationshipPeerChangelog(
+                            peer_id=primary_changelog.node_id,
+                            peer_kind=primary_changelog.node_kind,
+                            peer_status=DiffAction.ADDED,
+                        )
+                    ],
+                )
+                secondaries.append(node_changelog)
+
+        return secondaries
+
+    def _process_removed_peers(
+        self,
+        peer_id: str,
+        peer_kind: str,
+        peer_schema: MainSchemaTypes,
+        rel_schema: RelationshipSchema,
+        primary_changelog: NodeChangelog,
+    ) -> list[NodeChangelog]:
+        secondaries: list[NodeChangelog] = []
+        peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
+        if peer_relation:
+            node_changelog = NodeChangelog(
+                node_id=peer_id,
+                node_kind=peer_kind,
+                display_label="n/a",
+            )
+            if peer_relation.cardinality == RelationshipCardinality.ONE:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
+                    name=peer_relation.name,
+                    peer_id_previous=primary_changelog.node_id,
+                    peer_kind_previous=primary_changelog.node_kind,
+                )
+                secondaries.append(node_changelog)
+            elif peer_relation.cardinality == RelationshipCardinality.MANY:
+                node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
+                    name=peer_relation.name,
+                    peers=[
+                        RelationshipPeerChangelog(
+                            peer_id=primary_changelog.node_id,
+                            peer_kind=primary_changelog.node_kind,
+                            peer_status=DiffAction.REMOVED,
                         )
-                        if peer_relation.cardinality == RelationshipCardinality.MANY:
-                            node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
-                                name=peer_relation.name,
-                                peers=[
-                                    RelationshipPeerChangelog(
-                                        peer_id=primary_changelog.node_id,
-                                        peer_kind=primary_changelog.node_kind,
-                                        peer_status=DiffAction.ADDED,
-                                    )
-                                ],
-                            )
-                            secondaries.append(node_changelog)
+                    ],
+                )
+                secondaries.append(node_changelog)
 
         return secondaries

infrahub/core/constants/__init__.py

@@ -52,7 +52,7 @@ class EventType(InfrahubStringEnum):
     BRANCH_MERGED = f"{EVENT_NAMESPACE}.branch.merged"
     BRANCH_REBASED = f"{EVENT_NAMESPACE}.branch.rebased"
 
-    SCHEMA_UPDATED = f"{EVENT_NAMESPACE}.schema.update"
+    SCHEMA_UPDATED = f"{EVENT_NAMESPACE}.schema.updated"
 
     NODE_CREATED = f"{EVENT_NAMESPACE}.node.created"
     NODE_UPDATED = f"{EVENT_NAMESPACE}.node.updated"
@@ -66,6 +66,10 @@ class EventType(InfrahubStringEnum):
     ARTIFACT_CREATED = f"{EVENT_NAMESPACE}.artifact.created"
     ARTIFACT_UPDATED = f"{EVENT_NAMESPACE}.artifact.updated"
 
+    VALIDATOR_STARTED = f"{EVENT_NAMESPACE}.validator.started"
+    VALIDATOR_PASSED = f"{EVENT_NAMESPACE}.validator.passed"
+    VALIDATOR_FAILED = f"{EVENT_NAMESPACE}.validator.failed"
+
 
 class PermissionLevel(enum.Flag):
     READ = 1

infrahub/core/constants/infrahubkind.py

@@ -11,6 +11,7 @@ ARTIFACTVALIDATOR = "CoreArtifactValidator"
 BASEPERMISSION = "CoreBasePermission"
 CHANGECOMMENT = "CoreChangeComment"
 CHANGETHREAD = "CoreChangeThread"
+CHECK = "CoreCheck"
 CHECKDEFINITION = "CoreCheckDefinition"
 COMMENT = "CoreComment"
 CUSTOMWEBHOOK = "CoreCustomWebhook"
@@ -41,6 +42,7 @@ NODE = "CoreNode"
 NUMBERPOOL = "CoreNumberPool"
 LINEAGEOWNER = "LineageOwner"
 LINEAGESOURCE = "LineageSource"
+OBJECTCOMPONENTTEMPLATE = "CoreObjectComponentTemplate"
 OBJECTPERMISSION = "CoreObjectPermission"
 OBJECTTEMPLATE = "CoreObjectTemplate"
 OBJECTTHREAD = "CoreObjectThread"

infrahub/core/constraint/node/runner.py

@@ -1,8 +1,8 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core.branch import Branch
 from infrahub.core.node import Node
-from infrahub.core.node.constraints.interface import NodeConstraintInterface
+from infrahub.core.node.constraints.grouped_uniqueness import NodeGroupedUniquenessConstraint
 from infrahub.core.relationship.constraints.interface import RelationshipManagerConstraintInterface
 from infrahub.database import InfrahubDatabase
 
@@ -15,21 +15,18 @@ class NodeConstraintRunner:
         self,
         db: InfrahubDatabase,
         branch: Branch,
-        node_constraints: list[NodeConstraintInterface],
+        uniqueness_constraint: NodeGroupedUniquenessConstraint,
         relationship_manager_constraints: list[RelationshipManagerConstraintInterface],
     ) -> None:
         self.db = db
         self.branch = branch
-        self.node_constraints = node_constraints
+        self.uniqueness_constraint = uniqueness_constraint
         self.relationship_manager_constraints = relationship_manager_constraints
 
-    async def check(self, node: Node, field_filters: Optional[list[str]] = None) -> None:
+    async def check(self, node: Node, field_filters: list[str] | None = None) -> None:
         async with self.db.start_session() as db:
             await node.resolve_relationships(db=db)
 
-            for node_constraint in self.node_constraints:
-                await node_constraint.check(node, filters=field_filters)
-
             for relationship_name in node.get_schema().relationship_names:
                 if field_filters and relationship_name not in field_filters:
                     continue
@@ -37,3 +34,7 @@ class NodeConstraintRunner:
                 await relationship_manager.fetch_relationship_ids(db=db, force_refresh=True)
                 for relationship_constraint in self.relationship_manager_constraints:
                     await relationship_constraint.check(relm=relationship_manager, node_schema=node.get_schema())
+
+            # If HFID constraint is the only constraint violated, all other constraints need to have ran before,
+            # as it means there is an existing node that we might want to update in the case of an upsert
+            await self.uniqueness_constraint.check(node, filters=field_filters)

infrahub/core/diff/branch_differ.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -35,12 +35,12 @@ class BranchDiffer:
     def __init__(
         self,
         branch: Branch,
-        origin_branch: Optional[Branch] = None,
+        origin_branch: Branch | None = None,
         branch_only: bool = False,
-        diff_from: Optional[Union[str, Timestamp]] = None,
-        diff_to: Optional[Union[str, Timestamp]] = None,
-        db: Optional[InfrahubDatabase] = None,
-        service: Optional[InfrahubServices] = None,
+        diff_from: str | Timestamp | None = None,
+        diff_to: str | Timestamp | None = None,
+        db: InfrahubDatabase | None = None,
+        service: InfrahubServices | None = None,
     ):
         """_summary_
 
@@ -81,7 +81,7 @@ class BranchDiffer:
 
         # Results organized by Branch
         self._results: dict[str, dict] = defaultdict(lambda: {"nodes": {}, "rels": defaultdict(dict), "files": {}})
-        self._calculated_diff_files_at: Optional[Timestamp] = None
+        self._calculated_diff_files_at: Timestamp | None = None
 
     @property
     def service(self) -> InfrahubServices:
@@ -101,9 +101,9 @@ class BranchDiffer:
         db: InfrahubDatabase,
         branch: Branch,
         branch_only: bool = False,
-        diff_from: Optional[Union[str, Timestamp]] = None,
-        diff_to: Optional[Union[str, Timestamp]] = None,
-        service: Optional[InfrahubServices] = None,
+        diff_from: str | Timestamp | None = None,
+        diff_to: str | Timestamp | None = None,
+        service: InfrahubServices | None = None,
     ) -> Self:
         origin_branch = branch.get_origin_branch()
 

infrahub/core/diff/ipam_diff_parser.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from infrahub.core.constants import DiffAction
 from infrahub.core.constants.database import DatabaseEdgeType
@@ -18,8 +17,8 @@ class ChangedIpamNodeDetails:
     node_uuid: str
     is_address: bool
     is_delete: bool
-    namespace_id: Optional[str]
-    ip_value: Optional[str]
+    namespace_id: str | None
+    ip_value: str | None
 
 
 class IpamDiffParser:
@@ -142,7 +141,7 @@ class IpamDiffParser:
             uuids_missing_data=uuids_missing_data,
         )
 
-    def _get_ip_value(self, node_diff: EnrichedDiffNode) -> Optional[str]:
+    def _get_ip_value(self, node_diff: EnrichedDiffNode) -> str | None:
         ip_attr_diff = None
         for diff_attr in node_diff.attributes:
             if diff_attr.name in {"prefix", "address"}:
@@ -155,7 +154,7 @@ class IpamDiffParser:
                 return diff_property.new_value or diff_property.previous_value
         return None
 
-    def _get_namespace_id(self, node_diff: EnrichedDiffNode) -> Optional[str]:
+    def _get_namespace_id(self, node_diff: EnrichedDiffNode) -> str | None:
         namespace_rel = None
         for diff_rel in node_diff.relationships:
             if diff_rel.name == "ip_namespace":

infrahub/core/diff/model/diff.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -46,8 +46,8 @@ class BaseDiffElement(BaseModel):
 
 
 class ValueElement(BaseDiffElement):
-    previous: Optional[Any] = None
-    new: Optional[Any] = None
+    previous: Any | None = None
+    new: Any | None = None
 
     def __hash__(self) -> int:
         return hash(type(self))
@@ -57,12 +57,12 @@ class PropertyDiffElement(BaseDiffElement):
     branch: str
     type: str
     action: DiffAction
-    path: Optional[str] = None
+    path: str | None = None
     db_id: str = Field(exclude=True)
     rel_id: str = Field(exclude=True)
-    origin_rel_id: Optional[str] = Field(None, exclude=True)
-    value: Optional[ValueElement] = None
-    changed_at: Optional[Timestamp] = None
+    origin_rel_id: str | None = Field(None, exclude=True)
+    value: ValueElement | None = None
+    changed_at: Timestamp | None = None
 
 
 class NodeAttributeDiffElement(BaseDiffElement):
@@ -72,28 +72,28 @@ class NodeAttributeDiffElement(BaseDiffElement):
     action: DiffAction
     db_id: str = Field(exclude=True)
     rel_id: str = Field(exclude=True)
-    origin_rel_id: Optional[str] = Field(None, exclude=True)
-    changed_at: Optional[Timestamp] = None
+    origin_rel_id: str | None = Field(None, exclude=True)
+    changed_at: Timestamp | None = None
     properties: dict[str, PropertyDiffElement]
 
 
 class NodeDiffElement(BaseDiffElement):
-    branch: Optional[str] = None
+    branch: str | None = None
     labels: list[str]
     kind: str
     id: str
     path: str
     action: DiffAction
     db_id: str = Field(exclude=True)
-    rel_id: Optional[str] = Field(None, exclude=True)
-    changed_at: Optional[Timestamp] = None
+    rel_id: str | None = Field(None, exclude=True)
+    changed_at: Timestamp | None = None
     attributes: dict[str, NodeAttributeDiffElement] = Field(default_factory=dict)
 
 
 class RelationshipEdgeNodeDiffElement(BaseDiffElement):
     id: str
-    db_id: Optional[str] = Field(None, exclude=True)
-    rel_id: Optional[str] = Field(None, exclude=True)
+    db_id: str | None = Field(None, exclude=True)
+    rel_id: str | None = Field(None, exclude=True)
     labels: list[str]
     kind: str
 
@@ -106,11 +106,11 @@ class RelationshipDiffElement(BaseDiffElement):
     action: DiffAction
     nodes: dict[str, RelationshipEdgeNodeDiffElement]
     properties: dict[str, PropertyDiffElement]
-    changed_at: Optional[Timestamp] = None
+    changed_at: Timestamp | None = None
     paths: list[str]
     conflict_paths: list[str]
 
-    def get_node_id_by_kind(self, kind: str) -> Optional[str]:
+    def get_node_id_by_kind(self, kind: str) -> str | None:
         ids = [rel.id for rel in self.nodes.values() if rel.kind == kind]
         if ids:
             return ids[0]
@@ -149,11 +149,11 @@ class ModifiedPath(BaseModel):
     node_id: str
     path_type: PathType
     kind: str
-    element_name: Optional[str] = None
-    property_name: Optional[str] = None
-    peer_id: Optional[str] = None
+    element_name: str | None = None
+    property_name: str | None = None
+    peer_id: str | None = None
     action: DiffAction
-    change: Optional[ValueElement] = None
+    change: ValueElement | None = None
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ModifiedPath):
@@ -248,7 +248,7 @@ class DataConflict(ObjectConflict):
     conflict_path: str
     path: str
     path_type: PathType
-    property_name: Optional[str] = None
+    property_name: str | None = None
     change_type: str
     changes: list[BranchChanges] = Field(default_factory=list)
 
@@ -311,7 +311,7 @@ class BranchDiffFile(BaseModel):
 class BranchDiffRepository(BaseModel):
     branch: str
     id: str
-    display_name: Optional[str] = None
+    display_name: str | None = None
     commit_from: str
     commit_to: str
     files: list[BranchDiffFile] = Field(default_factory=list)
@@ -325,14 +325,14 @@ class BranchDiffArtifactStorage(BaseModel):
 class ArtifactTarget(BaseModel):
     id: str
     kind: str
-    display_label: Optional[str] = None
+    display_label: str | None = None
 
 
 class BranchDiffArtifact(BaseModel):
     branch: str
     id: str
-    display_label: Optional[str] = None
+    display_label: str | None = None
     action: DiffAction
-    target: Optional[ArtifactTarget] = None
-    item_new: Optional[BranchDiffArtifactStorage] = None
-    item_previous: Optional[BranchDiffArtifactStorage] = None
+    target: ArtifactTarget | None = None
+    item_new: BranchDiffArtifactStorage | None = None
+    item_previous: BranchDiffArtifactStorage | None = None

infrahub/core/diff/model/path.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import (
     BranchSupportType,
@@ -848,13 +848,13 @@ class DatabasePath:
         return "Node" in self.property_node.labels
 
     @property
-    def peer_id(self) -> Optional[str]:
+    def peer_id(self) -> str | None:
         if not self.property_is_peer:
             return None
         return str(self.property_node.get("uuid"))
 
     @property
-    def peer_kind(self) -> Optional[str]:
+    def peer_kind(self) -> str | None:
         if not self.property_is_peer:
             return None
         return str(self.property_node.get("kind"))

infrahub/core/diff/query/merge.py

@@ -36,6 +36,7 @@ class DiffMergeQuery(Query):
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
         }
+        # ruff: noqa: E501
         query = """
 UNWIND $node_diff_dicts AS node_diff_map
 CALL {
@@ -242,9 +243,11 @@ CALL {
                 CASE
                     WHEN startNode(source_r_rel_2).uuid = r.uuid THEN "r"
                     ELSE "l"
-                END AS r2_dir
+                END AS r2_dir,
+                source_r_rel_1.hierarchy AS r1_hierarchy,
+                source_r_rel_2.hierarchy AS r2_hierarchy
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             CALL {
                 WITH n, rel_name, rel_peer_id, related_rel_status
                 OPTIONAL MATCH (n)
@@ -258,12 +261,12 @@ CALL {
                 SET target_r_rel_1.to = $at
                 SET target_r_rel_2.to = $at
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
             CALL {
-                WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
                 MATCH (p:Node {uuid: rel_peer_id})
                 OPTIONAL MATCH (n)
                     -[r_rel_1:IS_RELATED {branch: $target_branch, status: related_rel_status}]
@@ -274,42 +277,42 @@ CALL {
                 AND (r_rel_1.to >= $at OR r_rel_1.to IS NULL)
                 AND r_rel_2.from <= $at
                 AND (r_rel_2.to >= $at OR r_rel_2.to IS NULL)
-                WITH n, r, r1_dir, r2_dir, p, related_rel_status, r_rel_1, r_rel_2
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, p, related_rel_status, r_rel_1, r_rel_2
                 WHERE r_rel_1 IS NULL
                 AND r_rel_2 IS NULL
                 // ------------------------------
                 // create IS_RELATED relationships with directions maintained from source
                 // ------------------------------
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "r"
                     CREATE (n)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         ->(r)
                 }
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "l"
                     CREATE (n)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         -(r)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "r"
                     CREATE (r)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         ->(p)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "l"
                     CREATE (r)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         -(p)
                 }
             }