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

infrahub/graphql/mutations/main.py

@@ -150,7 +150,8 @@ class InfrahubMutationMixin:
         database: InfrahubDatabase | None = None,
         override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
-        db = database or info.context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
         schema = cls._meta.active_schema
 
         create_data = dict(data)
@@ -161,6 +162,7 @@ class InfrahubMutationMixin:
             db=db,
             branch=branch,
             schema=schema,
+            user_id=graphql_context.assigned_user_id,
         )
 
         graphql_response = await build_graphql_response(info=info, db=db, obj=obj)
@@ -239,12 +241,13 @@ class InfrahubMutationMixin:
     async def mutate_update_object(
         cls,
         db: InfrahubDatabase,
-        info: GraphQLResolveInfo,  # noqa: ARG003
+        info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
         obj: Node,
         skip_uniqueness_check: bool = False,
     ) -> Node:
+        graphql_context: GraphqlContext = info.context
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
 
@@ -264,7 +267,7 @@ class InfrahubMutationMixin:
             node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
             updated_field_names = await node_profiles_applier.apply_profiles(node=obj)
             fields += updated_field_names
-        await obj.save(db=db, fields=fields)
+        await obj.save(db=db, fields=fields, user_id=graphql_context.assigned_user_id)
 
         return obj
 
@@ -381,7 +384,9 @@ class InfrahubMutationMixin:
     async def _delete_obj(cls, graphql_context: GraphqlContext, branch: Branch, obj: Node) -> list[Node]:
         db = graphql_context.db
         async with db.start_transaction() as dbt:
-            deleted = await NodeManager.delete(db=dbt, branch=branch, nodes=[obj])
+            deleted = await NodeManager.delete(
+                db=dbt, branch=branch, nodes=[obj], user_id=graphql_context.assigned_user_id
+            )
         deleted_str = ", ".join([f"{d.get_kind()}({d.get_id()})" for d in deleted])
         log.info(f"nodes deleted: {deleted_str}")
         return deleted

infrahub/graphql/mutations/profile.py

@@ -7,8 +7,11 @@ from graphql import GraphQLResolveInfo
 from opentelemetry import trace
 from typing_extensions import Self
 
+from infrahub.core.constants import MetadataOptions
 from infrahub.core.manager import NodeManager
+from infrahub.core.relationship.constraints.profiles_removal import RelationshipProfileRemovalConstraint
 from infrahub.core.schema import ProfileSchema
+from infrahub.dependencies.registry import get_component_registry
 from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_logger
 from infrahub.profiles.node_applier import NodeProfilesApplier
@@ -69,16 +72,6 @@ class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
                 },
             )
 
-    @classmethod
-    def _get_profile_attr_values_map(cls, obj: Node) -> dict[str, Any]:
-        attr_values_map = {}
-        for attr_schema in obj.get_schema().attributes:
-            # profile name update can be ignored
-            if attr_schema.name == "profile_name":
-                continue
-            attr_values_map[attr_schema.name] = getattr(obj, attr_schema.name).value
-        return attr_values_map
-
     @classmethod
     async def _get_profile_related_node_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
         related_nodes = []
@@ -126,29 +119,24 @@ class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
         skip_uniqueness_check: bool = False,
     ) -> tuple[Node, Self]:
         workflow_service = info.context.active_service.workflow
-        original_attr_values = cls._get_profile_attr_values_map(obj=obj)
         original_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
 
         obj, mutation = await super()._call_mutate_update(
             info=info, data=data, branch=branch, db=db, obj=obj, skip_uniqueness_check=skip_uniqueness_check
         )
 
-        updated_attr_values = cls._get_profile_attr_values_map(obj=obj)
         updated_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
 
-        if original_attr_values != updated_attr_values:
-            await cls._send_profile_refresh_workflows(
-                db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj
-            )
-        elif updated_related_node_ids != original_related_node_ids:
-            removed_node_ids = original_related_node_ids - updated_related_node_ids
-            added_node_ids = updated_related_node_ids - original_related_node_ids
+        # Handle nodes removed from related_nodes - these need explicit refresh
+        # since the async automation won't find them in the profile's related_nodes after the change.
+        # Attribute changes and added nodes are handled by the Prefect automation
+        if removed_node_ids := original_related_node_ids - updated_related_node_ids:
             await cls._send_profile_refresh_workflows(
                 db=db,
                 workflow_service=workflow_service,
                 branch_name=branch.name,
                 obj=obj,
-                node_ids=list(removed_node_ids) + list(added_node_ids),
+                node_ids=list(removed_node_ids),
             )
 
         return obj, mutation
@@ -158,6 +146,12 @@ class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
         db = graphql_context.db
         workflow_service = graphql_context.active_service.workflow
         related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+
+        profile_schema: ProfileSchema = obj.get_schema()  # type: ignore[assignment]
+        component_registry = get_component_registry()
+        constraint = await component_registry.get_component(RelationshipProfileRemovalConstraint, db=db, branch=branch)
+        await constraint.validate_profile_deletion(profile=obj, profile_schema=profile_schema)
+
         deleted = await super()._delete_obj(graphql_context=graphql_context, branch=branch, obj=obj)
         await cls._send_profile_refresh_workflows(
             db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj, node_ids=list(related_node_ids)
@@ -192,12 +186,12 @@ class InfrahubProfilesRefresh(Mutation):
             db=db,
             branch=branch,
             id=str(data.id),
-            include_source=True,
+            include_metadata=MetadataOptions.SOURCE,
             raise_on_error=True,
         )
         node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
         updated_fields = await node_profiles_applier.apply_profiles(node=obj)
         if updated_fields:
-            await obj.save(db=db, fields=updated_fields)
+            await obj.save(db=db, fields=updated_fields, user_id=graphql_context.assigned_user_id)
 
         return cls(ok=True)

infrahub/graphql/mutations/proposed_change.py

@@ -13,6 +13,7 @@ from infrahub.core.constants import (
     CheckType,
     GlobalPermissions,
     InfrahubKind,
+    MetadataOptions,
     PermissionDecision,
 )
 from infrahub.core.manager import NodeManager
@@ -128,8 +129,7 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
             kind=cls._meta.schema.kind,
             id=data.get("id"),
             branch=branch,
-            include_owner=True,
-            include_source=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
         state = ProposedChangeState(obj.state.value.value)
         state.validate_updatable()
@@ -292,7 +292,7 @@ class ProposedChangeReview(Mutation):
                     current_user=current_user,
                     context=graphql_context,
                 )
-                await proposed_change.save(db=db)
+                await proposed_change.save(db=db, user_id=graphql_context.active_account_session.account_id)
 
                 if event:
                     event_service = await get_event_service()
@@ -426,7 +426,7 @@ class ProposedChangeMerge(Mutation):
 
         async with graphql_context.db.start_session() as db:
             proposed_change.state.value = ProposedChangeState.MERGING.value
-            await proposed_change.save(db=db)
+            await proposed_change.save(db=db, user_id=graphql_context.assigned_user_id)
 
         if wait_until_completion:
             await graphql_context.service.workflow.execute_workflow(

infrahub/graphql/mutations/relationship.py

@@ -11,6 +11,7 @@ from infrahub.core.account import GlobalPermission, ObjectPermission
 from infrahub.core.changelog.models import NodeChangelog, RelationshipChangelogGetter
 from infrahub.core.constants import (
     InfrahubKind,
+    MetadataOptions,
     PermissionAction,
     PermissionDecision,
     RelationshipCardinality,
@@ -22,7 +23,7 @@ from infrahub.core.query.relationship import (
     RelationshipPeerData,
 )
 from infrahub.core.relationship import Relationship
-from infrahub.database import retry_db_transaction
+from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.events import EventMeta
 from infrahub.events.group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
 from infrahub.events.models import EventNode
@@ -32,12 +33,14 @@ from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
 from infrahub.groups.ancestors import collect_ancestors
 from infrahub.permissions import get_global_permission_for_kind
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
 from ..types import RelatedNodeInput
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
+    from infrahub.core.branch import Branch
     from infrahub.core.node import Node
     from infrahub.core.relationship import RelationshipManager
     from infrahub.core.schema.relationship_schema import RelationshipSchema
@@ -91,7 +94,7 @@ class RelationshipAdd(Mutation):
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         rel_schema = source.get_schema().get_relationship(name=relationship_name)
-        display_label: str = await source.get_display_label(db=graphql_context.db) or ""
+        display_label = await source.get_display_label(db=graphql_context.db)
         node_changelog = NodeChangelog(
             node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )
@@ -107,7 +110,9 @@ class RelationshipAdd(Mutation):
             for node_data in data.get("nodes"):
                 # Instantiate and resolve a relationship
                 # This will take care of allocating a node from a pool if needed
-                rel = Relationship(schema=rel_schema, branch=graphql_context.branch, node=source)
+                rel = Relationship(
+                    schema=rel_schema, branch=graphql_context.branch, source_kind=source.get_kind(), node=source
+                )
                 await rel.new(db=db, data=node_data)
                 await rel.resolve(db=db)
                 # Save it only if it does not exist
@@ -115,7 +120,14 @@ class RelationshipAdd(Mutation):
                     if group_event_type != GroupUpdateType.NONE:
                         peers.append(EventNode(id=rel.get_peer_id(), kind=nodes[rel.get_peer_id()].get_kind()))
                     node_changelog.create_relationship(relationship=rel)
-                    await rel.save(db=db)
+                    await rel.save(db=db, user_id=graphql_context.assigned_user_id)
+
+            if relationship_name == "profiles":
+                await _apply_profiles(node=source, db=db, branch=graphql_context.branch)
+
+            if source.get_schema().is_profile_schema and relationship_name == "related_nodes":
+                for node in nodes.values():
+                    await _apply_profiles(node=node, db=db, branch=graphql_context.branch)
 
         if config.SETTINGS.broker.enable and graphql_context.background and node_changelog.has_changes:
             if group_event_type == GroupUpdateType.MEMBERS:
@@ -230,14 +242,23 @@ class RelationshipRemove(Mutation):
             for node_data in data.get("nodes"):
                 if node_data.get("id") in existing_peers.keys():
                     # TODO once https://github.com/opsmill/infrahub/issues/792 has been fixed
-                    # we should use RelationshipDataDeleteQuery to delete the relationship
+                    # we should use RelationshipDeleteQuery to delete the relationship
                     # it would be more query efficient
-                    rel = Relationship(schema=rel_schema, branch=graphql_context.branch, node=source)
+                    rel = Relationship(
+                        schema=rel_schema, branch=graphql_context.branch, source_kind=source.get_kind(), node=source
+                    )
                     rel.load(db=db, data=existing_peers[node_data.get("id")])
                     if group_event_type != GroupUpdateType.NONE:
                         peers.append(EventNode(id=rel.get_peer_id(), kind=nodes[rel.get_peer_id()].get_kind()))
                     node_changelog.delete_relationship(relationship=rel)
-                    await rel.delete(db=db)
+                    await rel.delete(db=db, user_id=graphql_context.assigned_user_id)
+
+            if relationship_name == "profiles":
+                await _apply_profiles(node=source, db=db, branch=graphql_context.branch)
+
+            if source.get_schema().is_profile_schema and relationship_name == "related_nodes":
+                for node in nodes.values():
+                    await _apply_profiles(node=node, db=db, branch=graphql_context.branch)
 
         if config.SETTINGS.broker.enable and graphql_context.background and node_changelog.has_changes:
             if group_event_type == GroupUpdateType.MEMBERS:
@@ -318,8 +339,7 @@ async def _validate_node(info: GraphQLResolveInfo, data: RelationshipNodesInput)
             db=graphql_context.db,
             id=input_id,
             branch=graphql_context.branch,
-            include_owner=False,
-            include_source=False,
+            include_metadata=MetadataOptions.NONE,
         )
     ):
         raise NodeNotFoundError(node_type="node", identifier=input_id, branch_name=graphql_context.branch.name)
@@ -455,7 +475,9 @@ async def _collect_current_peers(
     query = await RelationshipGetPeerQuery.init(
         db=graphql_context.db,
         source=source_node,
-        rel=Relationship(schema=rel_schema, branch=graphql_context.branch, node=source_node),
+        rel=Relationship(
+            schema=rel_schema, branch=graphql_context.branch, source_kind=source_node.get_kind(), node=source_node
+        ),
     )
     await query.execute(db=graphql_context.db)
     return {str(peer.peer_id): peer for peer in query.get_peers()}
@@ -474,3 +496,11 @@ def _get_group_event_type(
             # Modifying the membership of the current node
             group_event_type = GroupUpdateType.MEMBER_OF_GROUPS
     return group_event_type
+
+
+async def _apply_profiles(node: Node, db: InfrahubDatabase, branch: Branch) -> None:
+    refreshed_node = await NodeManager.get_one(db=db, id=node.get_id(), branch=branch)
+    node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+    updated_fields = await node_profiles_applier.apply_profiles(node=refreshed_node)
+    if updated_fields:
+        await refreshed_node.save(db=db, fields=updated_fields)

infrahub/graphql/mutations/repository.py

@@ -7,7 +7,7 @@ import httpx
 from graphene import Boolean, Field, InputObjectType, Mutation, String
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, MetadataOptions
 from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
 from infrahub.git.models import (
@@ -42,7 +42,9 @@ log = get_logger()
 
 class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(cls, schema: NodeSchema | None = None, _meta=None, **options) -> None:
+    def __init_subclass_with_meta__(
+        cls, schema: NodeSchema | None = None, _meta: InfrahubMutationOptions | None = None, **options: Any
+    ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
         if not isinstance(schema, NodeSchema):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
@@ -95,21 +97,21 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         graphql_context: GraphqlContext = info.context
 
         cleanup_payload(data)
-        if not node:
-            node: CoreReadOnlyRepository | CoreRepository = await NodeManager.get_one_by_id_or_default_filter(
+        repo_node: CoreReadOnlyRepository | CoreRepository | Node | None = node
+        if not repo_node:
+            repo_node = await NodeManager.get_one_by_id_or_default_filter(
                 db=graphql_context.db,
                 kind=cls._meta.schema.kind,
                 id=data.get("id"),
                 branch=branch,
-                include_owner=True,
-                include_source=True,
+                include_metadata=MetadataOptions.LINKED_NODES,
             )
-        if node.get_kind() != InfrahubKind.READONLYREPOSITORY:
-            return await super().mutate_update(info, data, branch, database=graphql_context.db, node=node)
+        if repo_node.get_kind() != InfrahubKind.READONLYREPOSITORY:
+            return await super().mutate_update(info, data, branch, database=graphql_context.db, node=repo_node)
 
-        node = cast("CoreReadOnlyRepository", node)
-        current_commit = node.commit.value
-        current_ref = node.ref.value
+        repo_node = cast("CoreReadOnlyRepository", repo_node)
+        current_commit = repo_node.commit.value
+        current_ref = repo_node.ref.value
         new_commit = None
         if data.commit and data.commit.value:
             new_commit = data.commit.value
@@ -117,7 +119,7 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         if data.ref and data.ref.value:
             new_ref = data.ref.value
 
-        obj, result = await super().mutate_update(info, data, branch, database=graphql_context.db, node=node)
+        obj, result = await super().mutate_update(info, data, branch, database=graphql_context.db, node=repo_node)
         obj = cast("CoreReadOnlyRepository", obj)
 
         send_update_message = (new_commit and new_commit != current_commit) or (new_ref and new_ref != current_ref)

infrahub/graphql/mutations/schema.py

@@ -329,11 +329,11 @@ async def update_registry(
             log.info(f"Schema has diff, will need to be updated {diff.all}", branch=branch.name)
             async with db.start_transaction() as dbt:
                 await registry.schema.update_schema_branch(
-                    schema=tmp_schema, db=dbt, branch=branch.name, limit=diff.all, update_db=True
+                    schema=tmp_schema, db=dbt, branch=branch.name, limit=diff.all, update_db=True, user_id=account_id
                 )
                 branch.update_schema_hash()
                 log.info("Schema has been updated", branch=branch.name, hash=branch.active_schema_hash.main)
-                await branch.save(db=dbt)
+                await branch.save(db=dbt, user_id=account_id)
 
             await service.component.refresh_schema_hash(branches=[branch.name])
 

infrahub/graphql/queries/branch.py

@@ -2,24 +2,59 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import ID, Field, Int, List, NonNull, String
+from graphene import ID, Argument, Boolean, Field, Int, List, NonNull, String
 
+from infrahub.constants.enums import OrderByField, OrderDirection
+from infrahub.core.node.standard import StandardNodeOrdering, StandardNodeQueryFields
 from infrahub.core.registry import registry
 from infrahub.exceptions import ValidationError
 from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.types import BranchType, InfrahubBranch, InfrahubBranchType
+from infrahub.graphql.types.metadata import OrderInput
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
 
+def standard_node_ordering_from_order_input(order: OrderInput | None = None) -> StandardNodeOrdering:
+    """Create a StandardNodeOrdering from an OrderInput.
+
+    Args:
+        order: Optional ordering specification from GraphQL input.
+
+    Returns:
+        StandardNodeOrdering with the specified field and direction, or defaults to ID with no direction.
+
+    Raises:
+        ValidationError: If both created_at and updated_at are specified.
+    """
+    if order is None or not order.node_metadata:
+        return StandardNodeOrdering()
+
+    created_at = getattr(order.node_metadata, "created_at", None)
+    updated_at = getattr(order.node_metadata, "updated_at", None)
+
+    if created_at and updated_at:
+        raise ValidationError("Only one of 'created_at' or 'updated_at' can be specified for ordering.")
+
+    if created_at:
+        return StandardNodeOrdering(order_by=OrderByField.CREATED_AT, direction=OrderDirection(created_at.value))
+
+    if updated_at:
+        return StandardNodeOrdering(order_by=OrderByField.UPDATED_AT, direction=OrderDirection(updated_at.value))
+
+    return StandardNodeOrdering()
+
+
 async def branch_resolver(
     root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
     **kwargs: Any,
 ) -> list[dict[str, Any]]:
     fields = extract_graphql_fields(info)
-    return await BranchType.get_list(graphql_context=info.context, fields=fields, exclude_global=True, **kwargs)
+    return await BranchType.get_list(
+        graphql_context=info.context, fields=StandardNodeQueryFields(node=fields), exclude_global=True, **kwargs
+    )
 
 
 BranchQueryList = Field(
@@ -39,36 +74,51 @@ async def infrahub_branch_resolver(
     offset: int | None = None,
     name__value: str | None = None,
     ids: list[str] | None = None,
+    partial_match: bool = False,
+    order: OrderInput | None = None,
 ) -> dict[str, Any]:
     if isinstance(limit, int) and limit < 1:
         raise ValidationError("limit must be >= 1")
     if isinstance(offset, int) and offset < 0:
         raise ValidationError("offset must be >= 0")
 
+    node_ordering = standard_node_ordering_from_order_input(order)
+
     fields = extract_graphql_fields(info)
     result: dict[str, Any] = {}
     if "edges" in fields:
+        query_fields = StandardNodeQueryFields(
+            node=fields.get("edges", {}).get("node", {}),
+            node_metadata=fields.get("edges", {}).get("node_metadata", {}),
+        )
         branches = await InfrahubBranch.get_list(
             graphql_context=info.context,
-            fields=fields.get("edges", {}).get("node", {}),
+            fields=query_fields,
             limit=limit,
             offset=offset,
             name=name__value,
             ids=ids,
             exclude_global=True,
+            partial_match=partial_match,
+            node_ordering=node_ordering,
         )
-        result["edges"] = [{"node": branch} for branch in branches]
+        result["edges"] = branches
     if "count" in fields:
         result["count"] = await InfrahubBranchType.get_list_count(
-            graphql_context=info.context, name=name__value, ids=ids
+            graphql_context=info.context,
+            name=name__value,
+            ids=ids,
+            partial_match=partial_match,
+            node_ordering=node_ordering,
         )
 
     if "default_branch" in fields:
-        result["default_branch"] = await InfrahubBranch.get_by_name(
+        default_branch = await InfrahubBranch.get_by_name(
             graphql_context=info.context,
             fields=fields["default_branch"],
             name=registry.default_branch,
         )
+        result["default_branch"] = default_branch["node"]
 
     return result
 
@@ -79,6 +129,12 @@ InfrahubBranchQueryList = Field(
     limit=Int(),
     name__value=String(),
     ids=List(ID),
+    partial_match=Boolean(default_value=False),
+    order=Argument(
+        OrderInput,
+        required=False,
+        description="Define ordering of results for branch queries.",
+    ),
     description="Retrieve paginated information about active branches.",
     resolver=infrahub_branch_resolver,
     required=True,

infrahub/graphql/queries/diff/tree.py

@@ -60,10 +60,10 @@ class ConflictDetails(ObjectType):
 
 
 class DiffSummaryCounts(ObjectType):
-    num_added = Int(required=True)
-    num_updated = Int(required=True)
-    num_removed = Int(required=True)
-    num_conflicts = Int(required=True)
+    num_added = Int(required=False)
+    num_updated = Int(required=False)
+    num_removed = Int(required=False)
+    num_conflicts = Int(required=False)
 
 
 class DiffProperty(ObjectType):
@@ -146,7 +146,7 @@ class DiffTreeSummary(DiffSummaryCounts):
     diff_branch = String(required=True)
     from_time = DateTime(required=True)
     to_time = DateTime(required=True)
-    num_unchanged = Int(required=True)
+    num_unchanged = Int(required=False)
     num_untracked_base_changes = Int(required=False)
     num_untracked_diff_changes = Int(required=False)
 

infrahub/graphql/resolvers/account_metadata.py

@@ -0,0 +1,84 @@
+"""Resolvers for account metadata fields (created_by, updated_by)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.graphql.field_extractor import extract_graphql_fields
+from infrahub.graphql.loaders.account import AccountDataLoader, AccountLoaderParams
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch.models import Branch
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class AccountMetadataResolver:
+    """Resolver class for account metadata fields (created_by, updated_by).
+
+    This class maintains DataLoader instances to enable batching and caching
+    of account lookups across multiple fields within the same request.
+    """
+
+    def __init__(self) -> None:
+        self._data_loader_instances: dict[AccountLoaderParams, AccountDataLoader] = {}
+
+    def _get_or_create_loader(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        at: Timestamp | None,
+        fields: dict[str, Any],
+    ) -> AccountDataLoader:
+        """Get an existing loader or create a new one for the given parameters."""
+        params = AccountLoaderParams(branch=branch, at=at, fields=fields)
+
+        if params not in self._data_loader_instances:
+            self._data_loader_instances[params] = AccountDataLoader(db=db, params=params)
+
+        return self._data_loader_instances[params]
+
+    async def resolve(
+        self,
+        parent: dict[str, Any],
+        info: GraphQLResolveInfo,
+    ) -> dict[str, Any] | None:
+        """Resolve created_by/updated_by fields in metadata objects.
+
+        The parent dict should contain {"id": "account-uuid", "__kind__": "CoreAccount"}
+        for the field being resolved, or the field value may be None.
+        """
+        field_name = info.field_name  # "created_by" or "updated_by"
+        account_data = parent.get(field_name)
+
+        if not account_data or not account_data.get("id"):
+            return None
+
+        account_id = account_data["id"]
+        graphql_context: GraphqlContext = info.context
+
+        # Extract the fields requested for this account
+        fields = extract_graphql_fields(info=info)
+
+        # Get or create a loader for these parameters
+        loader = self._get_or_create_loader(
+            db=graphql_context.db,
+            branch=graphql_context.branch,
+            at=graphql_context.at,
+            fields=fields,
+        )
+
+        return await loader.load(account_id)
+
+
+async def account_metadata_resolver(
+    parent: dict[str, Any],
+    info: GraphQLResolveInfo,
+) -> dict[str, Any] | None:
+    """Function resolver that delegates to the AccountMetadataResolver on the context."""
+    graphql_context: GraphqlContext = info.context
+    resolver = graphql_context.account_metadata_resolver
+    return await resolver.resolve(parent=parent, info=info)