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

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)

infrahub/graphql/resolvers/ipam.py

@@ -9,7 +9,7 @@ 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
@@ -19,7 +19,7 @@ from infrahub.exceptions import ValidationError
 from infrahub.graphql.parser import extract_selection
 from infrahub.graphql.permissions import get_permissions
 
-from ..models import OrderModel
+from ..order import deserialize_order_input
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -31,7 +31,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 +310,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 +323,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 = deserialize_order_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]
@@ -399,11 +399,9 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
                 branch=graphql_context.branch,
                 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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
 from graphql.type.definition import GraphQLNonNull
@@ -7,18 +8,19 @@ from opentelemetry import trace
 
 from infrahub.core.constants import BranchSupportType, InfrahubKind, RelationshipHierarchyDirection
 from infrahub.core.manager import NodeManager
+from infrahub.core.order import OrderModel
 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 ..order import deserialize_order_input
 from ..parser import extract_selection
 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
 
 
@@ -140,22 +142,63 @@ async def parent_field_name_resolver(parent: dict[str, dict], info: GraphQLResol
     return parent[info.field_name]
 
 
+def _transform_metadata_day_filters(filters: dict[str, Any]) -> dict[str, Any]:
+    """Transform metadata datetime filters with 00:00:00 time into day range filters.
+
+    When a filter like `node_metadata__created_at="2025-02-03T00:00:00"` has a time
+    of exactly midnight, transform it into __after and __before filters to match
+    the entire day (inclusive of midnight).
+
+    If __after or __before filters are already explicitly defined, they will not be
+    overwritten by the generated day range filters.
+    """
+    result = dict(filters)
+    metadata_datetime_fields = ("node_metadata__created_at", "node_metadata__updated_at")
+
+    for field in metadata_datetime_fields:
+        if field not in result:
+            continue
+        value = result[field]
+        if not isinstance(value, datetime):
+            continue
+        # Check if time is midnight (00:00:00)
+        if value.hour == 0 and value.minute == 0 and value.second == 0 and value.microsecond == 0:
+            # Remove the exact match filter
+            del result[field]
+            # Add __after filter with one microsecond before midnight to include objects at exactly midnight
+            # Skip if __after is already explicitly defined
+            after_key = f"{field}__after"
+            if after_key not in result:
+                one_microsecond_before = value - timedelta(microseconds=1)
+                result[after_key] = one_microsecond_before
+            # Add __before filter with next day (exclusive: <)
+            # Skip if __before is already explicitly defined
+            before_key = f"{field}__before"
+            if before_key not in result:
+                next_day = value + timedelta(days=1)
+                result[before_key] = next_day
+
+    return result
+
+
 @trace.get_tracer(__name__).start_as_current_span("default_paginated_list_resolver")
 async def default_paginated_list_resolver(
     root: dict,  # noqa: ARG001
     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 = deserialize_order_input(input_data=order)
+
     fields = await extract_selection(info=info, schema=schema)
 
     graphql_context: GraphqlContext = info.context
@@ -164,9 +207,15 @@ async def default_paginated_list_resolver(
         filters = {
             key: value for key, value in kwargs.items() if ("__" in key and value is not None) or key in ("ids", "hfid")
         }
+        filters = _transform_metadata_day_filters(filters)
 
-        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 +235,18 @@ 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 +271,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
             ]