infrahub-server 1.2.9rc0__py3-none-any.whl → 1.2.11__py3-none-any.whl

infrahub/core/query/relationship.py

@@ -73,9 +73,18 @@ class RelationshipPeerData:
     source_id: UUID
     """UUID of the Source Node."""
 
+    source_db_id: str
+    """Internal DB ID of the Source Node."""
+
+    source_kind: str
+    """Kind of the Source Node."""
+
     peer_id: UUID
     """UUID of the Peer Node."""
 
+    peer_db_id: str
+    """Internal DB ID of the Peer Node."""
+
     peer_kind: str
     """Kind of the Peer Node."""
 
@@ -85,9 +94,6 @@ class RelationshipPeerData:
     rel_node_id: UUID | None = None
     """UUID of the Relationship Node."""
 
-    peer_db_id: str | None = None
-    """Internal DB ID of the Peer Node."""
-
     rel_node_db_id: str | None = None
     """Internal DB ID of the Relationship Node."""
 
@@ -196,6 +202,63 @@ class RelationshipQuery(Query):
             rel_prop_dict["hierarchy"] = self.schema.hierarchical
         return rel_prop_dict
 
+    def add_source_match_to_query(self, source_branch: Branch) -> None:
+        self.params["source_id"] = self.source_id or self.source.get_id()
+        if source_branch.is_global or source_branch.is_default:
+            source_query_match = """
+            MATCH (s:Node { uuid: $source_id })
+            OPTIONAL MATCH (s)-[delete_edge:IS_PART_OF {status: "deleted", branch: $source_branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH *, s WHERE delete_edge IS NULL
+            """
+            self.params["source_branch"] = source_branch.name
+        source_filter, source_filter_params = source_branch.get_query_filter_path(
+            at=self.at, variable_name="r", params_prefix="src_"
+        )
+        source_query_match = """
+            MATCH (s:Node { uuid: $source_id })
+            CALL {
+                WITH s
+                MATCH (s)-[r:IS_PART_OF]->(:Root)
+                WHERE %(source_filter)s
+                RETURN r.status = "active" AS s_is_active
+                ORDER BY r.from DESC
+                LIMIT 1
+            }
+            WITH *, s WHERE s_is_active = TRUE
+            """ % {"source_filter": source_filter}
+        self.params.update(source_filter_params)
+        self.add_to_query(source_query_match)
+
+    def add_dest_match_to_query(self, destination_branch: Branch, destination_id: str) -> None:
+        self.params["destination_id"] = destination_id
+        if destination_branch.is_global or destination_branch.is_default:
+            destination_query_match = """
+            MATCH (d:Node { uuid: $destination_id })
+            OPTIONAL MATCH (d)-[delete_edge:IS_PART_OF {status: "deleted", branch: $destination_branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH *, d WHERE delete_edge IS NULL
+            """
+            self.params["destination_branch"] = destination_branch.name
+        else:
+            destination_filter, destination_filter_params = destination_branch.get_query_filter_path(
+                at=self.at, variable_name="r", params_prefix="dst_"
+            )
+            destination_query_match = """
+            MATCH (d:Node { uuid: $destination_id })
+            CALL {
+                WITH d
+                MATCH (d)-[r:IS_PART_OF]->(:Root)
+                WHERE %(destination_filter)s
+                RETURN r.status = "active" AS d_is_active
+                ORDER BY r.from DESC
+                LIMIT 1
+            }
+            WITH *, d WHERE d_is_active = TRUE
+            """ % {"destination_filter": destination_filter}
+            self.params.update(destination_filter_params)
+        self.add_to_query(destination_query_match)
+
 
 class RelationshipCreateQuery(RelationshipQuery):
     name = "relationship_create"
@@ -214,8 +277,6 @@ class RelationshipCreateQuery(RelationshipQuery):
         super().__init__(destination=destination, destination_id=destination_id, **kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["name"] = self.schema.identifier
         self.params["branch_support"] = self.schema.branch.value
 
@@ -228,12 +289,11 @@ class RelationshipCreateQuery(RelationshipQuery):
         self.params["is_protected"] = self.rel.is_protected
         self.params["is_visible"] = self.rel.is_visible
 
-        query_match = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
-        """
-        self.add_to_query(query_match)
-
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         self.query_add_all_node_property_match()
 
         self.params["rel_prop"] = self.get_relationship_properties_dict(status=RelationshipStatus.ACTIVE)
@@ -378,7 +438,6 @@ class RelationshipDataDeleteQuery(RelationshipQuery):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.data.peer_id
         self.params["rel_node_id"] = self.data.rel_node_id
         self.params["name"] = self.schema.identifier
         self.params["branch"] = self.branch.name
@@ -388,9 +447,10 @@ class RelationshipDataDeleteQuery(RelationshipQuery):
         # -----------------------------------------------------------------------
         # Match all nodes, including properties
         # -----------------------------------------------------------------------
+
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(destination_branch=self.branch, destination_id=self.data.peer_id)
         query = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
         MATCH (rl:Relationship { uuid: $rel_node_id })
         """
         self.add_to_query(query)
@@ -442,8 +502,6 @@ class RelationshipDeleteQuery(RelationshipQuery):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         rel_filter, rel_params = self.branch.get_query_filter_path(at=self.at, variable_name="edge")
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["rel_id"] = self.rel.id
         self.params["branch"] = self.branch.name
         self.params["rel_prop"] = self.get_relationship_properties_dict(status=RelationshipStatus.DELETED)
@@ -454,9 +512,14 @@ class RelationshipDeleteQuery(RelationshipQuery):
         r1 = f"{arrows.left.start}[r1:{self.rel_type} $rel_prop ]{arrows.left.end}"
         r2 = f"{arrows.right.start}[r2:{self.rel_type} $rel_prop ]{arrows.right.end}"
 
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         query = """
-        MATCH (s:Node { uuid: $source_id })-[:IS_RELATED]-(rl:Relationship {uuid: $rel_id})-[:IS_RELATED]-(d:Node { uuid: $destination_id })
-        WITH s, rl, d
+        MATCH (s)-[:IS_RELATED]-(rl:Relationship {uuid: $rel_id})-[:IS_RELATED]-(d)
+        WITH DISTINCT s, rl, d
         LIMIT 1
         CREATE (s)%(r1)s(rl)
         CREATE (rl)%(r2)s(d)
@@ -752,10 +815,15 @@ class RelationshipGetPeerQuery(Query):
     def get_peers(self) -> Generator[RelationshipPeerData, None, None]:
         for result in self.get_results_group_by(("peer", "uuid"), ("source_node", "uuid")):
             rels = result.get("rels")
+            source_node = result.get_node("source_node")
+            peer_node = result.get_node("peer")
             data = RelationshipPeerData(
-                source_id=result.get_node("source_node").get("uuid"),
-                peer_id=result.get_node("peer").get("uuid"),
-                peer_kind=result.get_node("peer").get("kind"),
+                source_id=source_node.get("uuid"),
+                source_db_id=source_node.element_id,
+                source_kind=source_node.get("kind"),
+                peer_id=peer_node.get("uuid"),
+                peer_db_id=peer_node.element_id,
+                peer_kind=peer_node.get("kind"),
                 rel_node_db_id=result.get("rl").element_id,
                 rel_node_id=result.get("rl").get("uuid"),
                 updated_at=rels[0]["from"],
@@ -793,8 +861,6 @@ class RelationshipGetQuery(RelationshipQuery):
     type: QueryType = QueryType.READ
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["name"] = self.schema.identifier
         self.params["branch"] = self.branch.name
 
@@ -808,9 +874,12 @@ class RelationshipGetQuery(RelationshipQuery):
         r1 = f"{arrows.left.start}[r1:{self.rel.rel_type}]{arrows.left.end}"
         r2 = f"{arrows.right.start}[r2:{self.rel.rel_type}]{arrows.right.end}"
 
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         query = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
         MATCH (s)%s(rl:Relationship { name: $name })%s(d)
         WHERE %s
         """ % (
@@ -1037,7 +1106,11 @@ class RelationshipDeleteAllQuery(Query):
         CALL {
             WITH rl
             MATCH (rl)-[active_edge:IS_RELATED]->(n)
-            WHERE %(active_rel_filter)s AND active_edge.status ="active"
+            WHERE %(active_rel_filter)s
+            WITH rl, active_edge, n
+            ORDER BY %(id_func)s(rl), %(id_func)s(n), active_edge.from DESC
+            WITH rl, n, head(collect(active_edge)) AS active_edge
+            WHERE active_edge.status = "active"
             CREATE (rl)-[deleted_edge:IS_RELATED $rel_prop]->(n)
             SET deleted_edge.hierarchy = active_edge.hierarchy
             WITH rl, active_edge, n
@@ -1053,7 +1126,11 @@ class RelationshipDeleteAllQuery(Query):
 
             WITH rl
             MATCH (rl)<-[active_edge:IS_RELATED]-(n)
-            WHERE %(active_rel_filter)s AND active_edge.status ="active"
+            WHERE %(active_rel_filter)s
+            WITH rl, active_edge, n
+            ORDER BY %(id_func)s(rl), %(id_func)s(n), active_edge.from DESC
+            WITH rl, n, head(collect(active_edge)) AS active_edge
+            WHERE active_edge.status = "active"
             CREATE (rl)<-[deleted_edge:IS_RELATED $rel_prop]-(n)
             SET deleted_edge.hierarchy = active_edge.hierarchy
             WITH rl, active_edge, n
@@ -1066,9 +1143,7 @@ class RelationshipDeleteAllQuery(Query):
                 "inbound" as rel_direction
         }
         RETURN DISTINCT uuid, kind, rel_identifier, rel_direction
-        """ % {
-            "active_rel_filter": active_rel_filter,
-        }
+        """ % {"active_rel_filter": active_rel_filter, "id_func": db.get_id_function_name()}
 
         self.add_to_query(query)
 

infrahub/core/query/subquery.py

@@ -57,7 +57,7 @@ async def build_subquery_filter(
     params.update(field_params)
 
     field_where.append("all(r IN relationships(path) WHERE (%s))" % branch_filter)
-    filter_str = f"({node_alias})" + "".join([str(item) for item in field_filter])
+    filter_str = f"({node_alias}:Node {{uuid: {node_alias}.uuid}})" + "".join([str(item) for item in field_filter])
     where_str = " AND ".join(field_where)
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
@@ -138,7 +138,7 @@ async def build_subquery_order(
     field_filter[-1].name = "last"
 
     field_where.append("all(r IN relationships(path) WHERE (%s))" % branch_filter)
-    filter_str = f"({node_alias})" + "".join([str(item) for item in field_filter])
+    filter_str = f"({node_alias}:Node {{uuid: {node_alias}.uuid}})" + "".join([str(item) for item in field_filter])
     where_str = " AND ".join(field_where)
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")

infrahub/core/relationship/model.py

@@ -416,7 +416,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             await update_relationships_to(rel_ids_to_update, to=delete_at, db=db)
 
         delete_query = await RelationshipDeleteQuery.init(
-            db=db, rel=self, source_id=node.id, destination_id=peer.id, branch=branch, at=delete_at
+            db=db, rel=self, source=node, destination=peer, branch=branch, at=delete_at
         )
         await delete_query.execute(db=db)
 

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

@@ -2050,6 +2050,9 @@ class SchemaBranch:
 
         identified.add(node_schema)
 
+        if node_schema.is_node_schema:
+            identified.update([self.get(name=kind, duplicate=False) for kind in node_schema.inherit_from])
+
         for relationship in node_schema.relationships:
             if (
                 relationship.peer in [InfrahubKind.GENERICGROUP, InfrahubKind.PROFILE]

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/core/validators/uniqueness/query.py

@@ -225,6 +225,13 @@ class NodeUniqueAttributeConstraintQuery(Query):
             attr_name,
             attr_value,
             relationship_identifier
+        ORDER BY
+            node_id,
+            deepest_branch_name,
+            node_count,
+            attr_name,
+            attr_value,
+            relationship_identifier
         """ % {
             "select_subqueries_str": select_subqueries_str,
             "branch_filter": branch_filter,

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/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/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/diff/tree.py

@@ -10,6 +10,7 @@ from infrahub.core import registry
 from infrahub.core.constants import DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.diff.model.path import NameTrackingId
+from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters
 from infrahub.core.diff.repository.repository import DiffRepository
 from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
@@ -415,7 +416,7 @@ class DiffTreeResolver:
             diff_branch_names=[diff_branch.name],
             from_time=from_timestamp,
             to_time=to_timestamp,
-            filters=filters_dict,
+            filters=EnrichedDiffQueryFilters(**filters_dict),
             include_parents=include_parents,
             limit=limit,
             offset=offset,

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)

infrahub/message_bus/operations/refresh/registry.py

@@ -11,7 +11,7 @@ async def branches(message: messages.RefreshRegistryBranches, service: InfrahubS
         service.log.info("Ignoring refresh registry refresh request originating from self", worker=WORKER_IDENTITY)
         return
 
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=True) as db:
         await refresh_branches(db=db)
 
     await service.component.refresh_schema_hash()