list versions with include param

Author: mohammedbabelly20

src/codemagic/apple/app_store_connect/apps/apps.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
+from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Sequence
 from typing import Type
 from typing import Union
 
 from codemagic.apple.app_store_connect.resource_manager import ResourceManager
+from codemagic.apple.app_store_connect.type_declarations import PaginateResult
 from codemagic.apple.app_store_connect.versioning import AppStoreVersions
 from codemagic.apple.resources import App
 from codemagic.apple.resources import AppStoreState
@@ -111,6 +113,25 @@ def list_app_store_versions_data(
         url = f"{self.client.API_URL}/apps/{app_id}/appStoreVersions"
         return self.client.paginate(url, params=params, limit=limit, page_size=page_size)
 
+    def list_app_store_versions_data_with_include(
+        self,
+        app: Union[LinkedResourceData, ResourceId],
+        include: str,
+        resource_filter: AppStoreVersions.Filter = AppStoreVersions.Filter(),
+        extra_params: Optional[Dict[str, str]] = None,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = 100,
+    ) -> PaginateResult:
+        """
+        https://developer.apple.com/documentation/appstoreconnectapi/list_all_app_store_versions_for_an_app
+        """
+        app_id = self._get_resource_id(app)
+        params: Dict[str, str] = {"include": include, **resource_filter.as_query_params()}
+        if extra_params:
+            params.update(extra_params)
+        url = f"{self.client.API_URL}/apps/{app_id}/appStoreVersions"
+        return self.client.paginate_with_included(url, params=params, limit=limit, page_size=page_size)
+
     def list_app_store_versions(
         self,
         app: Union[LinkedResourceData, ResourceId],

src/codemagic/apple/app_store_connect/builds/builds.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Sequence
@@ -8,6 +9,7 @@
 from typing import Union
 
 from codemagic.apple.app_store_connect.resource_manager import ResourceManager
+from codemagic.apple.app_store_connect.type_declarations import PaginateResult
 from codemagic.apple.resources import App
 from codemagic.apple.resources import AppStoreVersion
 from codemagic.apple.resources import BetaReviewState
@@ -83,6 +85,23 @@ def list(
         builds = self.client.paginate(f"{self.client.API_URL}/builds", params=params)
         return [Build(build) for build in builds]
 
+    def list_data_with_include(
+        self,
+        include: str,
+        resource_filter: Filter = Filter(),
+        extra_params: Optional[Dict[str, str]] = None,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = 100,
+    ) -> PaginateResult:
+        """
+        https://developer.apple.com/documentation/appstoreconnectapi/list_builds
+        """
+        params: Dict[str, str] = {"include": include, **resource_filter.as_query_params()}
+        if extra_params:
+            params.update(extra_params)
+        url = f"{self.client.API_URL}/builds"
+        return self.client.paginate_with_included(url, params=params, limit=limit, page_size=page_size)
+
     def read_app(self, build: Union[Build, ResourceId]) -> App:
         """
         https://developer.apple.com/documentation/appstoreconnectapi/read_the_app_information_of_a_build

src/codemagic/tools/app_store_connect/actions/latest_build_number_actions.py

@@ -136,46 +136,108 @@ def __get_testflight_latest_build_info(
         self,
         pre_release_versions: List[_ResourceVersion],
         build_expired_status: Optional[bool],
-        all_versions: bool = False,
     ) -> Optional[_LatestBuildInfo]:
-        candidates: List[_LatestBuildInfo] = []
         for pre_release_version in pre_release_versions:
             max_build = self.__get_pre_release_version_max_build(pre_release_version.id, build_expired_status)
             if not max_build:
                 continue
-            candidate = _LatestBuildInfo(
+            return _LatestBuildInfo(
                 build_id=max_build.id,
                 build_number=max_build.version,
                 pre_release_version=pre_release_version.version,
             )
-            if not all_versions:
-                return candidate
-            candidates.append(candidate)
-        if not candidates:
-            return None
-        return max(candidates, key=lambda info: versions.sorting_key(info.build_number))
+        return None
 
     def __get_app_store_latest_build_info(
         self,
         app_store_versions: List[_ResourceVersion],
-        all_versions: bool = False,
     ) -> Optional[_LatestBuildInfo]:
-        candidates: List[_LatestBuildInfo] = []
         for app_store_version in app_store_versions:
             max_build_data = self.api_client.app_store_versions.read_build_data(
                 ResourceId(app_store_version.id),
                 fields=("version",),
             )
             if not max_build_data:
                 continue
-            candidate = _LatestBuildInfo(
+            return _LatestBuildInfo(
                 build_id=ResourceId(max_build_data["id"]),
                 build_number=max_build_data["attributes"]["version"],
                 app_store_version=app_store_version.version,
             )
-            if not all_versions:
-                return candidate
-            candidates.append(candidate)
+        return None
+
+    def __get_app_store_latest_build_info_all_versions(
+        self,
+        application_id: ResourceId,
+        platform: Optional[Platform],
+    ) -> Optional[_LatestBuildInfo]:
+        versions_filter = self.api_client.app_store_versions.Filter(platform=platform)
+        result = self.api_client.apps.list_app_store_versions_data_with_include(
+            application_id,
+            include="build",
+            resource_filter=versions_filter,
+            extra_params={
+                "fields[appStoreVersions]": "versionString,build",
+                "fields[builds]": "version",
+            },
+            page_size=200,
+        )
+        builds_by_id = {b["id"]: b for b in result.included}
+        candidates: List[_LatestBuildInfo] = []
+        for asv in result.data:
+            build_ref = asv.get("relationships", {}).get("build", {}).get("data")
+            if not build_ref:
+                continue
+            build = builds_by_id.get(build_ref["id"])
+            if not build:
+                continue
+            candidates.append(
+                _LatestBuildInfo(
+                    build_id=ResourceId(build["id"]),
+                    build_number=build["attributes"]["version"],
+                    app_store_version=asv["attributes"]["versionString"],
+                ),
+            )
+        if not candidates:
+            return None
+        return max(candidates, key=lambda info: versions.sorting_key(info.build_number))
+
+    def __get_testflight_latest_build_info_all_versions(
+        self,
+        application_id: ResourceId,
+        platform: Optional[Platform],
+        build_expired_status: Optional[bool],
+    ) -> Optional[_LatestBuildInfo]:
+        builds_filter = self.api_client.builds.Filter(
+            app=application_id,
+            expired=build_expired_status,
+            pre_release_version_platform=platform,
+        )
+        result = self.api_client.builds.list_data_with_include(
+            include="preReleaseVersion",
+            resource_filter=builds_filter,
+            extra_params={
+                "fields[builds]": "version,preReleaseVersion",
+                "fields[preReleaseVersions]": "version",
+            },
+            page_size=200,
+        )
+        prvs_by_id = {p["id"]: p for p in result.included}
+        candidates: List[_LatestBuildInfo] = []
+        for build in result.data:
+            prv_ref = build.get("relationships", {}).get("preReleaseVersion", {}).get("data")
+            if not prv_ref:
+                continue
+            prv = prvs_by_id.get(prv_ref["id"])
+            if not prv:
+                continue
+            candidates.append(
+                _LatestBuildInfo(
+                    build_id=ResourceId(build["id"]),
+                    build_number=build["attributes"]["version"],
+                    pre_release_version=prv["attributes"]["version"],
+                ),
+            )
         if not candidates:
             return None
         return max(candidates, key=lambda info: versions.sorting_key(info.build_number))
@@ -189,16 +251,18 @@ def _get_testflight_latest_build_info(
         all_versions: bool = False,
     ) -> Optional[_LatestBuildInfo]:
         try:
+            if all_versions:
+                return self.__get_testflight_latest_build_info_all_versions(
+                    application_id,
+                    platform,
+                    build_expired_status,
+                )
             pre_release_version_numbers = self.__get_ordered_pre_release_version_numbers(
                 application_id,
                 pre_release_version,
                 platform,
             )
-            return self.__get_testflight_latest_build_info(
-                pre_release_version_numbers,
-                build_expired_status,
-                all_versions=all_versions,
-            )
+            return self.__get_testflight_latest_build_info(pre_release_version_numbers, build_expired_status)
         except AppStoreConnectApiError as api_error:
             raise AppStoreConnectError(str(api_error))
 
@@ -210,15 +274,14 @@ def _get_app_store_latest_build_info(
         all_versions: bool = False,
     ) -> Optional[_LatestBuildInfo]:
         try:
+            if all_versions:
+                return self.__get_app_store_latest_build_info_all_versions(application_id, platform)
             app_store_version_numbers = self.__get_ordered_app_store_version_numbers(
                 application_id,
                 version_string,
                 platform,
             )
-            return self.__get_app_store_latest_build_info(
-                app_store_version_numbers,
-                all_versions=all_versions,
-            )
+            return self.__get_app_store_latest_build_info(app_store_version_numbers)
         except AppStoreConnectApiError as api_error:
             raise AppStoreConnectError(str(api_error))
 

tests/tools/app_store_connect/actions/test_latest_build_number_actions.py

@@ -5,6 +5,7 @@
 
 from codemagic.apple.app_store_connect import IssuerId
 from codemagic.apple.app_store_connect import KeyIdentifier
+from codemagic.apple.app_store_connect.type_declarations import PaginateResult
 from codemagic.apple.resources import ResourceId
 from codemagic.tools import AppStoreConnect
 from codemagic.tools.app_store_connect.actions.latest_build_number_actions import _LatestBuildInfo
@@ -199,14 +200,24 @@ def test_get_latest_app_store_build_number_all_versions_picks_global_max(app_sto
     application_id = ResourceId("application-id")
 
     mock_api = mock.MagicMock()
-    mock_api.apps.list_app_store_versions_data.return_value = [
-        {"id": "asv1", "attributes": {"versionString": "2.0.0"}},
-        {"id": "asv2", "attributes": {"versionString": "1.9.0"}},
-    ]
-    mock_api.app_store_versions.read_build_data.side_effect = [
-        {"id": "build-2.0.0", "attributes": {"version": "5"}},
-        {"id": "build-1.9.0", "attributes": {"version": "12"}},
-    ]
+    mock_api.apps.list_app_store_versions_data_with_include.return_value = PaginateResult(
+        data=[
+            {
+                "id": "asv1",
+                "attributes": {"versionString": "2.0.0"},
+                "relationships": {"build": {"data": {"id": "build-2.0.0"}}},
+            },
+            {
+                "id": "asv2",
+                "attributes": {"versionString": "1.9.0"},
+                "relationships": {"build": {"data": {"id": "build-1.9.0"}}},
+            },
+        ],
+        included=[
+            {"id": "build-2.0.0", "attributes": {"version": "5"}},
+            {"id": "build-1.9.0", "attributes": {"version": "12"}},
+        ],
+    )
 
     with mock.patch.object(app_store_connect, "_get_api_client", return_value=mock_api), mock.patch.object(
         app_store_connect,
@@ -215,21 +226,31 @@ def test_get_latest_app_store_build_number_all_versions_picks_global_max(app_sto
         result = app_store_connect.get_latest_app_store_build_number(application_id, all_versions=True)
 
     assert result == "12"
-    assert mock_api.app_store_versions.read_build_data.call_count == 2
+    assert mock_api.apps.list_app_store_versions_data_with_include.call_count == 1
 
 
 def test_get_latest_testflight_build_number_all_versions_picks_global_max(app_store_connect: AppStoreConnect):
     application_id = ResourceId("application-id")
 
     mock_api = mock.MagicMock()
-    mock_api.pre_release_versions.list_data.return_value = [
-        {"id": "prv1", "attributes": {"version": "2.0.0"}},
-        {"id": "prv2", "attributes": {"version": "1.9.0"}},
-    ]
-    mock_api.pre_release_versions.list_builds_data.side_effect = [
-        [{"id": "b1", "attributes": {"version": "5"}}],
-        [{"id": "b2", "attributes": {"version": "12"}}],
-    ]
+    mock_api.builds.list_data_with_include.return_value = PaginateResult(
+        data=[
+            {
+                "id": "b1",
+                "attributes": {"version": "5"},
+                "relationships": {"preReleaseVersion": {"data": {"id": "prv1"}}},
+            },
+            {
+                "id": "b2",
+                "attributes": {"version": "12"},
+                "relationships": {"preReleaseVersion": {"data": {"id": "prv2"}}},
+            },
+        ],
+        included=[
+            {"id": "prv1", "attributes": {"version": "2.0.0"}},
+            {"id": "prv2", "attributes": {"version": "1.9.0"}},
+        ],
+    )
 
     with mock.patch.object(app_store_connect, "_get_api_client", return_value=mock_api), mock.patch.object(
         app_store_connect,
@@ -238,7 +259,7 @@ def test_get_latest_testflight_build_number_all_versions_picks_global_max(app_st
         result = app_store_connect.get_latest_testflight_build_number(application_id, all_versions=True)
 
     assert result == "12"
-    assert mock_api.pre_release_versions.list_builds_data.call_count == 2
+    assert mock_api.builds.list_data_with_include.call_count == 1
 
 
 def test_get_latest_build_number_with_all_versions_and_version_raises(app_store_connect: AppStoreConnect):