[MPT-14951] Integrated api client into product api service and flow (#159)

Integrated api client into product api service and flow

https://softwareone.atlassian.net/browse/MPT-18516

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
Closes [MPT-14951](https://softwareone.atlassian.net/browse/MPT-14951)

- Add create_api_mpt_client_from_account(account) and wire
api_mpt_client into account and product containers
- Replace direct MPT HTTP client usage with collection-service
abstractions (mpt_client.catalog.{products, items, price_lists, ...})
and update container wiring and service constructors
- APIService / RelatedAPIService now delegate to collection_service for
exists, get, list, post (form/json + files), post_action and update
(including sub-resource updates)
- Swap wrap_http_error for wrap_mpt_api_error across API and flow layers
for consistent error mapping
- Update product and price-list flows to use RQLQuery filtering and
collection.fetch_page pagination with explicit metadata validation
- Item API/service: new ItemAPIService ctor accepts collection_service
and mpt_client; UOM lookups switched to use api_mpt_client;
search_uom_by_name accepts optional name and returns clearer 404s
- Tests refactored to mock the new MPT API client and collection_service
behaviors (use mocker.Mock, model-based test data); fixtures and many
test cases adjusted accordingly
- Test utilities updated (ANSI-stripping helper, mock factories) and
small TODO comment added for settings-update handling
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

[MPT-14951]:
https://softwareone.atlassian.net/browse/MPT-14951?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

Author: robcsegal

cli/core/accounts/containers.py

@@ -1,5 +1,6 @@
 from cli.core.accounts.app import get_active_account
 from cli.core.mpt.client import client_from_account
+from cli.core.mpt.mpt_client import create_api_mpt_client_from_account
 from dependency_injector import containers, providers
 
 
@@ -10,8 +11,10 @@ class AccountContainer(containers.DeclarativeContainer):
     Attributes:
         account: Provides the active account.
         mpt_client: Provides the MPT client based on the active account.
+        api_mpt_client: Provides the API MPT client based on the active account.
 
     """
 
     account = providers.Singleton(get_active_account)
     mpt_client = providers.Singleton(client_from_account, account)
+    api_mpt_client = providers.Singleton(create_api_mpt_client_from_account, account)

cli/core/mpt/api.py

@@ -1,9 +1,9 @@
-from abc import ABC
+import json as json_module
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
-from cli.core.errors import MPTAPIError, wrap_http_error
-from cli.core.mpt.client import MPTClient
-from cli.core.mpt.models import Meta
+from cli.core.errors import MPTAPIError, wrap_mpt_api_error
+from mpt_api_client import MPTClient, RQLQuery
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -25,7 +25,16 @@ class APIService[APIModel: "BaseModel"](ABC):
     _api_model: APIModel
 
     def __init__(self, client: MPTClient):
-        self.client = client
+        self._client = client
+
+    @property
+    @abstractmethod
+    def api_collection(self):
+        raise NotImplementedError
+
+    @property
+    def client(self) -> MPTClient:
+        return self._client
 
     @property
     def api_model(self) -> APIModel:
@@ -35,7 +44,7 @@ def api_model(self) -> APIModel:
     def url(self) -> str:
         return self._base_url
 
-    @wrap_http_error
+    @wrap_mpt_api_error
     def exists(self, query_params: dict[str, Any] | None = None) -> bool:
         """Check if any resources exist matching the given parameters.
 
@@ -46,13 +55,15 @@ def exists(self, query_params: dict[str, Any] | None = None) -> bool:
             True if at least one resource exists, False otherwise.
 
         """
-        query_params = query_params or {}
-        query_params["limit"] = 0
-        response = self.client.get(f"{self.url}", params=query_params)
-        response.raise_for_status()
-        return response.json()["$meta"]["pagination"]["total"] > 0
-
-    @wrap_http_error
+        service = self.api_collection
+        if query_params:
+            service = service.filter(RQLQuery(**query_params))
+        service_collection_data = service.fetch_page(limit=0)
+        if service_collection_data.meta is None or service_collection_data.meta.pagination is None:
+            raise MPTAPIError("Missing pagination metadata in response.", "Invalid response")
+        return service_collection_data.meta.pagination.total > 0
+
+    @wrap_mpt_api_error
     def get(
         self,
         resource_id: str,
@@ -71,18 +82,15 @@ def get(
             MPTAPIError: If the resource is not found.
 
         """
-        query_params = query_params or {}
-        response = self.client.get(f"{self.url}/{resource_id}", params=query_params)
-        response.raise_for_status()
-        response_payload = response.json()
-        if not response_payload:
+        select_value = (query_params or {}).get("select")
+        resource_data = self.api_collection.get(resource_id, select=select_value)
+        if not resource_data:
             raise MPTAPIError(
                 f"Resource with ID {resource_id} not found at {self.url}", "404 not found"
             )
-        self.api_model.model_validate(response_payload)
-        return response_payload
+        return resource_data.to_dict()
 
-    @wrap_http_error
+    @wrap_mpt_api_error
     def list(self, query_params: dict[str, Any] | None = None) -> dict[str, Any]:
         """List resources with optional query parameters.
 
@@ -93,17 +101,34 @@ def list(self, query_params: dict[str, Any] | None = None) -> dict[str, Any]:
             A dictionary containing meta information and the list of resources.
 
         """
-        query_params = query_params or {}
-        response = self.client.get(self.url, params=query_params)
-        response.raise_for_status()
-        json_body = response.json()
-        meta = Meta.model_validate(json_body["$meta"]["pagination"])
-        return {"meta": meta.model_dump(), "data": json_body["data"]}
-
-    @wrap_http_error
+        query_params = dict(query_params or {})
+        limit = query_params.pop("limit", 100)
+        offset = query_params.pop("offset", 0)
+        select = query_params.pop("select", None)
+        service = self.api_collection
+
+        if query_params:
+            service = service.filter(RQLQuery(**query_params))
+        if select:
+            service = service.select(select)
+
+        collection = service.fetch_page(limit=limit, offset=offset)
+        if collection.meta is None or collection.meta.pagination is None:
+            raise MPTAPIError("Missing pagination metadata in response.", "Invalid response")
+        pagination = collection.meta.pagination
+        return {
+            "meta": {
+                "limit": pagination.limit,
+                "offset": pagination.offset,
+                "total": pagination.total,
+            },
+            "data": [resource.to_dict() for resource in collection.resources],
+        }
+
+    @wrap_mpt_api_error
     def post(
         self,
-        form_payload: dict[str, Any] | None = None,
+        form_payload: Any | None = None,
         json: dict[str, Any] | None = None,
         headers: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
@@ -119,11 +144,22 @@ def post(
 
         """
         headers = headers or {}
-        response = self.client.post(self.url, data=form_payload, json=json, headers=headers)
-        response.raise_for_status()
-        return self.api_model.model_validate(response.json(), by_alias=True).model_dump()
 
-    @wrap_http_error
+        if form_payload is None:
+            created_resource = self.api_collection.create(json)
+        else:
+            json_data = None
+            file_data = None
+            for form_value in form_payload.fields.values():
+                if isinstance(form_value, tuple):
+                    file_data = form_value
+                elif isinstance(form_value, str):
+                    json_data = json_module.loads(form_value)
+            created_resource = self.api_collection.create(json_data, file=file_data)
+
+        return created_resource.to_dict()
+
+    @wrap_mpt_api_error
     def post_action(self, resource_id: str, action: str) -> None:
         """Perform an action on a specific resource.
 
@@ -132,10 +168,12 @@ def post_action(self, resource_id: str, action: str) -> None:
             action: The action to perform.
 
         """
-        response = self.client.post(f"{self.url}/{resource_id}/{action}")
-        response.raise_for_status()
+        action_handler = getattr(self.api_collection, action, None)
+        if action_handler is None:
+            raise MPTAPIError(f"Unsupported action '{action}' at {self.url}", "400 bad request")
+        return action_handler(resource_id)
 
-    @wrap_http_error
+    @wrap_mpt_api_error
     def update(self, resource_id: str, json_payload: dict[str, Any]) -> None:
         """Update a resource by its ID.
 
@@ -144,14 +182,25 @@ def update(self, resource_id: str, json_payload: dict[str, Any]) -> None:
             json_payload: The data to update the resource with.
 
         """
-        response = self.client.put(f"{self.url}/{resource_id}", json=json_payload)
-        response.raise_for_status()
+        if "/" in resource_id:
+            base_id, sub_resource = resource_id.split("/", 1)
+            updater = getattr(self.api_collection, f"update_{sub_resource}", None)
+            if updater is None:
+                raise MPTAPIError(
+                    f"Unsupported sub-resource update '{sub_resource}' at {self.url}",
+                    "400 bad request",
+                )
+            updated_resource = updater(base_id, json_payload)
+        else:
+            updated_resource = self.api_collection.update(resource_id, json_payload)
+
+        return updated_resource.to_dict()
 
 
 class RelatedAPIService(APIService, ABC):
     """Abstract base class for related API service operations."""
 
-    def __init__(self, client, resource_id: str):
+    def __init__(self, client: MPTClient, resource_id: str):
         super().__init__(client)
         self.resource_id = resource_id
 

cli/core/mpt/flows.py

@@ -1,17 +1,14 @@
-from functools import cache
-from urllib.parse import quote_plus
-
-from cli.core.errors import MPTAPIError, wrap_http_error
-from cli.core.mpt.client import MPTClient
+from cli.core.errors import MPTAPIError, wrap_mpt_api_error
 from cli.core.mpt.models import (
     ListResponse,
     Meta,
     Product,
     Uom,
 )
+from mpt_api_client import MPTClient, RQLQuery
 
 
-@wrap_http_error
+@wrap_mpt_api_error
 def get_products(
     mpt_client: MPTClient, limit: int, offset: int, query: str | None = None
 ) -> ListResponse[Product]:
@@ -27,20 +24,20 @@ def get_products(
         A tuple containing pagination metadata and a list of Product objects.
 
     """
-    url = f"/catalog/products?limit={quote_plus(str(limit))}&offset={quote_plus(str(offset))}"
+    product_collection = mpt_client.catalog.products
     if query:
-        url = f"{url}&{quote_plus(query)}"
-    response = mpt_client.get(url)
-    response.raise_for_status()
-    json_body = response.json()
+        product_collection = product_collection.filter(RQLQuery.from_string(query))
+    product_response = product_collection.fetch_page(limit=limit, offset=offset)
+    if product_response.meta is None or product_response.meta.pagination is None:
+        raise MPTAPIError("Missing pagination metadata in product response.", "Invalid response")
+    pagination = product_response.meta.pagination
     return (
-        Meta.model_validate(json_body["$meta"]["pagination"]),
-        [Product.model_validate(product_data) for product_data in json_body["data"]],
+        Meta(limit=pagination.limit, offset=pagination.offset, total=pagination.total),
+        [Product.model_validate(resource.to_dict()) for resource in product_response.resources],
     )
 
 
-@cache
-@wrap_http_error
+@wrap_mpt_api_error
 def search_uom_by_name(mpt_client: MPTClient, uom_name: str) -> Uom:
     """Searches for a unit of measure by name using the MPT Platform.
 
@@ -55,11 +52,11 @@ def search_uom_by_name(mpt_client: MPTClient, uom_name: str) -> Uom:
         MPTAPIError: If the unit of measure is not found.
 
     """
-    response = mpt_client.get(f"/catalog/units-of-measure?name={uom_name}&limit=1&offset=0")
-    response.raise_for_status()
+    uom_collection = mpt_client.catalog.units_of_measure.filter(RQLQuery(name=uom_name))
+
+    collection_page = uom_collection.fetch_page(limit=1, offset=0)
 
-    response_data = response.json()["data"]
-    if not response_data:
+    if not collection_page.resources:
         raise MPTAPIError(f"Unit of measure by name '{uom_name}' is not found.", "404 not found")
 
-    return Uom.model_validate(response_data[0])
+    return Uom.model_validate(collection_page.resources[0].to_dict())

cli/core/mpt/mpt_client.py

@@ -0,0 +1,14 @@
+from cli.core.accounts.models import Account
+from mpt_api_client import MPTClient
+
+
+def create_api_mpt_client_from_account(account: Account):
+    """Create an API client MPTClient instance using credentials from the given account.
+
+    Args:
+        account: An Account object containing the base URL and API token.
+
+    Returns:
+        An instance of MPTClient to be used for API Client operations.
+    """
+    return MPTClient.from_config(api_token=account.token, base_url=account.environment)

cli/core/price_lists/api/price_list_api_service.py

@@ -7,3 +7,7 @@ class PriceListAPIService(APIService):
 
     _base_url = "/catalog/price-lists/"
     _api_model = PriceList
+
+    @property
+    def api_collection(self):
+        return self._client.catalog.price_lists

cli/core/price_lists/api/price_list_item_api_service.py

@@ -12,6 +12,10 @@ def __init__(self, client, price_list_id: str):
         super().__init__(client)
         self._price_list_id = price_list_id
 
+    @property
+    def api_collection(self):
+        return self._client.catalog.price_lists.items(self._price_list_id)
+
     @property
     def url(self) -> str:
         return self._base_url.format(price_list_id=self._price_list_id)

cli/core/price_lists/app.py

@@ -5,7 +5,7 @@
 from cli.core.accounts.app import get_active_account
 from cli.core.console import console
 from cli.core.file_discovery import get_files_path
-from cli.core.mpt.client import client_from_account
+from cli.core.mpt.mpt_client import create_api_mpt_client_from_account
 from cli.core.price_lists.api import PriceListAPIService
 from cli.core.price_lists.api.price_list_item_api_service import PriceListItemAPIService
 from cli.core.price_lists.handlers import (
@@ -49,7 +49,7 @@ def sync_price_lists(  # noqa: C901
     )
 
     active_account = get_active_account()
-    mpt_client = client_from_account(active_account)
+    mpt_client = create_api_mpt_client_from_account(active_account)
     stats = PriceListStatsCollector()
     has_error = False
     for file_path in file_paths:
@@ -142,7 +142,7 @@ def export(  # noqa: C901
         raise typer.Exit(code=4)
 
     out_path = out_path if out_path is not None else str(Path.cwd())
-    mpt_client = client_from_account(active_account)
+    mpt_client = create_api_mpt_client_from_account(active_account)
     stats = PriceListStatsCollector()
     has_error = False
     for price_list_id in price_list_ids:

cli/core/products/api/item_api_service.py

@@ -7,3 +7,7 @@ class ItemAPIService(RelatedAPIService):
 
     _base_url = "/catalog/items"
     _api_model = MPTItem
+
+    @property
+    def api_collection(self):
+        return self._client.catalog.items

cli/core/products/api/item_group_api_service.py

@@ -7,3 +7,7 @@ class ItemGroupAPIService(RelatedAPIService):
 
     _base_url = "/catalog/products/{resource_id}/item-groups"
     _api_model = ItemGroup
+
+    @property
+    def api_collection(self):
+        return self._client.catalog.products.item_groups(self.resource_id)

cli/core/products/api/parameter_group_api_service.py

@@ -7,3 +7,7 @@ class ParameterGroupAPIService(RelatedAPIService):
 
     _base_url = "/catalog/products/{resource_id}/parameter-groups"
     _api_model = ParameterGroup
+
+    @property
+    def api_collection(self):
+        return self._client.catalog.products.parameter_groups(self.resource_id)