orchestrator-core 4.6.2__py3-none-any.whl → 4.6.3__py3-none-any.whl

orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.6.2"
+__version__ = "4.6.3"
 
 
 from structlog import get_logger

orchestrator/api/api_v1/endpoints/search.py

@@ -21,35 +21,32 @@ from orchestrator.schemas.search import (
     PathsResponse,
     SearchResultsSchema,
 )
+from orchestrator.schemas.search_requests import SearchRequest
 from orchestrator.search.core.exceptions import InvalidCursorError, QueryStateNotFoundError
 from orchestrator.search.core.types import EntityType, UIType
-from orchestrator.search.filters.definitions import generate_definitions
-from orchestrator.search.retrieval import SearchQueryState, execute_search, execute_search_for_export
-from orchestrator.search.retrieval.builder import build_paths_query, create_path_autocomplete_lquery, process_path_rows
+from orchestrator.search.filters.definitions import TypeDefinition, generate_definitions
+from orchestrator.search.query import QueryState, engine
+from orchestrator.search.query.builder import build_paths_query, create_path_autocomplete_lquery, process_path_rows
+from orchestrator.search.query.queries import ExportQuery, SelectQuery
+from orchestrator.search.query.results import SearchResult
+from orchestrator.search.query.validation import is_lquery_syntactically_valid
 from orchestrator.search.retrieval.pagination import PageCursor, encode_next_page_cursor
-from orchestrator.search.retrieval.validation import is_lquery_syntactically_valid
-from orchestrator.search.schemas.parameters import (
-    ProcessSearchParameters,
-    ProductSearchParameters,
-    SearchParameters,
-    SubscriptionSearchParameters,
-    WorkflowSearchParameters,
-)
-from orchestrator.search.schemas.results import SearchResult, TypeDefinition
 
 router = APIRouter()
 logger = structlog.get_logger(__name__)
 
 
 async def _perform_search_and_fetch(
-    search_params: SearchParameters | None = None,
+    entity_type: EntityType | None = None,
+    request: SearchRequest | None = None,
     cursor: str | None = None,
     query_id: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
     """Execute search with optional pagination.
 
     Args:
-        search_params: Search parameters for new search
+        entity_type: Entity type to search
+        request: Search request for new search
         cursor: Pagination cursor (loads saved query state)
         query_id: Saved query ID to retrieve and execute
 
@@ -58,27 +55,31 @@ async def _perform_search_and_fetch(
     """
     try:
         page_cursor: PageCursor | None = None
+        query: SelectQuery
 
         if cursor:
             page_cursor = PageCursor.decode(cursor)
-            query_state = SearchQueryState.load_from_id(page_cursor.query_id)
+            query_state = QueryState.load_from_id(page_cursor.query_id, SelectQuery)
+            query = query_state.query
+
         elif query_id:
-            query_state = SearchQueryState.load_from_id(query_id)
-        elif search_params:
-            query_state = SearchQueryState(parameters=search_params, query_embedding=None)
+            query_state = QueryState.load_from_id(query_id, SelectQuery)
+            query = query_state.query
+
+        elif request and entity_type:
+            query = request.to_query(entity_type)
+            query_state = QueryState(query=query, query_embedding=None)
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Either search_params, cursor, or query_id must be provided",
+                detail="Either (request + entity_type), cursor, or query_id must be provided",
             )
 
-        search_response = await execute_search(
-            query_state.parameters, db.session, page_cursor, query_state.query_embedding
-        )
+        search_response = await engine.execute_search(query, db.session, page_cursor, query_state.query_embedding)
         if not search_response.results:
             return SearchResultsSchema(search_metadata=search_response.metadata)
 
-        next_page_cursor = encode_next_page_cursor(search_response, page_cursor, query_state.parameters)
+        next_page_cursor = encode_next_page_cursor(search_response, page_cursor, query)
         has_next_page = next_page_cursor is not None
         page_info = PageInfoSchema(has_next_page=has_next_page, next_page_cursor=next_page_cursor)
 
@@ -98,34 +99,34 @@ async def _perform_search_and_fetch(
 
 @router.post("/subscriptions", response_model=SearchResultsSchema[SearchResult])
 async def search_subscriptions(
-    search_params: SubscriptionSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.SUBSCRIPTION, request, cursor)
 
 
 @router.post("/workflows", response_model=SearchResultsSchema[SearchResult])
 async def search_workflows(
-    search_params: WorkflowSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.WORKFLOW, request, cursor)
 
 
 @router.post("/products", response_model=SearchResultsSchema[SearchResult])
 async def search_products(
-    search_params: ProductSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.PRODUCT, request, cursor)
 
 
 @router.post("/processes", response_model=SearchResultsSchema[SearchResult])
 async def search_processes(
-    search_params: ProcessSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.PROCESS, request, cursor)
 
 
 @router.get(
@@ -191,7 +192,7 @@ async def export_by_query_id(query_id: str) -> ExportResponse:
     as flattened records suitable for CSV download.
 
     Args:
-        query_id: Query UUID
+        query_id: QueryTypes UUID
 
     Returns:
         ExportResponse containing 'page' with an array of flattened entity records.
@@ -200,8 +201,17 @@ async def export_by_query_id(query_id: str) -> ExportResponse:
         HTTPException: 404 if query not found, 400 if invalid data
     """
     try:
-        query_state = SearchQueryState.load_from_id(query_id)
-        export_records = await execute_search_for_export(query_state, db.session)
+        # Load SelectQuery from the database (what gets saved during search)
+        query_state = QueryState.load_from_id(query_id, SelectQuery)
+
+        # Convert to ExportQuery with export-appropriate limit
+        export_query = ExportQuery(
+            entity_type=query_state.query.entity_type,
+            filters=query_state.query.filters,
+            query_text=query_state.query.query_text,
+        )
+
+        export_records = await engine.execute_export(export_query, db.session, query_state.query_embedding)
         return ExportResponse(page=export_records)
     except ValueError as e:
         raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))

orchestrator/{search/retrieval/utils.py → cli/search/display.py}

@@ -12,7 +12,6 @@
 # limitations under the License.
 
 import json
-import re
 
 import structlog
 from sqlalchemy import and_
@@ -22,37 +21,13 @@ from orchestrator.db.database import WrappedSession
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import EntityType
 from orchestrator.search.indexing.registry import ENTITY_CONFIG_REGISTRY
-from orchestrator.search.schemas.parameters import BaseSearchParameters
-from orchestrator.search.schemas.results import SearchResult
+from orchestrator.search.query.queries import BaseQuery
+from orchestrator.search.query.results import SearchResult
 
 logger = structlog.get_logger(__name__)
 
 
-def generate_highlight_indices(text: str, term: str) -> list[tuple[int, int]]:
-    """Finds all occurrences of individual words from the term, including both word boundary and substring matches."""
-    if not text or not term:
-        return []
-
-    all_matches = []
-    words = [w.strip() for w in term.split() if w.strip()]
-
-    for word in words:
-        # First find word boundary matches
-        word_boundary_pattern = rf"\b{re.escape(word)}\b"
-        word_matches = list(re.finditer(word_boundary_pattern, text, re.IGNORECASE))
-        all_matches.extend([(m.start(), m.end()) for m in word_matches])
-
-        # Then find all substring matches
-        substring_pattern = re.escape(word)
-        substring_matches = list(re.finditer(substring_pattern, text, re.IGNORECASE))
-        all_matches.extend([(m.start(), m.end()) for m in substring_matches])
-
-    return sorted(set(all_matches))
-
-
-def display_filtered_paths_only(
-    results: list[SearchResult], search_params: BaseSearchParameters, db_session: WrappedSession
-) -> None:
+def display_filtered_paths_only(results: list[SearchResult], query: BaseQuery, db_session: WrappedSession) -> None:
     """Display only the paths that were searched for in the results."""
     if not results:
         logger.info("No results found.")
@@ -60,7 +35,7 @@ def display_filtered_paths_only(
 
     logger.info("--- Search Results ---")
 
-    searched_paths = search_params.filters.get_all_paths() if search_params.filters else []
+    searched_paths = query.filters.get_all_paths() if query.filters else []
     if not searched_paths:
         return
 

orchestrator/cli/search/search_explore.py

@@ -4,13 +4,13 @@ import structlog
 import typer
 from pydantic import ValidationError
 
+from orchestrator.cli.search.display import display_filtered_paths_only, display_results
 from orchestrator.db import db
 from orchestrator.search.core.types import EntityType, FilterOp, UIType
 from orchestrator.search.filters import EqualityFilter, FilterTree, LtreeFilter, PathFilter
-from orchestrator.search.retrieval import execute_search
-from orchestrator.search.retrieval.utils import display_filtered_paths_only, display_results
-from orchestrator.search.retrieval.validation import get_structured_filter_schema
-from orchestrator.search.schemas.parameters import BaseSearchParameters
+from orchestrator.search.query import engine
+from orchestrator.search.query.queries import SelectQuery
+from orchestrator.search.query.validation import get_structured_filter_schema
 
 app = typer.Typer(help="Experiment with the subscription search indexes.")
 
@@ -31,16 +31,14 @@ def structured(path: str, value: str, entity_type: EntityType = EntityType.SUBSC
         ...
     """
     path_filter = PathFilter(path=path, condition=EqualityFilter(op=FilterOp.EQ, value=value), value_kind=UIType.STRING)
-    search_params = BaseSearchParameters.create(
-        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), limit=limit
-    )
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
-    display_filtered_paths_only(search_response.results, search_params, db.session)
+    query = SelectQuery(entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
+    display_filtered_paths_only(search_response.results, query, db.session)
     display_results(search_response.results, db.session, "Match")
 
 
 @app.command()
-def semantic(query: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
+def semantic(query_text: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
     """Finds subscriptions that are conceptually most similar to the query text.
 
     Example:
@@ -52,8 +50,8 @@ def semantic(query: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limi
         },
         ...
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=query, limit=limit)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=query_text, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Distance")
 
 
@@ -70,8 +68,8 @@ def fuzzy(term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: i
         },
         ...
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=term, limit=limit)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=term, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Similarity")
 
 
@@ -79,7 +77,7 @@ def fuzzy(term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: i
 def hierarchical(
     op: str = typer.Argument(..., help="The hierarchical operation to perform."),
     path: str = typer.Argument(..., help="The ltree path or lquery pattern for the operation."),
-    query: str | None = typer.Option(None, "--query", "-f", help="An optional fuzzy term to rank the results."),
+    query_text: str | None = typer.Option(None, "--query", "-q", help="An optional fuzzy term to rank the results."),
     entity_type: EntityType = EntityType.SUBSCRIPTION,
     limit: int = 10,
 ) -> None:
@@ -96,23 +94,23 @@ def hierarchical(
 
     path_filter = PathFilter(path="ltree_hierarchical_filter", condition=condition, value_kind=UIType.STRING)
 
-    search_params = BaseSearchParameters.create(
-        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), query=query, limit=limit
+    query = SelectQuery(
+        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), query_text=query_text, limit=limit
     )
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Hierarchical Score")
 
 
 @app.command()
-def hybrid(query: str, term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
+def hybrid(query_text: str, term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
     """Performs a hybrid search, combining semantic and fuzzy matching.
 
     Example:
         dotenv run python main.py search hybrid "reptile store" "Kingswood"
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=query, limit=limit)
-    logger.info("Executing Hybrid Search", query=query, term=term)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=query_text, limit=limit)
+    logger.info("Executing Hybrid Search", query_text=query_text, term=term)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Hybrid Score")
 
 
@@ -198,8 +196,8 @@ def nested_demo(entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int =
         }
     )
 
-    params = BaseSearchParameters.create(entity_type=entity_type, filters=tree, limit=limit)
-    search_response = asyncio.run(execute_search(params, db.session))
+    query = SelectQuery(entity_type=entity_type, filters=tree, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
 
     display_results(search_response.results, db.session, "Score")
 

orchestrator/cli/search/speedtest.py

@@ -12,8 +12,8 @@ from orchestrator.db import db
 from orchestrator.search.core.embedding import QueryEmbedder
 from orchestrator.search.core.types import EntityType
 from orchestrator.search.core.validators import is_uuid
-from orchestrator.search.retrieval.engine import execute_search
-from orchestrator.search.schemas.parameters import BaseSearchParameters
+from orchestrator.search.query import engine
+from orchestrator.search.query.queries import SelectQuery
 
 logger = structlog.get_logger(__name__)
 console = Console()
@@ -50,23 +50,25 @@ async def generate_embeddings_for_queries(queries: list[str]) -> dict[str, list[
     return embedding_lookup
 
 
-async def run_single_query(query: str, embedding_lookup: dict[str, list[float]]) -> dict[str, Any]:
-    search_params = BaseSearchParameters(entity_type=EntityType.SUBSCRIPTION, query=query, limit=30)
+async def run_single_query(query_text: str, embedding_lookup: dict[str, list[float]]) -> dict[str, Any]:
+    query = SelectQuery(entity_type=EntityType.SUBSCRIPTION, query_text=query_text, limit=30)
 
     query_embedding = None
 
-    if is_uuid(query):
-        logger.debug("Using fuzzy-only ranking for full UUID", query=query)
+    if is_uuid(query_text):
+        logger.debug("Using fuzzy-only ranking for full UUID", query_text=query_text)
     else:
-        query_embedding = embedding_lookup[query]
+        query_embedding = embedding_lookup[query_text]
 
     with db.session as session:
         start_time = time.perf_counter()
-        response = await execute_search(search_params, session, cursor=None, query_embedding=query_embedding)
+        response = await engine.execute_search(
+            query=query, db_session=session, cursor=None, query_embedding=query_embedding
+        )
         end_time = time.perf_counter()
 
         return {
-            "query": query,
+            "query": query_text,
             "time": end_time - start_time,
             "results": len(response.results),
             "search_type": response.metadata.search_type if hasattr(response, "metadata") else "unknown",

orchestrator/db/models.py

@@ -60,7 +60,7 @@ from orchestrator.utils.datetime import nowtz
 from orchestrator.version import GIT_COMMIT_HASH
 
 if TYPE_CHECKING:
-    from orchestrator.search.retrieval.query_state import SearchQueryState
+    from orchestrator.search.query.state import QueryState
 
 logger = structlog.get_logger(__name__)
 
@@ -707,7 +707,7 @@ class SearchQueryTable(BaseModel):
     )
     query_number = mapped_column(Integer, nullable=False)
 
-    # Search parameters as JSONB (maps to BaseSearchParameters subclasses)
+    # Search parameters as JSONB (maps to BaseQuery subclasses)
     parameters = mapped_column(pg.JSONB, nullable=False)
 
     # Query embedding for semantic search (pgvector)
@@ -726,14 +726,14 @@ class SearchQueryTable(BaseModel):
     @classmethod
     def from_state(
         cls,
-        state: "SearchQueryState",
+        state: "QueryState",
         run_id: "UUID | None" = None,
         query_number: int = 1,
     ) -> "SearchQueryTable":
-        """Create a SearchQueryTable instance from a SearchQueryState.
+        """Create a SearchQueryTable instance from a QueryState.
 
         Args:
-            state: The search query state with parameters and embedding
+            state: QueryState wrapping the query and embedding
             run_id: Optional agent run ID (NULL for regular API searches)
             query_number: Query number within the run (default=1)
 
@@ -743,7 +743,7 @@ class SearchQueryTable(BaseModel):
         return cls(
             run_id=run_id,
             query_number=query_number,
-            parameters=state.parameters.model_dump(),
+            parameters=state.query.model_dump(),
             query_embedding=state.query_embedding,
         )
 

orchestrator/graphql/resolvers/helpers.py

@@ -1,11 +1,17 @@
 from collections.abc import Sequence
+from functools import wraps
+from typing import Callable, Coroutine
 
+import structlog
 from sqlalchemy import CompoundSelect, Select, select
 from sqlalchemy.orm.strategy_options import _AbstractLoad
+from starlette.concurrency import run_in_threadpool
 
 from orchestrator.db import db
 from orchestrator.db.database import BaseModel
 
+logger = structlog.get_logger(__name__)
+
 
 def rows_from_statement(
     stmt: Select | CompoundSelect,
@@ -19,3 +25,12 @@ def rows_from_statement(
     result = db.session.scalars(from_stmt)
     uresult = result.unique() if unique else result
     return uresult.all()
+
+
+def make_async(f: Callable):  # type: ignore
+    @wraps(f)
+    async def wrapper(*args, **kwargs) -> Coroutine:  # type: ignore
+        logger.debug(f"**async, calling fn {f.__name__}")
+        return await run_in_threadpool(f, *args, **kwargs)
+
+    return wrapper

orchestrator/graphql/resolvers/process.py

@@ -25,7 +25,7 @@ from orchestrator.db.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.process import process_sort_fields, sort_processes
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.process import ProcessType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import (
@@ -55,7 +55,8 @@ def _enrich_process(process: ProcessTable, with_details: bool = False) -> Proces
     return ProcessSchema(**process_data)
 
 
-async def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessType | None:
+@make_async
+def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessType | None:
     query_loaders = get_query_loaders_for_gql_fields(ProcessTable, info)
     stmt = select(ProcessTable).options(*query_loaders).where(ProcessTable.process_id == process_id)
     if process := db.session.scalar(stmt):
@@ -64,7 +65,8 @@ async def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessTy
     return None
 
 
-async def resolve_processes(
+@make_async
+def resolve_processes(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

orchestrator/graphql/resolvers/product.py

@@ -9,7 +9,7 @@ from orchestrator.db.range.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.product import product_sort_fields, sort_products
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.product import ProductType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -19,7 +19,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_products(
+@make_async
+def resolve_products(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

orchestrator/graphql/resolvers/product_block.py

@@ -13,7 +13,7 @@ from orchestrator.db.range.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.product_block import product_block_sort_fields, sort_product_blocks
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.product_block import ProductBlock
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -23,7 +23,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_product_blocks(
+@make_async
+def resolve_product_blocks(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

orchestrator/graphql/resolvers/resource_type.py

@@ -13,7 +13,7 @@ from orchestrator.db.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.resource_type import resource_type_sort_fields, sort_resource_types
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.resource_type import ResourceType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -23,7 +23,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_resource_types(
+@make_async
+def resolve_resource_types(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

orchestrator/graphql/resolvers/scheduled_tasks.py

@@ -3,6 +3,7 @@ import structlog
 from orchestrator.db.filters import Filter
 from orchestrator.db.sorting import Sort
 from orchestrator.graphql.pagination import Connection
+from orchestrator.graphql.resolvers.helpers import make_async
 from orchestrator.graphql.schemas.scheduled_task import ScheduledTaskGraphql
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, to_graphql_result_page
@@ -12,7 +13,8 @@ from orchestrator.schedules.scheduler import get_scheduler_tasks, scheduled_task
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_scheduled_tasks(
+@make_async
+def resolve_scheduled_tasks(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

orchestrator/graphql/resolvers/settings.py

@@ -4,6 +4,7 @@ from redis.asyncio import Redis as AIORedis
 
 from oauth2_lib.strawberry import authenticated_mutation_field
 from orchestrator.api.api_v1.endpoints.settings import generate_engine_status_response
+from orchestrator.graphql.resolvers.helpers import make_async
 from orchestrator.graphql.schemas.errors import Error
 from orchestrator.graphql.schemas.settings import (
     CACHE_FLUSH_OPTIONS,
@@ -27,6 +28,7 @@ logger = structlog.get_logger(__name__)
 
 
 # Queries
+@make_async
 def resolve_settings(info: OrchestratorInfo) -> StatusType:
     selected_fields = get_selected_fields(info)
 

orchestrator/graphql/resolvers/subscription.py

@@ -18,6 +18,7 @@ from graphql import GraphQLError
 from pydantic.alias_generators import to_camel as to_lower_camel
 from sqlalchemy import Select, func, select
 from sqlalchemy.orm import contains_eager
+from starlette.concurrency import run_in_threadpool
 from strawberry.experimental.pydantic.conversion_types import StrawberryTypeFromPydantic
 
 from nwastdlib.asyncio import gather_nice
@@ -101,7 +102,7 @@ async def format_subscription(info: OrchestratorInfo, subscription: Subscription
 async def resolve_subscription(info: OrchestratorInfo, id: UUID) -> SubscriptionInterface | None:
     stmt = select(SubscriptionTable).where(SubscriptionTable.subscription_id == id)
 
-    if subscription := db.session.scalar(stmt):
+    if subscription := await run_in_threadpool(db.session.scalar, stmt):
         return await format_subscription(info, subscription)
     return None
 
@@ -141,12 +142,13 @@ async def resolve_subscriptions(
         stmt = filter_by_query_string(stmt, query)
 
     stmt = cast(Select, sort_subscriptions(stmt, pydantic_sort_by, _error_handler))
-    total = db.session.scalar(select(func.count()).select_from(stmt.subquery()))
+    total = await run_in_threadpool(db.session.scalar, select(func.count()).select_from(stmt.subquery()))
     stmt = apply_range_to_statement(stmt, after, after + first + 1)
 
     graphql_subscriptions: list[SubscriptionInterface] = []
     if is_querying_page_data(info):
-        subscriptions = db.session.scalars(stmt).all()
+        scalars = await run_in_threadpool(db.session.scalars, stmt)
+        subscriptions = scalars.all()
         graphql_subscriptions = list(await gather_nice((format_subscription(info, p) for p in subscriptions)))  # type: ignore
     logger.info("Resolve subscriptions", filter_by=filter_by, total=total)
 

orchestrator/graphql/resolvers/version.py

@@ -1,6 +1,7 @@
 from structlog import get_logger
 
 from orchestrator import __version__
+from orchestrator.graphql.resolvers.helpers import make_async
 from orchestrator.graphql.schemas.version import VersionType
 from orchestrator.graphql.types import OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler
@@ -11,6 +12,7 @@ logger = get_logger(__name__)
 VERSIONS = [f"orchestrator-core: {__version__}"]
 
 
+@make_async
 def resolve_version(info: OrchestratorInfo) -> VersionType | None:
     logger.debug("resolve_version() called")
     _error_handler = create_resolver_error_handler(info)

orchestrator/graphql/resolvers/workflow.py

@@ -9,7 +9,7 @@ from orchestrator.db.range.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.workflow import sort_workflows, workflow_sort_fields
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.workflow import Workflow
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -19,7 +19,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_workflows(
+@make_async
+def resolve_workflows(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,