infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/graphql/mutations/action.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from graphene import InputObjectType, Mutation
+from typing_extensions import Self
+
+from infrahub.core.protocols import CoreNodeTriggerAttributeMatch, CoreNodeTriggerRelationshipMatch, CoreNodeTriggerRule
+from infrahub.exceptions import SchemaNotFoundError, ValidationError
+from infrahub.log import get_logger
+
+from .main import InfrahubMutationMixin, InfrahubMutationOptions
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import NodeSchema
+    from infrahub.database import InfrahubDatabase
+
+    from ..initialization import GraphqlContext
+
+log = get_logger()
+
+
+class InfrahubTriggerRuleMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: NodeSchema,
+        _meta: Any | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        _validate_node_kind(data=data, db=db)
+        trigger_rule_definition, result = await super().mutate_create(info=info, data=data, branch=branch, database=db)
+
+        return trigger_rule_definition, result
+
+    @classmethod
+    async def mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+        node: Node | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        _validate_node_kind(data=data, db=db)
+        trigger_rule_definition, result = await super().mutate_update(info=info, data=data, branch=branch, database=db)
+
+        return trigger_rule_definition, result
+
+
+class InfrahubTriggerRuleMatchMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: NodeSchema,
+        _meta: Any | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+
+        async with graphql_context.db.start_transaction() as dbt:
+            trigger_match, result = await super().mutate_create(info=info, data=data, branch=branch, database=dbt)
+            trigger_match_model = cast(CoreNodeTriggerAttributeMatch | CoreNodeTriggerRelationshipMatch, trigger_match)
+            node_trigger_rule = await trigger_match_model.trigger.get_peer(db=dbt, raise_on_error=True)
+            node_trigger_rule_model = cast(CoreNodeTriggerRule, node_trigger_rule)
+            node_schema = dbt.schema.get_node_schema(name=node_trigger_rule_model.node_kind.value, duplicate=False)
+            _validate_node_kind_field(data=data, node_schema=node_schema)
+
+        return trigger_match, result
+
+    @classmethod
+    async def mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
+        node: Node | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        async with graphql_context.db.start_transaction() as dbt:
+            trigger_match, result = await super().mutate_update(info=info, data=data, branch=branch, database=dbt)
+            trigger_match_model = cast(CoreNodeTriggerAttributeMatch | CoreNodeTriggerRelationshipMatch, trigger_match)
+            node_trigger_rule = await trigger_match_model.trigger.get_peer(db=dbt, raise_on_error=True)
+            node_trigger_rule_model = cast(CoreNodeTriggerRule, node_trigger_rule)
+            node_schema = dbt.schema.get_node_schema(name=node_trigger_rule_model.node_kind.value, duplicate=False)
+            _validate_node_kind_field(data=data, node_schema=node_schema)
+
+        return trigger_match, result
+
+
+def _validate_node_kind(data: InputObjectType, db: InfrahubDatabase) -> None:
+    input_data = cast(dict[str, dict[str, Any]], data)
+    if node_kind := input_data.get("node_kind"):
+        value = node_kind.get("value")
+        if isinstance(value, str):
+            try:
+                db.schema.get_node_schema(name=value, duplicate=False)
+            except SchemaNotFoundError as exc:
+                raise ValidationError(
+                    input_value={"node_kind": "The requested node_kind schema was not found"}
+                ) from exc
+            except ValueError as exc:
+                raise ValidationError(input_value={"node_kind": "The requested node_kind is not a valid node"}) from exc
+
+
+def _validate_node_kind_field(data: InputObjectType, node_schema: NodeSchema) -> None:
+    input_data = cast(dict[str, dict[str, Any]], data)
+    if attribute_name := input_data.get("attribute_name"):
+        value = attribute_name.get("value")
+        if isinstance(value, str):
+            if value not in node_schema.attribute_names:
+                raise ValidationError(
+                    input_value={
+                        "attribute_name": f"The attribute {value} doesn't exist on related node trigger using {node_schema.kind}"
+                    }
+                )
+    if relationship_name := input_data.get("relationship_name"):
+        value = relationship_name.get("value")
+        if isinstance(value, str):
+            if value not in node_schema.relationship_names:
+                raise ValidationError(
+                    input_value={
+                        "relationship_name": f"The relationship {value} doesn't exist on related node trigger using {node_schema.kind}"
+                    }
+                )

infrahub/graphql/mutations/convert_object_type.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING, Any, Self
+
+from graphene import Boolean, InputObjectType, Mutation, String
+from graphene.types.generic import GenericScalar
+from graphql import GraphQLResolveInfo
+
+from infrahub.core import registry
+from infrahub.core.convert_object_type.conversion import InputForDestField, convert_object_type
+from infrahub.core.manager import NodeManager
+
+if TYPE_CHECKING:
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class ConvertObjectTypeInput(InputObjectType):
+    node_id = String(required=True)
+    target_kind = String(required=True)
+    fields_mapping = GenericScalar(required=True)  # keys are destination attributes/relationships names.
+    branch = String(required=True)
+
+
+class ConvertObjectType(Mutation):
+    class Arguments:
+        data = ConvertObjectTypeInput(required=True)
+
+    ok = Boolean()
+    node = GenericScalar()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ConvertObjectTypeInput,
+    ) -> Self:
+        """Convert an input node to a given compatible kind."""
+
+        graphql_context: GraphqlContext = info.context
+
+        fields_mapping: dict[str, InputForDestField] = {}
+        if not isinstance(data.fields_mapping, dict):
+            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(fields_mapping)}")
+
+        for field, input_for_dest_field_str in data.fields_mapping.items():
+            fields_mapping[field] = InputForDestField(**input_for_dest_field_str)
+
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=str(data.branch)
+        )
+        target_schema = registry.get_node_schema(name=str(data.target_kind), branch=data.branch)
+        new_node = await convert_object_type(
+            node=node_to_convert,
+            target_schema=target_schema,
+            mapping=fields_mapping,
+            branch=graphql_context.branch,
+            db=graphql_context.db,
+        )
+
+        dict_node = await new_node.to_graphql(db=graphql_context.db, fields={})
+        result: dict[str, Any] = {"ok": True, "node": dict_node}
+
+        return cls(**result)

infrahub/graphql/mutations/main.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
@@ -9,12 +9,15 @@ from infrahub_sdk.utils import extract_fields
 from typing_extensions import Self
 
 from infrahub import config, lock
-from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind, MutationAction, RelationshipCardinality, RelationshipKind
+from infrahub.core.constants import InfrahubKind, MutationAction
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.manager import NodeManager
-from infrahub.core.node import Node
-from infrahub.core.schema import MainSchemaTypes, NodeSchema, RelationshipSchema
+from infrahub.core.node.create import (
+    create_node,
+    get_profile_ids,
+    refresh_for_profile_update,
+)
+from infrahub.core.schema import MainSchemaTypes, NodeSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
 from infrahub.core.schema.template_schema import TemplateSchema
@@ -33,8 +36,7 @@ if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
     from infrahub.core.branch import Branch
-    from infrahub.core.protocols import CoreObjectTemplate
-    from infrahub.core.relationship.model import RelationshipManager
+    from infrahub.core.node import Node
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.types.context import ContextInput
@@ -143,33 +145,6 @@ class InfrahubMutationMixin:
 
         return mutation
 
-    @classmethod
-    async def _get_profile_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
-        if not hasattr(obj, "profiles"):
-            return set()
-        profile_rels = await obj.profiles.get_relationships(db=db)
-        return {pr.peer_id for pr in profile_rels}
-
-    @classmethod
-    async def _refresh_for_profile_update(
-        cls, db: InfrahubDatabase, branch: Branch, obj: Node, previous_profile_ids: set[str] | None = None
-    ) -> Node:
-        if not hasattr(obj, "profiles"):
-            return obj
-        current_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
-        if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-            refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
-                db=db,
-                kind=cls._meta.active_schema.kind,
-                id=obj.get_id(),
-                branch=branch,
-                include_owner=True,
-                include_source=True,
-            )
-            refreshed_node._node_changelog = obj.node_changelog
-            return refreshed_node
-        return obj
-
     @classmethod
     async def _call_mutate_create_object(cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch) -> Node:
         """
@@ -185,100 +160,6 @@ class InfrahubMutationMixin:
 
         return await cls.mutate_create_object(data=data, db=db, branch=branch)
 
-    @classmethod
-    async def _get_template_relationship_peers(
-        cls, db: InfrahubDatabase, template: CoreObjectTemplate, relationship: RelationshipSchema
-    ) -> Mapping[str, Node]:
-        """For a given relationship on the template, fetch the related peers."""
-        template_relationship_manager: RelationshipManager = getattr(template, relationship.name)
-        if relationship.cardinality == RelationshipCardinality.MANY:
-            return await template_relationship_manager.get_peers(db=db)
-
-        peers: dict[str, Node] = {}
-        template_relationship_peer = await template_relationship_manager.get_peer(db=db)
-        if template_relationship_peer:
-            peers[template_relationship_peer.id] = template_relationship_peer
-        return peers
-
-    @classmethod
-    async def _extract_peer_data(
-        cls,
-        db: InfrahubDatabase,
-        template_peer: Node,
-        obj_peer_schema: MainSchemaTypes,
-        parent_obj: Node,
-        current_template: CoreObjectTemplate,
-    ) -> Mapping[str, Any]:
-        obj_peer_data: dict[str, Any] = {}
-
-        for attr in template_peer.get_schema().attribute_names:
-            if attr not in obj_peer_schema.attribute_names:
-                continue
-            obj_peer_data[attr] = {"value": getattr(template_peer, attr).value, "source": template_peer.id}
-
-        for rel in template_peer.get_schema().relationship_names:
-            rel_manager: RelationshipManager = getattr(template_peer, rel)
-            if (
-                rel_manager.schema.kind not in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-                or rel_manager.schema.name not in obj_peer_schema.relationship_names
-            ):
-                continue
-
-            if list(await rel_manager.get_peers(db=db)) == [current_template.id]:
-                obj_peer_data[rel] = {"id": parent_obj.id}
-
-        return obj_peer_data
-
-    @classmethod
-    async def _handle_template_relationships(
-        cls,
-        db: InfrahubDatabase,
-        branch: Branch,
-        obj: Node,
-        template: CoreObjectTemplate,
-        data: InputObjectType,
-        constraint_runner: NodeConstraintRunner | None = None,
-    ) -> None:
-        if constraint_runner is None:
-            component_registry = get_component_registry()
-            constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
-
-        for relationship in obj.get_relationships(kind=RelationshipKind.COMPONENT, exclude=list(data)):
-            template_relationship_peers = await cls._get_template_relationship_peers(
-                db=db, template=template, relationship=relationship
-            )
-            if not template_relationship_peers:
-                continue
-
-            for template_relationship_peer in template_relationship_peers.values():
-                # We retrieve peer schema for each peer in case we are processing a relationship which is based on a generic
-                obj_peer_schema = registry.schema.get_node_schema(
-                    name=template_relationship_peer.get_schema().kind.removeprefix("Template"),
-                    branch=branch,
-                    duplicate=False,
-                )
-                obj_peer_data = await cls._extract_peer_data(
-                    db=db,
-                    template_peer=template_relationship_peer,
-                    obj_peer_schema=obj_peer_schema,
-                    parent_obj=obj,
-                    current_template=template,
-                )
-
-                obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
-                await obj_peer.new(db=db, **obj_peer_data)
-                await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
-                await obj_peer.save(db=db)
-
-                await cls._handle_template_relationships(
-                    db=db,
-                    branch=branch,
-                    constraint_runner=constraint_runner,
-                    obj=obj_peer,
-                    template=template_relationship_peer,
-                    data=data,
-                )
-
     @classmethod
     async def mutate_create(
         cls,
@@ -301,51 +182,15 @@ class InfrahubMutationMixin:
         db: InfrahubDatabase,
         branch: Branch,
     ) -> Node:
-        component_registry = get_component_registry()
-        node_constraint_runner = await component_registry.get_component(
-            NodeConstraintRunner, db=db.start_session(), branch=branch
+        schema = cls._meta.active_schema
+        if isinstance(schema, GenericSchema):
+            raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+        return await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=schema,
         )
-        node_class = Node
-        if cls._meta.active_schema.kind in registry.node:
-            node_class = registry.node[cls._meta.active_schema.kind]
-
-        fields_to_validate = list(data)
-        if db.is_transaction:
-            obj = await node_class.init(db=db, schema=cls._meta.schema, branch=branch)
-            await obj.new(db=db, **data)
-            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-            await obj.save(db=db)
-
-            object_template = await obj.get_object_template(db=db)
-            if object_template:
-                await cls._handle_template_relationships(
-                    db=db,
-                    branch=branch,
-                    template=object_template,
-                    obj=obj,
-                    data=data,
-                )
-        else:
-            async with db.start_transaction() as dbt:
-                obj = await node_class.init(db=dbt, schema=cls._meta.schema, branch=branch)
-                await obj.new(db=dbt, **data)
-                await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-                await obj.save(db=dbt)
-
-                object_template = await obj.get_object_template(db=dbt)
-                if object_template:
-                    await cls._handle_template_relationships(
-                        db=dbt,
-                        branch=branch,
-                        template=object_template,
-                        obj=obj,
-                        data=data,
-                    )
-
-        if await cls._get_profile_ids(db=db, obj=obj):
-            obj = await cls._refresh_for_profile_update(db=db, branch=branch, obj=obj)
-
-        return obj
 
     @classmethod
     async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
@@ -439,7 +284,7 @@ class InfrahubMutationMixin:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
 
-        before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
+        before_mutate_profile_ids = await get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
         await node_constraint_runner.check(
@@ -453,8 +298,12 @@ class InfrahubMutationMixin:
 
         await obj.save(db=db, fields=fields)
 
-        obj = await cls._refresh_for_profile_update(
-            db=db, branch=branch, obj=obj, previous_profile_ids=before_mutate_profile_ids
+        obj = await refresh_for_profile_update(
+            db=db,
+            branch=branch,
+            obj=obj,
+            previous_profile_ids=before_mutate_profile_ids,
+            schema=cls._meta.active_schema,
         )
         return obj
 

infrahub/graphql/mutations/proposed_change.py

@@ -18,10 +18,10 @@ from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
-from infrahub.message_bus import messages
 from infrahub.proposed_change.constants import ProposedChangeState
-from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE
+from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE, REQUEST_PROPOSED_CHANGE_PIPELINE
 
+from ...proposed_change.models import RequestProposedChangePipeline
 from ..types.task import TaskInfo
 from .main import InfrahubMutationOptions
 
@@ -65,18 +65,18 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
                 )
 
         if graphql_context.service:
-            message_list = [
-                messages.RequestProposedChangePipeline(
-                    proposed_change=proposed_change.id,
-                    source_branch=source_branch.name,
-                    source_branch_sync_with_git=source_branch.sync_with_git,
-                    destination_branch=destination_branch,
-                    context=graphql_context.get_context(),
-                ),
-            ]
-
-            for message in message_list:
-                await graphql_context.service.message_bus.send(message=message)
+            request_proposed_change_model = RequestProposedChangePipeline(
+                proposed_change=proposed_change.id,
+                source_branch=source_branch.name,
+                source_branch_sync_with_git=source_branch.sync_with_git,
+                destination_branch=destination_branch,
+            )
+
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return proposed_change, result
 
@@ -175,16 +175,19 @@ class ProposedChangeRequestRunCheck(Mutation):
         destination_branch = proposed_change.destination_branch.value
         source_branch = await _get_source_branch(db=graphql_context.db, name=proposed_change.source_branch.value)
 
-        message = messages.RequestProposedChangePipeline(
+        request_proposed_change_model = RequestProposedChangePipeline(
             proposed_change=proposed_change.id,
             source_branch=source_branch.name,
             source_branch_sync_with_git=source_branch.sync_with_git,
             destination_branch=destination_branch,
             check_type=check_type,
-            context=graphql_context.get_context(),
         )
         if graphql_context.service:
-            await graphql_context.service.message_bus.send(message=message)
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return {"ok": True}
 
@@ -222,7 +225,7 @@ class ProposedChangeMerge(Mutation):
 
         async with graphql_context.db.start_session() as db:
             proposed_change.state.value = ProposedChangeState.MERGING.value
-            proposed_change.save(db=db)
+            await proposed_change.save(db=db)
 
         if wait_until_completion:
             await graphql_context.service.workflow.execute_workflow(

infrahub/graphql/queries/convert_object_type_mapping.py

@@ -0,0 +1,36 @@
+from graphene import Field, ObjectType, String
+from graphene.types.generic import GenericScalar
+from graphql import GraphQLResolveInfo
+
+from infrahub.core import registry
+from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
+
+
+class FieldsMapping(ObjectType):
+    mapping = GenericScalar(required=True)
+
+
+async def fields_mapping_type_conversion_resolver(
+    root: dict,  # noqa: ARG001
+    info: GraphQLResolveInfo,  # noqa: ARG001
+    source_kind: str,
+    target_kind: str,
+    branch: str,
+) -> dict:
+    source_schema = registry.get_node_schema(name=source_kind, branch=branch)
+    target_schema = registry.get_node_schema(name=target_kind, branch=branch)
+
+    mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
+    mapping_dict = {field_name: model.model_dump(mode="json") for field_name, model in mapping.items()}
+    return {"mapping": mapping_dict}
+
+
+FieldsMappingTypeConversion = Field(
+    FieldsMapping,
+    source_kind=String(),
+    target_kind=String(),
+    branch=String(),
+    description="Retrieve fields mapping for converting object type",
+    resolver=fields_mapping_type_conversion_resolver,
+    required=True,
+)

infrahub/graphql/queries/relationship.py

@@ -34,7 +34,7 @@ class Relationships(ObjectType):
 
         response: dict[str, Any] = {"edges": [], "count": None}
 
-        async with graphql_context.db.start_session() as db:
+        async with graphql_context.db.start_session(read_only=True) as db:
             query = await RelationshipGetByIdentifierQuery.init(
                 db=db,
                 branch=graphql_context.branch,

infrahub/graphql/resolvers/many_relationship.py

@@ -33,7 +33,7 @@ class ManyRelationshipResolver:
         parent_id: str,
         node_schema: NodeSchema,
     ) -> list[str]:
-        async with db.start_session() as dbs:
+        async with db.start_session(read_only=True) as dbs:
             query = await NodeGetHierarchyQuery.init(
                 db=dbs,
                 direction=RelationshipHierarchyDirection.DESCENDANTS,
@@ -55,7 +55,7 @@ class ManyRelationshipResolver:
         rel_schema: RelationshipSchema,
         filters: dict[str, Any],
     ) -> int:
-        async with db.start_session() as dbs:
+        async with db.start_session(read_only=True) as dbs:
             return await NodeManager.count_peers(
                 db=dbs,
                 ids=ids,
@@ -194,7 +194,7 @@ class ManyRelationshipResolver:
         offset: int | None = None,
         limit: int | None = None,
     ) -> list[dict[str, Any]] | None:
-        async with db.start_session() as dbs:
+        async with db.start_session(read_only=True) as dbs:
             objs = await NodeManager.query_peers(
                 db=dbs,
                 ids=ids,
@@ -257,7 +257,7 @@ class ManyRelationshipResolver:
             all_peer_rels.extend(node_peer_rels)
         if not all_peer_rels:
             return None
-        async with db.start_session() as dbs:
+        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

infrahub/graphql/resolvers/resolver.py

@@ -29,7 +29,7 @@ async def account_resolver(
     fields = await extract_fields(info.field_nodes[0].selection_set)
     graphql_context: GraphqlContext = info.context
 
-    async with graphql_context.db.start_session() as db:
+    async with graphql_context.db.start_session(read_only=True) as db:
         results = await NodeManager.query(
             schema=InfrahubKind.GENERICACCOUNT,
             filters={"ids": [graphql_context.account_session.account_id]},
@@ -102,7 +102,7 @@ async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
         if "__" in key and value or key in ["id", "ids"]
     }
 
-    async with graphql_context.db.start_session() as db:
+    async with graphql_context.db.start_session(read_only=True) as db:
         objs = await NodeManager.query_peers(
             db=db,
             ids=[parent["id"]],
@@ -158,7 +158,7 @@ async def default_paginated_list_resolver(
     fields = await extract_selection(info.field_nodes[0], schema=schema)
 
     graphql_context: GraphqlContext = info.context
-    async with graphql_context.db.start_session() as db:
+    async with graphql_context.db.start_session(read_only=True) as db:
         response: dict[str, Any] = {"edges": []}
         filters = {
             key: value for key, value in kwargs.items() if ("__" in key and value is not None) or key in ("ids", "hfid")
@@ -293,7 +293,7 @@ async def hierarchy_resolver(
 
     response: dict[str, Any] = {"edges": [], "count": None}
 
-    async with graphql_context.db.start_session() as db:
+    async with graphql_context.db.start_session(read_only=True) as db:
         if "count" in fields:
             response["count"] = await NodeManager.count_hierarchy(
                 db=db,