Change sorting to work similar to the generic filtering (#285)

* Change sorting to work similar to the generic filtering

- this makes it possible to sort with different tables.

* Fix typo CallableErrorHander to CallableErrorHandler

* Change graphql sorting to use SortOrder instead of a new graphql enum

* Fix graphql subscriptions tests

Author: tjeerddie

orchestrator/db/filters/__init__.py

@@ -1,5 +1,5 @@
 from orchestrator.db.filters.filters import (
-    CallableErrorHander,
+    CallableErrorHandler,
     Filter,
     generic_apply_filters,
     generic_filter,
@@ -8,7 +8,7 @@
 
 __all__ = [
     "Filter",
-    "CallableErrorHander",
+    "CallableErrorHandler",
     "generic_filter",
     "generic_apply_filters",
     "generic_filters_validate",

orchestrator/db/filters/filters.py

@@ -20,7 +20,7 @@
 from orchestrator.db.database import SearchQuery
 
 
-class CallableErrorHander(Protocol):
+class CallableErrorHandler(Protocol):
     def __call__(self, message: str, **kwargs: Any) -> None:
         ...
 
@@ -48,9 +48,9 @@ def _is_valid_filter(item: Filter) -> bool:
 
 def generic_apply_filters(
     valid_filter_functions_by_column: ValidFilterFunctionsByColumnType,
-) -> Callable[[QueryType, Iterator[Filter], CallableErrorHander], QueryType]:
+) -> Callable[[QueryType, Iterator[Filter], CallableErrorHandler], QueryType]:
     def _apply_filters(
-        query: QueryType, filter_by: Iterator[Filter], handle_filter_error: CallableErrorHander
+        query: QueryType, filter_by: Iterator[Filter], handle_filter_error: CallableErrorHandler
     ) -> QueryType:
         for item in filter_by:
             field = item.field
@@ -76,15 +76,15 @@ def _apply_filters(
 
 def generic_filter(
     valid_filter_functions_by_column: ValidFilterFunctionsByColumnType,
-) -> Callable[[QueryType, list[Filter], CallableErrorHander], QueryType]:
+) -> Callable[[QueryType, list[Filter], CallableErrorHandler], QueryType]:
     valid_filter_functions_by_column_KEYS = list(valid_filter_functions_by_column.keys())
     _validate_filters = generic_filters_validate(valid_filter_functions_by_column)
     _apply_filters = generic_apply_filters(valid_filter_functions_by_column)
 
     def _filter(
         query: QueryType,
         filter_by: list[Filter],
-        handle_filter_error: CallableErrorHander,
+        handle_filter_error: CallableErrorHandler,
     ) -> QueryType:
         invalid_filter_items, valid_filter_items = _validate_filters(filter_by)
         if invalid_list := [item.dict() for item in invalid_filter_items]:

orchestrator/db/sorting/__init__.py

@@ -1,12 +1,12 @@
 from orchestrator.db.sorting.process import sort_processes
-from orchestrator.db.sorting.sorting import Sort, SortOrder, generic_apply_sorts, generic_sort, generic_sorts_validate
+from orchestrator.db.sorting.sorting import Sort, SortOrder, generic_apply_sorting, generic_sort, generic_sorts_validate
 from orchestrator.db.sorting.subscription import sort_subscriptions
 
 __all__ = [
     "Sort",
     "SortOrder",
     "generic_sort",
-    "generic_apply_sorts",
+    "generic_apply_sorting",
     "generic_sorts_validate",
     "sort_processes",
     "sort_subscriptions",

orchestrator/db/sorting/process.py

@@ -1,13 +1,18 @@
+from sqlalchemy.inspection import inspect
+
 from orchestrator.db import ProcessTable
-from orchestrator.db.sorting.sorting import generic_sort
+from orchestrator.db.sorting.sorting import generic_column_sort, generic_sort
+from orchestrator.utils.helpers import to_camel
 
 VALID_SORT_KEY_MAP = {
-    "creator": "created_by",
-    "started": "started_at",
-    "status": "last_status",
-    "assignee": "assignee",
-    "modified": "last_modified_at",
-    "workflow": "workflow",
+    "created_by": "created_by",
+    "started_at": "started",
+    "last_status": "status",
+    "last_modified_at": "modified",
+}
+PROCESS_SORT_FUNCTIONS_BY_COLUMN = {
+    to_camel(VALID_SORT_KEY_MAP.get(key, key)): generic_column_sort(value)
+    for [key, value] in inspect(ProcessTable).columns.items()
 }
 
-sort_processes = generic_sort(VALID_SORT_KEY_MAP, ProcessTable)
+sort_processes = generic_sort(PROCESS_SORT_FUNCTIONS_BY_COLUMN)

orchestrator/db/sorting/product.py

@@ -1,13 +1,11 @@
+from sqlalchemy.inspection import inspect
+
 from orchestrator.db import ProductTable
-from orchestrator.db.sorting.sorting import generic_sort
+from orchestrator.db.sorting.sorting import generic_column_sort, generic_sort
+from orchestrator.utils.helpers import to_camel
 
-VALID_SORT_KEY_MAP = {
-    "created_at": "created_at",
-    "end_date": "end_date",
-    "status": "status",
-    "product_type": "product_type",
-    "name": "name",
-    "tag": "tag",
+PRODUCT_SORT_FUNCTIONS_BY_COLUMN = {
+    to_camel(key): generic_column_sort(value) for [key, value] in inspect(ProductTable).columns.items()
 }
 
-sort_products = generic_sort(VALID_SORT_KEY_MAP, ProductTable)
+sort_products = generic_sort(PRODUCT_SORT_FUNCTIONS_BY_COLUMN)

orchestrator/db/sorting/sorting.py

@@ -14,15 +14,18 @@
 from enum import Enum
 from typing import Callable, Iterator, TypeVar
 
+import strawberry
 from more_itertools import partition
 from pydantic import BaseModel
+from sqlalchemy import Column
 from sqlalchemy.sql import expression
 
-from orchestrator.db.database import BaseModel as SqlBaseModel
+from orchestrator.api.error_handling import ProblemDetailException
 from orchestrator.db.database import SearchQuery
-from orchestrator.db.filters import CallableErrorHander
+from orchestrator.db.filters import CallableErrorHandler
 
 
+@strawberry.enum(description="Sort order (ASC or DESC)")
 class SortOrder(Enum):
     ASC = "asc"
     DESC = "desc"
@@ -32,16 +35,14 @@ class Sort(BaseModel):
     field: str
     order: SortOrder
 
-    class Config:
-        use_enum_values = True
-
 
 GenericType = TypeVar("GenericType")
 QueryType = SearchQuery
+ValidSortFunctionsByColumnType = dict[str, Callable[[QueryType, SortOrder], QueryType]]
 
 
 def generic_sorts_validate(
-    valid_sort_dict: dict[str, str]
+    valid_sort_functions_by_column: ValidSortFunctionsByColumnType,
 ) -> Callable[[list[Sort]], tuple[Iterator[Sort], Iterator[Sort]]]:
     """Create generic validate sort factory that creates a validate function based on the valid sort dict.
 
@@ -54,51 +55,69 @@ def generic_sorts_validate(
     """
 
     def validate_sort_items(sort_by: list[Sort]) -> tuple[Iterator[Sort], Iterator[Sort]]:
-        return partition(lambda item: item.field in valid_sort_dict, sort_by)
+        def _is_valid_sort(item: Sort) -> bool:
+            return item.field in valid_sort_functions_by_column
+
+        return partition(_is_valid_sort, sort_by)
 
     return validate_sort_items
 
 
-def generic_apply_sorts(
-    valid_sort_dict: dict[str, str], model: SqlBaseModel
-) -> Callable[[QueryType, Iterator[Sort]], QueryType]:
-    def _apply_sorts(query: QueryType, sort_by: Iterator[Sort]) -> QueryType:
+def generic_apply_sorting(
+    valid_sort_functions_by_column: ValidSortFunctionsByColumnType,
+) -> Callable[[QueryType, Iterator[Sort], CallableErrorHandler], QueryType]:
+    def _apply_sorting(query: QueryType, sort_by: Iterator[Sort], handle_sort_error: CallableErrorHandler) -> QueryType:
         for item in sort_by:
-            field = item.field.lower()
-            sort_key = valid_sort_dict[field]
-
-            if item.order == SortOrder.DESC.value:  # type: ignore
-                query = query.order_by(expression.desc(model.__dict__[sort_key]))
-            else:
-                query = query.order_by(expression.asc(model.__dict__[sort_key]))
+            field = item.field
+            sort_fn = valid_sort_functions_by_column[field]
+            try:
+                query = sort_fn(query, item.order)
+            except ProblemDetailException as exception:
+                handle_sort_error(
+                    exception.detail,
+                    field=field,
+                    order=item.order,
+                )
+            except ValueError as exception:
+                handle_sort_error(
+                    str(exception),
+                    field=field,
+                    order=item.order,
+                )
         return query
 
-    return _apply_sorts
+    return _apply_sorting
 
 
 def generic_sort(
-    valid_sort_dict: dict[str, str],
-    model: SqlBaseModel,
-) -> Callable[[QueryType, list[Sort], CallableErrorHander], QueryType]:
-    valid_sort_keys = list(valid_sort_dict.keys())
-    _validate_sorts = generic_sorts_validate(valid_sort_dict)
-    _apply_sorts = generic_apply_sorts(valid_sort_dict, model)
+    valid_sort_functions_by_column: ValidSortFunctionsByColumnType,
+) -> Callable[[QueryType, list[Sort], CallableErrorHandler], QueryType]:
+    valid_sort_functions_by_column_KEYS = list(valid_sort_functions_by_column.keys())
+    _validate_sorts = generic_sorts_validate(valid_sort_functions_by_column)
+    _apply_sorting = generic_apply_sorting(valid_sort_functions_by_column)
 
     def _sort(
         query: QueryType,
         sort_by: list[Sort],
-        handle_sort_error: CallableErrorHander,
+        handle_sort_error: CallableErrorHandler,
     ) -> QueryType:
-        if sort_by:
-            invalid_sort_items, valid_sort_items = _validate_sorts(sort_by)
-            if invalid_list := [item.dict() for item in invalid_sort_items]:
-                handle_sort_error(
-                    "Invalid sort arguments",
-                    invalid_filters=invalid_list,
-                    valid_filter_keys=valid_sort_keys,
-                )
+        invalid_sort_items, valid_sort_items = _validate_sorts(sort_by)
+        if invalid_list := [{"field": item.field, "order": item.order.value.upper()} for item in invalid_sort_items]:
+            handle_sort_error(
+                "Invalid sort arguments",
+                invalid_sorting=invalid_list,
+                valid_sort_keys=valid_sort_functions_by_column_KEYS,
+            )
 
-            query = _apply_sorts(query, valid_sort_items)
-        return query
+        return _apply_sorting(query, valid_sort_items, handle_sort_error)
 
     return _sort
+
+
+def generic_column_sort(field: Column) -> Callable[[SearchQuery, SortOrder], SearchQuery]:
+    def sort_function(query: SearchQuery, order: SortOrder) -> SearchQuery:
+        if order == SortOrder.DESC:
+            return query.order_by(expression.desc(field))
+        return query.order_by(expression.asc(field))
+
+    return sort_function

orchestrator/db/sorting/subscription.py

@@ -1,18 +1,14 @@
+from sqlalchemy.inspection import inspect
+
 from orchestrator.db import SubscriptionTable
-from orchestrator.db.sorting.sorting import generic_sort
+from orchestrator.db.sorting.product import PRODUCT_SORT_FUNCTIONS_BY_COLUMN
+from orchestrator.db.sorting.sorting import generic_column_sort, generic_sort
+from orchestrator.utils.helpers import to_camel
+
+subscription_table_sort = {
+    to_camel(key): generic_column_sort(value) for [key, value] in inspect(SubscriptionTable).columns.items()
+}
 
-VALID_SORT_KEY_LIST = [
-    "subscription_id",
-    "product_id",
-    "name",
-    "description",
-    "insync",
-    "status",
-    "note",
-    "tag",
-    "start_date",
-    "end_date",
-]
-VALID_SORT_KEY_MAP = {key: key for key in VALID_SORT_KEY_LIST}
+SUBSCRIPTION_SORT_FUNCTIONS_BY_COLUMN = PRODUCT_SORT_FUNCTIONS_BY_COLUMN | subscription_table_sort
 
-sort_subscriptions = generic_sort(VALID_SORT_KEY_MAP, SubscriptionTable)
+sort_subscriptions = generic_sort(SUBSCRIPTION_SORT_FUNCTIONS_BY_COLUMN)

orchestrator/graphql/resolvers/process.py

@@ -18,7 +18,7 @@
 from sqlalchemy.orm import defer, joinedload
 
 from orchestrator.db import ProcessSubscriptionTable, ProcessTable, SubscriptionTable
-from orchestrator.db.filters import CallableErrorHander, Filter
+from orchestrator.db.filters import CallableErrorHandler, Filter
 from orchestrator.db.filters.process import filter_processes
 from orchestrator.db.range import apply_range_to_query
 from orchestrator.db.sorting import Sort
@@ -38,7 +38,7 @@ def enrich_process(process: ProcessTable) -> ProcessGraphqlSchema:
     return ProcessGraphqlSchema(**data)
 
 
-def handle_process_error(info: CustomInfo) -> CallableErrorHander:
+def handle_process_error(info: CustomInfo) -> CallableErrorHandler:
     def _handle_process_error(message: str, **kwargs) -> None:  # type: ignore
         logger.debug(message, **kwargs)
         extra_values = kwargs if kwargs else {}
@@ -55,7 +55,6 @@ async def resolve_processes(
     after: int = 0,
 ) -> Connection[ProcessType]:
     _error_handler = handle_process_error(info)
-
     pydantic_filter_by: list[Filter] = [item.to_pydantic() for item in filter_by] if filter_by else []
     pydantic_sort_by: list[Sort] = [item.to_pydantic() for item in sort_by] if sort_by else []
     logger.info("resolve_processes() called", range=[after, after + first], sort=sort_by, filter=pydantic_filter_by)

orchestrator/graphql/resolvers/product.py

@@ -3,7 +3,7 @@
 import structlog
 from graphql import GraphQLError
 
-from orchestrator.db.filters import CallableErrorHander, Filter
+from orchestrator.db.filters import CallableErrorHandler, Filter
 from orchestrator.db.filters.product import filter_products
 from orchestrator.db.models import ProductTable
 from orchestrator.db.range.range import apply_range_to_query
@@ -16,7 +16,7 @@
 logger = structlog.get_logger(__name__)
 
 
-def handle_product_error(info: CustomInfo) -> CallableErrorHander:
+def handle_product_error(info: CustomInfo) -> CallableErrorHandler:
     def _handle_product_error(message: str, **kwargs) -> None:  # type: ignore
         logger.debug(message, **kwargs)
         extra_values = kwargs if kwargs else {}

orchestrator/graphql/resolvers/subscription.py

@@ -15,10 +15,9 @@
 
 import structlog
 from graphql import GraphQLError
-from sqlalchemy.orm import joinedload
 
-from orchestrator.db import SubscriptionTable
-from orchestrator.db.filters import CallableErrorHander, Filter
+from orchestrator.db import ProductTable, SubscriptionTable
+from orchestrator.db.filters import CallableErrorHandler, Filter
 from orchestrator.db.filters.subscription import filter_subscriptions
 from orchestrator.db.range import apply_range_to_query
 from orchestrator.db.sorting import Sort, sort_subscriptions
@@ -29,7 +28,7 @@
 logger = structlog.get_logger(__name__)
 
 
-def handle_subscription_error(info: CustomInfo) -> CallableErrorHander:
+def handle_subscription_error(info: CustomInfo) -> CallableErrorHandler:
     def _handle_subscription_error(message: str, **kwargs) -> None:  # type: ignore
         logger.debug(message, **kwargs)
         extra_values = kwargs if kwargs else {}
@@ -51,7 +50,7 @@ async def resolve_subscriptions(
     pydantic_sort_by: list[Sort] = [item.to_pydantic() for item in sort_by] if sort_by else []
     logger.info("resolve_subscription() called", range=[after, after + first], sort=sort_by, filter=pydantic_filter_by)
 
-    query = SubscriptionTable.query.options(joinedload(SubscriptionTable.product))
+    query = SubscriptionTable.query.join(ProductTable)
 
     query = filter_subscriptions(query, pydantic_filter_by, _error_handler)
     query = sort_subscriptions(query, pydantic_sort_by, _error_handler)