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

infrahub/graphql/resolvers/single_relationship.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Any
 
 from graphql import GraphQLResolveInfo
+from graphql.type.definition import GraphQLNonNull
 from infrahub_sdk.utils import deep_merge_dict, extract_fields
 
 from infrahub.core.branch.models import Branch
@@ -31,9 +32,14 @@ class SingleRelationshipResolver:
         """
         # Extract the InfraHub schema by inspecting the GQL Schema
 
-        node_schema: NodeSchema = info.parent_type.graphene_type._meta.schema  # type: ignore[attr-defined]
+        # :
+        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  # type: ignore[attr-defined]
+        )
 
-        context: GraphqlContext = info.context
+        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)
@@ -53,10 +59,10 @@ class SingleRelationshipResolver:
 
         if requires_relationship_metadata:
             node_graph = await self._get_entities_simple(
-                db=context.db,
-                branch=context.branch,
-                at=context.at,
-                related_node_ids=context.related_node_ids,
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                at=graphql_context.at,
+                related_node_ids=graphql_context.related_node_ids,
                 field_name=info.field_name,
                 parent_id=parent["id"],
                 source_kind=node_schema.kind,
@@ -66,10 +72,10 @@ class SingleRelationshipResolver:
             )
         else:
             node_graph = await self._get_entities_with_data_loader(
-                db=context.db,
-                branch=context.branch,
-                at=context.at,
-                related_node_ids=context.related_node_ids,
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                at=graphql_context.at,
+                related_node_ids=graphql_context.related_node_ids,
                 rel_schema=node_rel,
                 parent=parent,
                 node_fields=node_fields,

infrahub/graphql/schema.py

@@ -48,6 +48,7 @@ from .queries import (
     Relationship,
 )
 from .queries.diff.tree import DiffTreeQuery, DiffTreeSummaryQuery
+from .queries.event import Event
 from .queries.task import Task, TaskBranchStatus
 
 
@@ -67,6 +68,7 @@ class InfrahubBaseQuery(ObjectType):
     InfrahubSearchAnywhere = InfrahubSearchAnywhere
 
     InfrahubTask = Task
+    InfrahubEvent = Event
     InfrahubTaskBranchStatus = TaskBranchStatus
 
     IPAddressGetNextAvailable = InfrahubIPAddressGetNextAvailable

infrahub/graphql/subscription/__init__.py

@@ -21,7 +21,7 @@ class InfrahubBaseSubscription(ObjectType):
     @classmethod
     async def subscribe_query(
         cls,
-        parent: dict,  # pylint: disable=unused-argument
+        parent: dict,
         info: GraphQLResolveInfo,
         name: str,
         params: dict[str, Any] | None = None,

infrahub/graphql/subscription/events.py

@@ -19,7 +19,7 @@
 
 # log = get_logger(name="infrahub.graphql")
 
-# async def resolver_event(root: dict, info: GraphQLResolveInfo, topics: Optional[List] = None):  # pylint: disable=unused-argument
+# async def resolver_event(root: dict, info: GraphQLResolveInfo, topics: Optional[List] = None):
 #     pass
 # connection = await get_broker()
 

infrahub/graphql/subscription/graphql_query.py

@@ -18,35 +18,35 @@ log = get_logger(name="infrahub.graphql")
 
 
 async def resolver_graphql_query(
-    parent: dict,  # pylint: disable=unused-argument
+    parent: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
     name: str,
     graphql_schema: Schema,
     params: dict[str, Any] | None = None,
     interval: int = 10,
 ) -> AsyncGenerator[dict[str, Any], None]:
-    context: GraphqlContext = info.context
+    graphql_context: GraphqlContext = info.context
     at = Timestamp()
 
-    async with context.db.start_session() as db:
+    async with graphql_context.db.start_session() as db:
         # Find the GraphQLQuery and the GraphQL Schema
         graphql_query = await NodeManager.get_one_by_default_filter(
-            db=db, id=name, kind=CoreGraphQLQuery, branch=context.branch, at=at
+            db=db, id=name, kind=CoreGraphQLQuery, branch=graphql_context.branch, at=at
         )
         if not graphql_query:
             raise ValueError(f"Unable to find the {InfrahubKind.GRAPHQLQUERY} {name}")
 
     while True:
-        async with context.db.start_session() as db:
+        async with graphql_context.db.start_session() as db:
             result = await graphql(
                 schema=graphql_schema,
                 source=graphql_query.query.value,
-                context_value=context.__class__(
+                context_value=graphql_context.__class__(
                     db=db,
-                    branch=context.branch,
+                    branch=graphql_context.branch,
                     at=Timestamp(),
                     related_node_ids=set(),
-                    types=context.types,
+                    types=graphql_context.types,
                     single_relationship_resolver=SingleRelationshipResolver(),
                 ),
                 root_value=None,

infrahub/graphql/types/branch.py

@@ -34,10 +34,10 @@ class BranchType(InfrahubObjectType):
     async def get_list(
         cls,
         fields: dict,
-        context: GraphqlContext,
+        graphql_context: GraphqlContext,
         **kwargs: Any,
     ) -> list[dict[str, Any]]:
-        async with context.db.start_session() as db:
+        async with graphql_context.db.start_session() as db:
             objs = await Branch.get_list(db=db, **kwargs)
 
             if not objs:

infrahub/graphql/types/common.py

@@ -1,7 +1,12 @@
 from __future__ import annotations
 
-from graphene import InputObjectType, String
+from graphene import InputObjectType, ObjectType, String
 
 
 class IdentifierInput(InputObjectType):
     id = String(required=True, description="The ID of the requested object")
+
+
+class RelatedNode(ObjectType):
+    id = String(required=True, description="The ID of the requested object")
+    kind = String(required=True, description="The ID of the requested object")

infrahub/graphql/types/enums.py

@@ -5,6 +5,8 @@ from infrahub.permissions import constants as permission_constants
 
 CheckType = Enum.from_enum(constants.CheckType)
 
+DiffAction = Enum.from_enum(constants.DiffAction)
+
 Severity = Enum.from_enum(constants.Severity)
 
 BranchRelativePermissionDecision = Enum.from_enum(permission_constants.BranchRelativePermissionDecision)

infrahub/graphql/types/event.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, DateTime, Field, Int, Interface, List, NonNull, ObjectType, String
+from graphene.types.generic import GenericScalar
+
+from .common import RelatedNode
+from .enums import DiffAction
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+
+class InfrahubMutatedAttribute(ObjectType):
+    name = String(required=True)
+    action = DiffAction(required=True)
+    value = String(required=False)
+    kind = String(required=True)
+    value_previous = String(required=False)
+
+
+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)
+
+    @classmethod
+    def resolve_type(
+        cls,
+        instance: dict[str, Any],
+        info: GraphQLResolveInfo,  # noqa: ARG003
+    ) -> type[ObjectType]:
+        if "event" in instance:
+            return EVENT_TYPES.get(instance["event"], StandardEvent)
+        return StandardEvent
+
+
+class EventNodes(ObjectType):
+    node = Field(EventNodeInterface)
+
+
+# ---------------------------------------
+# Branch events
+# ---------------------------------------
+class BranchCreatedEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    payload = Field(GenericScalar, required=True)
+
+
+class BranchRebasedEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    payload = Field(GenericScalar, required=True)
+
+
+class BranchDeletedEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    payload = Field(GenericScalar, required=True)
+
+
+# ---------------------------------------
+# Node/Object events
+# ---------------------------------------
+class NodeMutatedEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    payload = Field(GenericScalar, required=True)
+    attributes = Field(List(of_type=NonNull(InfrahubMutatedAttribute), required=True), required=True)
+
+
+class StandardEvent(ObjectType):
+    class Meta:
+        interfaces = (EventNodeInterface,)
+
+    payload = Field(GenericScalar, required=True)
+
+
+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,
+    "undefined": StandardEvent,
+}

infrahub/graphql/types/interface.py

@@ -21,8 +21,8 @@ class InfrahubInterfaceOptions(InterfaceOptions):
 class InfrahubInterface(Interface):
     @classmethod
     def resolve_type(cls, instance: dict[str, Any], info: GraphQLResolveInfo) -> InfrahubObject:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
         if KIND_GRAPHQL_FIELD_NAME in instance:
-            return context.types[instance[KIND_GRAPHQL_FIELD_NAME]]
+            return graphql_context.types[instance[KIND_GRAPHQL_FIELD_NAME]]
 
         raise ValueError("Unable to identify the type of the instance.")

infrahub/graphql/types/node.py

@@ -5,7 +5,7 @@ from typing import Any, Optional
 from graphene import ObjectType
 from graphene.types.objecttype import ObjectTypeOptions
 
-from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema, ProfileSchema
+from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema, ProfileSchema, TemplateSchema
 
 
 class InfrahubObjectOptions(ObjectTypeOptions):
@@ -14,14 +14,14 @@ class InfrahubObjectOptions(ObjectTypeOptions):
 
 class InfrahubObject(ObjectType):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls,
         schema: Optional[MainSchemaTypes] = None,
         interfaces: tuple = (),
         _meta: InfrahubObjectOptions | None = None,
         **options: Any,
     ) -> None:
-        if not isinstance(schema, (NodeSchema, GenericSchema, ProfileSchema)):
+        if not isinstance(schema, NodeSchema | GenericSchema | ProfileSchema | TemplateSchema):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
 
         if not _meta:

infrahub/graphql/types/permission.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from graphene import Field, Int, List, ObjectType, String
+from graphene import Field, Int, List, NonNull, ObjectType, String
 
 from infrahub.graphql.types.enums import BranchRelativePermissionDecision
 
@@ -39,4 +39,4 @@ class PaginatedObjectPermission(ObjectType):
         required=True,
         description="The number of permissions applicable, will be 1 for normal nodes or possibly more for generics",
     )
-    edges = Field(List(of_type=ObjectPermissionNode, required=True), required=True)
+    edges = Field(List(of_type=NonNull(ObjectPermissionNode), required=True), required=True)

infrahub/graphql/types/relationship.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from graphene import Field, List, ObjectType, String
+from graphene import Field, List, NonNull, ObjectType, String
 
 
 class RelationshipPeer(ObjectType):
@@ -11,8 +11,8 @@ class RelationshipPeer(ObjectType):
 class Relationship(ObjectType):
     id = String(required=False)
     identifier = String(required=False)
-    peers = List(RelationshipPeer)
+    peers = List(NonNull(RelationshipPeer))
 
 
 class RelationshipNode(ObjectType):
-    node = Field(Relationship)
+    node = Field(Relationship, required=True)

infrahub/graphql/types/standard_node.py

@@ -17,9 +17,7 @@ class InfrahubObjectTypeOptions(ObjectTypeOptions):
 
 class InfrahubObjectType(ObjectType):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
-        cls, model=None, interfaces=(), _meta=None, **options
-    ) -> None:
+    def __init_subclass_with_meta__(cls, model=None, interfaces=(), _meta=None, **options) -> None:
         if not _meta:
             _meta = InfrahubObjectTypeOptions(cls)
 
@@ -28,24 +26,24 @@ class InfrahubObjectType(ObjectType):
         super().__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options)
 
     @classmethod
-    async def get_list(cls, fields: dict[str, Any], context: GraphqlContext, **kwargs) -> list[dict[str, Any]]:
-        async with context.db.session(database=config.SETTINGS.database.database_name) as db:
+    async def get_list(cls, fields: dict[str, Any], graphql_context: GraphqlContext, **kwargs) -> list[dict[str, Any]]:
+        async with graphql_context.db.session(database=config.SETTINGS.database.database_name) as db:
             filters = {key: value for key, value in kwargs.items() if "__" in key and value}
 
             if filters:
                 objs = await cls._meta.model.get_list(
                     filters=filters,
-                    at=context.at,
-                    branch=context.branch,
-                    account=context.account_session,
+                    at=graphql_context.at,
+                    branch=graphql_context.branch,
+                    account=graphql_context.account_session,
                     include_source=True,
                     db=db,
                 )
             else:
                 objs = await cls._meta.model.get_list(
-                    at=context.at,
-                    branch=context.branch,
-                    account=context.account_session,
+                    at=graphql_context.at,
+                    branch=graphql_context.branch,
+                    account=graphql_context.account_session,
                     include_source=True,
                     db=db,
                 )

infrahub/graphql/utils.py

@@ -3,24 +3,16 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Union
 
 from graphene.types.definitions import GrapheneInterfaceType, GrapheneObjectType
-from graphql import (  # pylint: disable=no-name-in-module
-    ExecutionContext,
-    FieldNode,
-    FragmentSpreadNode,
+from graphql import (
     GraphQLList,
-    GraphQLObjectType,
-    GraphQLResolveInfo,
+    GraphQLNonNull,
     GraphQLSchema,
     GraphQLUnionType,
-    InlineFragmentNode,
-    SelectionSetNode,
 )
 
 from infrahub.exceptions import GraphQLQueryError
 
 if TYPE_CHECKING:
-    import abc
-
     from graphql.execution import ExecutionResult
 
 
@@ -42,171 +34,6 @@ def extract_data(query_name: str, result: ExecutionResult) -> dict:
     return result.data or {}
 
 
-# --------------------------------------------------------------
-# The functions below :
-#   - selected_field_names_fast
-#   - selected_field_names_naive
-#   - selected_field_names
-#   - selected_field_names_from_context
-# Are not currently used and they have been copied from internet as a reference
-#  >>  https://github.com/graphql-python/graphene/issues/57#issuecomment-774227086
-#
-# --------------------------------------------------------------
-def selected_field_names_fast(
-    selection_set: SelectionSetNode, context: GraphQLResolveInfo, runtime_type: Union[str, GraphQLObjectType] = None
-) -> abc.Iterator[str]:
-    """Use the fastest available function to provide the list of selected field names
-
-    Note that this function may give false positives because in the absence of fragments it ignores directives.
-    """
-    # Any fragments?
-    no_fragments = all(isinstance(node, FieldNode) for node in selection_set.selections)
-
-    # Choose the function to execute
-    if no_fragments:
-        return selected_field_names_naive(selection_set)
-
-    return selected_field_names(selection_set, context, runtime_type)
-
-
-def selected_field_names_naive(selection_set: SelectionSetNode) -> list:
-    """Get the list of field names that are selected at the current level. Does not include nested names.
-
-    Limitations:
-    * Does not resolve fragments; throws RuntimeError
-    * Does not take directives into account. A field might be disabled, and this function wouldn't know
-
-    As a result:
-    * It will give a RuntimeError if a fragment is provided
-    * It may give false positives in case directives are used
-    * It is 20x faster than the alternative
-
-    Benefits:
-    * Fast!
-
-    Args:
-        selection_set: the selected fields
-
-    Code copied from https://github.com/graphql-python/graphene/issues/57#issuecomment-774227086
-        This link also includes a more powerful and complexe alternative.
-    """
-    assert isinstance(selection_set, SelectionSetNode)
-
-    field_names = []
-
-    for node in selection_set.selections:
-        # Field
-        if isinstance(node, FieldNode):
-            field_names.append(node.name.value)
-        # Fragment spread (`... fragmentName`)
-        elif isinstance(node, (FragmentSpreadNode, InlineFragmentNode)):
-            raise NotImplementedError("Fragments are not supported by this simplistic function")
-        # Something new
-        else:
-            raise NotImplementedError(str(type(node)))
-
-    return field_names
-
-
-def selected_field_names(
-    selection_set: SelectionSetNode, info: GraphQLResolveInfo, runtime_type: Union[str, GraphQLObjectType] = None
-) -> abc.Iterator[str]:
-    """Get the list of field names that are selected at the current level. Does not include nested names.
-
-    This function re-evaluates the AST, but gives a complete list of included fields.
-    It is 25x slower than `selected_field_names_naive()`, but still, it completes in 7ns or so. Not bad.
-
-    Args:
-        selection_set: the selected fields
-        info: GraphQL resolve info
-        runtime_type: The type of the object you resolve to. Either its string name, or its ObjectType.
-            If none is provided, this function will fail with a RuntimeError() when resolving fragments
-    """
-    # pylint: disable=no-value-for-parameter
-
-    # Create a temporary execution context. This operation is quite cheap, actually.
-    execution_context = ExecutionContext(
-        schema=info.schema,
-        fragments=info.fragments,
-        root_value=info.root_value,
-        operation=info.operation,
-        variable_values=info.variable_values,
-        # The only purpose of this context is to be able to run the collect_fields() method.
-        # Therefore, many parameters are actually irrelevant
-        context_value=None,
-        field_resolver=None,
-        type_resolver=None,
-        errors=[],
-        middleware_manager=None,
-    )
-
-    # Use it
-    return selected_field_names_from_context(selection_set, execution_context, runtime_type)
-
-
-def selected_field_names_from_context(
-    selection_set: SelectionSetNode, context: ExecutionContext, runtime_type: Union[str, GraphQLObjectType] = None
-) -> abc.Iterator[str]:
-    """Get the list of field names that are selected at the current level.
-
-    This function is useless because `graphql.ExecutionContext` is not available at all inside resolvers.
-    Therefore, `selected_field_names()` wraps it and provides one.
-    """
-    assert isinstance(selection_set, SelectionSetNode)
-
-    # Resolve `runtime_type`
-    if isinstance(runtime_type, str):
-        runtime_type = context.schema.type_map[runtime_type]  # raises: KeyError
-
-    # Resolve all fields
-    fields_map = context.collect_fields(
-        # Use the provided Object type, or use a dummy object that fails all tests
-        runtime_type=runtime_type or None,
-        # runtime_type=runtime_type or graphql.GraphQLObjectType('<temp>', []),
-        selection_set=selection_set,
-        fields={},  # out
-        visited_fragment_names=(visited_fragment_names := set()),  # out
-    )
-
-    # Test fragment resolution
-    if visited_fragment_names and not runtime_type:
-        raise RuntimeError(
-            "The query contains fragments which cannot be resolved "
-            "because `runtime_type` is not provided by the lazy developer"
-        )
-
-    # Results!
-    return (field.name.value for fields_list in fields_map.values() for field in fields_list)
-
-
-def print_query(info: GraphQLResolveInfo) -> None:
-    """Traverse the query"""
-    initial_selection_set = info.field_nodes[0].selection_set
-    print_selection_set(initial_selection_set, 1)
-
-
-def print_selection_set(selection_set: SelectionSetNode, level: int = 1) -> int:
-    # max_depth = level
-    tab = "  "
-    for field in getattr(selection_set, "selections", []):
-        # print(f"in print_selection_set loop {field}")
-        # The field we are at is already a lever deeper, even if it doesn't have its own selection set.
-        # max_depth = max(max_depth, level + 1)
-        print(f"{level * tab}{field.name.value}")
-        if selection_set := getattr(field, "selection_set", None):
-            # max_depth = max(max_depth, self._get_query_depth(selection_set, level + 1))
-            print_selection_set(selection_set, level + 1)
-
-    # """
-    # MATCH (d:Device)
-    # WHERE (d)-[]-(:Attribute {name: "name"})-[]-(:AttributeValue {value: "spine1"})
-    # MAT36CH (d)-[:IS_RELATED]-(r1:Relationship{type: "device_interface"})-[:IS_RELATED]-(n1)
-    # WHERE (n1)-[]-(:Attribute {name: "enabled"})-[]-(:AttributeValue {value: false})
-    # OPTIONAL MATCH (d)-[:IS_RELATED]-(r1)-[:IS_RELATED]-(n1)-[:IS_RELATED]-(r2:Relationship {type: "interface_ip"})-[:IS_RELATED]-(n2)
-    # RETURN d,n1,r1,n2,r2
-    # """
-
-
 def find_types_implementing_interface(
     interface: GrapheneInterfaceType, root_schema: GraphQLSchema
 ) -> list[GrapheneObjectType]:
@@ -234,12 +61,19 @@ async def extract_schema_models(
         if field_name not in schema.fields:
             continue
 
-        if isinstance(schema.fields[field_name].type, GrapheneObjectType):
-            object_type = schema.fields[field_name].type
-        elif isinstance(schema.fields[field_name].type, GraphQLList):
-            object_type = schema.fields[field_name].type.of_type
-        elif isinstance(schema.fields[field_name].type, GrapheneInterfaceType):
-            object_type = schema.fields[field_name].type
+        gql_type = schema.fields[field_name].type
+        if isinstance(schema.fields[field_name].type, GraphQLNonNull):
+            gql_type = schema.fields[field_name].type.of_type
+
+        if isinstance(gql_type, GrapheneObjectType):
+            object_type = gql_type
+        elif isinstance(gql_type, GraphQLList):
+            if isinstance(gql_type.of_type, GraphQLNonNull):
+                object_type = gql_type.of_type.of_type
+            else:
+                object_type = gql_type.of_type
+        elif isinstance(gql_type, GrapheneInterfaceType):
+            object_type = gql_type
             sub_types = find_types_implementing_interface(interface=object_type, root_schema=root_schema)
             for sub_type in sub_types:
                 response.add(sub_type.name)
@@ -247,6 +81,15 @@ async def extract_schema_models(
         else:
             continue
 
+        # Ensure that Attribute types are not reported by this function
+        if isinstance(object_type, GrapheneObjectType) and object_type.interfaces:
+            inherit_from = [intf.name for intf in object_type.interfaces]
+            if "AttributeInterface" in inherit_from:
+                continue
+
+        if isinstance(object_type, GraphQLNonNull):
+            raise ValueError("object_type shouldn't be a of type GraphQLNonNull")
+
         response.add(object_type.name)
 
         if isinstance(value, dict):
@@ -255,6 +98,9 @@ async def extract_schema_models(
             if isinstance(schema.fields[value].type, GrapheneObjectType):
                 response.add(schema.fields[value].type.name)
             elif isinstance(schema.fields[value].type, GraphQLList):
-                response.add(schema.fields[value].type.of_type.name)
+                if isinstance(schema.fields[value].type.of_type, GraphQLNonNull):
+                    response.add(schema.fields[value].type.of_type.of_type.name)
+                else:
+                    response.add(schema.fields[value].type.of_type.name)
 
     return response

infrahub/groups/tasks.py

@@ -4,12 +4,12 @@ from prefect import flow
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.groups.models import RequestGraphQLQueryGroupUpdate
-from infrahub.services import services
+from infrahub.services import InfrahubServices
 from infrahub.workflows.utils import add_tags
 
 
 @flow(name="graphql-query-group-update", flow_run_name="Update GraphQLQuery Group '{model.query_name}'")
-async def update_graphql_query_group(model: RequestGraphQLQueryGroupUpdate) -> None:
+async def update_graphql_query_group(model: RequestGraphQLQueryGroupUpdate, service: InfrahubServices) -> None:
     """Create or Update a GraphQLQueryGroup."""
 
     # If there is only one subscriber, associate the task to it
@@ -19,7 +19,6 @@ async def update_graphql_query_group(model: RequestGraphQLQueryGroupUpdate) -> N
         related_nodes.append(model.subscribers[0])
 
     await add_tags(branches=[model.branch], nodes=related_nodes)
-    service = services.service
 
     params_hash = dict_hash(model.params)
     group_name = f"{model.query_name}__{params_hash}"

infrahub/lock.py

@@ -253,7 +253,7 @@ class InfrahubLockRegistry:
 
 
 def initialize_lock(local_only: bool = False, service: Optional[InfrahubServices] = None) -> None:
-    global registry  # pylint: disable=global-statement
+    global registry
     registry = InfrahubLockRegistry(local_only=local_only, service=service)