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

infrahub/graphql/resolvers/ipam.py

@@ -9,18 +9,17 @@ from netaddr import IPSet
 from opentelemetry import trace
 
 from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, MetadataOptions
 from infrahub.core.ipam.constants import PrefixMemberType
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
 from infrahub.core.protocols import BuiltinIPNamespace, BuiltinIPPrefix
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.exceptions import ValidationError
+from infrahub.graphql.models import OrderModel
 from infrahub.graphql.parser import extract_selection
 from infrahub.graphql.permissions import get_permissions
 
-from ..models import OrderModel
-
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
@@ -31,7 +30,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import NodeSchema
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.initialization import GraphqlContext
-    from infrahub.graphql.models import OrderModel
 
 
 def _ip_range_display_label(node: Node) -> str:
@@ -311,7 +309,7 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
     info: GraphQLResolveInfo,
     offset: int | None = None,
     limit: int | None = None,
-    order: OrderModel | None = None,
+    order: dict[str, Any] | None = None,
     partial_match: bool = False,
     **kwargs: dict[str, Any],
 ) -> dict[str, Any]:
@@ -324,6 +322,7 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
     if not isinstance(schema, GenericSchema) or schema.kind not in [InfrahubKind.IPADDRESS, InfrahubKind.IPPREFIX]:
         raise ValidationError(f"{schema.kind} is not {InfrahubKind.IPADDRESS} or {InfrahubKind.IPPREFIX}")
 
+    order_model = OrderModel.from_input(input_data=order)
     fields = await extract_selection(info=info, schema=schema)
     resolve_available = bool(kwargs.pop("include_available", False))
     kinds_to_filter: list[str] = kwargs.pop("kinds", [])  # type: ignore[assignment]
@@ -400,10 +399,9 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
                 limit=query_limit,
                 offset=offset,
                 account=graphql_context.account_session,
-                include_source=True,
-                include_owner=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
                 partial_match=partial_match,
-                order=order,
+                order=order_model,
             )
 
             if fetch_first_node_context and len(objs) > 2:

infrahub/graphql/resolvers/many_relationship.py

@@ -3,15 +3,20 @@ from typing import TYPE_CHECKING, Any
 from graphql import GraphQLResolveInfo
 
 from infrahub.core.branch.models import Branch
-from infrahub.core.constants import BranchSupportType, RelationshipHierarchyDirection
+from infrahub.core.constants import (
+    BranchSupportType,
+    RelationshipHierarchyDirection,
+)
 from infrahub.core.manager import NodeManager
+from infrahub.core.metadata.model import MetadataQueryOptions
 from infrahub.core.query.node import NodeGetHierarchyQuery
+from infrahub.core.relationship import Relationship
 from infrahub.core.schema.node_schema import NodeSchema
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.graphql.field_extractor import extract_graphql_fields
-from infrahub.utils import has_any_key
+from infrahub.graphql.metadata import build_metadata_query_options, get_metadata_options_from_fields
 
 from ..loaders.peers import PeerRelationshipsDataLoader, QueryPeerParams
 from ..types import RELATIONS_PROPERTY_MAP, RELATIONS_PROPERTY_MAP_REVERSED
@@ -68,6 +73,25 @@ class ManyRelationshipResolver:
                 branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
             )
 
+    def _build_relationship_meta_response(
+        self, relationship: Relationship, metadata_fields: dict[str, Any]
+    ) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        for meta_field in metadata_fields.keys():
+            if meta_field == "created_at":
+                created_at = relationship._get_created_at()
+                data["created_at"] = created_at.to_datetime() if created_at else None
+            elif meta_field == "created_by":
+                account_id = relationship._get_created_by()
+                data["created_by"] = {"id": account_id} if account_id else None
+            elif meta_field == "updated_at":
+                updated_at = relationship._get_updated_at()
+                data["updated_at"] = updated_at.to_datetime() if updated_at else None
+            elif meta_field == "updated_by":
+                account_id = relationship._get_updated_by()
+                data["updated_by"] = {"id": account_id} if account_id else None
+        return data
+
     async def resolve(
         self,
         parent: dict,
@@ -93,6 +117,10 @@ class ManyRelationshipResolver:
         edges = fields.get("edges", {})
         node_fields = edges.get("node", {})
         property_fields = edges.get("properties", {})
+        metadata_fields = {
+            "node_metadata": edges.get("node_metadata", {}),
+            "relationship_metadata": edges.get("relationship_metadata", {}),
+        }
         for key, value in property_fields.items():
             mapped_name = RELATIONS_PROPERTY_MAP[key]
             node_fields[mapped_name] = value
@@ -138,45 +166,71 @@ class ManyRelationshipResolver:
         if not node_fields:
             return response
 
+        include_metadata = build_metadata_query_options(
+            node_metadata_fields=metadata_fields.get("node_metadata"),
+            relationship_metadata_fields=metadata_fields.get("relationship_metadata"),
+            node_fields=node_fields,
+        )
+        # Add relationship properties metadata to relationship_level
+        include_metadata |= MetadataQueryOptions(relationship_level=get_metadata_options_from_fields(property_fields))
+
         if offset or limit:
-            node_graph = await self._get_entities_simple(
+            relationships = await self._get_entities_simple(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 ids=ids,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 source_kind=source_kind,
                 rel_schema=node_rel,
                 filters=filters,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
                 offset=offset,
                 limit=limit,
             )
         else:
-            node_graph = await self._get_entities_with_data_loader(
+            relationships = await self._get_entities_with_data_loader(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 ids=ids,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 source_kind=source_kind,
                 rel_schema=node_rel,
                 filters=filters,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
             )
 
-        if not node_graph:
+        if not relationships:
             return response
 
         entries = []
-        for node in node_graph:
-            entry: dict[str, dict[str, Any]] = {"node": {}, "properties": {}}
-            for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
-                value = node.pop(key, None)
-                if value:
-                    entry["properties"][mapped] = value
-            entry["node"] = node
-            entries.append(entry)
+        async with graphql_context.db.start_session(read_only=True) as db:
+            for rel in relationships:
+                node = await rel.to_graphql(
+                    db=db,
+                    fields=node_fields,
+                    related_node_ids=graphql_context.related_node_ids,
+                )
+                entry: dict[str, dict[str, Any]] = {"node": {}, "properties": {}}
+                for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
+                    value = node.pop(key, None)
+                    if value:
+                        entry["properties"][mapped] = value
+                entry["node"] = node
+
+                if metadata_fields.get("node_metadata"):
+                    peer = await rel.get_peer(db=db)
+                    if peer:
+                        entry["node_metadata"] = await peer._build_meta_response("node_metadata", edges)
+
+                if metadata_fields.get("relationship_metadata"):
+                    entry["relationship_metadata"] = self._build_relationship_meta_response(
+                        relationship=rel,
+                        metadata_fields=metadata_fields["relationship_metadata"],
+                    )
+
+                entries.append(entry)
 
         response["edges"] = entries
         return response
@@ -187,17 +241,14 @@ class ManyRelationshipResolver:
         branch: Branch,
         ids: list[str],
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         source_kind: str,
         rel_schema: RelationshipSchema,
         filters: dict[str, Any],
         node_fields: dict[str, Any],
+        include_metadata: MetadataQueryOptions,
         offset: int | None = None,
         limit: int | None = None,
-    ) -> list[dict[str, Any]] | None:
-        include_source = has_any_key(data=node_fields, keys=["_relation__source", "source"])
-        include_owner = has_any_key(data=node_fields, keys=["_relation__owner", "owner"])
-
+    ) -> list[Relationship] | None:
         async with db.start_session(read_only=True) as dbs:
             objs = await NodeManager.query_peers(
                 db=dbs,
@@ -212,12 +263,11 @@ class ManyRelationshipResolver:
                 branch=branch,
                 branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
                 fetch_peers=True,
-                include_source=include_source,
-                include_owner=include_owner,
+                include_metadata=include_metadata,
             )
             if not objs:
                 return None
-            return [await obj.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids) for obj in objs]
+            return objs
 
     async def _get_entities_with_data_loader(
         self,
@@ -225,18 +275,15 @@ class ManyRelationshipResolver:
         branch: Branch,
         ids: list[str],
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         source_kind: str,
         rel_schema: RelationshipSchema,
         filters: dict[str, Any],
         node_fields: dict[str, Any],
-    ) -> list[dict[str, Any]] | None:
+        include_metadata: MetadataQueryOptions,
+    ) -> list[Relationship] | None:
         if node_fields and "hfid" in node_fields:
             node_fields["human_friendly_id"] = None
 
-        include_source = has_any_key(data=node_fields, keys=["_relation__source", "source"])
-        include_owner = has_any_key(data=node_fields, keys=["_relation__owner", "owner"])
-
         query_params = QueryPeerParams(
             branch=branch,
             source_kind=source_kind,
@@ -245,8 +292,7 @@ class ManyRelationshipResolver:
             fields=node_fields,
             at=at,
             branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
-            include_source=include_source,
-            include_owner=include_owner,
+            include_metadata=include_metadata,
         )
         if query_params in self._data_loader_instances:
             loader = self._data_loader_instances[query_params]
@@ -259,8 +305,4 @@ class ManyRelationshipResolver:
             all_peer_rels.extend(node_peer_rels)
         if not all_peer_rels:
             return None
-        async with db.start_session(read_only=True) as dbs:
-            return [
-                await obj.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
-                for obj in all_peer_rels
-            ]
+        return all_peer_rels

infrahub/graphql/resolvers/resolver.py

@@ -9,7 +9,7 @@ from infrahub.core.constants import BranchSupportType, InfrahubKind, Relationshi
 from infrahub.core.manager import NodeManager
 from infrahub.exceptions import NodeNotFoundError
 from infrahub.graphql.field_extractor import extract_graphql_fields
-from infrahub.utils import has_any_key
+from infrahub.graphql.metadata import build_metadata_query_options
 
 from ..models import OrderModel
 from ..parser import extract_selection
@@ -18,7 +18,7 @@ from ..permissions import get_permissions
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
-    from infrahub.core.schema import NodeSchema
+    from infrahub.core.schema import MainSchemaTypes, NodeSchema
     from infrahub.graphql.initialization import GraphqlContext
 
 
@@ -146,16 +146,18 @@ async def default_paginated_list_resolver(
     info: GraphQLResolveInfo,
     offset: int | None = None,
     limit: int | None = None,
-    order: OrderModel | None = None,
+    order: dict | None = None,
     partial_match: bool = False,
     **kwargs: dict[str, Any],
 ) -> dict[str, Any]:
-    schema: NodeSchema = (
+    schema: MainSchemaTypes = (
         info.return_type.of_type.graphene_type._meta.schema
         if isinstance(info.return_type, GraphQLNonNull)
         else info.return_type.graphene_type._meta.schema
     )
 
+    order_model = OrderModel.from_input(input_data=order)
+
     fields = await extract_selection(info=info, schema=schema)
 
     graphql_context: GraphqlContext = info.context
@@ -165,8 +167,13 @@ async def default_paginated_list_resolver(
             key: value for key, value in kwargs.items() if ("__" in key and value is not None) or key in ("ids", "hfid")
         }
 
-        edges = fields.get("edges", {})
+        edges: dict[str, Any] = fields.get("edges", {})
         node_fields = edges.get("node", {})
+        node_metadata_fields: dict[str, Any] = edges.get("node_metadata", {})
+        include_metadata = build_metadata_query_options(
+            node_metadata_fields=node_metadata_fields,
+            node_fields=node_fields,
+        )
         if "hfid" in node_fields:
             node_fields["human_friendly_id"] = None
 
@@ -186,23 +193,19 @@ async def default_paginated_list_resolver(
 
         objs = []
         if edges or "hfid" in filters:
-            include_source = has_any_key(data=node_fields, keys=["_relation__source", "source"])
-            include_owner = has_any_key(data=node_fields, keys=["_relation__owner", "owner"])
-
             objs = await NodeManager.query(
                 db=db,
                 schema=schema,
                 filters=filters or None,
                 fields=node_fields,
+                include_metadata=include_metadata,
                 at=graphql_context.at,
                 branch=graphql_context.branch,
                 limit=limit,
                 offset=offset,
                 account=graphql_context.account_session,
-                include_source=include_source,
-                include_owner=include_owner,
                 partial_match=partial_match,
-                order=order,
+                order=order_model,
             )
 
         if "count" in fields:
@@ -227,7 +230,8 @@ async def default_paginated_list_resolver(
                         fields=node_fields,
                         related_node_ids=graphql_context.related_node_ids,
                         permissions=permission_set,
-                    )
+                    ),
+                    "node_metadata": await obj._build_meta_response("node_metadata", edges),
                 }
                 for obj in objs
             ]

infrahub/graphql/resolvers/single_relationship.py

@@ -4,12 +4,16 @@ from graphql import GraphQLResolveInfo
 from graphql.type.definition import GraphQLNonNull
 
 from infrahub.core.branch.models import Branch
-from infrahub.core.constants import BranchSupportType
+from infrahub.core.constants import BranchSupportType, MetadataOptions
 from infrahub.core.manager import NodeManager
+from infrahub.core.metadata.model import MetadataQueryOptions
+from infrahub.core.node import Node
+from infrahub.core.relationship import Relationship
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.graphql.field_extractor import extract_graphql_fields
+from infrahub.graphql.metadata import build_metadata_query_options, get_metadata_options_from_fields
 
 from ..loaders.node import GetManyParams, NodeDataLoader
 from ..types import RELATIONS_PROPERTY_MAP, RELATIONS_PROPERTY_MAP_REVERSED
@@ -24,6 +28,25 @@ class SingleRelationshipResolver:
     def __init__(self) -> None:
         self._data_loader_instances: dict[GetManyParams, NodeDataLoader] = {}
 
+    def _build_relationship_meta_response(
+        self, relationship: Relationship, metadata_fields: dict[str, Any]
+    ) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        for meta_field in metadata_fields.keys():
+            if meta_field == "created_at":
+                created_at = relationship._get_created_at()
+                data["created_at"] = created_at.to_datetime() if created_at else None
+            elif meta_field == "created_by":
+                account_id = relationship._get_created_by()
+                data["created_by"] = {"id": account_id} if account_id else None
+            elif meta_field == "updated_at":
+                updated_at = relationship._get_updated_at()
+                data["updated_at"] = updated_at.to_datetime() if updated_at else None
+            elif meta_field == "updated_by":
+                account_id = relationship._get_updated_by()
+                data["updated_by"] = {"id": account_id} if account_id else None
+        return data
+
     async def resolve(self, parent: dict, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
         """Resolver for relationships of cardinality=one for Edged responses
 
@@ -45,50 +68,92 @@ class SingleRelationshipResolver:
         fields = extract_graphql_fields(info=info)
         node_fields = fields.get("node", {})
         property_fields = fields.get("properties", {})
+        metadata_fields = {
+            "node_metadata": fields.get("node_metadata", {}),
+            "relationship_metadata": fields.get("relationship_metadata", {}),
+        }
         for key, value in property_fields.items():
             mapped_name = RELATIONS_PROPERTY_MAP[key]
             node_fields[mapped_name] = value
 
         metadata_field_names = {prop_name for prop_name in RELATIONS_PROPERTY_MAP if prop_name != "__typename"}
-        requires_relationship_metadata = bool(set(property_fields.keys()) & metadata_field_names)
+        requires_relationship_properties = bool(set(property_fields.keys()) & metadata_field_names)
+        requires_relationship_metadata = bool(metadata_fields["relationship_metadata"])
 
         # Extract the schema of the node on the other end of the relationship from the GQL Schema
         node_rel = node_schema.get_relationship(info.field_name)
 
         response: dict[str, Any] = {"node": None, "properties": {}}
 
-        if requires_relationship_metadata:
-            node_graph = await self._get_entities_simple(
+        relationship: Relationship | None = None
+        peer_node: Node | None = None
+
+        if requires_relationship_properties or requires_relationship_metadata:
+            include_metadata = build_metadata_query_options(
+                node_metadata_fields=metadata_fields.get("node_metadata"),
+                relationship_metadata_fields=metadata_fields.get("relationship_metadata"),
+                node_fields=node_fields,
+            )
+            # Add relationship properties metadata to relationship_level
+            include_metadata |= MetadataQueryOptions(
+                relationship_level=get_metadata_options_from_fields(property_fields)
+            )
+            relationship = await self._get_entities_simple(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 field_name=info.field_name,
                 parent_id=parent["id"],
                 source_kind=node_schema.kind,
                 rel_schema=node_rel,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
                 **kwargs,
             )
         else:
-            node_graph = await self._get_entities_with_data_loader(
+            include_metadata = build_metadata_query_options(
+                node_metadata_fields=metadata_fields.get("node_metadata"),
+                node_fields=node_fields,
+            )
+            peer_node = await self._get_entities_with_data_loader(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 rel_schema=node_rel,
                 parent=parent,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
             )
 
-        if not node_graph:
+        if not relationship and not peer_node:
             return response
-        response["node"] = node_graph
 
-        for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
-            value = node_graph.pop(key, None)
-            if value:
-                response["properties"][mapped] = value
+        async with graphql_context.db.start_session(read_only=True) as db:
+            if relationship:
+                node_graph = await relationship.to_graphql(
+                    db=db, fields=node_fields, related_node_ids=graphql_context.related_node_ids
+                )
+                peer_node = await relationship.get_peer(db=db)
+            elif peer_node:
+                node_graph = await peer_node.to_graphql(
+                    db=db, fields=node_fields, related_node_ids=graphql_context.related_node_ids
+                )
+
+            response["node"] = node_graph
+
+            for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
+                value = node_graph.pop(key, None)
+                if value:
+                    response["properties"][mapped] = value
+
+            if metadata_fields.get("node_metadata") and peer_node:
+                response["node_metadata"] = await peer_node._build_meta_response("node_metadata", fields)
+
+            if metadata_fields.get("relationship_metadata") and relationship:
+                response["relationship_metadata"] = self._build_relationship_meta_response(
+                    relationship=relationship, metadata_fields=metadata_fields["relationship_metadata"]
+                )
+
         return response
 
     async def _get_entities_simple(
@@ -96,14 +161,14 @@ class SingleRelationshipResolver:
         db: InfrahubDatabase,
         branch: Branch,
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         field_name: str,
         parent_id: str,
         source_kind: str,
         rel_schema: RelationshipSchema,
         node_fields: dict[str, Any],
+        include_metadata: MetadataQueryOptions,
         **kwargs: Any,
-    ) -> dict[str, Any] | None:
+    ) -> Relationship | None:
         filters = {
             f"{field_name}__{key}": value
             for key, value in kwargs.items()
@@ -121,21 +186,22 @@ class SingleRelationshipResolver:
                 branch=branch,
                 branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
                 fetch_peers=True,
+                include_metadata=include_metadata,
             )
             if not objs:
                 return None
-            return await objs[0].to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
+            return objs[0]
 
     async def _get_entities_with_data_loader(
         self,
         db: InfrahubDatabase,
         branch: Branch,
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         rel_schema: RelationshipSchema,
         parent: dict[str, Any],
         node_fields: dict[str, Any],
-    ) -> dict[str, Any] | None:
+        include_metadata: MetadataQueryOptions,
+    ) -> Node | None:
         try:
             peer_id: str = parent[rel_schema.name][0]["node"]["id"]
         except (KeyError, IndexError):
@@ -144,14 +210,13 @@ class SingleRelationshipResolver:
         if node_fields and "hfid" in node_fields:
             node_fields["human_friendly_id"] = None
 
+        include_metadata |= MetadataQueryOptions(attribute_level=MetadataOptions.LINKED_NODES)
         query_params = GetManyParams(
             fields=node_fields,
             at=at,
             branch=branch,
-            include_source=True,
-            include_owner=True,
+            include_metadata=include_metadata,
             prefetch_relationships=False,
-            account=None,
             branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
         )
         if query_params in self._data_loader_instances:
@@ -162,5 +227,4 @@ class SingleRelationshipResolver:
         node = await loader.load(key=peer_id)
         if not node:
             return None
-        async with db.start_session(read_only=True) as dbs:
-            return await node.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
+        return node

infrahub/graphql/subscription/graphql_query.py

@@ -8,6 +8,7 @@ from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.protocols import CoreGraphQLQuery
 from infrahub.core.timestamp import Timestamp
+from infrahub.graphql.resolvers.account_metadata import AccountMetadataResolver
 from infrahub.graphql.resolvers.many_relationship import ManyRelationshipResolver
 from infrahub.graphql.resolvers.single_relationship import SingleRelationshipResolver
 from infrahub.log import get_logger
@@ -50,6 +51,7 @@ async def resolver_graphql_query(
                     types=graphql_context.types,
                     single_relationship_resolver=SingleRelationshipResolver(),
                     many_relationship_resolver=ManyRelationshipResolver(),
+                    account_metadata_resolver=AccountMetadataResolver(),
                 ),
                 root_value=None,
                 variable_values=params or {},

infrahub/graphql/types/__init__.py

@@ -66,7 +66,6 @@ __all__ = [
 
 
 RELATIONS_PROPERTY_MAP: dict[str, str] = {
-    "is_visible": "_relation__is_visible",
     "is_protected": "_relation__is_protected",
     "owner": "_relation__owner",
     "source": "_relation__source",

infrahub/graphql/types/attribute.py

@@ -22,7 +22,6 @@ class RelatedNodeInput(InputObjectType):
     hfid = Field(List(of_type=String), required=False)
     kind = String(required=False)  # Only used to resolve hfid of a related node on a generic relationship, see #4649
     from_pool = Field(GenericPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -41,7 +40,6 @@ class IPPrefixPoolInput(GenericPoolInput):
 class RelatedIPAddressNodeInput(InputObjectType):
     id = String(required=False)
     from_pool = Field(IPAddressPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -51,7 +49,6 @@ class RelatedIPPrefixNodeInput(InputObjectType):
     id = String(required=False)
     hfid = Field(List(of_type=String), required=False)
     from_pool = Field(IPPrefixPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -65,7 +62,6 @@ class AttributeInterface(InfrahubInterface):
     is_default = Field(Boolean)
     is_inherited = Field(Boolean)
     is_protected = Field(Boolean)
-    is_visible = Field(Boolean)
     updated_at = Field(DateTime)
     # Since source and owner are using a Type that is generated dynamically
     # these 2 fields will be dynamically inserted when we generate the GraphQL Schema
@@ -73,7 +69,16 @@ class AttributeInterface(InfrahubInterface):
     # owner = Field("DataOwner")
 
 
-class BaseAttribute(ObjectType):
+class InfrahubAttributeMetaObject(ObjectType):
+    # updated_by is dynamically added in GraphQLSchemaManager.generate_object_types()
+    # to use the account_type (CoreGenericAccount) instead of a plain String
+    updated_at = DateTime(
+        required=False,
+        description="Date/Time when the attribute was last modified by a user or a system task",
+    )
+
+
+class BaseAttribute(InfrahubAttributeMetaObject):
     id = Field(String)
     is_from_profile = Field(Boolean)
     permissions = Field(PermissionType, required=False)