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

infrahub/core/metadata/interface.py

@@ -0,0 +1,37 @@
+from abc import abstractmethod
+
+from infrahub.core.timestamp import Timestamp
+
+
+class MetadataInterface:
+    @abstractmethod
+    def _set_created_at(self, value: Timestamp | None) -> None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _set_created_by(self, value: str | None) -> None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _set_updated_at(self, value: Timestamp | None) -> None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _set_updated_by(self, value: str | None) -> None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _get_created_at(self) -> Timestamp | None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _get_created_by(self) -> str | None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _get_updated_at(self) -> Timestamp | None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _get_updated_by(self) -> str | None:
+        raise NotImplementedError()

infrahub/core/metadata/model.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from infrahub.core.constants import MetadataOptions
+
+if TYPE_CHECKING:
+    from infrahub.core.timestamp import Timestamp
+
+
+@dataclass(frozen=True)
+class MetadataQueryOptions:
+    node_level: MetadataOptions = MetadataOptions.NONE
+    attribute_level: MetadataOptions = MetadataOptions.NONE
+    relationship_level: MetadataOptions = MetadataOptions.NONE
+
+    def __or__(self, other: MetadataQueryOptions) -> MetadataQueryOptions:
+        return MetadataQueryOptions(
+            node_level=self.node_level | other.node_level,
+            attribute_level=self.attribute_level | other.attribute_level,
+            relationship_level=self.relationship_level | other.relationship_level,
+        )
+
+
+@dataclass
+class MetadataInfo:
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None

infrahub/core/metadata/query/node_metadata.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+
+class RelationshipDirection(Enum):
+    OUTBOUND = "outbound"
+    INBOUND = "inbound"
+    BIDIRECTIONAL = "bidirectional"
+
+
+@dataclass
+class AttributeMetadata:
+    uuid: str
+    name: str
+    is_deleted: bool
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.uuid,
+                self.name,
+                self.is_deleted,
+                self.created_at,
+                self.created_by,
+                self.updated_at,
+                self.updated_by,
+            )
+        )
+
+
+@dataclass
+class RelationshipMetadata:
+    uuid: str
+    identifier: str  # Relationship.name in DB (e.g., "testcar__testperson")
+    peer_uuid: str
+    direction: RelationshipDirection
+    is_deleted: bool
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.uuid,
+                self.identifier,
+                self.peer_uuid,
+                self.direction,
+                self.is_deleted,
+                self.created_at,
+                self.created_by,
+                self.updated_at,
+                self.updated_by,
+            )
+        )
+
+
+@dataclass
+class NodeMetadata:
+    uuid: str
+    kind: str
+    is_deleted: bool
+    created_at: Timestamp | None = None
+    created_by: str | None = None
+    updated_at: Timestamp | None = None
+    updated_by: str | None = None
+    attributes: list[AttributeMetadata] = field(default_factory=list)
+    relationships: list[RelationshipMetadata] = field(default_factory=list)
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.uuid,
+                self.kind,
+                self.is_deleted,
+                self.created_at,
+                self.created_by,
+                self.updated_at,
+                self.updated_by,
+                tuple(self.attributes),
+                tuple(self.relationships),
+            )
+        )
+
+
+class NodeMetadataDefaultBranchQuery(Query):
+    """Query to retrieve metadata for nodes and their attributes/relationships.
+
+    This query only works on the default branch and reads metadata directly from
+    vertex properties. It supports retrieving deleted nodes, attributes, and
+    relationships.
+    """
+
+    name = "node_metadata"
+    type = QueryType.READ
+    insert_return = False
+
+    def __init__(self, node_uuids: list[str], **kwargs: Any) -> None:
+        self.node_uuids = node_uuids
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        if not self.branch.is_default:
+            raise ValueError("NodeMetadataQuery only runs on the default branch")
+
+        self.params["node_uuids"] = self.node_uuids
+        self.params["branch"] = self.branch.name
+
+        # Query nodes with their metadata and deletion status
+        # Then query attributes and relationships
+        query = """
+// ------------------
+// Part 1: Get node metadata with deletion status
+// ------------------
+UNWIND $node_uuids AS node_uuid
+CALL (node_uuid) {
+    MATCH (n:Node {uuid: node_uuid})-[r_ipo:IS_PART_OF]->(root:Root)
+    WHERE r_ipo.branch = $branch
+    RETURN n, r_ipo
+    ORDER BY r_ipo.from DESC
+    LIMIT 1
+}
+WITH n,
+    CASE
+        WHEN r_ipo.status = "deleted" THEN true
+        WHEN r_ipo.to IS NOT NULL THEN true
+        ELSE false
+    END AS node_is_deleted
+
+// ------------------
+// Part 2: Get attribute details
+// ------------------
+OPTIONAL MATCH (n)-[:HAS_ATTRIBUTE {branch: $branch}]->(attr:Attribute)
+WITH DISTINCT n, node_is_deleted, attr
+CALL (n, attr) {
+    OPTIONAL MATCH (n)-[r_attr:HAS_ATTRIBUTE]->(attr)
+    WHERE r_attr.branch = $branch
+    WITH r_attr, attr
+    ORDER BY r_attr.from DESC
+    LIMIT 1
+    RETURN {
+        uuid: attr.uuid,
+        name: attr.name,
+        is_deleted: CASE
+            WHEN r_attr.status = "deleted" THEN true
+            WHEN r_attr.to IS NOT NULL THEN true
+            ELSE false
+        END,
+        created_at: attr.created_at,
+        created_by: attr.created_by,
+        updated_at: attr.updated_at,
+        updated_by: attr.updated_by
+    } AS attribute_details
+}
+WITH n, node_is_deleted, COALESCE(collect(attribute_details), []) AS attributes
+
+// ------------------
+// Part 3: Get relationship details
+// ------------------
+OPTIONAL MATCH (n)-[:IS_RELATED {branch: $branch}]-(rel:Relationship)-[:IS_RELATED {branch: $branch}]-(peer:Node)
+WHERE n <> peer
+WITH DISTINCT n, node_is_deleted, attributes, rel, peer
+CALL (n, rel, peer) {
+    OPTIONAL MATCH (n)-[r1:IS_RELATED]-(rel:Relationship)-[r2:IS_RELATED]-(peer:Node)
+    WHERE r1.branch = $branch AND r2.branch = $branch
+    WITH r1, r2
+    ORDER BY r1.from DESC, r2.from DESC
+    LIMIT 1
+    RETURN {
+        uuid: rel.uuid,
+        identifier: rel.name,
+        peer_uuid: peer.uuid,
+        direction: CASE
+            WHEN startNode(r1) = n AND startNode(r2) = rel THEN "outbound"
+            WHEN startNode(r1) = rel AND startNode(r2) = peer THEN "inbound"
+            ELSE "bidirectional"
+        END,
+        is_deleted: CASE
+            WHEN (r1.status = "deleted" OR r1.to IS NOT NULL) AND (r2.status = "deleted" OR r2.to IS NOT NULL) THEN true
+            ELSE false
+        END,
+        created_at: rel.created_at,
+        created_by: rel.created_by,
+        updated_at: rel.updated_at,
+        updated_by: rel.updated_by
+    } AS relationship_details
+}
+WITH n, node_is_deleted, attributes, COALESCE(collect(relationship_details), []) AS relationships
+
+RETURN n.uuid AS node_uuid, n.kind AS node_kind, node_is_deleted,
+       n.created_at AS node_created_at, n.created_by AS node_created_by,
+       n.updated_at AS node_updated_at, n.updated_by AS node_updated_by,
+       attributes, relationships
+        """
+        self.return_labels = [
+            "node_uuid",
+            "node_kind",
+            "node_is_deleted",
+            "node_created_at",
+            "node_created_by",
+            "node_updated_at",
+            "node_updated_by",
+            "attributes",
+            "relationships",
+        ]
+        self.add_to_query(query)
+
+    def get_metadatas(self) -> list[NodeMetadata]:
+        """Process query results into NodeMetadata dataclasses."""
+        from infrahub.core.timestamp import Timestamp
+
+        nodes: list[NodeMetadata] = []
+
+        for result in self.get_results():
+            node_uuid = result.get_as_type("node_uuid", return_type=str)
+            node_kind = result.get_as_type("node_kind", return_type=str)
+            node_is_deleted = result.get_as_type("node_is_deleted", bool)
+
+            node_created_at_str = result.get_as_str("node_created_at")
+            node_created_at = Timestamp(node_created_at_str) if node_created_at_str else None
+            node_created_by = result.get_as_str("node_created_by")
+            node_updated_at_str = result.get_as_str("node_updated_at")
+            node_updated_at = Timestamp(node_updated_at_str) if node_updated_at_str else None
+            node_updated_by = result.get_as_str("node_updated_by")
+
+            # Parse attributes
+            attributes_data: list[dict[str, Any]] = result.get_as_type("attributes", list)
+            attributes: list[AttributeMetadata] = []
+            for attr_data in attributes_data:
+                attr_created_at_str = attr_data.get("created_at")
+                attr_created_at = Timestamp(attr_created_at_str) if attr_created_at_str else None
+                attr_updated_at_str = attr_data.get("updated_at")
+                attr_updated_at = Timestamp(attr_updated_at_str) if attr_updated_at_str else None
+
+                attributes.append(
+                    AttributeMetadata(
+                        uuid=attr_data["uuid"],
+                        name=attr_data["name"],
+                        is_deleted=attr_data["is_deleted"],
+                        created_at=attr_created_at,
+                        created_by=attr_data.get("created_by"),
+                        updated_at=attr_updated_at,
+                        updated_by=attr_data.get("updated_by"),
+                    )
+                )
+
+            # Parse relationships
+            relationships_data: list[dict[str, Any]] = result.get_as_type("relationships", list)
+            relationships: list[RelationshipMetadata] = []
+            for rel_data in relationships_data:
+                rel_created_at_str = rel_data.get("created_at")
+                rel_created_at = Timestamp(rel_created_at_str) if rel_created_at_str else None
+                rel_updated_at_str = rel_data.get("updated_at")
+                rel_updated_at = Timestamp(rel_updated_at_str) if rel_updated_at_str else None
+
+                direction_str = rel_data["direction"]
+                direction = RelationshipDirection(direction_str)
+
+                relationships.append(
+                    RelationshipMetadata(
+                        uuid=rel_data["uuid"],
+                        identifier=rel_data["identifier"],
+                        peer_uuid=rel_data["peer_uuid"],
+                        direction=direction,
+                        is_deleted=rel_data["is_deleted"],
+                        created_at=rel_created_at,
+                        created_by=rel_data.get("created_by"),
+                        updated_at=rel_updated_at,
+                        updated_by=rel_data.get("updated_by"),
+                    )
+                )
+
+            nodes.append(
+                NodeMetadata(
+                    uuid=node_uuid,
+                    kind=node_kind,
+                    is_deleted=node_is_deleted,
+                    created_at=node_created_at,
+                    created_by=node_created_by,
+                    updated_at=node_updated_at,
+                    updated_by=node_updated_by,
+                    attributes=attributes,
+                    relationships=relationships,
+                )
+            )
+
+        return nodes

infrahub/core/migrations/graph/__init__.py

@@ -50,6 +50,8 @@ from .m045_backfill_hfid_display_label_in_db_profile_template import Migration04
 from .m046_fill_agnostic_hfid_display_labels import Migration046
 from .m047_backfill_or_null_display_label import Migration047
 from .m048_undelete_rel_props import Migration048
+from .m049_remove_is_visible_relationship import Migration049
+from .m050_backfill_vertex_metadata import Migration050
 
 if TYPE_CHECKING:
     from ..shared import MigrationTypes
@@ -104,6 +106,8 @@ MIGRATIONS: list[type[MigrationTypes]] = [
     Migration046,
     Migration047,
     Migration048,
+    Migration049,
+    Migration050,
 ]
 
 

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -73,7 +73,6 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
 
         self.params["current_time"] = self.at.to_string()
         self.params["is_protected_default"] = False
-        self.params["is_visible_default"] = True
         self.params["branch_support"] = BranchSupportType.AGNOSTIC.value
 
         self.params["rel_identifier"] = "gitrepository__credential"
@@ -91,8 +90,7 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
         // Prepare some nodes we'll need later
         // --------------------------------
         MERGE (is_protected_value:Boolean { value: $is_protected_default })
-        MERGE (is_visible_value:Boolean { value: $is_visible_default })
-        WITH git_repo, root, is_protected_value, is_visible_value
+        WITH git_repo, root, is_protected_value
         // --------------------------------
         // Retrieve the name of the current repository
         // --------------------------------
@@ -106,9 +104,9 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
             ORDER BY r1.branch_level DESC, r1.from DESC
             LIMIT 1
         }
-        WITH  n1 as git_repo, r11 as r1, r22 as r2, av1 as git_name_value, root, is_protected_value, is_visible_value
+        WITH  n1 as git_repo, r11 as r1, r22 as r2, av1 as git_name_value, root, is_protected_value
         WHERE r1.status = "active" AND r2.status = "active"
-        WITH DISTINCT(git_repo) as git_repo, root, is_protected_value, is_visible_value, git_name_value
+        WITH DISTINCT(git_repo) as git_repo, root, is_protected_value, git_name_value
         // --------------------------------
         // Create new CorePasswordCredential node
         // --------------------------------
@@ -119,20 +117,17 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
         CREATE (attr_name)<-[:HAS_ATTRIBUTE $rel_props_new ]-(cred)
         CREATE (attr_name)-[:HAS_VALUE $rel_props_new ]->(git_name_value)
         CREATE (attr_name)-[:IS_PROTECTED $rel_props_new]->(is_protected_value)
-        CREATE (attr_name)-[:IS_VISIBLE $rel_props_new]->(is_visible_value)
         // attribute: label
         CREATE (attr_lbl:Attribute { name: "label", branch_support: $branch_support })
         CREATE (attr_lbl)<-[:HAS_ATTRIBUTE $rel_props_new ]-(cred)
         CREATE (attr_lbl)-[:HAS_VALUE $rel_props_new ]->(git_name_value)
         CREATE (attr_lbl)-[:IS_PROTECTED $rel_props_new]->(is_protected_value)
-        CREATE (attr_lbl)-[:IS_VISIBLE $rel_props_new]->(is_visible_value)
         // attribute: description
         CREATE (attr_desc:Attribute { name: "description", branch_support: $branch_support })
         MERGE (av_desc:AttributeValue { value: "Credential for " + git_name_value.value, is_default: true })
         CREATE (attr_desc)<-[:HAS_ATTRIBUTE $rel_props_new ]-(cred)
         CREATE (attr_desc)-[:HAS_VALUE $rel_props_new ]->(av_desc)
         CREATE (attr_desc)-[:IS_PROTECTED $rel_props_new]->(is_protected_value)
-        CREATE (attr_desc)-[:IS_VISIBLE $rel_props_new]->(is_visible_value)
         %(attr_name_guid)s
         %(attr_label_guid)s
         %(attr_desc_guid)s

infrahub/core/migrations/graph/m017_add_core_profile.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core import registry
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.schema.manager import SchemaManager
@@ -26,7 +27,7 @@ class Migration017(InternalSchemaMigration):
 
         return result
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:
         """
         Load CoreProfile schema node in db.
         """
@@ -35,6 +36,8 @@ class Migration017(InternalSchemaMigration):
         manager.set_schema_branch(name=default_branch.name, schema=self.get_internal_schema())
 
         db.add_schema(manager.get_schema_branch(default_branch.name))
-        await manager.load_node_to_db(node=core_profile_schema_definition, db=db, branch=default_branch)
+        await manager.load_node_to_db(
+            node=core_profile_schema_definition, db=db, branch=default_branch, user_id=user_id
+        )
 
         return MigrationResult()

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -4,6 +4,7 @@ from collections import defaultdict
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core import registry
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.diff.payload_builder import get_display_labels_per_kind
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.core.schema import GenericSchema, NodeSchema, SchemaRoot, internal_schema
@@ -95,5 +96,5 @@ class Migration018(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m019_restore_rels_to_time.py

@@ -169,11 +169,6 @@ class DeleteNodesRelsQuery(Query):
             MERGE (rel)-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL (rel, peer_2, branch, branch_level, deleted_time) {
-            MATCH (rel)-[:IS_VISIBLE]->(peer_2)
-            MERGE (rel)-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
-        }
-
         CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:HAS_OWNER]->(peer_2)
             MERGE (rel)-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
@@ -194,11 +189,6 @@ class DeleteNodesRelsQuery(Query):
             MERGE (rel)<-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL (rel, peer_2, branch, branch_level, deleted_time) {
-            MATCH (rel)<-[:IS_VISIBLE]-(peer_2)
-            MERGE (rel)<-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
-        }
-
         CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:HAS_OWNER]-(peer_2)
             MERGE (rel)<-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)

infrahub/core/migrations/graph/m020_duplicate_edges.py

@@ -108,13 +108,6 @@ CALL (a, branch, status, from, to, b, e_id_to_keep) {
         self.add_to_query(query)
 
 
-class DeleteDuplicateIsVisibleEdgesQuery(DeleteDuplicateBooleanEdgesQuery):
-    name = "delete_duplicate_is_visible_edges"
-    type = QueryType.WRITE
-    insert_return = False
-    edge_type = DatabaseEdgeType.IS_VISIBLE
-
-
 class DeleteDuplicateIsProtectedEdgesQuery(DeleteDuplicateBooleanEdgesQuery):
     name = "delete_duplicate_is_protected_edges"
     type = QueryType.WRITE
@@ -144,7 +137,6 @@ class Migration020(GraphMigration):
     minimum_version: int = 19
     queries: Sequence[type[Query]] = [
         DeleteDuplicateHasValueEdgesQuery,
-        DeleteDuplicateIsVisibleEdgesQuery,
         DeleteDuplicateIsProtectedEdgesQuery,
     ]
 

infrahub/core/migrations/graph/m025_uniqueness_nulls.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Sequence
 
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.log import get_logger
 
@@ -22,5 +23,5 @@ class Migration025(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m026_0000_prefix_fix.py

@@ -4,6 +4,7 @@ import ipaddress
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core.branch.models import Branch
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.manager import NodeManager
@@ -28,7 +29,7 @@ class Migration026(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)

infrahub/core/migrations/graph/m029_duplicates_cleanup.py

@@ -631,7 +631,6 @@ class Migration029(ArbitraryMigration):
                     offset=offset,
                     outbound_edge_types=[
                         DatabaseEdgeType.IS_RELATED,
-                        DatabaseEdgeType.IS_VISIBLE,
                         DatabaseEdgeType.IS_PROTECTED,
                         DatabaseEdgeType.HAS_OWNER,
                         DatabaseEdgeType.HAS_SOURCE,

infrahub/core/migrations/graph/m031_check_number_attributes.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Sequence
 from infrahub import config
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.constants import SchemaPathType
+from infrahub.core.constants import SYSTEM_USER_ID, SchemaPathType
 from infrahub.core.initialization import initialization
 from infrahub.core.migrations.shared import InternalSchemaMigration, MigrationResult, SchemaMigration
 from infrahub.core.path import SchemaPath
@@ -35,7 +35,7 @@ class Migration031(InternalSchemaMigration):
     minimum_version: int = 30
     migrations: Sequence[SchemaMigration] = []
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         """Retrieve all number attributes that have a min/max/excluded_values
         For any of these attributes, check if corresponding existing nodes are valid."""
 

infrahub/core/migrations/graph/m038_redo_0000_prefix_fix.py

@@ -4,6 +4,7 @@ import ipaddress
 from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core.branch.models import Branch
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.manager import NodeManager
@@ -37,7 +38,7 @@ class Migration038(InternalSchemaMigration):
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
         return MigrationResult()
 
-    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> MigrationResult:  # noqa: ARG002
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)

infrahub/core/migrations/graph/m049_remove_is_visible_relationship.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+
+from ..shared import GraphMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class RemoveIsVisibleRelationshipQuery(Query):
+    name = "remove_is_visible_relationship"
+    type: QueryType = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        MATCH ()-[rel:IS_VISIBLE]->()
+        CALL (rel) {
+          DELETE rel
+        } IN TRANSACTIONS
+        """
+        self.add_to_query(query)
+
+
+class Migration049(GraphMigration):
+    name: str = "049_remove_is_visible_relationship"
+    minimum_version: int = 48
+    queries: Sequence[type[Query]] = [RemoveIsVisibleRelationshipQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        return await self.do_execute(db=db)