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

infrahub/graphql/manager.py

@@ -21,8 +21,10 @@ from infrahub.core.schema import (
 from infrahub.graphql.mutations.attribute import BaseAttributeCreate, BaseAttributeUpdate
 from infrahub.graphql.mutations.graphql_query import InfrahubGraphQLQueryMutation
 from infrahub.graphql.mutations.profile import InfrahubProfileMutation
+from infrahub.graphql.types.metadata import OrderInput
 from infrahub.types import ATTRIBUTE_TYPES, InfrahubDataType, get_attribute_type
 
+from .constants import NODE_METADATA_TYPE, RELATIONSHIP_METADATA_TYPE
 from .directives import DIRECTIVES
 from .enums import generate_graphql_enum, get_enum_attribute_type_name
 from .metrics import SCHEMA_GENERATE_GRAPHQL_METRICS
@@ -42,6 +44,7 @@ from .mutations.resource_manager import (
 )
 from .mutations.webhook import InfrahubWebhookMutation
 from .registry import registry
+from .resolvers.account_metadata import account_metadata_resolver
 from .resolvers.ipam import ipam_paginated_list_resolver
 from .resolvers.resolver import (
     account_resolver,
@@ -65,8 +68,10 @@ from .types import (
 )
 from .types.attribute import BaseAttribute as BaseAttributeType
 from .types.attribute import TextAttributeType
+from .types.branch import InfrahubBranchEdge
 from .types.context import ContextInput
 from .types.event import EVENT_TYPES
+from .types.node import InfrahubObjectWithoutMeta
 
 if TYPE_CHECKING:
     from graphql import GraphQLSchema
@@ -82,10 +87,6 @@ class DeleteInput(graphene.InputObjectType):
 GraphQLTypes = type[InfrahubMutation] | type[BaseAttributeType] | type[graphene.Interface] | type[graphene.ObjectType]
 
 
-class OrderInput(graphene.InputObjectType):
-    disable = graphene.Boolean(required=False)
-
-
 @dataclass
 class GraphqlMutations:
     create: type[InfrahubMutation]
@@ -243,15 +244,37 @@ class GraphQLSchemaManager:
             self.set_type(name=event._meta.name, graphql_type=event)
 
     def _load_node_interface(self) -> None:
+        """Load the base CoreNode interface. Edged/paginated objects are created later in generate_object_types."""
+        node_interface_schema = GenericSchema(
+            name="Node", namespace="Core", description="Interface for all nodes in Infrahub"
+        )
+        self.generate_interface_object(schema=node_interface_schema, populate_cache=True)
+
+    def _complete_node_interface(self, node_metadata: type[InfrahubObject]) -> None:
+        """Complete the CoreNode interface by creating its edged and paginated objects."""
         node_interface_schema = GenericSchema(
             name="Node", namespace="Core", description="Interface for all nodes in Infrahub"
         )
-        interface = self.generate_interface_object(schema=node_interface_schema, populate_cache=True)
+        # Re-call generate_interface_object to get the InterfaceReference (will use cached version)
+        interface = self.generate_interface_object(schema=node_interface_schema, populate_cache=False)
         edged_interface = self.generate_graphql_edged_object(
-            schema=node_interface_schema, node=interface, populate_cache=True
+            schema=node_interface_schema, node=interface, node_metadata=node_metadata, populate_cache=True
         )
         self.generate_graphql_paginated_object(schema=node_interface_schema, edge=edged_interface, populate_cache=True)
 
+    def _patch_static_types(self, node_metadata: type[InfrahubObject]) -> None:
+        """Patch statically defined GraphQL types to use dynamically generated types.
+
+        Some GraphQL types like InfrahubBranchEdge are defined statically but need to
+        reference dynamically generated types (like node_metadata with GenericAccount).
+        This method patches those static types after the dynamic types are created.
+
+        The method checks if the patch has already been applied to avoid redundant updates.
+        """
+        current_field = InfrahubBranchEdge._meta.fields.get("node_metadata")
+        if current_field is None or current_field.type != node_metadata:
+            InfrahubBranchEdge._meta.fields["node_metadata"] = graphene.Field(node_metadata, required=True)
+
     def _load_all_enum_types(self, node_schemas: Iterable[MainSchemaTypes]) -> None:
         for node_schema in node_schemas:
             self._load_enum_type(node_schema=node_schema)
@@ -311,25 +334,49 @@ class GraphQLSchemaManager:
 
         full_schema = self.schema.get_all(duplicate=False)
 
-        # Generate all GraphQL Interface  Object first and store them in the registry
+        # Pass 1: Generate all GraphQL Interface objects first (without edged/paginated)
+        # This ensures GENERICACCOUNT exists before we create node_metadata
         for node_schema in full_schema.values():
-            if not isinstance(node_schema, GenericSchema):
-                continue
-            interface = self.generate_interface_object(schema=node_schema, populate_cache=True)
-            edged_interface = self.generate_graphql_edged_object(
-                schema=node_schema, node=interface, populate_cache=True
-            )
-            self.generate_graphql_paginated_object(schema=node_schema, edge=edged_interface, populate_cache=True)
+            if isinstance(node_schema, GenericSchema):
+                self.generate_interface_object(schema=node_schema, populate_cache=True)
 
         # Define LineageSource and LineageOwner
         data_source = self.get_type(name=InfrahubKind.LINEAGESOURCE)
         data_owner = self.get_type(name=InfrahubKind.LINEAGEOWNER)
         self.define_relationship_property(data_source=data_source, data_owner=data_owner)
+
+        # Now that GENERICACCOUNT exists, create node_metadata and relationship_metadata
+        account_type = self.get_type(name=InfrahubKind.GENERICACCOUNT)
+        self.define_node_metadata(account_type=account_type)
+        self.define_relationship_metadata(account_type=account_type)
+        node_metadata = self.get_type(name=NODE_METADATA_TYPE)
+        relationship_metadata = self.get_type(name=RELATIONSHIP_METADATA_TYPE)
+
+        # Complete the CoreNode interface (edged/paginated) now that node_metadata exists
+        self._complete_node_interface(node_metadata=node_metadata)
+
+        # Patch statically defined types to use dynamically generated types
+        self._patch_static_types(node_metadata=node_metadata)
+
         relationship_property = self.get_type(name="RelationshipProperty")
         for data_type in ATTRIBUTE_TYPES.values():
             gql_type = self.get_type(name=data_type.get_graphql_type_name())
             gql_type._meta.fields["source"] = graphene.Field(data_source)
             gql_type._meta.fields["owner"] = graphene.Field(data_owner)
+            gql_type._meta.fields["updated_by"] = graphene.Field(
+                account_type, required=False, resolver=account_metadata_resolver
+            )
+
+        # Pass 2: Generate edged/paginated objects for all GenericSchema interfaces
+        for node_schema in full_schema.values():
+            if not isinstance(node_schema, GenericSchema):
+                continue
+            # Re-call generate_interface_object to get the InterfaceReference (will use cached version)
+            interface = self.generate_interface_object(schema=node_schema, populate_cache=False)
+            edged_interface = self.generate_graphql_edged_object(
+                schema=node_schema, node=interface, node_metadata=node_metadata, populate_cache=True
+            )
+            self.generate_graphql_paginated_object(schema=node_schema, edge=edged_interface, populate_cache=True)
 
         # Generate all Nested, Edged and NestedEdged Interfaces and store them in the registry
         for node_name, node_schema in full_schema.items():
@@ -340,7 +387,9 @@ class GraphQLSchemaManager:
             nested_edged_interface = self.generate_nested_interface_object(
                 schema=node_schema,
                 base_interface=node_interface,
+                node_metadata=node_metadata,
                 relation_property=relationship_property,
+                relationship_metadata=relationship_metadata,
             )
 
             nested_interface = self.generate_paginated_interface_object(
@@ -356,11 +405,13 @@ class GraphQLSchemaManager:
             if isinstance(node_schema, NodeSchema | ProfileSchema | TemplateSchema):
                 node_object_type = self.generate_graphql_object(schema=node_schema, populate_cache=True)
                 node_type_edged = self.generate_graphql_edged_object(
-                    schema=node_schema, node=node_object_type, populate_cache=True
+                    schema=node_schema, node=node_object_type, node_metadata=node_metadata, populate_cache=True
                 )
                 nested_node_type_edged = self.generate_graphql_edged_object(
                     schema=node_schema,
                     node=node_object_type,
+                    node_metadata=node_metadata,
+                    relationship_metadata=relationship_metadata,
                     relation_property=relationship_property,
                     populate_cache=True,
                 )
@@ -615,7 +666,6 @@ class GraphQLSchemaManager:
         }
 
         main_attrs = {
-            "is_visible": graphene.Boolean(required=False),
             "is_protected": graphene.Boolean(required=False),
             "updated_at": graphene.DateTime(required=False),
             "source": graphene.Field(data_source),
@@ -627,6 +677,42 @@ class GraphQLSchemaManager:
 
         self.set_type(name=type_name, graphql_type=relationship_property)
 
+    def define_node_metadata(self, account_type: type[InfrahubObject]) -> None:
+        meta_attrs = {
+            "name": NODE_METADATA_TYPE,
+            "description": "Defines node metadata information",
+        }
+
+        main_attrs = {
+            "created_at": graphene.DateTime(required=False),
+            "created_by": graphene.Field(account_type, required=False, resolver=account_metadata_resolver),
+            "updated_at": graphene.DateTime(required=False),
+            "updated_by": graphene.Field(account_type, required=False, resolver=account_metadata_resolver),
+            "Meta": type("Meta", (object,), meta_attrs),
+        }
+
+        node_metadata = type(NODE_METADATA_TYPE, (graphene.ObjectType,), main_attrs)
+
+        self.set_type(name=NODE_METADATA_TYPE, graphql_type=node_metadata)
+
+    def define_relationship_metadata(self, account_type: type[InfrahubObject]) -> None:
+        meta_attrs = {
+            "name": RELATIONSHIP_METADATA_TYPE,
+            "description": "Defines relationship metadata information",
+        }
+
+        main_attrs = {
+            "created_at": graphene.DateTime(required=False),
+            "created_by": graphene.Field(account_type, required=False, resolver=account_metadata_resolver),
+            "updated_at": graphene.DateTime(required=False),
+            "updated_by": graphene.Field(account_type, required=False, resolver=account_metadata_resolver),
+            "Meta": type("Meta", (object,), meta_attrs),
+        }
+
+        relationship_metadata = type(RELATIONSHIP_METADATA_TYPE, (graphene.ObjectType,), main_attrs)
+
+        self.set_type(name=RELATIONSHIP_METADATA_TYPE, graphql_type=relationship_metadata)
+
     def generate_graphql_mutations(
         self,
         schema: NodeSchema | ProfileSchema | TemplateSchema,
@@ -935,6 +1021,9 @@ class GraphQLSchemaManager:
             filters.update(get_attribute_type().get_graphql_filters(name="any"))
             filters["partial_match"] = graphene.Boolean()
 
+            # Add metadata filters for filtering by created_by, updated_by, created_at, updated_at
+            filters.update(self._generate_metadata_filters())
+
             if schema.kind in [InfrahubKind.IPADDRESS, InfrahubKind.IPPREFIX]:
                 # This is only available for IPAM generics
                 filters["include_available"] = graphene.Boolean()
@@ -961,10 +1050,53 @@ class GraphQLSchemaManager:
 
         return filters
 
+    def _generate_metadata_filters(self) -> dict[str, Any]:
+        """Generate GraphQL filters for object-level metadata fields.
+
+        These filters allow querying nodes based on their metadata:
+        - created_by: Filter by the account that created the node
+        - updated_by: Filter by the account that last updated the node
+        - created_at: Filter by creation timestamp
+        - updated_at: Filter by last update timestamp
+
+        Returns:
+            dict: Filter definitions with names as keys and graphene types as values
+        """
+        return {
+            # Account-based filters (created_by)
+            "node_metadata__created_by__id": graphene.ID(description="Filter by exact creator account UUID"),
+            "node_metadata__created_by__ids": graphene.List(
+                graphene.ID, description="Filter by list of creator account UUIDs"
+            ),
+            # Account-based filters (updated_by)
+            "node_metadata__updated_by__id": graphene.ID(description="Filter by exact updater account UUID"),
+            "node_metadata__updated_by__ids": graphene.List(
+                graphene.ID, description="Filter by list of updater account UUIDs"
+            ),
+            # DateTime-based filters (created_at)
+            "node_metadata__created_at": graphene.DateTime(description="Filter by exact creation timestamp"),
+            "node_metadata__created_at__before": graphene.DateTime(
+                description="Filter for objects created before this timestamp"
+            ),
+            "node_metadata__created_at__after": graphene.DateTime(
+                description="Filter for objects created after this timestamp"
+            ),
+            # DateTime-based filters (updated_at)
+            "node_metadata__updated_at": graphene.DateTime(description="Filter by exact update timestamp"),
+            "node_metadata__updated_at__before": graphene.DateTime(
+                description="Filter for objects updated before this timestamp"
+            ),
+            "node_metadata__updated_at__after": graphene.DateTime(
+                description="Filter for objects updated after this timestamp"
+            ),
+        }
+
     def generate_graphql_edged_object(
         self,
         schema: MainSchemaTypes,
         node: InterfaceReference | InfrahubObjectReference,
+        node_metadata: type[InfrahubObject],
+        relationship_metadata: type[InfrahubObject] | None = None,
         relation_property: type[InfrahubObject] | None = None,
         populate_cache: bool = False,
     ) -> InfrahubEdgedReference:
@@ -987,15 +1119,18 @@ class GraphQLSchemaManager:
 
         main_attrs: dict[str, Any] = {
             "node": graphene.Field(node.reference, required=False),
+            "node_metadata": graphene.Field(node_metadata, required=False),
             "Meta": type("Meta", (object,), meta_attrs),
         }
 
         if relation_property:
             main_attrs["properties"] = graphene.Field(relation_property, required=False)
+        if relationship_metadata:
+            main_attrs["relationship_metadata"] = graphene.Field(relationship_metadata, required=False)
 
         graphql_edged_object = registry.get_edge_type(reference_hash=edge_hash, schema_hash=self.schema_hash)
         if not graphql_edged_object:
-            graphql_edged_object = type(object_name, (InfrahubObject,), main_attrs)
+            graphql_edged_object = type(object_name, (InfrahubObjectWithoutMeta,), main_attrs)
             registry.set_edge_type(
                 reference=graphql_edged_object, reference_hash=edge_hash, schema_hash=self.schema_hash
             )
@@ -1039,7 +1174,7 @@ class GraphQLSchemaManager:
         )
         if not graphql_paginated_object:
             main_attrs["Meta"] = type("Meta", (object,), meta_attrs)
-            graphql_paginated_object = type(object_name, (InfrahubObject,), main_attrs)
+            graphql_paginated_object = type(object_name, (InfrahubObjectWithoutMeta,), main_attrs)
             registry.set_paginated_type(
                 reference=graphql_paginated_object, reference_hash=paginated_hash, schema_hash=self.schema_hash
             )
@@ -1054,6 +1189,8 @@ class GraphQLSchemaManager:
         schema: GenericSchema,
         relation_property: graphene.ObjectType,
         base_interface: graphene.ObjectType,
+        node_metadata: type[InfrahubObject],
+        relationship_metadata: type[InfrahubObject] | None = None,
         populate_cache: bool = False,
     ) -> type[InfrahubObject]:
         meta_attrs: dict[str, Any] = {
@@ -1065,11 +1202,14 @@ class GraphQLSchemaManager:
         main_attrs: dict[str, Any] = {
             "node": graphene.Field(base_interface, required=False),
             "_updated_at": graphene.DateTime(required=False),
+            "node_metadata": graphene.Field(node_metadata, required=True),
             "Meta": type("Meta", (object,), meta_attrs),
         }
 
         if relation_property:
             main_attrs["properties"] = graphene.Field(relation_property, required=False)
+        if relationship_metadata:
+            main_attrs["relationship_metadata"] = graphene.Field(relationship_metadata, required=False)
 
         object_name = f"NestedEdged{schema.kind}"
         md5hash = hashlib.md5(usedforsecurity=False)

infrahub/graphql/metadata.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+from infrahub.core.constants import MetadataOptions
+from infrahub.core.metadata.model import MetadataQueryOptions
+
+
+def get_metadata_options_from_fields(fields: dict[str, Any]) -> MetadataOptions:
+    """Convert a dict of requested metadata fields to MetadataOptions flags."""
+    options = MetadataOptions.NONE
+    if "created_at" in fields:
+        options |= MetadataOptions.CREATED_AT
+    if "created_by" in fields:
+        options |= MetadataOptions.CREATED_BY
+    if "updated_at" in fields or "_updated_at" in fields:
+        options |= MetadataOptions.UPDATED_AT
+    if "updated_by" in fields:
+        options |= MetadataOptions.UPDATED_BY
+    if "source" in fields or "_relation__source" in fields:
+        options |= MetadataOptions.SOURCE
+    if "owner" in fields or "_relation__owner" in fields:
+        options |= MetadataOptions.OWNER
+    if "is_protected" in fields:
+        options |= MetadataOptions.IS_PROTECTED
+    return options
+
+
+def _extract_attribute_metadata_from_node_fields(node_fields: dict[str, Any]) -> MetadataOptions:
+    """Extract attribute-level metadata options from nested node fields.
+
+    This handles GraphQL query structures like:
+        name {
+            value
+            updated_by { id }
+            updated_at
+        }
+
+    Where `updated_by` and `updated_at` are attribute-level metadata.
+    """
+    attribute_metadata_options = MetadataOptions.NONE
+
+    for field_properties_dict in node_fields.values():
+        if not field_properties_dict or not isinstance(field_properties_dict, dict):
+            continue
+
+        # For attributes, metadata fields are at the same level as 'value'
+        # Check if this looks like an attribute (has metadata fields directly)
+        metadata_properties_dict = field_properties_dict
+
+        # Extract metadata from attribute fields
+        if "updated_at" in metadata_properties_dict or "_updated_at" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.UPDATED_AT
+        if "updated_by" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.UPDATED_BY
+        if "created_at" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.CREATED_AT
+        if "created_by" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.CREATED_BY
+        if "source" in metadata_properties_dict or "_relation__source" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.SOURCE
+        if "owner" in metadata_properties_dict or "_relation__owner" in metadata_properties_dict:
+            attribute_metadata_options |= MetadataOptions.OWNER
+
+    return attribute_metadata_options
+
+
+def build_metadata_query_options(
+    node_metadata_fields: dict[str, Any] | None = None,
+    relationship_metadata_fields: dict[str, Any] | None = None,
+    node_fields: dict[str, Any] | None = None,
+) -> MetadataQueryOptions:
+    """Build MetadataQueryOptions from GraphQL extracted fields.
+
+    Args:
+        node_metadata_fields: Fields from the node_metadata section of a GraphQL query.
+        relationship_metadata_fields: Fields from the relationship_metadata section.
+        node_fields: The node fields dict to extract attribute-level metadata from.
+
+    Returns:
+        MetadataQueryOptions with appropriate flags set for each level.
+    """
+    node_level = get_metadata_options_from_fields(node_metadata_fields or {})
+    relationship_level = get_metadata_options_from_fields(relationship_metadata_fields or {})
+    attribute_level = _extract_attribute_metadata_from_node_fields(node_fields or {})
+
+    return MetadataQueryOptions(
+        node_level=node_level,
+        attribute_level=attribute_level,
+        relationship_level=relationship_level,
+    )

infrahub/graphql/models.py

@@ -1,6 +1,36 @@
-from pydantic import BaseModel
+from __future__ import annotations
 
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
 
-# Corresponds to infrahub.graphql.manager.OrderInput
-class OrderModel(BaseModel):
+from infrahub.exceptions import ValidationError
+
+if TYPE_CHECKING:
+    from infrahub.constants.enums import OrderDirection
+
+
+@dataclass
+class NodeMetaOrder:
+    created_at: OrderDirection | None = None
+    updated_at: OrderDirection | None = None
+
+
+@dataclass
+class OrderModel:
+    # Corresponds to infrahub.graphql.manager.OrderInput
     disable: bool | None = None
+    node_metadata: NodeMetaOrder | None = None
+
+    @classmethod
+    def from_input(cls, input_data: dict[str, Any] | None) -> OrderModel | None:
+        """Convert the dictionary type input data from GraphQL into an OrderModel instance."""
+        if not input_data:
+            return None
+
+        order_model = cls(**input_data)
+        order_model.validate()
+        return order_model
+
+    def validate(self) -> None:
+        if self.node_metadata and self.node_metadata.created_at and self.node_metadata.updated_at:
+            raise ValidationError("Cannot order by both created_at and updated_at simultaneously.")

infrahub/graphql/mutations/account.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, InputField, InputObjectType, Mutation, String
+from graphene import Boolean, Field, InputField, InputObjectType, Mutation, ObjectType, String
 from graphql import GraphQLResolveInfo
 from infrahub_sdk.uuidt import UUIDT
 from typing_extensions import Self
@@ -36,7 +36,7 @@ class InfrahubAccountUpdateSelfInput(InputObjectType):
     description = InputField(String(required=False), description="Description to use instead of the current one")
 
 
-class ValueType(InfrahubObjectType):
+class ValueType(ObjectType):
     value = String(required=True)
 
 
@@ -99,7 +99,7 @@ class AccountMixin:
         )
 
         async with db.start_transaction() as dbt:
-            await obj.save(db=dbt)
+            await obj.save(db=dbt, user_id=account.id)
 
         fields = extract_graphql_fields(info=info)
         return cls(object=await obj.to_graphql(db=db, fields=fields.get("object", {})), ok=True)  # type: ignore[call-arg]
@@ -126,7 +126,7 @@ class AccountMixin:
             raise NodeNotFoundError(node_type="AccountToken", identifier=token_id)
 
         async with db.start_transaction() as dbt:
-            await results[0].delete(db=dbt)
+            await results[0].delete(db=dbt, user_id=account.id)
 
         return cls(ok=True)  # type: ignore[call-arg]
 
@@ -144,7 +144,7 @@ class AccountMixin:
                 getattr(account, field).value = value
 
         async with db.start_transaction() as dbt:
-            await account.save(db=dbt)
+            await account.save(db=dbt, user_id=account.id)
 
         return cls(ok=True)  # type: ignore[call-arg]
 

infrahub/graphql/mutations/attribute.py

@@ -8,7 +8,6 @@ from infrahub.graphql.types.attribute import GenericPoolInput
 
 
 class BaseAttributeCreate(InputObjectType):
-    is_visible = Boolean(required=False)
     is_protected = Boolean(required=False)
     source = String(required=False)
     owner = String(required=False)
@@ -21,7 +20,6 @@ class BaseAttributeCreate(InputObjectType):
 
 class BaseAttributeUpdate(InputObjectType):
     is_default = Boolean(required=False)
-    is_visible = Boolean(required=False)
     is_protected = Boolean(required=False)
     source = String(required=False)
     owner = String(required=False)

infrahub/graphql/mutations/branch.py

@@ -98,7 +98,11 @@ class BranchCreate(Mutation):
         # Retrieve created branch
         obj = await Branch.get_by_name(db=graphql_context.db, name=model.name)
         fields = extract_graphql_fields(info=info)
-        return cls(object=await obj.to_graphql(fields=fields.get("object", {})), ok=True, task=task)
+        return cls(
+            object=await obj.to_graphql_flat(fields=fields.get("object", {})),
+            ok=True,
+            task=task,
+        )
 
 
 class BranchNameInput(InputObjectType):
@@ -172,7 +176,7 @@ class BranchUpdate(Mutation):
                 setattr(obj, field_name, data[field_name])
 
         async with graphql_context.db.start_transaction() as db:
-            await obj.save(db=db)
+            await obj.save(db=db, user_id=graphql_context.active_account_session.account_id)
 
         return cls(ok=True)
 
@@ -218,7 +222,7 @@ class BranchRebase(Mutation):
         fields = extract_graphql_fields(info=info)
         ok = True
 
-        return cls(object=await obj.to_graphql(fields=fields.get("object", {})), ok=ok, task=task)
+        return cls(object=await obj.to_graphql_flat(fields=fields.get("object", {})), ok=ok, task=task)
 
 
 class BranchValidate(Mutation):
@@ -260,7 +264,7 @@ class BranchValidate(Mutation):
 
         fields = extract_graphql_fields(info=info)
 
-        return cls(object=await obj.to_graphql(fields=fields.get("object", {})), ok=ok, task=task)
+        return cls(object=await obj.to_graphql_flat(fields=fields.get("object", {})), ok=ok, task=task)
 
 
 class BranchMerge(Mutation):
@@ -315,4 +319,4 @@ class BranchMerge(Mutation):
         fields = extract_graphql_fields(info=info)
         ok = True
 
-        return cls(object=await obj.to_graphql(fields=fields.get("object", {})), ok=ok, task=task)
+        return cls(object=await obj.to_graphql_flat(fields=fields.get("object", {})), ok=ok, task=task)

infrahub/graphql/mutations/computed_attribute.py

@@ -102,7 +102,7 @@ class UpdateComputedAttribute(Mutation):
         if attribute_field.value != str(data.value):
             attribute_field.value = str(data.value)
             async with graphql_context.db.start_transaction() as dbt:
-                await target_node.save(db=dbt, fields=[str(data.attribute)])
+                await target_node.save(db=dbt, fields=[str(data.attribute)], user_id=graphql_context.assigned_user_id)
 
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")

infrahub/graphql/mutations/display_label.py

@@ -93,7 +93,7 @@ class UpdateDisplayLabel(Mutation):
             await target_node.set_display_label(value=str(data.value))
 
             async with graphql_context.db.start_transaction() as dbt:
-                await target_node.save(db=dbt, fields=["display_label"])
+                await target_node.save(db=dbt, fields=["display_label"], user_id=graphql_context.assigned_user_id)
 
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")

infrahub/graphql/mutations/hfid.py

@@ -100,7 +100,7 @@ class UpdateHFID(Mutation):
             await target_node.set_human_friendly_id(value=updated_hfid)
 
             async with graphql_context.db.start_transaction() as dbt:
-                await target_node.save(db=dbt, fields=["human_friendly_id"])
+                await target_node.save(db=dbt, fields=["human_friendly_id"], user_id=graphql_context.assigned_user_id)
 
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")

infrahub/graphql/mutations/ipam.py

@@ -9,7 +9,7 @@ from typing_extensions import Self
 from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, MetadataOptions
 from infrahub.core.ipam.reconciler import IpamReconciler
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
@@ -196,8 +196,7 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
             kind=cls._meta.schema.kind,
             id=data.get("id"),
             branch=branch,
-            include_owner=True,
-            include_source=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
         namespace = await address.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
@@ -356,8 +355,7 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
             kind=cls._meta.schema.kind,
             id=data.get("id"),
             branch=branch,
-            include_owner=True,
-            include_source=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
         namespace = await prefix.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
@@ -435,7 +433,7 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
             data.get("id"), graphql_context.db, branch=branch, prefetch_relationships=True
         )
         if not prefix:
-            raise NodeNotFoundError(branch, cls._meta.schema.kind, data.get("id"))
+            raise NodeNotFoundError(node_type=cls._meta.schema.kind, identifier=data.get("id"), branch_name=branch.name)
 
         namespace_rels = await prefix.ip_namespace.get_relationships(db=db)
         namespace_id = namespace_rels[0].peer_id