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

infrahub/core/changelog/diff.py

@@ -7,6 +7,8 @@ from infrahub_sdk.utils import str_to_bool
 
 from infrahub.core.constants import DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
+from infrahub.core.diff.model.path import ConflictSelection
+from infrahub.exceptions import SchemaNotFoundError
 
 from .models import (
     AttributeChangelog,
@@ -21,9 +23,11 @@ if TYPE_CHECKING:
     from infrahub.core.diff.model.path import (
         EnrichedDiffAttribute,
         EnrichedDiffNode,
+        EnrichedDiffProperty,
         EnrichedDiffRelationship,
         EnrichedDiffRoot,
     )
+    from infrahub.core.models import SchemaUpdateMigrationInfo
     from infrahub.core.schema import MainSchemaTypes
     from infrahub.database import InfrahubDatabase
 
@@ -36,11 +40,18 @@ class NodeInDiff:
 
 
 class DiffChangelogCollector:
-    def __init__(self, diff: EnrichedDiffRoot, branch: Branch, db: InfrahubDatabase) -> None:
+    def __init__(
+        self,
+        diff: EnrichedDiffRoot,
+        branch: Branch,
+        db: InfrahubDatabase,
+        migration_tracker: MigrationTracker | None = None,
+    ) -> None:
         self._diff = diff
         self._branch = branch
         self._db = db
         self._diff_nodes: dict[str, NodeInDiff]
+        self.migration = migration_tracker or MigrationTracker()
 
     def _populate_diff_nodes(self) -> None:
         self._diff_nodes = {
@@ -61,7 +72,11 @@ class DiffChangelogCollector:
 
     def _process_node(self, node: EnrichedDiffNode) -> NodeChangelog:
         node_changelog = NodeChangelog(node_id=node.uuid, node_kind=node.kind, display_label=node.label)
-        schema = self._db.schema.get(node_changelog.node_kind, branch=self._branch, duplicate=False)
+        try:
+            schema = self._db.schema.get(node_changelog.node_kind, branch=self._branch, duplicate=False)
+        except SchemaNotFoundError:
+            # if the schema has been deleted on self._branch
+            schema = None
         for attribute in node.attributes:
             self._process_node_attribute(node=node_changelog, attribute=attribute, schema=schema)
 
@@ -71,49 +86,59 @@ class DiffChangelogCollector:
         return node_changelog
 
     def _process_node_attribute(
-        self, node: NodeChangelog, attribute: EnrichedDiffAttribute, schema: MainSchemaTypes
+        self, node: NodeChangelog, attribute: EnrichedDiffAttribute, schema: MainSchemaTypes | None
     ) -> None:
-        try:
-            schema_attribute = schema.get_attribute(name=attribute.name)
-            attribute_kind = schema_attribute.kind
-        except ValueError:
-            # This would currently happen if there has been a schema migration as part of the merge
-            # then we don't have access to the attribute kind
+        if schema is None:
             attribute_kind = "n/a"
+        else:
+            try:
+                schema_attribute = schema.get_attribute(name=attribute.name)
+                attribute_kind = schema_attribute.kind
+            except ValueError:
+                # This would currently happen if there has been a schema migration as part of the merge
+                # then we don't have access to the attribute kind
+                attribute_kind = "n/a"
 
-        changelog_attribute = AttributeChangelog(name=attribute.name, kind=attribute_kind)
+        changelog_attribute = AttributeChangelog(
+            name=self.migration.get_attribute_name(node=node, attribute=attribute), kind=attribute_kind
+        )
         for attr_property in attribute.properties:
             match attr_property.property_type:
                 case DatabaseEdgeType.HAS_VALUE:
                     # TODO deserialize correct value type from string
-                    changelog_attribute.value = attr_property.new_value
-                    changelog_attribute.value_previous = attr_property.previous_value
+                    if _keep_branch_update(diff_property=attr_property):
+                        changelog_attribute.set_value(value=attr_property.new_value)
+                        changelog_attribute.set_value_previous(value=attr_property.previous_value)
                 case DatabaseEdgeType.IS_PROTECTED:
-                    changelog_attribute.add_property(
-                        name="is_protected",
-                        value_current=self._convert_string_boolean_value(value=attr_property.new_value),
-                        value_previous=self._convert_string_boolean_value(value=attr_property.previous_value),
-                    )
+                    if _keep_branch_update(diff_property=attr_property):
+                        changelog_attribute.add_property(
+                            name="is_protected",
+                            value_current=self._convert_string_boolean_value(value=attr_property.new_value),
+                            value_previous=self._convert_string_boolean_value(value=attr_property.previous_value),
+                        )
                 case DatabaseEdgeType.IS_VISIBLE:
-                    changelog_attribute.add_property(
-                        name="is_visible",
-                        value_current=self._convert_string_boolean_value(value=attr_property.new_value),
-                        value_previous=self._convert_string_boolean_value(value=attr_property.previous_value),
-                    )
+                    if _keep_branch_update(diff_property=attr_property):
+                        changelog_attribute.add_property(
+                            name="is_visible",
+                            value_current=self._convert_string_boolean_value(value=attr_property.new_value),
+                            value_previous=self._convert_string_boolean_value(value=attr_property.previous_value),
+                        )
                 case DatabaseEdgeType.HAS_SOURCE:
-                    changelog_attribute.add_property(
-                        name="source",
-                        value_current=attr_property.new_value,
-                        value_previous=attr_property.previous_value,
-                    )
+                    if _keep_branch_update(diff_property=attr_property):
+                        changelog_attribute.add_property(
+                            name="source",
+                            value_current=attr_property.new_value,
+                            value_previous=attr_property.previous_value,
+                        )
                 case DatabaseEdgeType.HAS_OWNER:
-                    changelog_attribute.add_property(
-                        name="owner",
-                        value_current=attr_property.new_value,
-                        value_previous=attr_property.previous_value,
-                    )
+                    if _keep_branch_update(diff_property=attr_property):
+                        changelog_attribute.add_property(
+                            name="owner",
+                            value_current=attr_property.new_value,
+                            value_previous=attr_property.previous_value,
+                        )
 
-        node.attributes[attribute.name] = changelog_attribute
+        node.add_attribute(attribute=changelog_attribute)
 
     def _process_node_relationship(self, node: NodeChangelog, relationship: EnrichedDiffRelationship) -> None:
         match relationship.cardinality:
@@ -170,7 +195,7 @@ class DiffChangelogCollector:
                             value_previous=rel_prop.previous_value,
                         )
 
-        node.add_relationship(relationship=changelog_rel)
+        node.add_relationship(relationship_changelog=changelog_rel)
 
     def _convert_string_boolean_value(self, value: str | None) -> bool | None:
         """Convert string based boolean for is_protected and is_visible."""
@@ -220,7 +245,7 @@ class DiffChangelogCollector:
 
             changelog_rel.peers.append(peer_log)
 
-        node.add_relationship(relationship=changelog_rel)
+        node.add_relationship(relationship_changelog=changelog_rel)
 
     def collect_changelogs(self) -> Sequence[tuple[DiffAction, NodeChangelog]]:
         self._populate_diff_nodes()
@@ -229,4 +254,38 @@ class DiffChangelogCollector:
             for node in self._diff.nodes
             if node.action != DiffAction.UNCHANGED
         ]
-        return changelogs
+        return [(action, node_changelog) for action, node_changelog in changelogs if node_changelog.has_changes]
+
+
+def _keep_branch_update(diff_property: EnrichedDiffProperty) -> bool:
+    if diff_property.conflict and diff_property.conflict.selected_branch == ConflictSelection.BASE_BRANCH:
+        return False
+    return True
+
+
+class MigrationTracker:
+    """Keeps track of schema updates that happened as part of a migration"""
+
+    def __init__(self, migrations: list[SchemaUpdateMigrationInfo] | None = None) -> None:
+        # A dictionary of Node kind, previous attribute name and new attribute
+        # {"TestPerson": {"old_attribute_name": "new_attribute_name"}}
+        self._migrations_attribute_map: dict[str, dict[str, str]] = {}
+
+        migrations = migrations or []
+        for migration in migrations:
+            if migration.migration_name == "attribute.name.update":
+                if migration.path.schema_kind not in self._migrations_attribute_map:
+                    self._migrations_attribute_map[migration.path.schema_kind] = {}
+                if migration.path.property_name and migration.path.field_name:
+                    self._migrations_attribute_map[migration.path.schema_kind][migration.path.property_name] = (
+                        migration.path.field_name
+                    )
+
+    def get_attribute_name(self, node: NodeChangelog, attribute: EnrichedDiffAttribute) -> str:
+        """Return the current name of the requested attribute"""
+        if node.node_kind not in self._migrations_attribute_map:
+            return attribute.name
+        if attribute.name not in self._migrations_attribute_map[node.node_kind]:
+            return attribute.name
+
+        return self._migrations_attribute_map[node.node_kind][attribute.name]

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
 
 
@@ -75,6 +77,18 @@ class AttributeChangelog(BaseModel):
             return True
         return False
 
+    def set_value(self, value: Any) -> None:
+        if isinstance(value, str) and value == NULL_VALUE:
+            self.value = None
+            return
+        self.value = value
+
+    def set_value_previous(self, value: Any) -> None:
+        if isinstance(value, str) and value == NULL_VALUE:
+            self.value_previous = None
+            return
+        self.value_previous = value
+
     @field_validator("value", "value_previous")
     @classmethod
     def convert_null_values(cls, value: Any) -> Any:
@@ -129,8 +143,8 @@ class RelationshipCardinalityOneChangelog(BaseModel):
     def set_parent(self, parent_id: str, parent_kind: str) -> None:
         self._parent = ChangelogRelatedNode(node_id=parent_id, node_kind=parent_kind)
 
-    def set_parent_from_relationship(self, relationship: Relationship) -> None:
-        if relationship.schema.kind == RelationshipKind.PARENT:
+    def set_parent_from_relationship(self, rel_kind: RelationshipKind) -> None:
+        if rel_kind == RelationshipKind.PARENT:
             if (
                 self.peer_status in [DiffAction.ADDED, DiffAction.UNCHANGED, DiffAction.UPDATED]
                 and self.peer_id
@@ -304,17 +318,18 @@ class NodeChangelog(BaseModel):
             )
 
     def add_attribute(self, attribute: AttributeChangelog) -> None:
-        self.attributes[attribute.name] = attribute
+        if attribute.has_updates:
+            self.attributes[attribute.name] = attribute
 
     def add_relationship(
-        self, relationship: RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog
+        self, relationship_changelog: RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog
     ) -> None:
-        if isinstance(relationship, RelationshipCardinalityOneChangelog) and relationship.parent:
-            self.add_parent(parent=relationship.parent)
-        if relationship.is_empty:
+        if isinstance(relationship_changelog, RelationshipCardinalityOneChangelog) and relationship_changelog.parent:
+            self.add_parent(parent=relationship_changelog.parent)
+        if relationship_changelog.is_empty:
             return
 
-        self.relationships[relationship.name] = relationship
+        self.relationships[relationship_changelog.name] = relationship_changelog
 
     def create_attribute(self, attribute: BaseAttribute) -> None:
         changelog_attribute = AttributeChangelog(
@@ -382,7 +397,7 @@ class ChangelogRelationshipMapper:
     def _set_cardinality_one_peer(self, relationship: Relationship) -> None:
         self.cardinality_one_relationship.peer_id = relationship.peer_id
         self.cardinality_one_relationship.peer_kind = relationship.get_peer_kind()
-        self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+        self.cardinality_one_relationship.set_parent_from_relationship(rel_kind=relationship.schema.kind)
 
     def add_parent_from_relationship(self, relationship: Relationship) -> None:
         if self.schema.cardinality == RelationshipCardinality.ONE:
@@ -419,18 +434,16 @@ class ChangelogRelationshipMapper:
                     value_current=getattr(relationship, property_name),
                     value_previous=previous_value,
                 )
-            self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+            self.cardinality_one_relationship.set_parent_from_relationship(rel_kind=relationship.schema.kind)
 
-    def delete_relationship(self, relationship: Relationship) -> None:
+    def delete_relationship(self, peer_id: str, peer_kind: str, rel_schema: RelationshipSchema) -> None:
         if self.schema.cardinality == RelationshipCardinality.ONE:
-            self.cardinality_one_relationship.peer_id_previous = relationship.get_peer_id()
-            self.cardinality_one_relationship.peer_kind_previous = relationship.get_peer_kind()
-            self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+            self.cardinality_one_relationship.peer_id_previous = peer_id
+            self.cardinality_one_relationship.peer_kind_previous = peer_kind
+            self.cardinality_one_relationship.set_parent_from_relationship(rel_kind=rel_schema.kind)
 
         elif self.schema.cardinality == RelationshipCardinality.MANY:
-            self.cardinality_many_relationship.remove_peer(
-                peer_id=relationship.get_peer_id(), peer_kind=relationship.get_peer_kind()
-            )
+            self.cardinality_many_relationship.remove_peer(peer_id=peer_id, peer_kind=peer_kind)
 
     @property
     def changelog(self) -> RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog:
@@ -452,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,
                         )
-                        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
+
+    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,
+                        )
+                    ],
+                )
+                secondaries.append(node_changelog)
 
         return secondaries

infrahub/core/constants/__init__.py

@@ -43,6 +43,33 @@ RESERVED_ATTR_GEN_NAMES = ["type"]
 
 NULL_VALUE = "NULL"
 
+EVENT_NAMESPACE = "infrahub"
+
+
+class EventType(InfrahubStringEnum):
+    BRANCH_CREATED = f"{EVENT_NAMESPACE}.branch.created"
+    BRANCH_DELETED = f"{EVENT_NAMESPACE}.branch.deleted"
+    BRANCH_MERGED = f"{EVENT_NAMESPACE}.branch.merged"
+    BRANCH_REBASED = f"{EVENT_NAMESPACE}.branch.rebased"
+
+    SCHEMA_UPDATED = f"{EVENT_NAMESPACE}.schema.updated"
+
+    NODE_CREATED = f"{EVENT_NAMESPACE}.node.created"
+    NODE_UPDATED = f"{EVENT_NAMESPACE}.node.updated"
+    NODE_DELETED = f"{EVENT_NAMESPACE}.node.deleted"
+
+    GROUP_MEMBER_ADDED = f"{EVENT_NAMESPACE}.group.member_added"
+    GROUP_MEMBER_REMOVED = f"{EVENT_NAMESPACE}.group.member_removed"
+
+    REPOSITORY_UPDATE_COMMIT = f"{EVENT_NAMESPACE}.repository.update_commit"
+
+    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
@@ -60,6 +87,7 @@ class GlobalPermissions(InfrahubStringEnum):
     MANAGE_ACCOUNTS = "manage_accounts"
     MANAGE_PERMISSIONS = "manage_permissions"
     MANAGE_REPOSITORIES = "manage_repositories"
+    OVERRIDE_CONTEXT = "override_context"
 
 
 class PermissionAction(InfrahubStringEnum):

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/constants/schema.py

@@ -1,5 +1,7 @@
 from enum import Enum, Flag, auto
 
+PARENT_CHILD_IDENTIFIER = "parent__child"
+
 
 class FlagProperty(Enum):
     IS_VISIBLE = "is_visible"

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)