b1sl-python 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

b1sl/b1sl/__init__.py

@@ -13,9 +13,20 @@ from b1sl.b1sl.client import B1Client
 from b1sl.b1sl.config import B1Config
 from b1sl.b1sl.config_manager import B1Environment
 from b1sl.b1sl.environment import B1Env
-from b1sl.b1sl.exceptions.exceptions import SAPConcurrencyError
+from b1sl.b1sl.exceptions.exceptions import (
+    B1SqlNotAllowedError,
+    B1SqlParamError,
+    B1SqlSyntaxError,
+    SAPConcurrencyError,
+)
 from b1sl.b1sl.resources.async_base import AsyncGenericResource
 from b1sl.b1sl.resources.base import GenericResource, ODataQuery
+from b1sl.b1sl.resources.sql_queries import (
+    DEFAULT_ACCESSIBLE_TABLES,
+    KNOWN_INACCESSIBLE_PATTERNS,
+    SQLQueryInfo,
+    SQLRunResult,
+)
 from b1sl.b1sl.rest_adapter import RestAdapter
 
 try:
@@ -42,9 +53,16 @@ __all__ = [
     "RestAdapter",
     "B1Env",
     "SAPConcurrencyError",
+    "B1SqlSyntaxError",
+    "B1SqlNotAllowedError",
+    "B1SqlParamError",
     "AsyncGenericResource",
     "GenericResource",
     "ODataQuery",
+    "DEFAULT_ACCESSIBLE_TABLES",
+    "KNOWN_INACCESSIBLE_PATTERNS",
+    "SQLQueryInfo",
+    "SQLRunResult",
     "entities",
     "fields",
     "HookContext",

b1sl/b1sl/async_client.py

@@ -17,6 +17,11 @@ if TYPE_CHECKING:
     from b1sl.b1sl.models._generated.entities.inventory import Item
     from b1sl.b1sl.models.base import B1Model
     from b1sl.b1sl.resources.async_base import AsyncGenericResource
+    from b1sl.b1sl.resources.crossjoin import (
+        AsyncCrossJoinQueryBuilder,
+        AsyncQueryServiceBuilder,
+    )
+    from b1sl.b1sl.resources.sql_queries import AsyncSQLQueriesResource
     from b1sl.b1sl.resources.udo import AsyncUDOResource
 
 
@@ -351,6 +356,15 @@ class AsyncB1Client:
         from b1sl.b1sl.models._generated.entities.general import Document
         return self.get_resource(Document, "CorrectionPurchaseInvoiceReversal")
 
+    # --- SQL Queries ---
+
+    @property
+    def sql_queries(self) -> "AsyncSQLQueriesResource":
+        """Access the 'SQLQueries' endpoint (supports ETags, run() / run_stream())."""
+        from b1sl.b1sl.resources.sql_queries import AsyncSQLQueriesResource
+        resource = AsyncSQLQueriesResource(self._adapter)
+        return resource
+
     def udo(self, table_name: str) -> "AsyncUDOResource":
         """
         Asynchronously access a User Defined Object (UDO) or User Table.
@@ -360,4 +374,45 @@ class AsyncB1Client:
         from b1sl.b1sl.resources.udo import AsyncUDOResource
         return AsyncUDOResource(adapter=self._adapter, table_name=table_name)
 
+    def crossjoin(self, *entities: str) -> "AsyncCrossJoinQueryBuilder":
+        """Build an async ``$crossjoin`` query (SAP HANA only, B1 9.2 patch 07+).
+
+        At least 2 entity names are required.  A bare crossjoin without
+        ``$expand`` or ``$apply`` will raise ``ValueError`` before the request.
+
+        Example::
+
+            rows = await (
+                client.crossjoin("Orders", "BusinessPartners")
+                .expand({"Orders": ["DocEntry", "DocNum"], "BusinessPartners": ["CardCode"]})
+                .filter("Orders/CardCode eq BusinessPartners/CardCode")
+                .execute()
+            )
+        """
+        from b1sl.b1sl.resources.crossjoin import AsyncCrossJoinQueryBuilder
+
+        return AsyncCrossJoinQueryBuilder(self._adapter, *entities)
+
+    def query_service(self, query_path: str) -> "AsyncQueryServiceBuilder":
+        """Async ``QueryService_PostQuery`` row-level filter (SAP HANA only, B1 9.2 PL11+).
+
+        Example::
+
+            rows = await (
+                client.query_service("$crossjoin(Orders,Orders/DocumentLines)")
+                .expand({
+                    "Orders": ["DocEntry", "DocNum"],
+                    "Orders/DocumentLines": ["ItemCode", "LineNum"],
+                })
+                .filter(
+                    "Orders/DocEntry eq Orders/DocumentLines/DocEntry"
+                    " and Orders/DocumentLines/ItemCode eq 'WIDGET'"
+                )
+                .execute()
+            )
+        """
+        from b1sl.b1sl.resources.crossjoin import AsyncQueryServiceBuilder
+
+        return AsyncQueryServiceBuilder(self._adapter, query_path)
+
 

b1sl/b1sl/async_rest_adapter.py

@@ -16,6 +16,7 @@ from b1sl.b1sl.exceptions.exceptions import (
     B1ValidationError,
 )
 from b1sl.b1sl.models.result import Result
+from b1sl.b1sl.pagination import extract_next_link
 
 _HTTP_STATUS_TO_EXC: dict[int, type] = {
     400: B1ValidationError,
@@ -278,7 +279,10 @@ class AsyncRestAdapter(BaseRestAdapter):
             self._raise_if_concurrency_error(
                 e.response.status_code, sap_code, sap_msg, endpoint_path, body
             )
-            
+            self._raise_if_sql_error(
+                e.response.status_code, sap_code, sap_msg, body
+            )
+
             # Use specialized exception based on status code if available
             exc_cls = _HTTP_STATUS_TO_EXC.get(e.response.status_code, B1Exception)
             raise exc_cls(f"SAP Error {sap_code}: {sap_msg}", details=body) from e
@@ -335,13 +339,11 @@ class AsyncRestAdapter(BaseRestAdapter):
                 status_code=response.status_code,
                 message=response.reason_phrase,
                 data=data_out,
-                next_link=data_out.get("odata.nextLink")
-                if isinstance(data_out, dict)
-                else None,
-                next_params=self._get_ep_params(data_out.get("odata.nextLink"))
-                if isinstance(data_out, dict) and data_out.get("odata.nextLink")
+                next_link=extract_next_link(data_out) if isinstance(data_out, dict) else None,
+                next_params=self._get_ep_params(extract_next_link(data_out))
+                if isinstance(data_out, dict) and extract_next_link(data_out)
                 else None,
-                metadata=data_out.get("odata.metadata")
+                metadata=(data_out.get("@odata.context") or data_out.get("odata.metadata"))
                 if isinstance(data_out, dict)
                 else None,
             )

b1sl/b1sl/base_adapter.py

@@ -16,7 +16,12 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import parse_qs, urlencode, urlparse
 
-from b1sl.b1sl.exceptions.exceptions import SAPConcurrencyError
+from b1sl.b1sl.exceptions.exceptions import (
+    B1SqlNotAllowedError,
+    B1SqlParamError,
+    B1SqlSyntaxError,
+    SAPConcurrencyError,
+)
 
 
 @dataclass
@@ -403,6 +408,44 @@ class BaseRestAdapter:
                 details=response_body,
             )
 
+    @staticmethod
+    def _raise_if_sql_error(
+        status_code: int,
+        sap_code: str,
+        sap_message: str,
+        response_body: dict | None,
+    ) -> None:
+        """Convert SAP 400 responses with SQL-specific codes into typed exceptions.
+
+        SAP error codes handled:
+        - ``"702"`` / ``"703"`` → ``B1SqlNotAllowedError`` (table or column blocked)
+        - ``"704"`` → ``B1SqlParamError`` (missing, extra, or mis-typed parameter)
+
+        Called from ``_do`` in both sync and async adapters, right before the
+        generic ``B1ValidationError`` fallback, so callers can catch the
+        granular subclass or the broader ``B1ValidationError``.
+
+        Note: SAP returns ``code`` as a JSON string (e.g. ``"702"``), not an int.
+        """
+        if status_code != 400:
+            return
+        if sap_code == B1SqlSyntaxError.SAP_ERROR_CODE:
+            raise B1SqlSyntaxError(
+                f"SAP SQL syntax error: {sap_message}",
+                details=response_body,
+            )
+        if sap_code in ("702", "703"):
+            raise B1SqlNotAllowedError(
+                f"SAP SQL allowlist violation [{sap_code}]: {sap_message}",
+                sap_code=sap_code,
+                details=response_body,
+            )
+        if sap_code == B1SqlParamError.SAP_ERROR_CODE:
+            raise B1SqlParamError(
+                f"SAP SQL parameter error: {sap_message}",
+                details=response_body,
+            )
+
     def _redact_data(self, data: dict | None) -> dict:
         """Mask sensitive information in data dictionaries before logging."""
         return {k: "***" if k == "Password" else v for k, v in (data or {}).items()}

b1sl/b1sl/batch/_recording_adapter.py

@@ -18,6 +18,7 @@ class PendingRequest:
     endpoint: str
     data: dict | None = None
     ep_params: dict | None = None
+    headers: dict | None = None
     model_type: Type[B1Model] | None = None
     changeset_id: str | None = None
     content_id: str = field(default_factory=lambda: str(uuid.uuid4()))
@@ -31,7 +32,8 @@ class _RecordingAdapter:
         self._batch = batch_client
         self._current_model: Type[B1Model] | None = None
 
-    def _record(self, method: str, endpoint: str, ep_params: dict | None = None, data: dict | None = None):
+    def _record(self, method: str, endpoint: str, ep_params: dict | None = None,
+                data: dict | None = None, headers: dict | None = None):
         """Captures the request and adds it to the client's queue."""
         if method == "GET" and self._batch.active_changeset_id:
             raise ValueError("OData Batch Error: GET operations are not allowed within a ChangeSet.")
@@ -41,27 +43,28 @@ class _RecordingAdapter:
             endpoint=endpoint,
             ep_params=ep_params,
             data=data,
+            headers=headers,
             model_type=self._current_model,
             changeset_id=self._batch.active_changeset_id
         )
         self._batch._pending.append(req)
-        
+
         # Return a simulated Result so Pydantic doesn't crash
         return Result(status_code=202, data={})
 
     # Asynchronous implementation for AsyncGenericResource
-    async def get(self, endpoint, ep_params=None, data=None):
-        return self._record("GET", endpoint, ep_params, data)
+    async def get(self, endpoint, ep_params=None, data=None, headers=None):
+        return self._record("GET", endpoint, ep_params, data, headers)
 
-    async def post(self, endpoint, ep_params=None, data=None):
-        return self._record("POST", endpoint, ep_params, data)
+    async def post(self, endpoint, ep_params=None, data=None, headers=None):
+        return self._record("POST", endpoint, ep_params, data, headers)
 
-    async def patch(self, endpoint, ep_params=None, data=None):
-        return self._record("PATCH", endpoint, ep_params, data)
+    async def patch(self, endpoint, ep_params=None, data=None, headers=None):
+        return self._record("PATCH", endpoint, ep_params, data, headers)
 
-    async def delete(self, endpoint, ep_params=None, data=None):
-        return self._record("DELETE", endpoint, ep_params, data)
+    async def delete(self, endpoint, ep_params=None, data=None, headers=None):
+        return self._record("DELETE", endpoint, ep_params, data, headers)
 
     # Synchronous implementation for GenericResource (compatibility)
-    def get_sync(self, endpoint, ep_params=None, data=None):
-        return self._record("GET", endpoint, ep_params, data)
+    def get_sync(self, endpoint, ep_params=None, data=None, headers=None):
+        return self._record("GET", endpoint, ep_params, data, headers)

b1sl/b1sl/batch/serializer.py

@@ -49,14 +49,25 @@ class BatchSerializer:
             lines.append(f"{req.method} /b1s/v2/{clean_endpoint} HTTP/1.1")
             
             # 5. Internal Headers
-            if req.data:
+            # Any caller-supplied per-part headers (e.g. Prefer:
+            # odata.maxpagesize, If-Match) — skip Content-Type, we set our own
+            # below whenever a body is present.
+            if req.headers:
+                for hk, hv in req.headers.items():
+                    if hk.lower() == "content-type":
+                        continue
+                    lines.append(f"{hk}: {hv}")
+            # A body is present whenever data is not None — note an empty dict
+            # ({}) is a valid, required body for some bounded functions (e.g.
+            # the SQLQueries /List POST), so we must not skip it on falsiness.
+            if req.data is not None:
                 lines.append("Content-Type: application/json")
             lines.append("") # End of internal headers
 
             # 6. Body
-            if req.data:
+            if req.data is not None:
                 lines.append(json.dumps(req.data))
-            
+
             lines.append("")  # Blank line after body (OData multipart spec)
 
         # Close the last changeset if it remained open

b1sl/b1sl/client.py

@@ -18,6 +18,8 @@ if TYPE_CHECKING:
     from b1sl.b1sl.models._generated.entities.inventory import Item
     from b1sl.b1sl.models.base import B1Model
     from b1sl.b1sl.resources.base import GenericResource
+    from b1sl.b1sl.resources.crossjoin import CrossJoinQueryBuilder, QueryServiceBuilder
+    from b1sl.b1sl.resources.sql_queries import SQLQueriesResource
     from b1sl.b1sl.resources.udo import UDOResource
 
 
@@ -348,6 +350,15 @@ class B1Client:
         from b1sl.b1sl.models._generated.entities.general import Document
         return self.get_resource(Document, "CorrectionPurchaseInvoiceReversal")
 
+    # --- SQL Queries ---
+
+    @property
+    def sql_queries(self) -> "SQLQueriesResource":
+        """Access the 'SQLQueries' endpoint (supports ETags, run() / run_stream())."""
+        from b1sl.b1sl.resources.sql_queries import SQLQueriesResource
+        resource = SQLQueriesResource(self._adapter)
+        return resource
+
     def udo(self, table_name: str) -> "UDOResource":
         """
         Access a User Defined Object (UDO) or User Table dynamically.
@@ -362,3 +373,48 @@ class B1Client:
         from b1sl.b1sl.resources.udo import UDOResource
 
         return UDOResource(adapter=self._adapter, table_name=table_name)
+
+    def crossjoin(self, *entities: str) -> "CrossJoinQueryBuilder":
+        """Build a ``$crossjoin`` query across entity sets (SAP HANA only, B1 9.2 patch 07+).
+
+        At least 2 entity names are required.  A bare crossjoin without
+        ``$expand`` or ``$apply`` will raise ``ValueError`` before the request.
+
+        Example::
+
+            rows = (
+                client.crossjoin("Orders", "BusinessPartners")
+                .expand({"Orders": ["DocEntry", "DocNum"], "BusinessPartners": ["CardCode"]})
+                .filter("Orders/CardCode eq BusinessPartners/CardCode")
+                .execute()
+            )
+        """
+        from b1sl.b1sl.resources.crossjoin import CrossJoinQueryBuilder
+
+        return CrossJoinQueryBuilder(self._adapter, *entities)
+
+    def query_service(self, query_path: str) -> "QueryServiceBuilder":
+        """Build a ``QueryService_PostQuery`` row-level filter (SAP HANA only, B1 9.2 PL11+).
+
+        Joins a document header with its navigation lines via POST.  Use this
+        when you need to filter by line-level fields (ItemCode, LineNum, etc.)
+        combined with header fields — which regular ``$filter`` cannot do.
+
+        Example::
+
+            rows = (
+                client.query_service("$crossjoin(Orders,Orders/DocumentLines)")
+                .expand({
+                    "Orders": ["DocEntry", "DocNum"],
+                    "Orders/DocumentLines": ["ItemCode", "LineNum"],
+                })
+                .filter(
+                    "Orders/DocEntry eq Orders/DocumentLines/DocEntry"
+                    " and Orders/DocumentLines/ItemCode eq 'WIDGET'"
+                )
+                .execute()
+            )
+        """
+        from b1sl.b1sl.resources.crossjoin import QueryServiceBuilder
+
+        return QueryServiceBuilder(self._adapter, query_path)

b1sl/b1sl/exceptions/__init__.py

@@ -4,6 +4,9 @@ from b1sl.b1sl.exceptions.exceptions import (
     B1Exception,
     B1NotFoundError,
     B1ResponseError,
+    B1SqlNotAllowedError,
+    B1SqlParamError,
+    B1SqlSyntaxError,
     B1ValidationError,
     SAPConcurrencyError,
 )
@@ -14,6 +17,9 @@ __all__ = [
     "B1ConnectionError",
     "B1NotFoundError",
     "B1ValidationError",
+    "B1SqlSyntaxError",
+    "B1SqlNotAllowedError",
+    "B1SqlParamError",
     "B1ResponseError",
     "SAPConcurrencyError",
 ]

b1sl/b1sl/exceptions/exceptions.py

@@ -88,6 +88,101 @@ class B1ValidationError(B1Exception):
     """
 
 
+class B1SqlNotAllowedError(B1ValidationError):
+    """Raised when SAP rejects a SQLQuery because a table or column is blocked.
+
+    SAP error codes:
+    - ``"702"`` — table not in the server allowlist (``b1s_sqltable.conf``).
+    - ``"703"`` — column excluded via ``ColumnExcludeList`` in the same config.
+
+    Neither condition can be fixed at runtime; the SQL text or the server
+    configuration must change.  The ``sap_code`` attribute lets callers
+    distinguish table-level from column-level blocks::
+
+        try:
+            result = client.sql_queries.run("sql04")
+        except B1SqlNotAllowedError as e:
+            if e.sap_code == "702":
+                print(f"Table blocked: {e}")
+            else:
+                print(f"Column blocked: {e}")
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        sap_code: str = "702",
+        details: dict | None = None,
+    ) -> None:
+        super().__init__(message, details=details)
+        self.sap_code = sap_code
+
+
+class B1SqlSyntaxError(B1ValidationError):
+    """Raised when SAP rejects a SQL definition or execution due to invalid syntax.
+
+    SAP error code ``"701"`` — covers multiple sub-cases, all requiring a fix
+    to the SQL text itself (no runtime adjustment can resolve a 701 error):
+
+    - **Grammar error**: typos like ``ORDER BY x dsc`` instead of ``DESC``.
+    - **Unsupported function**: e.g. ``length()``, ``CASE WHEN``, ``COALESCE``.
+    - **``SELECT *`` in the top-level query**: only allowed inside subqueries.
+    - **Computed column without alias**: ``SUM(col)`` must be aliased as
+      ``SUM(col) AS total``.
+    - **Duplicate alias**: two columns sharing the same alias are rejected.
+    - **DML statement**: ``UPDATE``, ``INSERT``, ``DELETE``, ``ALTER``, etc. —
+      the ``SQLQueries`` endpoint accepts only ``SELECT`` queries.
+
+    The SAP error message includes the character position and a description::
+
+        try:
+            client.sql_queries.create(en.SQLQuery(sql_code="q1",
+                                                   sql_text="select * from ORDR"))
+        except B1SqlSyntaxError as e:
+            print(e)  # "Invalid SQL syntax: ..., Cannot support asterisk(*)..."
+    """
+
+    SAP_ERROR_CODE = "701"
+
+    def __init__(self, message: str, *, details: dict | None = None) -> None:
+        super().__init__(message, details=details)
+        self.sap_code = self.SAP_ERROR_CODE
+
+
+class B1SqlParamError(B1ValidationError):
+    """Raised when SAP rejects a ``/List`` invocation due to parameter problems.
+
+    SAP error code ``"704"`` — covers missing parameters, extra parameters, or
+    type mismatches.  Unlike ``B1SqlNotAllowedError``, this is fixable by the
+    caller: check that the kwargs passed to ``run()`` / ``run_stream()`` match
+    the ``ParamList`` declared in the stored ``SqlText``::
+
+        try:
+            rows = client.sql_queries.run("sql01", doc_total=100)
+        except B1SqlParamError:
+            # Wrong param name — SAP expects :docTotal, not :doc_total
+            rows = client.sql_queries.run("sql01", docTotal=100)
+
+    Note: SAP returns a generic ``"Parameter error."`` message without naming
+    the offending parameter.  Inspect the stored query's ``ParamList`` field
+    to cross-reference.
+    """
+
+    SAP_ERROR_CODE = "704"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        details: dict | None = None,
+        expected_params: list[str] | None = None,
+    ) -> None:
+        super().__init__(message, details=details)
+        self.sap_code = self.SAP_ERROR_CODE
+        self.expected_params: list[str] | None = expected_params
+
+
 class B1ResponseError(B1Exception):
     """Raised for unexpected non-2xx responses not covered by other subclasses."""
 

b1sl/b1sl/pagination.py

@@ -1,6 +1,18 @@
 from urllib.parse import parse_qs, urlparse
 
 
+def extract_next_link(data: dict) -> str | None:
+    """Return the OData nextLink from a response body, tolerating v3 and v4 formats.
+
+    SAP Service Layer uses different key names depending on the OData version:
+    - OData v3 (``b1s/v1``): ``"odata.nextLink"``
+    - OData v4 (``b1s/v2``): ``"@odata.nextLink"``
+
+    Returns the first non-empty value found, or ``None``.
+    """
+    return data.get("@odata.nextLink") or data.get("odata.nextLink") or None
+
+
 def extract_skip(next_link: str) -> int | None:
     """
     Extracts the $skip value from an odata.nextLink string.

b1sl/b1sl/resources/async_base.py

@@ -96,6 +96,11 @@ class AsyncGenericResource(Generic[T]):
 
         return AsyncQueryBuilder(self).expand(value)
 
+    def apply(self, expression: str) -> AsyncQueryBuilder[T]:
+        from b1sl.b1sl.resources.odata import AsyncQueryBuilder
+
+        return AsyncQueryBuilder(self).apply(expression)
+
     async def list(self, query: ODataQuery | None = None) -> list[T]:
         """
         Retrieves a single page of results based on the provided query.
@@ -107,52 +112,54 @@ class AsyncGenericResource(Generic[T]):
         data = result.data or {}
         return [self.model.model_validate(item) for item in data.get("value", [])]
 
-    async def stream(
-        self, 
-        query: ODataQuery | None = None, 
-        page_size: int | None = None, 
-        max_pages: int | None = None
-    ) -> AsyncGenerator[T, None]:
-        """
-        Execute the query asynchronously and yield individual entities, 
-        automatically fetching next pages until dataset exhausted or limits hit.
+    async def _iter_pages(
+        self,
+        url: str,
+        params: dict,
+        headers: dict,
+        max_pages: int | None = None,
+    ) -> AsyncGenerator[dict, None]:
+        """Yield raw item dicts from a paginated OData endpoint, following nextLink.
+
+        Async counterpart of ``GenericResource._iter_pages``.  Shared by
+        ``stream()`` and ``AsyncSQLQueriesResource.run_stream()``.
         """
-
-        params = query.to_params() if query else {}
-        headers = {"B1-PageSize": str(page_size)} if page_size else {}
-        
-        global_top = query.top if query else None
-        yielded_count = 0
-        pages_fetched = 0
-        
         current_params = params
-        
+        pages_fetched = 0
         while True:
-            result = await self._adapter.get(
-                self.endpoint, 
-                ep_params=current_params, 
-                headers=headers
-            )
+            result = await self._adapter.get(url, ep_params=current_params, headers=headers)
             data = result.data or {}
-            items = data.get("value", [])
             pages_fetched += 1
-            
-            for raw_item in items:
-                yield self.model.model_validate(raw_item)
-                yielded_count += 1
-                
-                if global_top is not None and yielded_count >= global_top:
-                    return
-
+            for item in data.get("value", []):
+                yield item
             next_link = result.next_link
             if not next_link:
                 break
-                
             if max_pages is not None and pages_fetched >= max_pages:
                 break
-                
             current_params = build_next_params(current_params, next_link)
 
+    async def stream(
+        self,
+        query: ODataQuery | None = None,
+        page_size: int | None = None,
+        max_pages: int | None = None
+    ) -> AsyncGenerator[T, None]:
+        """
+        Execute the query asynchronously and yield individual entities,
+        automatically fetching next pages until dataset exhausted or limits hit.
+        """
+        params = query.to_params() if query else {}
+        headers = {"B1-PageSize": str(page_size)} if page_size else {}
+        global_top = query.top if query else None
+        yielded_count = 0
+
+        async for raw_item in self._iter_pages(self.endpoint, params, headers, max_pages):
+            yield self.model.model_validate(raw_item)
+            yielded_count += 1
+            if global_top is not None and yielded_count >= global_top:
+                return
+
     async def count(self) -> int:
         """GET Endpoint/$count"""
         result = await self._adapter.get(f"{self.endpoint}/$count")
@@ -222,12 +229,33 @@ class AsyncGenericResource(Generic[T]):
 
     # ── Actions / Functions ───────────────────────────────────────────────────
 
-    async def _action(self, key: Any, name: str, payload: dict | None = None) -> Any:
-        """POST Endpoint(key)/ActionName"""
+    async def _action(
+        self,
+        key: Any,
+        name: str,
+        payload: dict | None = None,
+        *,
+        params: dict | None = None,
+        headers: dict | None = None,
+        method: str = "POST",
+    ) -> Any:
+        """Invoke a bound action or function on a keyed entity.
+
+        Covers two SAP OData patterns:
+        - POST Endpoint('key')/ActionName  (default, side-effecting actions)
+        - GET  Endpoint('key')/FunctionName (read-only bounded functions, e.g. /List)
+
+        The full response ``data`` dict is returned — callers needing
+        ``@odata.nextLink`` should inspect it directly.
+        """
         id_str = f"'{key}'" if isinstance(key, str) else str(key)
-        result = await self._adapter.post(
-            f"{self.endpoint}({id_str})/{name}", data=payload or {}
-        )
+        url = f"{self.endpoint}({id_str})/{name}"
+        if method == "GET":
+            result = await self._adapter.get(url, ep_params=params, headers=headers)
+        else:
+            result = await self._adapter.post(
+                url, ep_params=params, data=payload or {}, headers=headers
+            )
         return result.data if result else None
 
     async def _function(self, name: str, params: dict | None = None) -> Any: