infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/graphql/resolvers/resolver.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from graphql.type.definition import GraphQLNonNull
 from infrahub_sdk.utils import extract_fields
+from opentelemetry import trace
 
 from infrahub.core.constants import BranchSupportType, InfrahubKind, RelationshipHierarchyDirection
 from infrahub.core.manager import NodeManager
-from infrahub.core.query.node import NodeGetHierarchyQuery
 from infrahub.exceptions import NodeNotFoundError
 
 from ..models import OrderModel
 from ..parser import extract_selection
 from ..permissions import get_permissions
-from ..types import RELATIONS_PROPERTY_MAP, RELATIONS_PROPERTY_MAP_REVERSED
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -22,6 +21,7 @@ if TYPE_CHECKING:
     from infrahub.graphql.initialization import GraphqlContext
 
 
+@trace.get_tracer(__name__).start_as_current_span("account_resolver")
 async def account_resolver(
     root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
@@ -46,6 +46,7 @@ async def account_resolver(
         )
 
 
+@trace.get_tracer(__name__).start_as_current_span("default_resolver")
 async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
     """Not sure why but the default resolver returns sometime 4 positional args and sometime 2.
 
@@ -128,6 +129,7 @@ async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
         return await objs[0].to_graphql(db=db, fields=fields, related_node_ids=graphql_context.related_node_ids)
 
 
+@trace.get_tracer(__name__).start_as_current_span("parent_field_name_resolver")
 async def parent_field_name_resolver(parent: dict[str, dict], info: GraphQLResolveInfo) -> dict:
     """This resolver gets used when we know that the parent resolver has already gathered the required information.
 
@@ -137,6 +139,7 @@ async def parent_field_name_resolver(parent: dict[str, dict], info: GraphQLResol
     return parent[info.field_name]
 
 
+@trace.get_tracer(__name__).start_as_current_span("default_paginated_list_resolver")
 async def default_paginated_list_resolver(
     root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
@@ -164,7 +167,7 @@ async def default_paginated_list_resolver(
         edges = fields.get("edges", {})
         node_fields = edges.get("node", {})
 
-        permission_set: Optional[dict[str, Any]] = None
+        permission_set: dict[str, Any] | None = None
         permissions = (
             await get_permissions(schema=schema, graphql_context=graphql_context)
             if graphql_context.permissions
@@ -227,121 +230,20 @@ async def default_paginated_list_resolver(
         return response
 
 
+@trace.get_tracer(__name__).start_as_current_span("single_relationship_resolver")
 async def single_relationship_resolver(parent: dict, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
     graphql_context: GraphqlContext = info.context
     resolver = graphql_context.single_relationship_resolver
     return await resolver.resolve(parent=parent, info=info, **kwargs)
 
 
+@trace.get_tracer(__name__).start_as_current_span("many_relationship_resolver")
 async def many_relationship_resolver(
-    parent: dict, info: GraphQLResolveInfo, include_descendants: Optional[bool] = False, **kwargs: Any
+    parent: dict, info: GraphQLResolveInfo, include_descendants: bool | None = False, **kwargs: Any
 ) -> dict[str, Any]:
-    """Resolver for relationships of cardinality=many for Edged responses
-
-    This resolver is used for paginated responses and as such we redefined the requested
-    fields by only reusing information below the 'node' key.
-    """
-    # Extract the InfraHub schema by inspecting the GQL Schema
-    node_schema: NodeSchema = (
-        info.parent_type.of_type.graphene_type._meta.schema
-        if isinstance(info.parent_type, GraphQLNonNull)
-        else info.parent_type.graphene_type._meta.schema
-    )
-
     graphql_context: GraphqlContext = info.context
-
-    # Extract the name of the fields in the GQL query
-    fields = await extract_fields(info.field_nodes[0].selection_set)
-    edges = fields.get("edges", {})
-    node_fields = edges.get("node", {})
-    property_fields = edges.get("properties", {})
-    for key, value in property_fields.items():
-        mapped_name = RELATIONS_PROPERTY_MAP[key]
-        node_fields[mapped_name] = value
-
-    # Extract the schema of the node on the other end of the relationship from the GQL Schema
-    node_rel = node_schema.get_relationship(info.field_name)
-
-    # Extract only the filters from the kwargs and prepend the name of the field to the filters
-    offset = kwargs.pop("offset", None)
-    limit = kwargs.pop("limit", None)
-
-    filters = {
-        f"{info.field_name}__{key}": value
-        for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
-    }
-
-    response: dict[str, Any] = {"edges": [], "count": None}
-
-    source_kind = node_schema.kind
-
-    async with graphql_context.db.start_session() as db:
-        ids = [parent["id"]]
-        if include_descendants:
-            query = await NodeGetHierarchyQuery.init(
-                db=db,
-                direction=RelationshipHierarchyDirection.DESCENDANTS,
-                node_id=parent["id"],
-                node_schema=node_schema,
-                at=graphql_context.at,
-                branch=graphql_context.branch,
-            )
-            if node_schema.hierarchy:
-                source_kind = node_schema.hierarchy
-            await query.execute(db=db)
-            descendants_ids = list(query.get_peer_ids())
-            ids.extend(descendants_ids)
-
-        if "count" in fields:
-            response["count"] = await NodeManager.count_peers(
-                db=db,
-                ids=ids,
-                source_kind=source_kind,
-                schema=node_rel,
-                filters=filters,
-                at=graphql_context.at,
-                branch=graphql_context.branch,
-                branch_agnostic=node_rel.branch is BranchSupportType.AGNOSTIC,
-            )
-
-        if not node_fields:
-            return response
-
-        objs = await NodeManager.query_peers(
-            db=db,
-            ids=ids,
-            source_kind=source_kind,
-            schema=node_rel,
-            filters=filters,
-            fields=node_fields,
-            offset=offset,
-            limit=limit,
-            at=graphql_context.at,
-            branch=graphql_context.branch,
-            branch_agnostic=node_rel.branch is BranchSupportType.AGNOSTIC,
-            fetch_peers=True,
-        )
-
-        if not objs:
-            return response
-        node_graph = [
-            await obj.to_graphql(db=db, fields=node_fields, related_node_ids=graphql_context.related_node_ids)
-            for obj in objs
-        ]
-
-        entries = []
-        for node in node_graph:
-            entry = {"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)
-        response["edges"] = entries
-
-        return response
+    resolver = graphql_context.many_relationship_resolver
+    return await resolver.resolve(parent=parent, info=info, include_descendants=include_descendants, **kwargs)
 
 
 async def ancestors_resolver(parent: dict, info: GraphQLResolveInfo, **kwargs) -> dict[str, Any]:
@@ -356,6 +258,7 @@ async def descendants_resolver(parent: dict, info: GraphQLResolveInfo, **kwargs)
     )
 
 
+@trace.get_tracer(__name__).start_as_current_span("hierarchy_resolver")
 async def hierarchy_resolver(
     direction: RelationshipHierarchyDirection, parent: dict, info: GraphQLResolveInfo, **kwargs
 ) -> dict[str, Any]:

infrahub/graphql/schema.py

@@ -18,6 +18,7 @@ from .mutations.branch import (
 from .mutations.computed_attribute import UpdateComputedAttribute
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
+from .mutations.generator import GeneratorDefinitionRequestRun
 from .mutations.proposed_change import ProposedChangeMerge, ProposedChangeRequestRunCheck
 from .mutations.relationship import (
     RelationshipAdd,
@@ -83,6 +84,7 @@ class InfrahubBaseMutation(ObjectType):
     InfrahubAccountTokenDelete = InfrahubAccountTokenDelete.Field()
     CoreProposedChangeRunCheck = ProposedChangeRequestRunCheck.Field()
     CoreProposedChangeMerge = ProposedChangeMerge.Field()
+    CoreGeneratorDefinitionRun = GeneratorDefinitionRequestRun.Field()
 
     IPPrefixPoolGetResource = IPPrefixPoolGetResource.Field()
     IPAddressPoolGetResource = IPAddressPoolGetResource.Field()

infrahub/graphql/subscription/graphql_query.py

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

infrahub/graphql/types/context.py

@@ -0,0 +1,12 @@
+from graphene import InputObjectType, String
+
+
+class ContextAccountInput(InputObjectType):
+    id = String(required=True, description="The Infrahub ID of the account")
+
+
+class ContextInput(InputObjectType):
+    account = ContextAccountInput(
+        required=False,
+        description="The account context can be used to override the account information that will be associated with the mutation",
+    )

infrahub/graphql/types/event.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, DateTime, Field, Int, Interface, List, NonNull, ObjectType, String
+from graphene import Boolean, DateTime, Field, InputObjectType, Int, Interface, List, NonNull, ObjectType, String
 from graphene.types.generic import GenericScalar
 
+from infrahub import events
+
 from .common import RelatedNode
 from .enums import DiffAction
 
@@ -20,17 +22,32 @@ class InfrahubMutatedAttribute(ObjectType):
     value_previous = String(required=False)
 
 
+class InfrahubMutatedRelationship(ObjectType):
+    name = String(required=True)
+    action = DiffAction(required=True)
+    peer = Field(RelatedNode, required=True)
+
+
 class EventNodeInterface(Interface):
-    id = String(required=True)
-    event = String(required=True)
-    branch = String(required=False)
-    account_id = String(required=False)
-    occurred_at = DateTime(required=True)
-    level = Int(required=True)
-    primary_node = Field(RelatedNode, required=False)
-    related_nodes = List(NonNull(RelatedNode), required=True)
-    has_children = Boolean(required=True)
-    parent_id = String(required=False)
+    id = String(required=True, description="The ID of the event.")
+    event = String(required=True, description="The name of the event.")
+    branch = String(required=False, description="The branch where the event occurred.")
+    account_id = String(required=False, description="The account ID that triggered the event.")
+    occurred_at = DateTime(required=True, description="The timestamp when the event occurred.")
+    level = Int(
+        required=True,
+        description="The level of the event 0 is a root level event, the child events will have 1 and grand children 2.",
+    )
+    primary_node = Field(
+        RelatedNode, required=False, description="The primary Infrahub node this event is associated with."
+    )
+    related_nodes = List(
+        NonNull(RelatedNode), required=True, description="Related Infrahub nodes this event is associated with."
+    )
+    has_children = Boolean(
+        required=True, description="Indicates if the event is expected to have child events under it"
+    )
+    parent_id = String(required=False, description="The event ID of the direct parent to this event.")
 
     @classmethod
     def resolve_type(
@@ -47,6 +64,19 @@ class EventNodes(ObjectType):
     node = Field(EventNodeInterface)
 
 
+class BranchEventTypeFilter(InputObjectType):
+    branches = List(NonNull(String), required=True, description="Name of impacted branches")
+
+
+class EventTypeFilter(InputObjectType):
+    branch_merged = Field(
+        BranchEventTypeFilter, required=False, description="Filters specific to infrahub.branch.merged events"
+    )
+    branch_rebased = Field(
+        BranchEventTypeFilter, required=False, description="Filters specific to infrahub.branch.rebased events"
+    )
+
+
 # ---------------------------------------
 # Branch events
 # ---------------------------------------
@@ -54,13 +84,24 @@ class BranchCreatedEvent(ObjectType):
     class Meta:
         interfaces = (EventNodeInterface,)
 
+    created_branch = String(required=True, description="The name of the branch that was created")
     payload = Field(GenericScalar, required=True)
 
 
+class BranchMergedEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    source_branch = String(required=True, description="The name of the branch that was merged into the default branch")
+
+
 class BranchRebasedEvent(ObjectType):
     class Meta:
         interfaces = (EventNodeInterface,)
 
+    rebased_branch = String(
+        required=True, description="The name of the branch that was rebased and aligned with the default branch"
+    )
     payload = Field(GenericScalar, required=True)
 
 
@@ -68,6 +109,7 @@ class BranchDeletedEvent(ObjectType):
     class Meta:
         interfaces = (EventNodeInterface,)
 
+    deleted_branch = String(required=True, description="The name of the branch that was deleted")
     payload = Field(GenericScalar, required=True)
 
 
@@ -80,6 +122,26 @@ class NodeMutatedEvent(ObjectType):
 
     payload = Field(GenericScalar, required=True)
     attributes = Field(List(of_type=NonNull(InfrahubMutatedAttribute), required=True), required=True)
+    relationships = Field(List(of_type=NonNull(InfrahubMutatedRelationship), required=True), required=True)
+
+
+class ArtifactEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    checksum = String(required=True, description="The current checksum of the artifact")
+    checksum_previous = String(required=False, description="The previous checksum of the artifact")
+    storage_id = String(required=True, description="The current storage_id of the artifact")
+    storage_id_previous = String(required=False, description="The previous storage_id of the artifact")
+    artifact_definition_id = String(required=True, description="Artifact definition ID")
+
+
+class GroupEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    members = List(NonNull(RelatedNode), required=True, description="Group members modified in this event")
+    ancestors = List(NonNull(RelatedNode), required=True, description="Ancestor groups of this impacted group")
 
 
 class StandardEvent(ObjectType):
@@ -90,11 +152,16 @@ class StandardEvent(ObjectType):
 
 
 EVENT_TYPES: dict[str, type[ObjectType]] = {
-    "infrahub.node.created": NodeMutatedEvent,
-    "infrahub.node.updated": NodeMutatedEvent,
-    "infrahub.node.deleted": NodeMutatedEvent,
-    "infrahub.branch.created": BranchCreatedEvent,
-    "infrahub.branch.rebased": BranchRebasedEvent,
-    "infrahub.branch.deleted": BranchDeletedEvent,
+    events.ArtifactCreatedEvent.event_name: ArtifactEvent,
+    events.ArtifactUpdatedEvent.event_name: ArtifactEvent,
+    events.NodeCreatedEvent.event_name: NodeMutatedEvent,
+    events.NodeUpdatedEvent.event_name: NodeMutatedEvent,
+    events.NodeDeletedEvent.event_name: NodeMutatedEvent,
+    events.BranchCreatedEvent.event_name: BranchCreatedEvent,
+    events.BranchMergedEvent.event_name: BranchMergedEvent,
+    events.BranchRebasedEvent.event_name: BranchRebasedEvent,
+    events.BranchDeletedEvent.event_name: BranchDeletedEvent,
+    events.GroupMemberAddedEvent.event_name: GroupEvent,
+    events.GroupMemberRemovedEvent.event_name: GroupEvent,
     "undefined": StandardEvent,
 }

infrahub/graphql/types/node.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from graphene import ObjectType
 from graphene.types.objecttype import ObjectTypeOptions
@@ -16,7 +16,7 @@ class InfrahubObject(ObjectType):
     @classmethod
     def __init_subclass_with_meta__(
         cls,
-        schema: Optional[MainSchemaTypes] = None,
+        schema: MainSchemaTypes | None = None,
         interfaces: tuple = (),
         _meta: InfrahubObjectOptions | None = None,
         **options: Any,

infrahub/graphql/utils.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from graphene.types.definitions import GrapheneInterfaceType, GrapheneObjectType
 from graphql import (
@@ -50,7 +50,7 @@ def find_types_implementing_interface(
 
 
 async def extract_schema_models(
-    fields: dict, schema: Union[GrapheneObjectType, GraphQLUnionType], root_schema: GraphQLSchema
+    fields: dict, schema: GrapheneObjectType | GraphQLUnionType, root_schema: GraphQLSchema
 ) -> set[str]:
     response = set()
 

infrahub/groups/ancestors.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core.constants import RelationshipHierarchyDirection
+from infrahub.core.manager import NodeManager
+from infrahub.core.schema import NodeSchema
+from infrahub.events.models import EventNode
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+
+async def collect_ancestors(db: InfrahubDatabase, branch: Branch, node_kind: str, node_id: str) -> list[EventNode]:
+    schema = db.schema.get(name=node_kind, branch=branch, duplicate=False)
+
+    if not isinstance(schema, NodeSchema):
+        return []
+
+    ancestors = await NodeManager.query_hierarchy(
+        db=db,
+        branch=branch,
+        direction=RelationshipHierarchyDirection.ANCESTORS,
+        id=node_id,
+        node_schema=schema,
+        filters={"id": None},
+    )
+    return [EventNode(id=ancestor.get_id(), kind=ancestor.get_kind()) for ancestor in ancestors.values()]

infrahub/groups/parsers.py

@@ -0,0 +1,107 @@
+from dataclasses import dataclass
+
+from infrahub.core.branch import Branch
+from infrahub.core.changelog.models import RelationshipCardinalityManyChangelog
+from infrahub.core.constants import DiffAction, InfrahubKind
+from infrahub.core.schema import NodeSchema
+from infrahub.database import InfrahubDatabase
+from infrahub.events.group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent, GroupMutatedEvent
+from infrahub.events.models import EventMeta, EventNode, InfrahubEvent
+from infrahub.events.node_action import NodeCreatedEvent, NodeMutatedEvent, NodeUpdatedEvent
+from infrahub.exceptions import SchemaNotFoundError
+
+from .ancestors import collect_ancestors
+
+
+@dataclass
+class ApplicableEvent:
+    event: NodeMutatedEvent
+    node_schema: NodeSchema
+    relationship: RelationshipCardinalityManyChangelog
+
+
+class GroupNodeMutationParser:
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
+        self._db = db
+        self._branch = branch
+
+    def _get_schema(self, kind: str) -> NodeSchema | None:
+        try:
+            node_schema = self._db.schema.get_node_schema(name=kind, branch=self._branch, duplicate=False)
+        except (ValueError, SchemaNotFoundError):
+            return None
+        return node_schema
+
+    def _get_applicable_events(self, events: list[NodeMutatedEvent]) -> list[ApplicableEvent]:
+        applicable: list[ApplicableEvent] = []
+        for event in events:
+            if event_kind := self._get_schema(kind=event.kind):
+                if (
+                    InfrahubKind.GENERICGROUP in event_kind.inherit_from
+                    and "members" in event.changelog.relationships
+                    and isinstance(
+                        event.changelog.relationships["members"],
+                        RelationshipCardinalityManyChangelog,
+                    )
+                ):
+                    applicable.append(
+                        ApplicableEvent(
+                            event=event,
+                            node_schema=event_kind,
+                            relationship=event.changelog.relationships["members"],
+                        )
+                    )
+        return applicable
+
+    async def group_events_from_node_actions(self, events: list[NodeMutatedEvent]) -> list[InfrahubEvent]:
+        group_events: list[InfrahubEvent] = []
+
+        for applicable_event in self._get_applicable_events(events=events):
+            added_peers = [
+                EventNode(id=peer.peer_id, kind=peer.peer_kind)
+                for peer in applicable_event.relationship.peers
+                if peer.peer_status == DiffAction.ADDED
+            ]
+            removed_peers = [
+                EventNode(id=peer.peer_id, kind=peer.peer_kind)
+                for peer in applicable_event.relationship.peers
+                if peer.peer_status == DiffAction.REMOVED
+            ]
+            if added_peers:
+                group_events.append(
+                    await self._define_group_event(
+                        event_type=GroupMemberAddedEvent, parent=applicable_event.event, peers=added_peers
+                    )
+                )
+
+            if removed_peers:
+                group_events.append(
+                    await self._define_group_event(
+                        event_type=GroupMemberRemovedEvent, parent=applicable_event.event, peers=removed_peers
+                    )
+                )
+
+        return group_events
+
+    async def _define_group_event(
+        self,
+        event_type: type[GroupMemberAddedEvent | GroupMemberRemovedEvent],
+        parent: NodeMutatedEvent,
+        peers: list[EventNode],
+    ) -> GroupMutatedEvent:
+        event_meta = EventMeta.from_parent(parent=parent)
+        group_event = event_type(
+            meta=event_meta,
+            kind=parent.kind,
+            node_id=parent.node_id,
+            members=peers,
+        )
+        if isinstance(parent, NodeCreatedEvent | NodeUpdatedEvent):
+            # Avoid trying to find ancestors for deleted nodes
+            group_event.ancestors = await collect_ancestors(
+                db=self._db,
+                branch=self._branch,
+                node_kind=parent.kind,
+                node_id=parent.node_id,
+            )
+        return group_event