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

infrahub/core/task/task.py

@@ -1,9 +1,11 @@
+# This entire file and possibly everything in this module should be deleted. - Patrick (2025-12-11)
+
 from typing import Any
 
 from pydantic import ConfigDict, Field
 
 from infrahub.core.constants import TaskConclusion
-from infrahub.core.node.standard import StandardNode
+from infrahub.core.node.standard import StandardNode, StandardNodeQueryFields
 from infrahub.core.protocols import CoreNode
 from infrahub.core.query.standard_node import StandardNodeQuery
 from infrahub.core.query.task import TaskNodeCreateQuery, TaskNodeQuery, TaskNodeQueryWithLogs
@@ -70,7 +72,7 @@ class Task(StandardNode):
                 logs = [
                     {
                         "node": await TaskLog.from_db(result, extras={"task_id": task_result.get("uuid")}).to_graphql(
-                            fields=log_fields
+                            fields=StandardNodeQueryFields(node=log_fields)
                         )
                     }
                     for result in logs_results

infrahub/core/utils.py

@@ -62,28 +62,6 @@ async def delete_all_relationships_for_branch(branch_name: str, db: InfrahubData
     await db.execute_query(query=query, params=params, name="delete_all_relationships_for_branch")
 
 
-async def update_relationships_to(
-    ids: list[str], db: InfrahubDatabase, to: Timestamp | None = None
-) -> list[Record] | None:
-    """Update the "to" field on one or multiple relationships."""
-    if not ids:
-        return None
-
-    to = Timestamp(to)
-
-    query = """
-    MATCH ()-[r]->()
-    WHERE %(id_func)s(r) IN $ids
-    AND r.to IS NULL
-    SET r.to = $to
-    RETURN %(id_func)s(r)
-    """ % {"id_func": db.get_id_function_name()}
-
-    params = {"to": to.to_string(), "ids": [db.to_database_id(_id) for _id in ids]}
-
-    return await db.execute_query(query=query, params=params, name="update_relationships_to")
-
-
 async def get_paths_between_nodes(
     db: InfrahubDatabase,
     source_id: str,

infrahub/core/validators/attribute/kind.py

@@ -36,7 +36,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH (n:%(node_kinds)s)
+        MATCH p = (n:%(node_kind)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,10 +51,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {
-            "branch_filter": branch_filter,
-            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
-        }
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]

infrahub/core/validators/determiner.py

@@ -97,7 +97,7 @@ class ConstraintValidatorDeterminer:
         self, schema: MainSchemaTypes
     ) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
-        for prop_name, prop_field_info in schema.model_fields.items():
+        for prop_name, prop_field_info in schema.__class__.model_fields.items():
             if (
                 prop_name in ["attributes", "relationships"]
                 or not prop_field_info.json_schema_extra
@@ -158,10 +158,10 @@ class ConstraintValidatorDeterminer:
     ) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
         prop_details_list: list[tuple[str, FieldInfo, Any]] = []
-        for p_name, p_info in field.model_fields.items():
+        for p_name, p_info in field.__class__.model_fields.items():
             p_value = getattr(field, p_name)
             if isinstance(p_value, AttributeParameters):
-                for parameter_name, parameter_field_info in p_value.model_fields.items():
+                for parameter_name, parameter_field_info in p_value.__class__.model_fields.items():
                     parameter_value = getattr(p_value, parameter_name)
                     prop_details_list.append((f"{p_name}.{parameter_name}", parameter_field_info, parameter_value))
             else:

infrahub/database/__init__.py

@@ -13,7 +13,7 @@ from neo4j import (
     AsyncResult,
     AsyncSession,
     AsyncTransaction,
-    NotificationDisabledCategory,
+    NotificationDisabledClassification,
     NotificationMinimumSeverity,
     Query,
     Record,
@@ -492,8 +492,8 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         auth=(config.SETTINGS.database.username, config.SETTINGS.database.password),
         encrypted=config.SETTINGS.database.tls_enabled,
         trusted_certificates=trusted_certificates,
-        notifications_disabled_categories=[
-            NotificationDisabledCategory.UNRECOGNIZED,
+        notifications_disabled_classifications=[
+            NotificationDisabledClassification.UNRECOGNIZED,
         ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )

infrahub/dependencies/builder/constraint/grouped/node_runner.py

@@ -7,6 +7,7 @@ from ..relationship_manager.peer_kind import RelationshipPeerKindConstraintDepen
 from ..relationship_manager.peer_parent import RelationshipPeerParentConstraintDependency
 from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
+from ..relationship_manager.profiles_removal import RelationshipProfileRemovalConstraintDependency
 
 
 class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
@@ -20,6 +21,7 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipProfileRemovalConstraintDependency.build(context=context),
                 RelationshipPeerParentConstraintDependency.build(context=context),
                 RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],

infrahub/dependencies/builder/constraint/relationship_manager/profiles_removal.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.profiles_removal import RelationshipProfileRemovalConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipProfileRemovalConstraintDependency(DependencyBuilder[RelationshipProfileRemovalConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipProfileRemovalConstraint:
+        return RelationshipProfileRemovalConstraint(db=context.db, branch=context.branch)

infrahub/dependencies/registry.py

@@ -6,6 +6,7 @@ from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerK
 from .builder.constraint.relationship_manager.peer_parent import RelationshipPeerParentConstraintDependency
 from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
+from .builder.constraint.relationship_manager.profiles_removal import RelationshipProfileRemovalConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
 from .builder.constraint.schema.attribute_regex import SchemaAttributeRegexConstraintDependency
 from .builder.constraint.schema.attribute_uniqueness import SchemaAttributeUniqueConstraintDependency
@@ -38,6 +39,7 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(NodeGroupedUniquenessConstraintDependency)
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
+    component_registry.track_dependency(RelationshipProfileRemovalConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerParentConstraintDependency)
     component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)

infrahub/display_labels/tasks.py

@@ -21,9 +21,11 @@ UPDATE_DISPLAY_LABEL = """
 mutation UpdateDisplayLabel(
     $id: String!,
     $kind: String!,
-    $value: String!
+    $value: String!,
+    $context_account_id: String!
   ) {
   InfrahubUpdateDisplayLabel(
+    context: {account: {id: $context_account_id}},
     data: {id: $id, value: $value, kind: $kind}
   ) {
     ok
@@ -41,6 +43,7 @@ async def display_label_jinja2_update_value(
     obj: DisplayLabelJinja2GraphQLResponse,
     node_kind: str,
     template: Jinja2Template,
+    context: InfrahubContext,
 ) -> None:
     log = get_run_logger()
     client = get_client()
@@ -55,7 +58,12 @@ async def display_label_jinja2_update_value(
     try:
         await client.execute_graphql(
             query=UPDATE_DISPLAY_LABEL,
-            variables={"id": obj.node_id, "kind": node_kind, "value": value},
+            variables={
+                "id": obj.node_id,
+                "kind": node_kind,
+                "value": value,
+                "context_account_id": context.account.account_id,
+            },
             branch_name=branch_name,
         )
         log.info(f"Updating {node_kind}.display_label='{value}' ({obj.node_id})")
@@ -74,7 +82,7 @@ async def process_display_label(
     node_kind: str,
     object_id: str,
     target_kind: str,
-    context: InfrahubContext,  # noqa: ARG001
+    context: InfrahubContext,
 ) -> None:
     log = get_run_logger()
     client = get_client()
@@ -114,6 +122,7 @@ async def process_display_label(
             obj=node,
             node_kind=node_schema.kind,
             template=jinja_template,
+            context=context,
         )
 
     _ = [response async for _, response in batch.execute()]

infrahub/git/integrator.py

@@ -180,31 +180,31 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         self.create_commit_worktree(commit)
         await self._update_sync_status(branch_name=infrahub_branch_name, status=RepositorySyncStatus.SYNCING)
 
-        config_file = await self.get_repository_config(branch_name=infrahub_branch_name, commit=commit)  # type: ignore[misc]
+        config_file = await self.get_repository_config(branch_name=infrahub_branch_name, commit=commit)  # type: ignore[call-overload]
         sync_status = RepositorySyncStatus.IN_SYNC if config_file else RepositorySyncStatus.ERROR_IMPORT
 
         error: Exception | None = None
 
         try:
             if config_file:
-                await self.import_schema_files(branch_name=infrahub_branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
+                await self.import_schema_files(branch_name=infrahub_branch_name, commit=commit, config_file=config_file)  # type: ignore[call-overload]
                 await self.import_all_graphql_query(
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
                 await self.import_objects(
                     branch_name=infrahub_branch_name,
                     commit=commit,
                     config_file=config_file,
-                )  # type: ignore[misc]
-                await self.import_all_python_files(  # type: ignore[call-overload]
+                )  # type: ignore[call-overload]
+                await self.import_all_python_files(
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
                 await self.import_jinja2_transforms(
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
                 await self.import_artifact_definitions(
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
 
         except Exception as exc:
             sync_status = RepositorySyncStatus.ERROR_IMPORT
@@ -634,7 +634,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     module=module,
                     file_path=file_info.relative_path_file,
                     check_definition=check,
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
             )
 
         local_check_definitions = {check.name: check for check in checks}
@@ -797,7 +797,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     module=module,
                     file_path=file_info.relative_path_file,
                     transform=transform,
-                )  # type: ignore[misc]
+                )  # type: ignore[call-overload]
             )
 
         local_transform_definitions = {transform.name: transform for transform in transforms}
@@ -1156,9 +1156,9 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     ) -> None:
         await add_tags(branches=[branch_name], nodes=[str(self.id)])
 
-        await self.import_python_check_definitions(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
-        await self.import_python_transforms(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
-        await self.import_generator_definitions(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
+        await self.import_python_check_definitions(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[call-overload]
+        await self.import_python_transforms(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[call-overload]
+        await self.import_generator_definitions(branch_name=branch_name, commit=commit, config_file=config_file)  # type: ignore[call-overload]
 
     @task(name="jinja2-template-render", task_run_name="Render Jinja2 template", cache_policy=NONE)
     async def render_jinja2_template(self, commit: str, location: str, data: dict) -> str:
@@ -1324,7 +1324,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         if transformation.typename == InfrahubKind.TRANSFORMJINJA2:
             artifact_content = await self.render_jinja2_template.with_options(
                 timeout_seconds=transformation.timeout.value
-            )(commit=commit, location=transformation.template_path.value, data=response)  # type: ignore[misc]
+            )(commit=commit, location=transformation.template_path.value, data=response)  # type: ignore[call-overload]
         elif transformation.typename == InfrahubKind.TRANSFORMPYTHON:
             transformation_location = f"{transformation.file_path.value}::{transformation.class_name.value}"
             artifact_content = await self.execute_python_transform.with_options(
@@ -1336,7 +1336,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=transformation_location,
                 data=response,
                 convert_query_response=transformation.convert_query_response.value,
-            )  # type: ignore[misc]
+            )  # type: ignore[call-overload]
 
         if definition.content_type.value == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):
             artifact_content_str = ujson.dumps(artifact_content, indent=2)
@@ -1387,7 +1387,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         if message.transform_type == InfrahubKind.TRANSFORMJINJA2:
             artifact_content = await self.render_jinja2_template.with_options(timeout_seconds=message.timeout)(
                 commit=message.commit, location=message.transform_location, data=response
-            )  # type: ignore[misc]
+            )  # type: ignore[call-overload]
         elif message.transform_type == InfrahubKind.TRANSFORMPYTHON:
             artifact_content = await self.execute_python_transform.with_options(timeout_seconds=message.timeout)(
                 client=self.sdk,
@@ -1396,7 +1396,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                 location=message.transform_location,
                 data=response,
                 convert_query_response=message.convert_query_response,
-            )  # type: ignore[misc]
+            )  # type: ignore[call-overload]
 
         if message.content_type == ContentType.APPLICATION_JSON.value and isinstance(artifact_content, dict):
             artifact_content_str = ujson.dumps(artifact_content, indent=2)
@@ -1421,7 +1421,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         artifact.status.value = ArtifactStatus.READY.value
         if artifact.name.value != message.artifact_name:
             artifact.name.value = message.artifact_name
-        await artifact.save()
+        await artifact.save(request_context=message.context.to_request_context())
 
         event_class = ArtifactCreatedEvent if artifact_created else ArtifactUpdatedEvent
 

infrahub/git/tasks.py

@@ -950,7 +950,7 @@ async def run_user_check(model: UserCheckData) -> ValidatorConclusion:
             client=client,
             commit=model.commit,
             params=model.variables,
-        )  # type: ignore[misc]
+        )  # type: ignore[call-overload]
         if check_run.passed:
             conclusion = ValidatorConclusion.SUCCESS
             severity = "info"

infrahub/graphql/app.py

@@ -172,9 +172,9 @@ class InfrahubGraphQLApp:
 
         response = handler(request)
         if isawaitable(response):
-            return await response
+            return await cast("Awaitable[Response]", response)
 
-        return response
+        return cast("Response", response)
 
     async def _handle_http_request(
         self, request: Request, db: InfrahubDatabase, branch: Branch, account_session: AccountSession

infrahub/graphql/constants.py

@@ -1 +1,4 @@
 KIND_GRAPHQL_FIELD_NAME = "__kind__"
+
+NODE_METADATA_TYPE = "InfrahubNodeMetadata"
+RELATIONSHIP_METADATA_TYPE = "InfrahubRelationshipMetadata"

infrahub/graphql/context.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 async def apply_external_context(graphql_context: GraphqlContext, context_input: ContextInput | None) -> None:
     """Applies context provided by an external mutation to the GraphQL context"""
-    if not context_input or not context_input.account:
+    if not context_input or not context_input.account or not context_input.account.id:
         return
 
     if graphql_context.active_account_session.account_id == context_input.account.id:

infrahub/graphql/initialization.py

@@ -7,9 +7,11 @@ from starlette.background import BackgroundTasks
 
 from infrahub.context import InfrahubContext
 from infrahub.core import registry
+from infrahub.core.constants import SYSTEM_USER_ID
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError
 from infrahub.graphql.registry import registry as graphql_registry
+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.permissions import PermissionManager
@@ -37,6 +39,7 @@ class GraphqlContext:
     types: dict
     single_relationship_resolver: SingleRelationshipResolver
     many_relationship_resolver: ManyRelationshipResolver
+    account_metadata_resolver: AccountMetadataResolver
     service: InfrahubServices | None = None
     at: Timestamp | None = None
     related_node_ids: set | None = None
@@ -75,6 +78,13 @@ class GraphqlContext:
     def get_context(self) -> InfrahubContext:
         return InfrahubContext.init(branch=self.branch, account=self.active_account_session)
 
+    @property
+    def assigned_user_id(self) -> str:
+        """Return the user ID to be used for assignments in this context."""
+        if self.account_session and self.account_session.account_id:
+            return self.account_session.account_id
+        return SYSTEM_USER_ID
+
 
 async def prepare_graphql_params(
     db: InfrahubDatabase,
@@ -113,6 +123,7 @@ async def prepare_graphql_params(
             branch=branch,
             single_relationship_resolver=SingleRelationshipResolver(),
             many_relationship_resolver=ManyRelationshipResolver(),
+            account_metadata_resolver=AccountMetadataResolver(),
             at=Timestamp(at),
             types=gqlm.get_graphql_types(),
             related_node_ids=set(),

infrahub/graphql/loaders/account.py

@@ -0,0 +1,134 @@
+"""DataLoader for resolving account IDs to full account data."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from aiodataloader import DataLoader
+
+from infrahub.core.constants import SYSTEM_USER_ID, InfrahubKind
+from infrahub.core.manager import NodeManager
+from infrahub.graphql.constants import KIND_GRAPHQL_FIELD_NAME
+
+if TYPE_CHECKING:
+    from infrahub.core.branch.models import Branch
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+SYSTEM_ACCOUNT_DISPLAY_LABEL = "[Infrahub System]"
+UNKNOWN_ACCOUNT_DISPLAY_LABEL = "[Unknown Account]"
+
+
+@dataclass
+class AccountLoaderParams:
+    branch: Branch
+    at: Timestamp | None
+    fields: dict[str, Any] = field(default_factory=dict)
+
+    def __hash__(self) -> int:
+        # Fields are not included in hash as they vary per query but we want to reuse loader
+        at_str = self.at.to_string() if self.at else ""
+        return hash(f"{at_str}|{self.branch.name}")
+
+
+class AccountDataLoader(DataLoader[str, dict[str, Any] | None]):
+    """DataLoader for batch-loading account data by ID.
+
+    Handles SYSTEM_USER_ID specially by returning synthetic system account data.
+    All lookups are branch-agnostic since accounts don't vary by branch.
+    """
+
+    def __init__(
+        self,
+        db: InfrahubDatabase,
+        params: AccountLoaderParams,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.db = db
+        self.params = params
+
+    def _build_system_account_response(self, fields: dict[str, Any]) -> dict[str, Any]:
+        """Build response for SYSTEM_USER_ID based on requested fields."""
+        # Always include __kind__ for GraphQL interface type resolution
+        response: dict[str, Any] = {KIND_GRAPHQL_FIELD_NAME: InfrahubKind.ACCOUNT}
+
+        for field_name in fields:
+            if field_name == "id":
+                response["id"] = SYSTEM_USER_ID
+            elif field_name == "display_label":
+                response["display_label"] = SYSTEM_ACCOUNT_DISPLAY_LABEL
+            elif field_name == "__typename":
+                response["__typename"] = InfrahubKind.ACCOUNT
+            elif field_name == "name":
+                response["name"] = {"value": SYSTEM_ACCOUNT_DISPLAY_LABEL}
+            elif field_name == "label":
+                response["label"] = {"value": SYSTEM_ACCOUNT_DISPLAY_LABEL}
+            elif field_name == "description":
+                response["description"] = {"value": None}
+            else:
+                # For any other field, return None
+                response[field_name] = None
+
+        return response
+
+    def _build_unknown_account_response(self, account_id: str, fields: dict[str, Any]) -> dict[str, Any]:
+        """Build response for an unknown/deleted account based on requested fields."""
+        # Always include __kind__ for GraphQL interface type resolution
+        response: dict[str, Any] = {KIND_GRAPHQL_FIELD_NAME: InfrahubKind.ACCOUNT}
+
+        for field_name in fields:
+            if field_name == "id":
+                response["id"] = account_id
+            elif field_name == "display_label":
+                response["display_label"] = UNKNOWN_ACCOUNT_DISPLAY_LABEL
+            elif field_name == "__typename":
+                response["__typename"] = InfrahubKind.ACCOUNT
+            elif field_name == "name":
+                response["name"] = {"value": UNKNOWN_ACCOUNT_DISPLAY_LABEL}
+            elif field_name == "label":
+                response["label"] = {"value": UNKNOWN_ACCOUNT_DISPLAY_LABEL}
+            elif field_name == "description":
+                response["description"] = {"value": None}
+            else:
+                response[field_name] = None
+
+        return response
+
+    async def batch_load_fn(self, keys: list[str]) -> list[dict[str, Any] | None]:
+        # Separate system user from real account IDs
+        real_account_ids = [k for k in keys if k != SYSTEM_USER_ID]
+
+        # Batch load real accounts
+        accounts_by_id: dict[str, dict[str, Any]] = {}
+        if real_account_ids:
+            async with self.db.start_session(read_only=True) as db:
+                nodes = await NodeManager.get_many(
+                    db=db,
+                    ids=real_account_ids,
+                    fields=self.params.fields,
+                    at=self.params.at,
+                    branch=self.params.branch,
+                    branch_agnostic=True,  # Accounts are always branch-agnostic
+                )
+
+                for node_id, node in nodes.items():
+                    accounts_by_id[node_id] = await node.to_graphql(
+                        db=db,
+                        fields=self.params.fields,
+                    )
+
+        # Build results in same order as keys
+        results: list[dict[str, Any] | None] = []
+        for key in keys:
+            if key == SYSTEM_USER_ID:
+                results.append(self._build_system_account_response(self.params.fields))
+            elif key in accounts_by_id:
+                results.append(accounts_by_id[key])
+            else:
+                # Account not found - return placeholder
+                results.append(self._build_unknown_account_response(key, self.params.fields))
+
+        return results

infrahub/graphql/loaders/node.py

@@ -1,11 +1,11 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 from aiodataloader import DataLoader
 
-from infrahub.auth import AccountSession
 from infrahub.core.branch.models import Branch
 from infrahub.core.manager import NodeManager
+from infrahub.core.metadata.model import MetadataQueryOptions
 from infrahub.core.node import Node
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
@@ -18,10 +18,8 @@ class GetManyParams:
     branch: Branch | str
     fields: dict | None = None
     at: Timestamp | str | None = None
-    include_source: bool = False
-    include_owner: bool = False
+    include_metadata: MetadataQueryOptions = field(default_factory=MetadataQueryOptions)
     prefetch_relationships: bool = False
-    account: AccountSession | None = None
     branch_agnostic: bool = False
 
     def __hash__(self) -> int:
@@ -30,16 +28,13 @@ class GetManyParams:
             frozen_fields = to_frozen_set(self.fields)
         timestamp = Timestamp(self.at)
         branch = self.branch.name if isinstance(self.branch, Branch) else self.branch
-        account_id = self.account.account_id if isinstance(self.account, AccountSession) else None
         hash_str = "|".join(
             [
                 str(hash(frozen_fields)),
                 timestamp.to_string(),
                 branch,
-                str(self.include_source),
-                str(self.include_owner),
+                str(hash(self.include_metadata)),
                 str(self.prefetch_relationships),
-                str(account_id),
                 str(self.branch_agnostic),
             ]
         )
@@ -60,10 +55,8 @@ class NodeDataLoader(DataLoader[str, Node | None]):
                 fields=self.query_params.fields,
                 at=self.query_params.at,
                 branch=self.query_params.branch,
-                include_source=self.query_params.include_source,
-                include_owner=self.query_params.include_owner,
+                include_metadata=self.query_params.include_metadata,
                 prefetch_relationships=self.query_params.prefetch_relationships,
-                account=self.query_params.account,
                 branch_agnostic=self.query_params.branch_agnostic,
             )
         results = []

infrahub/graphql/loaders/peers.py

@@ -1,10 +1,11 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 from aiodataloader import DataLoader
 
 from infrahub.core.branch.models import Branch
 from infrahub.core.manager import NodeManager
+from infrahub.core.metadata.model import MetadataQueryOptions
 from infrahub.core.relationship.model import Relationship
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.timestamp import Timestamp
@@ -22,8 +23,7 @@ class QueryPeerParams:
     fields: dict | None = None
     at: Timestamp | str | None = None
     branch_agnostic: bool = False
-    include_source: bool = False
-    include_owner: bool = False
+    include_metadata: MetadataQueryOptions = field(default_factory=MetadataQueryOptions)
 
     def __hash__(self) -> int:
         frozen_fields: frozenset | None = None
@@ -41,8 +41,7 @@ class QueryPeerParams:
                 self.schema.name,
                 str(self.source_kind),
                 str(self.branch_agnostic),
-                str(self.include_source),
-                str(self.include_owner),
+                str(hash(self.include_metadata)),
             ]
         )
         return hash(hash_str)
@@ -66,9 +65,8 @@ class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
                 at=self.query_params.at,
                 branch=self.query_params.branch,
                 branch_agnostic=self.query_params.branch_agnostic,
+                include_metadata=self.query_params.include_metadata,
                 fetch_peers=True,
-                include_source=self.query_params.include_source,
-                include_owner=self.query_params.include_owner,
             )
         peer_rels_by_node_id: dict[str, list[Relationship]] = {}
         for rel in peer_rels: