infrahub-server 1.2.10__py3-none-any.whl → 1.2.12__py3-none-any.whl

infrahub/core/migrations/graph/m030_illegal_edges.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class DeletePosthumousEdges(Query):
+    name = "delete_posthumous_edges_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL {
+    WITH added_e
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+DELETE added_e
+// --------------
+// the peer _should_ only be an Attribute, but I want to make sure we don't
+// inadvertently delete Root or an AttributeValue or a Boolean
+// --------------
+WITH peer
+WHERE "Attribute" IN labels(peer)
+DETACH DELETE peer
+        """
+        self.add_to_query(query)
+
+
+class Migration030(GraphMigration):
+    """
+    Edges could have been added to Nodes after the Node was deleted, so we need to hard-delete those illegal edges
+    """
+
+    name: str = "030_delete_illegal_edges"
+    minimum_version: int = 29
+    queries: Sequence[type[Query]] = [DeletePosthumousEdges]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/migrations/query/attribute_add.py

@@ -63,28 +63,32 @@ class AttributeAddQuery(Query):
         MATCH p = (n:%(node_kind)s)
         CALL {
             WITH n
-            MATCH (root:Root)<-[r1:IS_PART_OF]-(n)
-            OPTIONAL MATCH (n)-[r2:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
-            WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
-            RETURN n as n1, r1 as r11, r2 as r12
-            ORDER BY r2.branch_level DESC, r2.from ASC, r1.branch_level DESC, r1.from ASC
+            MATCH (:Root)<-[r:IS_PART_OF]-(n)
+            WHERE %(branch_filter)s
+            WITH n, r AS is_part_of_e
+            OPTIONAL MATCH (n)-[r:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
+            WHERE %(branch_filter)s
+            WITH is_part_of_e, r AS has_attr_e
+            RETURN is_part_of_e, has_attr_e
+            ORDER BY has_attr_e.branch_level DESC, has_attr_e.from ASC, is_part_of_e.branch_level DESC, is_part_of_e.from ASC
             LIMIT 1
         }
-        WITH n1 as n, r11 as r1, r12 as r2, av, is_protected_value, is_visible_value
-        WHERE r1.status = "active" AND (r2 IS NULL OR r2.status = "deleted")
+        WITH n, is_part_of_e, has_attr_e, av, is_protected_value, is_visible_value
+        WHERE is_part_of_e.status = "active" AND (has_attr_e IS NULL OR has_attr_e.status = "deleted")
         CREATE (a:Attribute { name: $attr_name, branch_support: $branch_support })
         CREATE (n)-[:HAS_ATTRIBUTE $rel_props ]->(a)
         CREATE (a)-[:HAS_VALUE $rel_props ]->(av)
         CREATE (a)-[:IS_PROTECTED $rel_props]->(is_protected_value)
         CREATE (a)-[:IS_VISIBLE $rel_props]->(is_visible_value)
         %(uuid_generation)s
-        FOREACH (i in CASE WHEN r2.status = "deleted" THEN [1] ELSE [] END |
-            SET r2.to = $current_time
+        FOREACH (i in CASE WHEN has_attr_e.status = "deleted" THEN [1] ELSE [] END |
+            SET has_attr_e.to = $current_time
         )
         """ % {
             "branch_filter": branch_filter,
             "node_kind": self.node_kind,
             "uuid_generation": db.render_uuid_generation(node_label="a", node_attr="uuid"),
         }
+
         self.add_to_query(query)
         self.return_labels = ["n.uuid", "a.uuid"]

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -81,11 +81,15 @@ class CoreIPAddressPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             ip_prefix = ipaddress.ip_network(resource.prefix.value)  # type: ignore[attr-defined]
             prefix_length = prefixlen or ip_prefix.prefixlen
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -88,11 +88,15 @@ class CoreIPPrefixPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int) -> IPNetworkType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             subnets = await get_subnets(
                 db=db,
                 ip_prefix=ipaddress.ip_network(resource.prefix.value),  # type: ignore[attr-defined]

infrahub/core/protocols.py

@@ -209,6 +209,10 @@ class CoreWebhook(CoreNode):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResource(CoreNode):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwner(CoreNode):
     pass
 

infrahub/core/query/diff.py

@@ -201,6 +201,13 @@ WITH reduce(
     diff_rel_paths = [], item IN [penultimate_path, peer_path] |
     CASE WHEN item IS NULL THEN diff_rel_paths ELSE diff_rel_paths + [item] END
 ) AS diff_rel_paths, has_more_data
+// ------------------------
+// make sure we still include has_more_data if diff_rel_paths is empty
+// ------------------------
+WITH CASE
+    WHEN diff_rel_paths = [] THEN [NULL]
+    ELSE diff_rel_paths
+END AS diff_rel_paths, has_more_data
     """
 
     def get_previous_base_path_query(self, db: InfrahubDatabase) -> str:

infrahub/core/schema/definitions/core/__init__.py

@@ -56,7 +56,13 @@ from .propose_change_validator import (
     core_user_validator,
 )
 from .repository import core_generic_repository, core_read_only_repository, core_repository
-from .resource_pool import core_ip_address_pool, core_ip_prefix_pool, core_number_pool, core_resource_pool
+from .resource_pool import (
+    core_ip_address_pool,
+    core_ip_prefix_pool,
+    core_number_pool,
+    core_resource_pool,
+    core_weighted_pool_resource,
+)
 from .template import core_object_component_template, core_object_template
 from .transform import core_transform, core_transform_jinja2, core_transform_python
 from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
@@ -81,6 +87,7 @@ core_models_mixed: dict[str, list] = {
         builtin_ip_prefix,
         builtin_ip_address,
         core_resource_pool,
+        core_weighted_pool_resource,
         core_generic_account,
         core_base_permission,
         core_credential,

infrahub/core/schema/definitions/core/resource_pool.py

@@ -32,6 +32,26 @@ core_resource_pool = GenericSchema(
     ],
 )
 
+core_weighted_pool_resource = GenericSchema(
+    name="WeightedPoolResource",
+    namespace="Core",
+    label="Weighted Pool Resource",
+    description="Resource to be used in a pool, its weight is used to determine its priority on allocation.",
+    include_in_menu=False,
+    branch=BranchSupportType.AWARE,
+    generate_profile=False,
+    attributes=[
+        Attr(
+            name="allocation_weight",
+            label="Weight",
+            description="Weight determines allocation priority, resources with higher values are selected first.",
+            kind="Number",
+            optional=True,
+            order_weight=10000,
+        )
+    ],
+)
+
 core_ip_prefix_pool = NodeSchema(
     name="IPPrefixPool",
     namespace="Core",

infrahub/core/schema/schema_branch.py

@@ -1957,7 +1957,11 @@ class SchemaBranch:
             )
 
             parent_hfid = f"{relationship.name}__template_name__value"
-            if relationship.kind == RelationshipKind.PARENT and parent_hfid not in template_schema.human_friendly_id:
+            if (
+                not isinstance(template_schema, GenericSchema)
+                and relationship.kind == RelationshipKind.PARENT
+                and parent_hfid not in template_schema.human_friendly_id
+            ):
                 template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
@@ -1992,7 +1996,6 @@ class SchemaBranch:
                 include_in_menu=False,
                 display_labels=["template_name__value"],
                 human_friendly_id=["template_name__value"],
-                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
@@ -2011,7 +2014,6 @@ class SchemaBranch:
                 human_friendly_id=["template_name__value"],
                 uniqueness_constraints=[["template_name__value"]],
                 inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-                default_filter="template_name__value",
                 attributes=[template_name_attr],
                 relationships=[
                     RelationshipSchema(

infrahub/core/validators/tasks.py

@@ -71,7 +71,7 @@ async def schema_path_validate(
     schema_branch: SchemaBranch,
     service: InfrahubServices,
 ) -> SchemaValidatorPathResponseData:
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=True) as db:
         constraint_request = SchemaConstraintValidatorRequest(
             branch=branch,
             constraint_name=constraint_name,

infrahub/database/__init__.py

@@ -476,8 +476,6 @@ async def validate_database(
 
 
 async def get_db(retry: int = 0) -> AsyncDriver:
-    URI = f"{config.SETTINGS.database.protocol}://{config.SETTINGS.database.address}:{config.SETTINGS.database.port}"
-
     trusted_certificates = TrustSystemCAs()
     if config.SETTINGS.database.tls_insecure:
         trusted_certificates = TrustAll()
@@ -485,11 +483,14 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         trusted_certificates = TrustCustomCAs(config.SETTINGS.database.tls_ca_file)
 
     driver = AsyncGraphDatabase.driver(
-        URI,
+        config.SETTINGS.database.database_uri,
         auth=(config.SETTINGS.database.username, config.SETTINGS.database.password),
         encrypted=config.SETTINGS.database.tls_enabled,
         trusted_certificates=trusted_certificates,
-        notifications_disabled_categories=[NotificationDisabledCategory.UNRECOGNIZED],
+        notifications_disabled_categories=[
+            NotificationDisabledCategory.UNRECOGNIZED,
+            NotificationDisabledCategory.DEPRECATION,  # TODO: Remove me with 1.3
+        ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )
 

infrahub/database/validation.py

@@ -0,0 +1,101 @@
+from infrahub.database import InfrahubDatabase
+
+
+async def verify_no_duplicate_relationships(db: InfrahubDatabase) -> None:
+    """
+    Verify that no duplicate active relationships exist at the database level
+    A duplicate is defined as
+    - connecting the same two nodes
+    - having the same identifier
+    - having the same direction (inbound, outbound, bidirectional)
+    - having the same branch
+    A more thorough check that no duplicates exist at any point in time is possible, but more complex
+    """
+    query = """
+MATCH (a:Node)-[e1:IS_RELATED {status: "active"}]-(rel:Relationship)-[e2:IS_RELATED {branch: e1.branch, status: "active"}]-(b:Node)
+WHERE a.uuid <> b.uuid
+AND e1.to IS NULL
+AND e2.to IS NULL
+WITH a, rel.name AS rel_name, b, e1.branch AS branch, CASE
+    WHEN startNode(e1) = a AND startNode(e2) = rel THEN "out"
+    WHEN startNode(e1) = rel AND startNode(e2) = b THEN "in"
+    ELSE "bidir"
+END AS direction, COUNT(*) AS num_duplicates
+WHERE num_duplicates > 1
+RETURN a.uuid AS node_id1, b.uuid AS node_id2, rel_name, branch, direction, num_duplicates
+    """
+    results = await db.execute_query(query=query)
+    for result in results:
+        node_id1 = result.get("node_id1")
+        node_id2 = result.get("node_id2")
+        rel_name = result.get("rel_name")
+        branch = result.get("branch")
+        direction = result.get("direction")
+        num_duplicates = result.get("num_duplicates")
+        raise ValueError(
+            f"{num_duplicates} duplicate relationships ({branch=},{direction=}) between nodes '{node_id1}' and '{node_id2}'"
+            f" with relationship name '{rel_name}'"
+        )
+
+
+async def verify_no_edges_added_after_node_delete(db: InfrahubDatabase) -> None:
+    """
+    Verify that no edges are added to a Node after it is deleted on a given branch
+    """
+    query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer AS added_peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL {
+    WITH added_e
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, added_peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+RETURN n.uuid AS n_uuid, delete_branch, delete_time, added_e, added_peer
+    """
+    results = await db.execute_query(query=query)
+    error_messages = []
+    for result in results:
+        n_uuid = result.get("n_uuid")
+        delete_branch = result.get("delete_branch")
+        delete_time = result.get("delete_time")
+        added_e = result.get("added_e")
+        added_e_branch = added_e.get("branch")
+        added_e_from = added_e.get("from")
+        added_peer = result.get("added_peer")
+        message = (
+            f"Node {n_uuid} was deleted on {delete_branch} at {delete_time} but has an {added_e.type} edge added on"
+            f" branch {added_e_branch} at {added_e_from} to {added_peer.element_id}"
+        )
+        error_messages.append(message)
+    if error_messages:
+        raise ValueError(error_messages)

infrahub/graphql/app.py

@@ -155,7 +155,7 @@ class InfrahubGraphQLApp:
 
             db = websocket.app.state.db
 
-            async with db.start_session() as db:
+            async with db.start_session(read_only=True) as db:
                 branch_name = websocket.path_params.get("branch_name", registry.default_branch)
                 branch = await registry.get_branch(db=db, branch=branch_name)
 

infrahub/graphql/loaders/node.py

@@ -53,7 +53,7 @@ class NodeDataLoader(DataLoader[str, Node | None]):
         self.db = db
 
     async def batch_load_fn(self, keys: list[Any]) -> list[Node | None]:
-        async with self.db.start_session() as db:
+        async with self.db.start_session(read_only=True) as db:
             nodes_by_id = await NodeManager.get_many(
                 db=db,
                 ids=keys,

infrahub/graphql/loaders/peers.py

@@ -51,7 +51,7 @@ class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
         self.db = db
 
     async def batch_load_fn(self, keys: list[Any]) -> list[list[Relationship]]:  # pylint: disable=method-hidden
-        async with self.db.start_session() as db:
+        async with self.db.start_session(read_only=True) as db:
             peer_rels = await NodeManager.query_peers(
                 db=db,
                 ids=keys,

infrahub/graphql/mutations/main.py

@@ -533,7 +533,7 @@ class InfrahubMutationMixin:
         except HFIDViolatedError as exc:
             # Only the HFID constraint has been violated, it means the node exists and we can update without rerunning constraints
             if len(exc.matching_nodes_ids) > 1:
-                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid (database corrupted)") from exc
+                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid") from exc
             node_id = list(exc.matching_nodes_ids)[0]
             node = await NodeManager.get_one(db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True)
             updated_obj, mutation = await cls._call_mutate_update(

infrahub/graphql/mutations/proposed_change.py

@@ -222,7 +222,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/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/queries/task.py

@@ -32,6 +32,8 @@ class Tasks(ObjectType):
         workflow: list[str] | None = None,
         related_node__ids: list | None = None,
         q: str | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         related_nodes = related_node__ids or []
         ids = ids or []
@@ -45,6 +47,8 @@ class Tasks(ObjectType):
             statuses=state,
             workflows=workflow,
             related_nodes=related_nodes,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
 
     @staticmethod
@@ -71,6 +75,8 @@ class Tasks(ObjectType):
         branch: str | None = None,
         limit: int | None = None,
         offset: int | None = None,
+        log_limit: int | None = None,
+        log_offset: int | None = None,
     ) -> dict[str, Any]:
         graphql_context: GraphqlContext = info.context
         fields = await extract_fields_first_node(info)
@@ -87,6 +93,8 @@ class Tasks(ObjectType):
             related_nodes=related_nodes,
             limit=limit,
             offset=offset,
+            log_limit=log_limit,
+            log_offset=log_offset,
         )
         prefect_count = prefect_tasks.get("count", None)
         return {
@@ -105,6 +113,8 @@ Task = Field(
     workflow=List(String),
     ids=List(String),
     q=String(required=False),
+    log_limit=Int(required=False),
+    log_offset=Int(required=False),
     resolver=Tasks.resolve,
     required=True,
 )

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,

infrahub/graphql/resolvers/single_relationship.py

@@ -109,7 +109,7 @@ class SingleRelationshipResolver:
             for key, value in kwargs.items()
             if "__" in key and value or key in ["id", "ids"]
         }
-        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=[parent_id],
@@ -171,5 +171,5 @@ class SingleRelationshipResolver:
         node = await loader.load(key=peer_id)
         if not node:
             return None
-        async with db.start_session() as dbs:
+        async with db.start_session(read_only=True) as dbs:
             return await node.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)

infrahub/graphql/subscription/graphql_query.py

@@ -29,7 +29,7 @@ async def resolver_graphql_query(
     graphql_context: GraphqlContext = info.context
     at = Timestamp()
 
-    async with graphql_context.db.start_session() as db:
+    async with graphql_context.db.start_session(read_only=True) 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=graphql_context.branch, at=at
@@ -38,7 +38,7 @@ async def resolver_graphql_query(
             raise ValueError(f"Unable to find the {InfrahubKind.GRAPHQLQUERY} {name}")
 
     while True:
-        async with graphql_context.db.start_session() as db:
+        async with graphql_context.db.start_session(read_only=True) as db:
             result = await graphql(
                 schema=graphql_schema,
                 source=graphql_query.query.value,

infrahub/graphql/types/branch.py

@@ -37,7 +37,7 @@ class BranchType(InfrahubObjectType):
         graphql_context: GraphqlContext,
         **kwargs: Any,
     ) -> list[dict[str, Any]]:
-        async with graphql_context.db.start_session() as db:
+        async with graphql_context.db.start_session(read_only=True) as db:
             objs = await Branch.get_list(db=db, **kwargs)
 
             if not objs:

infrahub/graphql/types/task_log.py

@@ -1,4 +1,4 @@
-from graphene import Field, InputObjectType, List, ObjectType, String
+from graphene import Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene.types.uuid import UUID
 
 from .enums import Severity
@@ -26,4 +26,5 @@ class TaskLogNodes(ObjectType):
 
 
 class TaskLogEdge(ObjectType):
-    edges = List(TaskLogNodes)
+    edges = List(NonNull(TaskLogNodes), required=True)
+    count = Int(required=True)