✨ Implement service type filtering in latest services queries

Author: pcrespov

services/catalog/src/simcore_service_catalog/repository/_services_sql.py

@@ -19,7 +19,7 @@
 from sqlalchemy.sql.expression import func
 from sqlalchemy.sql.selectable import Select
 
-from ..models.services_db import ServiceMetaDataDBGet
+from ..models.services_db import ServiceFiltersDB, ServiceMetaDataDBGet
 
 SERVICES_META_DATA_COLS = get_columns_from_db_model(
     services_meta_data, ServiceMetaDataDBGet
@@ -113,13 +113,22 @@ def _has_access_rights(
     )
 
 
+def apply_services_filters(
+    stmt,
+    filters: ServiceFiltersDB,
+):
+    if filters.service_type:
+        stmt = stmt.where(services_meta_data.c.service_type == filters.service_type)
+
+
 def latest_services_total_count_stmt(
     *,
     product_name: ProductName,
     user_id: UserID,
     access_rights: sa.sql.ClauseElement,
+    filters: ServiceFiltersDB | None = None,
 ):
-    return (
+    stmt = (
         sa.select(func.count(sa.distinct(services_meta_data.c.key)))
         .select_from(
             services_meta_data.join(
@@ -136,6 +145,11 @@ def latest_services_total_count_stmt(
         .where(access_rights)
     )
 
+    if filters:
+        apply_services_filters(stmt, filters)
+
+    return stmt
+
 
 def list_latest_services_stmt(
     *,
@@ -144,10 +158,11 @@ def list_latest_services_stmt(
     access_rights: sa.sql.ClauseElement,
     limit: int | None,
     offset: int | None,
+    filters: ServiceFiltersDB | None = None,
 ):
     # get all distinct services key fitting a page
     # and its corresponding latest version
-    cte = (
+    cte_stmt = (
         sa.select(
             services_meta_data.c.key,
             services_meta_data.c.version.label("latest_version"),
@@ -172,9 +187,13 @@ def list_latest_services_stmt(
         .distinct(services_meta_data.c.key)  # get only first
         .limit(limit)
         .offset(offset)
-        .cte("cte")
     )
 
+    if filters:
+        apply_services_filters(cte_stmt, filters)
+
+    cte = cte_stmt.cte("cte")
+
     # get all information of latest's services listed in CTE
     latest_stmt = (
         sa.select(

services/catalog/src/simcore_service_catalog/repository/services.py

@@ -28,7 +28,6 @@
 from simcore_postgres_database.models.services_specifications import (
     services_specifications,
 )
-from simcore_postgres_database.utils import as_postgres_sql_query_str
 from simcore_postgres_database.utils_repos import pass_or_acquire_connection
 from simcore_postgres_database.utils_services import create_select_latest_services_query
 from sqlalchemy import sql
@@ -37,6 +36,7 @@
 from ..models.services_db import (
     ReleaseDBGet,
     ServiceAccessRightsAtDB,
+    ServiceFiltersDB,
     ServiceMetaDataDBCreate,
     ServiceMetaDataDBGet,
     ServiceMetaDataDBPatch,
@@ -47,6 +47,7 @@
 from ._services_sql import (
     SERVICES_META_DATA_COLS,
     AccessRightsClauses,
+    apply_services_filters,
     by_version,
     can_get_service_stmt,
     get_service_history_stmt,
@@ -391,20 +392,23 @@ async def list_latest_services(
         # list args: pagination
         limit: int | None = None,
         offset: int | None = None,
+        filters: ServiceFiltersDB | None = None,
     ) -> tuple[PositiveInt, list[ServiceWithHistoryDBGet]]:
 
         # get page
         stmt_total = latest_services_total_count_stmt(
             product_name=product_name,
             user_id=user_id,
             access_rights=AccessRightsClauses.can_read,
+            filters=filters,
         )
         stmt_page = list_latest_services_stmt(
             product_name=product_name,
             user_id=user_id,
             access_rights=AccessRightsClauses.can_read,
             limit=limit,
             offset=offset,
+            filters=filters,
         )
 
         async with self.db_engine.connect() as conn:
@@ -480,9 +484,10 @@ async def get_service_history_page(
         # list args: pagination
         limit: int | None = None,
         offset: int | None = None,
+        filters: ServiceFiltersDB | None = None,
     ) -> tuple[PositiveInt, list[ReleaseDBGet]]:
 
-        base_subquery = (
+        base_stmt = (
             # Search on service (key, *) for (product_name, user_id w/ access)
             sql.select(
                 services_meta_data.c.key,
@@ -506,11 +511,15 @@ async def get_service_history_page(
                 & (user_to_groups.c.uid == user_id)
                 & AccessRightsClauses.can_read
             )
-        ).subquery()
+        )
+
+        if filters:
+            apply_services_filters(base_stmt, filters)
+
+        base_subquery = base_stmt.subquery()
 
         # Query to count the TOTAL number of rows
         count_query = sql.select(sql.func.count()).select_from(base_subquery)
-        _logger.debug("count_query=\n%s", as_postgres_sql_query_str(count_query))
 
         # Query to retrieve page with additional columns, ordering, offset, and limit
         page_query = (
@@ -541,7 +550,6 @@ async def get_service_history_page(
             .offset(offset)
             .limit(limit)
         )
-        _logger.debug("page_query=\n%s", as_postgres_sql_query_str(page_query))
 
         async with pass_or_acquire_connection(self.db_engine) as conn:
             total_count: PositiveInt = await conn.scalar(count_query) or 0

services/catalog/tests/unit/with_dbs/test_repositories.py

@@ -13,6 +13,7 @@
 
 import pytest
 from models_library.products import ProductName
+from models_library.services_enums import ServiceType  # Import ServiceType enum
 from models_library.users import UserID
 from packaging import version
 from pydantic import EmailStr, HttpUrl, TypeAdapter
@@ -21,6 +22,7 @@
 from simcore_postgres_database.models.projects import ProjectType, projects
 from simcore_service_catalog.models.services_db import (
     ServiceAccessRightsAtDB,
+    ServiceFiltersDB,
     ServiceMetaDataDBCreate,
     ServiceMetaDataDBGet,
     ServiceMetaDataDBPatch,
@@ -310,7 +312,7 @@ async def test_get_latest_release(
     assert latest.version == fake_catalog_with_jupyterlab.expected_latest
 
 
-async def test_list_all_services_and_history(
+async def test_list_latest_services(
     target_product: ProductName,
     user_id: UserID,
     services_repo: ServicesRepository,
@@ -332,7 +334,7 @@ async def test_list_all_services_and_history(
     ), "list_latest_service does NOT show history"
 
 
-async def test_listing_with_no_services(
+async def test_list_latest_services_with_no_services(
     target_product: ProductName,
     services_repo: ServicesRepository,
     user_id: UserID,
@@ -344,7 +346,7 @@ async def test_listing_with_no_services(
     assert total_count == 0
 
 
-async def test_list_all_services_and_history_with_pagination(
+async def test_list_latest_services_with_pagination(
     target_product: ProductName,
     create_fake_service_data: Callable,
     services_db_tables_injector: Callable,
@@ -403,6 +405,64 @@ async def test_list_all_services_and_history_with_pagination(
     ), f"list of latest versions of services cannot have duplicates, found: {duplicates}"
 
 
+async def test_list_latest_services_with_filters(
+    target_product: ProductName,
+    create_fake_service_data: Callable,
+    services_db_tables_injector: Callable,
+    services_repo: ServicesRepository,
+    user_id: UserID,
+):
+    # Setup: Inject services with different service types
+    await services_db_tables_injector(
+        [
+            create_fake_service_data(
+                f"simcore/services/dynamic/service-type-a-{i}",
+                "1.0.0",
+                team_access=None,
+                everyone_access=None,
+                product=target_product,
+                service_type=ServiceType.DYNAMIC.value,
+            )
+            for i in range(3)
+        ]
+        + [
+            create_fake_service_data(
+                f"simcore/services/dynamic/service-type-b-{i}",
+                "1.0.0",
+                team_access=None,
+                everyone_access=None,
+                product=target_product,
+                service_type=ServiceType.COMPUTATIONAL.value,
+            )
+            for i in range(2)
+        ]
+    )
+
+    # Test: Apply filter for service_type=ServiceType.DYNAMIC
+    filters = ServiceFiltersDB(service_type=ServiceType.DYNAMIC)
+    total_count, services_items = await services_repo.list_latest_services(
+        product_name=target_product, user_id=user_id, filters=filters
+    )
+    assert total_count == 3
+    assert len(services_items) == 3
+    assert all(
+        service.key.startswith("simcore/services/dynamic/service-type-a")
+        for service in services_items
+    )
+
+    # Test: Apply filter for service_type=ServiceType.COMPUTATIONAL
+    filters = ServiceFiltersDB(service_type=ServiceType.COMPUTATIONAL)
+    total_count, services_items = await services_repo.list_latest_services(
+        product_name=target_product, user_id=user_id, filters=filters
+    )
+    assert total_count == 2
+    assert len(services_items) == 2
+    assert all(
+        service.key.startswith("simcore/services/dynamic/service-type-b")
+        for service in services_items
+    )
+
+
 async def test_get_and_update_service_meta_data(
     target_product: ProductName,
     create_fake_service_data: Callable,
@@ -566,6 +626,82 @@ async def test_get_service_history_page(
     assert paginated_history == history[offset : offset + limit]
 
 
+async def test_get_service_history_page_with_filters(
+    target_product: ProductName,
+    create_fake_service_data: Callable,
+    services_db_tables_injector: Callable,
+    services_repo: ServicesRepository,
+    user_id: UserID,
+):
+    # Setup: Inject services with multiple versions and types
+    service_key = "simcore/services/dynamic/test-service"
+    num_versions = 10
+
+    release_versions = set()
+    while len(release_versions) < num_versions:
+        release_versions.add(
+            f"{random.randint(0, 2)}.{random.randint(0, 9)}.{random.randint(0, 9)}"  # noqa: S311
+        )
+
+    await services_db_tables_injector(
+        [
+            create_fake_service_data(
+                service_key,
+                service_version,
+                team_access=None,
+                everyone_access=None,
+                product=target_product,
+                service_type=(
+                    ServiceType.DYNAMIC.value
+                    if i % 2 == 0
+                    else ServiceType.COMPUTATIONAL.value
+                ),
+            )
+            for i, service_version in enumerate(release_versions)
+        ]
+    )
+    # Sort versions after injecting
+    release_versions = sorted(release_versions, key=version.Version, reverse=True)
+
+    # Test: Fetch full history with no filters
+    total_count, history = await services_repo.get_service_history_page(
+        product_name=target_product,
+        user_id=user_id,
+        key=service_key,
+    )
+    assert total_count == num_versions
+    assert len(history) == num_versions
+    assert [release.version for release in history] == release_versions
+
+    # Test: Apply filter for service_type=ServiceType.DYNAMIC
+    filters = ServiceFiltersDB(service_type=ServiceType.DYNAMIC)
+    total_count, filtered_history = await services_repo.get_service_history_page(
+        product_name=target_product,
+        user_id=user_id,
+        key=service_key,
+        filters=filters,
+    )
+    assert total_count == num_versions // 2
+    assert len(filtered_history) == num_versions // 2
+    assert all(
+        int(release.version.split(".")[0]) % 2 == 0 for release in filtered_history
+    )
+
+    # Test: Apply filter for service_type=ServiceType.COMPUTATIONAL
+    filters = ServiceFiltersDB(service_type=ServiceType.COMPUTATIONAL)
+    total_count, filtered_history = await services_repo.get_service_history_page(
+        product_name=target_product,
+        user_id=user_id,
+        key=service_key,
+        filters=filters,
+    )
+    assert total_count == num_versions // 2
+    assert len(filtered_history) == num_versions // 2
+    assert all(
+        int(release.version.split(".")[0]) % 2 != 0 for release in filtered_history
+    )
+
+
 async def test_list_services_from_published_templates(
     user: dict[str, Any],
     projects_repo: ProjectsRepository,