infrahub-server 1.6.3__py3-none-any.whl → 1.7.0b0__py3-none-any.whl

infrahub/core/branch/models.py

@@ -6,17 +6,15 @@ from typing import TYPE_CHECKING, Any, Optional, Self, Union, cast
 from pydantic import Field, field_validator
 
 from infrahub.core.branch.enums import BranchStatus
-from infrahub.core.constants import GLOBAL_BRANCH_NAME
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, SYSTEM_USER_ID
 from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.models import SchemaBranchHash  # noqa: TC001
-from infrahub.core.node.standard import StandardNode
+from infrahub.core.node.standard import StandardNode, StandardNodeOrdering
 from infrahub.core.query import Query, QueryType
 from infrahub.core.query.branch import (
     BranchNodeGetListQuery,
     DeleteBranchRelationshipsQuery,
-    GetAllBranchInternalRelationshipQuery,
-    RebaseBranchDeleteRelationshipQuery,
-    RebaseBranchUpdateRelationshipQuery,
+    RebaseBranchQuery,
 )
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
@@ -37,7 +35,6 @@ class Branch(StandardNode):
     origin_branch: str = "main"
     branched_from: Optional[str] = Field(default=None, validate_default=True)
     hierarchy_level: int = 2
-    created_at: Optional[str] = Field(default=None, validate_default=True)
     is_default: bool = False
     is_global: bool = False
     is_protected: bool = False
@@ -93,11 +90,6 @@ class Branch(StandardNode):
             raise RuntimeError(f"branched_from not set for branch {self.name}")
         return self.branched_from
 
-    @field_validator("created_at", mode="before")
-    @classmethod
-    def set_created_at(cls, value: str) -> str:
-        return Timestamp(value).to_string()
-
     def get_created_at(self) -> str:
         if not self.created_at:
             raise RuntimeError(f"created_at not set for branch {self.name}")
@@ -162,10 +154,18 @@ class Branch(StandardNode):
         limit: int = 1000,
         ids: list[str] | None = None,
         name: str | None = None,
+        node_ordering: StandardNodeOrdering | None = None,
         **kwargs: Any,
     ) -> list[Self]:
+        node_ordering = node_ordering or StandardNodeOrdering()
         query: Query = await BranchNodeGetListQuery.init(
-            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs
+            db=db,
+            node_class=cls,
+            ids=ids,
+            node_name=name,
+            limit=limit,
+            node_ordering=node_ordering,
+            **kwargs,
         )
         await query.execute(db=db)
 
@@ -178,10 +178,18 @@ class Branch(StandardNode):
         limit: int = 1000,
         ids: list[str] | None = None,
         name: str | None = None,
+        partial_match: bool = False,
         **kwargs: Any,
     ) -> int:
         query: Query = await BranchNodeGetListQuery.init(
-            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, exclude_global=True, **kwargs
+            db=db,
+            node_class=cls,
+            ids=ids,
+            node_name=name,
+            limit=limit,
+            exclude_global=True,
+            partial_match=partial_match,
+            **kwargs,
         )
         return await query.count(db=db)
 
@@ -208,7 +216,7 @@ class Branch(StandardNode):
 
         return [default_branch, self.name]
 
-    def get_branches_and_times_to_query(self, at: Optional[Union[Timestamp, str]] = None) -> dict[frozenset, str]:
+    def get_branches_and_times_to_query(self, at: Optional[Timestamp] = None) -> dict[frozenset, str]:
         """Return all the names of the branches that are constituing this branch with the associated times excluding the global branch"""
 
         at = Timestamp(at)
@@ -229,7 +237,7 @@ class Branch(StandardNode):
 
     def get_branches_and_times_to_query_global(
         self,
-        at: Optional[Union[Timestamp, str]] = None,
+        at: Optional[Timestamp] = None,
         is_isolated: bool = True,
     ) -> dict[frozenset, str]:
         """Return all the names of the branches that are constituting this branch with the associated times."""
@@ -281,9 +289,9 @@ class Branch(StandardNode):
 
         return start, end
 
-    async def create(self, db: InfrahubDatabase) -> bool:
+    async def create(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> bool:
         self.graph_version = GRAPH_VERSION
-        return await super().create(db=db)
+        return await super().create(db=db, user_id=user_id)
 
     async def delete(self, db: InfrahubDatabase) -> None:
         if self.is_default:
@@ -299,7 +307,7 @@ class Branch(StandardNode):
         await super().delete(db=db)
 
     def get_query_filter_relationships(
-        self, rel_labels: list, at: Optional[Union[Timestamp, str]] = None, include_outside_parentheses: bool = False
+        self, rel_labels: list, at: Optional[Timestamp] = None, include_outside_parentheses: bool = False
     ) -> tuple[list, dict]:
         """
         Generate a CYPHER Query filter based on a list of relationships to query a part of the graph at a specific time and on a specific branch.
@@ -362,7 +370,7 @@ class Branch(StandardNode):
             params[f"{pp}time1"] = at_str
             return filter_str, params
 
-        branches_times = self.get_branches_and_times_to_query_global(at=at_str, is_isolated=is_isolated)
+        branches_times = self.get_branches_and_times_to_query_global(at=at, is_isolated=is_isolated)
 
         for idx, (branch_name, time_to_query) in enumerate(branches_times.items()):
             params[f"{pp}branch{idx}"] = list(branch_name)
@@ -387,8 +395,8 @@ class Branch(StandardNode):
     def get_query_filter_relationships_range(
         self,
         rel_labels: list,
-        start_time: Union[Timestamp, str],
-        end_time: Union[Timestamp, str],
+        start_time: Timestamp,
+        end_time: Timestamp,
         include_outside_parentheses: bool = False,
         include_global: bool = False,
     ) -> tuple[list, dict]:
@@ -468,9 +476,7 @@ class Branch(StandardNode):
 
         return filters, params
 
-    def get_query_filter_range(
-        self, rel_label: list, start_time: Union[Timestamp, str], end_time: Union[Timestamp, str]
-    ) -> tuple[list, dict]:
+    def get_query_filter_range(self, rel_label: list, start_time: Timestamp, end_time: Timestamp) -> tuple[list, dict]:
         """
         Generate a CYPHER Query filter to query a range of values in the graph between start_time and end_time."""
 
@@ -496,67 +502,34 @@ class Branch(StandardNode):
 
         return filters, params
 
-    async def rebase(self, db: InfrahubDatabase, at: Optional[Union[str, Timestamp]] = None) -> None:
+    async def rebase(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> None:
         """Rebase the current Branch with its origin branch"""
 
-        at = Timestamp(at)
-
-        # Find all relationships with the name of the branch
-        # Delete all relationship that have a to date defined in the past
-        # Update the from time on all other relationships
-        # If conflict is set, ignore the one with Drop
+        at = Timestamp()
 
         await self.rebase_graph(db=db, at=at)
 
-        # FIXME, we must ensure that there is no conflict before rebasing a branch
-        #   Otherwise we could endup with a complicated situation
         self.branched_from = at.to_string()
         self.status = BranchStatus.OPEN
-        await self.save(db=db)
+        await self.save(db=db, user_id=user_id)
 
         # Update the branch in the registry after the rebase
         registry.branch[self.name] = self
 
-    async def rebase_graph(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
-        at = Timestamp(at)
+    async def rebase_graph(self, db: InfrahubDatabase, at: Timestamp) -> None:
+        """Rebase all relationships on this branch to a new point in time.
 
-        query = await GetAllBranchInternalRelationshipQuery.init(db=db, branch=self)
-        await query.execute(db=db)
+        This method updates the graph to reflect the state of the branch as if it had been created
+        at the specified timestamp. Relationships are processed as follows:
 
-        rels_to_delete = []
-        rels_to_update = []
-        for result in query.get_results():
-            element_id = result.get("r").element_id
+        - Relationships with no `to` timestamp and `from` <= at: Updated to start from `at`
+        - Relationships with `to` < at: Deleted (ended before rebase point)
+        - Relationships with `to` >= at: Updated to start from `at`
 
-            conflict_status = result.get("r").get("conflict", None)
-            if conflict_status and conflict_status == "drop":
-                rels_to_delete.append(element_id)
-                continue
-
-            time_to_str = result.get("r").get("to", None)
-            time_from_str = result.get("r").get("from")
-            time_from = Timestamp(time_from_str)
-
-            if not time_to_str and time_from_str and time_from <= at:
-                rels_to_update.append(element_id)
-                continue
-
-            if not time_to_str and time_from_str and time_from > at:
-                rels_to_delete.append(element_id)
-                continue
-
-            time_to = Timestamp(time_to_str)
-            if time_to < at:
-                rels_to_delete.append(element_id)
-                continue
-
-            rels_to_update.append(element_id)
-
-        update_query = await RebaseBranchUpdateRelationshipQuery.init(db=db, ids=rels_to_update, at=at)
-        await update_query.execute(db=db)
-
-        delete_query = await RebaseBranchDeleteRelationshipQuery.init(db=db, ids=rels_to_delete, at=at)
-        await delete_query.execute(db=db)
+        Orphaned nodes (nodes with no remaining relationships) are also cleaned up.
+        """
+        query = await RebaseBranchQuery.init(db=db, branch=self, at=at)
+        await query.execute(db=db)
 
 
 registry.branch_object = Branch

infrahub/core/branch/tasks.py

@@ -170,7 +170,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
         migrations = []
         async with lock.registry.global_graph_lock():
             async with db.start_transaction() as dbt:
-                await obj.rebase(db=dbt)
+                await obj.rebase(db=dbt, user_id=context.account.account_id)
                 log.info("Branch successfully rebased")
 
             if obj.has_schema_changes:
@@ -187,7 +187,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
                 )
                 registry.schema.set_schema_branch(name=obj.name, schema=updated_schema)
                 obj.update_schema_hash()
-                await obj.save(db=db)
+                await obj.save(db=db, user_id=context.account.account_id)
 
                 # Execute the migrations
                 migrations = await merger.calculate_migrations(target_schema=updated_schema)
@@ -198,6 +198,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
                         new_schema=candidate_schema,
                         previous_schema=schema_in_main_before,
                         migrations=migrations,
+                        user_id=context.account.account_id,
                     )
                 )
                 for error in errors:
@@ -302,6 +303,7 @@ async def merge_branch(branch: str, context: InfrahubContext, proposed_change_id
                     new_schema=merger.destination_schema,
                     previous_schema=merger.initial_source_schema,
                     migrations=merger.migrations,
+                    user_id=context.account.account_id,
                 )
             )
             for error in errors:
@@ -431,7 +433,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
             new_schema = origin_schema.duplicate(name=obj.name)
             registry.schema.set_schema_branch(name=obj.name, schema=new_schema)
             obj.update_schema_hash()
-            await obj.save(db=db)
+            await obj.save(db=db, user_id=context.account.account_id)
 
             # Add Branch to registry
             registry.branch[obj.name] = obj

infrahub/core/changelog/diff.py

@@ -116,13 +116,6 @@ class DiffChangelogCollector:
                             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:
-                    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:
                     if _keep_branch_update(diff_property=attr_property):
                         changelog_attribute.add_property(
@@ -176,12 +169,6 @@ class DiffChangelogCollector:
                             value_current=self._convert_string_boolean_value(value=rel_prop.new_value),
                             value_previous=self._convert_string_boolean_value(value=rel_prop.previous_value),
                         )
-                    case DatabaseEdgeType.IS_VISIBLE:
-                        changelog_rel.add_property(
-                            name="is_visible",
-                            value_current=self._convert_string_boolean_value(value=rel_prop.new_value),
-                            value_previous=self._convert_string_boolean_value(value=rel_prop.previous_value),
-                        )
                     case DatabaseEdgeType.HAS_OWNER:
                         changelog_rel.add_property(
                             name="owner",
@@ -198,7 +185,7 @@ class DiffChangelogCollector:
         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."""
+        """Convert string based boolean for is_protected."""
         if value is not None:
             return str_to_bool(value)
 
@@ -218,12 +205,6 @@ class DiffChangelogCollector:
             )
             for peer_prop in peer.properties:
                 match peer_prop.property_type:
-                    case DatabaseEdgeType.IS_VISIBLE:
-                        peer_log.add_property(
-                            name="is_visible",
-                            value_current=self._convert_string_boolean_value(value=peer_prop.new_value),
-                            value_previous=self._convert_string_boolean_value(value=peer_prop.previous_value),
-                        )
                     case DatabaseEdgeType.IS_PROTECTED:
                         peer_log.add_property(
                             name="is_protected",

infrahub/core/changelog/models.py

@@ -186,9 +186,6 @@ class RelationshipCardinalityManyChangelog(BaseModel):
         properties["is_protected"] = PropertyChangelog(
             name="is_protected", value=relationship.is_protected, value_previous=None
         )
-        properties["is_visible"] = PropertyChangelog(
-            name="is_visible", value=relationship.is_protected, value_previous=None
-        )
         if owner := getattr(relationship, "owner_id", None):
             properties["owner"] = PropertyChangelog(name="owner", value=owner, value_previous=None)
         if source := getattr(relationship, "source_id", None):
@@ -280,9 +277,6 @@ class NodeChangelog(BaseModel):
             changelog_relationship.add_property(
                 name="is_protected", value_current=relationship.is_protected, value_previous=None
             )
-            changelog_relationship.add_property(
-                name="is_visible", value_current=relationship.is_visible, value_previous=None
-            )
             self.relationships[changelog_relationship.name] = changelog_relationship
         elif relationship.schema.cardinality == RelationshipCardinality.MANY:
             if relationship.schema.name not in self.relationships:
@@ -340,7 +334,6 @@ class NodeChangelog(BaseModel):
         if owner_id := getattr(attribute, "owner_id", None):
             changelog_attribute.add_property(name="owner", value_current=owner_id, value_previous=None)
         changelog_attribute.add_property(name="is_protected", value_current=attribute.is_protected, value_previous=None)
-        changelog_attribute.add_property(name="is_visible", value_current=attribute.is_visible, value_previous=None)
         self.attributes[changelog_attribute.name] = changelog_attribute
 
     def get_related_nodes(self) -> list[ChangelogRelatedNode]:

infrahub/core/constants/__init__.py

@@ -46,6 +46,8 @@ NULL_VALUE = "NULL"
 
 EVENT_NAMESPACE = "infrahub"
 
+SYSTEM_USER_ID = "__system__"
+
 
 class EventType(InfrahubStringEnum):
     BRANCH_CREATED = f"{EVENT_NAMESPACE}.branch.created"
@@ -359,6 +361,21 @@ class AttributeDBNodeType(Flag):
     IPNETWORK = DEFAULT | INDEX_ONLY | IPNETWORK_ONLY
 
 
+class MetadataOptions(Flag):
+    NONE = 0
+    SOURCE = auto()
+    OWNER = auto()
+    LINKED_NODES = SOURCE | OWNER
+    IS_PROTECTED = auto()
+    CREATED_BY = auto()
+    CREATED_AT = auto()
+    UPDATED_BY = auto()
+    UPDATED_AT = auto()
+    TIMESTAMPS = CREATED_AT | UPDATED_AT
+    USERS = CREATED_BY | UPDATED_BY
+    USER_TIMESTAMPS = TIMESTAMPS | USERS
+
+
 RESTRICTED_NAMESPACES: list[str] = [
     "Account",
     "Branch",

infrahub/core/constants/database.py

@@ -8,7 +8,6 @@ class DatabaseEdgeType(Enum):
     HAS_ATTRIBUTE = "HAS_ATTRIBUTE"
     IS_RELATED = "IS_RELATED"
     HAS_VALUE = "HAS_VALUE"
-    IS_VISIBLE = "IS_VISIBLE"
     IS_PROTECTED = "IS_PROTECTED"
     HAS_OWNER = "HAS_OWNER"
     HAS_SOURCE = "HAS_SOURCE"

infrahub/core/constants/schema.py

@@ -4,7 +4,6 @@ PARENT_CHILD_IDENTIFIER = "parent__child"
 
 
 class FlagProperty(Enum):
-    IS_VISIBLE = "is_visible"
     IS_PROTECTED = "is_protected"
 
 

infrahub/core/convert_object_type/repository_conversion.py

@@ -1,6 +1,5 @@
 from infrahub import lock
 from infrahub.core.branch import Branch
-from infrahub.core.constants.infrahubkind import REPOSITORYVALIDATOR, USERVALIDATOR
 from infrahub.core.convert_object_type.object_conversion import (
     ConversionFieldInput,
     convert_object_type,
@@ -8,7 +7,7 @@ from infrahub.core.convert_object_type.object_conversion import (
 )
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
-from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository
+from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository, CoreRepositoryValidator, CoreUserValidator
 from infrahub.core.schema import NodeSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
@@ -35,11 +34,11 @@ async def convert_repository_type(
 
             # Fetch validators before deleting the repository otherwise validator-repository would no longer exist
             user_validators = await NodeManager.query(
-                db=dbt, schema=USERVALIDATOR, prefetch_relationships=True, filters={"repository__id": repository.id}
+                db=dbt, schema=CoreUserValidator, prefetch_relationships=True, filters={"repository__id": repository.id}
             )
             repository_validators = await NodeManager.query(
                 db=dbt,
-                schema=REPOSITORYVALIDATOR,
+                schema=CoreRepositoryValidator,
                 prefetch_relationships=True,
                 filters={"repository__id": repository.id},
             )

infrahub/core/diff/data_check_synchronizer.py

@@ -1,10 +1,11 @@
 from enum import Enum
 
-from infrahub.core.constants import BranchConflictKeep, InfrahubKind
+from infrahub.core.constants import BranchConflictKeep
 from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters
 from infrahub.core.integrity.object_conflict.conflict_recorder import ObjectConflictValidatorRecorder
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange
 from infrahub.database import InfrahubDatabase
 from infrahub.exceptions import SchemaNotFoundError
 from infrahub.proposed_change.constants import ProposedChangeState
@@ -52,7 +53,7 @@ class DiffDataCheckSynchronizer:
         try:
             proposed_changes = await NodeManager.query(
                 db=self.db,
-                schema=InfrahubKind.PROPOSEDCHANGE,
+                schema=CoreProposedChange,
                 filters={"source_branch": enriched_diff.diff_branch_name, "state": ProposedChangeState.OPEN},
             )
         except SchemaNotFoundError:

infrahub/core/diff/enricher/cardinality_one.py

@@ -28,7 +28,7 @@ class DiffCardinalityOneEnricher(DiffEnricherInterface):
      - the peer_id property of the element will be the latest non-null peer ID for this element
      - the element MUST have an EnrichedDiffProperty of property_type=IS_RELATED that correctly records
         the previous and new values of the peer ID for this element
-     - changes to properties (IS_VISIBLE, etc) of a cardinality=one relationship are consolidated as well
+     - changes to properties (IS_PROTECTED, etc) of a cardinality=one relationship are consolidated as well
     """
 
     def __init__(self, db: InfrahubDatabase):

infrahub/core/diff/merger/merger.py

@@ -6,6 +6,7 @@ from infrahub.core import registry
 from infrahub.core.constants import DiffAction
 from infrahub.core.diff.model.path import BranchTrackingId
 from infrahub.core.diff.query.merge import (
+    DiffMergeMetadataQuery,
     DiffMergeMigratedKindsQuery,
     DiffMergePropertiesQuery,
     DiffMergeQuery,
@@ -26,6 +27,8 @@ log = get_logger()
 
 
 class DiffMerger:
+    metadata_batch_size = 500
+
     def __init__(
         self,
         db: InfrahubDatabase,
@@ -39,6 +42,7 @@ class DiffMerger:
         self.db = db
         self.diff_repository = diff_repository
         self.serializer = serializer
+        self._affected_node_uuids: list[str] = []
 
     async def merge_graph(self, at: Timestamp) -> EnrichedDiffRoot:
         tracking_id = BranchTrackingId(name=self.source_branch.name)
@@ -69,6 +73,7 @@ class DiffMerger:
                 # make sure that we use the ADDED db_id if it exists
                 # it will not if a node was migrated and then deleted
                 migrated_kinds_id_map[n.uuid] = n.identifier.db_id
+
         async for node_diff_dicts, property_diff_dicts in self.serializer.serialize_diff(diff=enriched_diff):
             if node_diff_dicts:
                 log.info(f"Merging batch of nodes #{batch_num}")
@@ -105,13 +110,34 @@ class DiffMerger:
             )
             await migrated_merge_query.execute(db=self.db)
 
+        affected_node_uuids = [n.uuid for n in enriched_diff.nodes]
+        self._affected_node_uuids = affected_node_uuids
+        if affected_node_uuids:
+            for i in range(0, len(affected_node_uuids), self.metadata_batch_size):
+                batch_uuids = affected_node_uuids[i : i + self.metadata_batch_size]
+                log.info(f"Updating metadata for batch {i // self.metadata_batch_size + 1} ({len(batch_uuids)} nodes)")
+                metadata_query = await DiffMergeMetadataQuery.init(
+                    db=self.db,
+                    branch=self.source_branch,
+                    at=at,
+                    target_branch=self.destination_branch,
+                    node_uuids=batch_uuids,
+                )
+                await metadata_query.execute(db=self.db)
+
         self.source_branch.branched_from = at.to_string()
         await self.source_branch.save(db=self.db)
         registry.branch[self.source_branch.name] = self.source_branch
         return enriched_diff
 
     async def rollback(self, at: Timestamp) -> None:
+        if not self._affected_node_uuids:
+            return
         rollback_query = await DiffMergeRollbackQuery.init(
-            db=self.db, branch=self.source_branch, target_branch=self.destination_branch, at=at
+            db=self.db,
+            branch=self.source_branch,
+            target_branch=self.destination_branch,
+            at=at,
+            node_uuids=self._affected_node_uuids,
         )
         await rollback_query.execute(db=self.db)

infrahub/core/diff/merger/serializer.py

@@ -93,9 +93,7 @@ class DiffMergeSerializer:
         if property_type in (DatabaseEdgeType.HAS_OWNER, DatabaseEdgeType.HAS_SOURCE, DatabaseEdgeType.IS_RELATED):
             return raw_value
         # these are boolean
-        if (property_type in (DatabaseEdgeType.IS_VISIBLE, DatabaseEdgeType.IS_PROTECTED)) and isinstance(
-            raw_value, str
-        ):
+        if property_type == DatabaseEdgeType.IS_PROTECTED and isinstance(raw_value, str):
             return raw_value.lower() == "true"
         # this must be HAS_VALUE
         if raw_value in (None, NULL_VALUE):
@@ -249,13 +247,8 @@ class DiffMergeSerializer:
         return attr_dict, attr_prop_dict
 
     def _get_default_property_merge_dicts(self, action: DiffAction) -> dict[DatabaseEdgeType, PropertyMergeDict]:
-        # start with default values for IS_VISIBLE and IS_PROTECTED b/c we always want to update them during a merge
+        # start with default values for IS_PROTECTED b/c we always want to update them during a merge
         return {
-            DatabaseEdgeType.IS_VISIBLE: PropertyMergeDict(
-                property_type=DatabaseEdgeType.IS_VISIBLE.value,
-                action=self._to_action_str(action),
-                value=None,
-            ),
             DatabaseEdgeType.IS_PROTECTED: PropertyMergeDict(
                 property_type=DatabaseEdgeType.IS_PROTECTED.value,
                 action=self._to_action_str(action),
@@ -335,7 +328,7 @@ class DiffMergeSerializer:
                 # handled above
                 continue
             python_value_type: type = str
-            if property_diff.property_type in (DatabaseEdgeType.IS_VISIBLE, DatabaseEdgeType.IS_PROTECTED):
+            if property_diff.property_type is DatabaseEdgeType.IS_PROTECTED:
                 python_value_type = bool
             actions_and_values = self._get_property_actions_and_values(
                 property_diff=property_diff, python_value_type=python_value_type

infrahub/core/diff/model/diff.py

@@ -26,7 +26,7 @@ class BaseDiffElement(BaseModel):
         """
         resp: dict[str, Any] = {}
         for key, value in self:
-            field_info = self.model_fields[key]
+            field_info = self.__class__.model_fields[key]
             if isinstance(value, BaseModel):
                 resp[key] = value.to_graphql()  # type: ignore[attr-defined]
             elif isinstance(value, dict):