b1sl-python 0.2.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/adapter_protocol.py

@@ -12,17 +12,17 @@ class RestAdapterProtocol(Protocol):
     """
 
     def get(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def post(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def patch(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def delete(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...

b1sl/b1sl/async_client.py

@@ -8,6 +8,7 @@ from b1sl.b1sl.base_adapter import ObservabilityConfig
 from b1sl.b1sl.config import B1Config
 
 if TYPE_CHECKING:
+    from b1sl.b1sl.batch.client import BatchClient
     from b1sl.b1sl.models._generated.entities.businesspartners import (
         Activity,
         BusinessPartner,
@@ -16,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
 
 
@@ -98,6 +104,30 @@ class AsyncB1Client:
         """
         return self._adapter.dry_run(enabled)
 
+    def with_schema(self, name: str):
+        """
+        Context manager to temporarily set the B1S-Schema header
+        **for the current asyncio.Task only** (task-safe via ContextVar).
+        
+        Usage::
+        
+            async with AsyncB1Client(config) as b1:
+                async with b1.with_schema("demo.schema"):
+                    await b1.items.get("A0001")
+        """
+        return self._adapter.with_schema(name)
+
+    def batch(self) -> BatchClient:
+        """
+        Returns a context manager that groups multiple resource operations
+        into a single OData $batch HTTP request.
+
+        Use this for high-concurrency scenarios (bulk GETs) or transactional
+        integrity (atomic ChangeSets). See :class:`BatchClient` for details.
+        """
+        from b1sl.b1sl.batch.client import BatchClient
+        return BatchClient(self)
+
     async def connect(self) -> None:
         """
         Initializes the underlying HTTP client and logs in.
@@ -326,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.
@@ -335,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,
@@ -215,6 +216,7 @@ class AsyncRestAdapter(BaseRestAdapter):
         endpoint: str,
         ep_params=None,
         data=None,
+        headers: dict | None = None,
         _is_login: bool = False,
         _retry_once=True,
     ) -> Result:
@@ -240,7 +242,9 @@ class AsyncRestAdapter(BaseRestAdapter):
 
         try:
             # ── ETag: inject If-None-Match (GET) or If-Match (PATCH/DELETE/POST) ──
-            headers = self._build_headers(http_method, endpoint_path)
+            req_headers = self._build_headers(http_method, endpoint_path)
+            if headers:
+                req_headers.update(headers)
 
             if self._dry_run_active and http_method in {"POST", "PATCH", "DELETE"} and not _is_login:
                 self._logger.info(f"[{req_id}] [DRY RUN] Intercepting {http_method} {full_url}")
@@ -250,7 +254,7 @@ class AsyncRestAdapter(BaseRestAdapter):
             else:
                 response = await self._client.request(
                     method=http_method, url=full_url, params=ep_params, json=data,
-                    headers=headers,
+                    headers=req_headers,
                 )
 
             if response.status_code == 401 and _retry_once and not _is_login:
@@ -259,7 +263,7 @@ class AsyncRestAdapter(BaseRestAdapter):
                 # Recursive call will handle its own finally block,
                 # but we need to return here to avoid double-logging/hooking.
                 return await self._do(
-                    http_method, endpoint, ep_params, data, _is_login, _retry_once=False
+                    http_method, endpoint, ep_params, data, headers, _is_login, _retry_once=False
                 )
 
             response.raise_for_status()
@@ -275,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
@@ -308,7 +315,7 @@ class AsyncRestAdapter(BaseRestAdapter):
                     status_code=status_code,
                     duration_ms=duration_ms,
                     payload=log_data if http_method in {"POST", "PATCH"} else None,
-                    if_match=headers.get("If-Match"),
+                    if_match=req_headers.get("If-Match"),
                     extra=context_extras,
                     exc=exc_captured,
                 )
@@ -332,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)
+                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,
-                next_params=self._get_ep_params(data_out.get("odata.nextLink"))
-                if isinstance(data_out, dict) and data_out.get("odata.nextLink")
-                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,
             )
@@ -347,18 +352,33 @@ class AsyncRestAdapter(BaseRestAdapter):
                 f"HTTP Error {response.status_code if response else 'Unknown'}"
             )
 
-    async def get(self, endpoint, ep_params=None, data=None):
+    async def get(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous GET request."""
-        return await self._do("GET", endpoint, ep_params, data)
+        return await self._do("GET", endpoint, ep_params, data, headers=headers)
 
-    async def post(self, endpoint, ep_params=None, data=None):
+    async def post(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous POST request."""
-        return await self._do("POST", endpoint, ep_params, data)
+        return await self._do("POST", endpoint, ep_params, data, headers=headers)
 
-    async def patch(self, endpoint, ep_params=None, data=None):
+    async def patch(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous PATCH request."""
-        return await self._do("PATCH", endpoint, ep_params, data)
+        return await self._do("PATCH", endpoint, ep_params, data, headers=headers)
 
-    async def delete(self, endpoint, ep_params=None, data=None):
+    async def delete(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous DELETE request."""
-        return await self._do("DELETE", endpoint, ep_params, data)
+        return await self._do("DELETE", endpoint, ep_params, data, headers=headers)
+
+    async def post_batch(self, body: str, headers: dict) -> httpx.Response:
+        """
+        Special method to send raw multipart content for $batch operations.
+        """
+        await self.ensure_session()
+        if not self._client:
+             raise B1Exception("AsyncRestAdapter not initialized.")
+        
+        url = f"{self.raw_base_url}/$batch"
+        # Combine with session headers if necessary,
+        # although httpx already handles them via cookies.
+        response = await self._client.post(url, content=body, headers=headers)
+        response.raise_for_status()
+        return response

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
@@ -185,12 +190,20 @@ class BaseRestAdapter:
         self._dry_run_var: ContextVar[bool] = ContextVar(
             f"dry_run_{id(self)}", default=config.dry_run
         )
+        self._b1s_schema_var: ContextVar[str | None] = ContextVar(
+            f"b1s_schema_{id(self)}", default=config.b1s_schema
+        )
 
     @property
     def _dry_run_active(self) -> bool:
         """Returns the current effective dry_run state for this task/thread."""
         return self._dry_run_var.get()
 
+    @property
+    def _schema_active(self) -> str | None:
+        """Returns the current effective schema state for this task/thread."""
+        return self._b1s_schema_var.get()
+
     @contextmanager
     def dry_run(self, enabled: bool = True):
         """
@@ -220,6 +233,28 @@ class BaseRestAdapter:
         finally:
             self._dry_run_var.reset(token)
 
+    @contextmanager
+    def with_schema(self, schema: str | None):
+        """
+        Context manager to temporarily override the B1S-Schema header
+        **for the current asyncio task / thread only**.
+
+        Usage::
+
+            # Use a specific schema for this block
+            with client.with_schema("demo.schema"):
+                await client.items.get("A0001")
+
+        Note:
+            Use ``with``, not ``async with`` — the context manager is
+            synchronous even in async code, which is correct and idiomatic.
+        """
+        token = self._b1s_schema_var.set(schema)
+        try:
+            yield
+        finally:
+            self._b1s_schema_var.reset(token)
+
     @classmethod
     def from_config(
         cls,
@@ -328,6 +363,10 @@ class BaseRestAdapter:
             # POST covers OData Actions (e.g. /BusinessPartners('C20000')/Cancel)
             headers["If-Match"] = cached_etag
 
+        active_schema = self._schema_active
+        if active_schema:
+            headers["B1S-Schema"] = active_schema
+
         if extra_headers:
             headers.update(extra_headers)
         return headers
@@ -369,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/__init__.py

@@ -0,0 +1,6 @@
+"""OData $batch support for the b1sl SDK."""
+
+from .client import BatchClient
+from .results import BatchResult, BatchResults
+
+__all__ = ["BatchClient", "BatchResult", "BatchResults"]

b1sl/b1sl/batch/_recording_adapter.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Type
+
+from b1sl.b1sl.models.result import Result
+
+if TYPE_CHECKING:
+    from b1sl.b1sl.models.base import B1Model
+
+    from .client import BatchClient
+
+@dataclass
+class PendingRequest:
+    """Represents an enqueued request within a batch."""
+    method: str
+    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()))
+
+class _RecordingAdapter:
+    """
+    Internal adapter that captures requests instead of executing them.
+    Complies with the RestAdapterProtocol asynchronously.
+    """
+    def __init__(self, batch_client: BatchClient):
+        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, 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.")
+
+        req = PendingRequest(
+            method=method,
+            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, headers=None):
+        return self._record("GET", endpoint, ep_params, data, headers)
+
+    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, headers=None):
+        return self._record("PATCH", endpoint, ep_params, data, headers)
+
+    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, headers=None):
+        return self._record("GET", endpoint, ep_params, data, headers)

b1sl/b1sl/batch/changeset.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import BatchClient
+
+class ChangeSetContext:
+    """
+    Manages the lifecycle of a ChangeSet in OData.
+    Ensures that operations are atomic and prohibits GETs.
+    """
+    def __init__(self, batch_client: BatchClient):
+        self._batch = batch_client
+        self._changeset_id = f"changeset_{uuid.uuid4()}"
+
+    def __enter__(self) -> BatchClient:
+        self._batch.active_changeset_id = self._changeset_id
+        return self._batch
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._batch.active_changeset_id = None
+
+    async def __aenter__(self) -> BatchClient:
+        return self.__enter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return self.__exit__(exc_type, exc_val, exc_tb)

b1sl/b1sl/batch/client.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import copy
+import functools
+import inspect
+import re
+import uuid
+from typing import TYPE_CHECKING, Any, Callable
+
+from ._recording_adapter import PendingRequest, _RecordingAdapter
+from .changeset import ChangeSetContext
+from .parser import BatchParser
+from .results import BatchResults
+from .serializer import BatchSerializer
+
+if TYPE_CHECKING:
+    from b1sl.b1sl import AsyncB1Client, B1Client
+
+class ResourceProxy:
+    """Recursive proxy for capturing batch requests."""
+    def __init__(self, target: Any, adapter: _RecordingAdapter, client: BatchClient):
+        self._target = target
+        self._adapter = adapter
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            return getattr(self._target, name)
+        attr = getattr(self._target, name)
+        if inspect.iscoroutinefunction(attr):
+            return self._wrap_async(attr)
+        if callable(attr):
+            return self._wrap_callable(attr)
+        return attr
+
+    def _wrap_async(self, method: Callable) -> Callable:
+        @functools.wraps(method)
+        async def wrapper(*args, **kwargs):
+            model = getattr(self._target, "model", None)
+            if model is None and hasattr(self._target, "_resource"):
+                model = getattr(self._target._resource, "model", None)
+            self._adapter._current_model = model
+            try:
+                await method(*args, **kwargs)
+            except (AttributeError, TypeError):
+                # Suppress infrastructure errors from the proxy mechanism;
+                # business-logic exceptions (e.g. ValueError for GET-in-ChangeSet)
+                # are intentionally allowed to propagate.
+                pass
+            return None
+        return wrapper
+
+    def _wrap_callable(self, method: Callable) -> Callable:
+        @functools.wraps(method)
+        def wrapper(*args, **kwargs):
+            result = method(*args, **kwargs)
+            if hasattr(result, "__dict__") or hasattr(result, "_adapter"):
+                if hasattr(result, "_adapter"):
+                    setattr(result, "_adapter", self._adapter)
+                if hasattr(result, "_resource") and hasattr(result._resource, "_adapter"):
+                    setattr(result._resource, "_adapter", self._adapter)
+                return ResourceProxy(result, self._adapter, self._client)
+            return result
+        return wrapper
+
+class BatchClient:
+    """OData Batch Orchestrator."""
+    def __init__(self, b1_session: AsyncB1Client | B1Client):
+        self._b1 = b1_session
+        self._pending: list[PendingRequest] = []
+        self._adapter = _RecordingAdapter(self)
+        self.active_changeset_id: str | None = None
+        self._batch_boundary = f"batch_{uuid.uuid4()}"
+
+    def __getattr__(self, name: str) -> Any:
+        real_resource = getattr(self._b1, name)
+        new_resource = copy.copy(real_resource)
+        if hasattr(new_resource, "_adapter"):
+            new_resource._adapter = self._adapter
+        return ResourceProxy(new_resource, self._adapter, self)
+
+    def changeset(self) -> ChangeSetContext:
+        return ChangeSetContext(self)
+
+    def _extract_response_boundary(self, response_content_type: str) -> str | None:
+        """Extracts the boundary string from a SAP Content-Type response header."""
+        match = re.search(r"boundary=([^\s;]+)", response_content_type)
+        if match:
+            return match.group(1).strip().replace('"', '')
+        return None
+
+    async def execute(self) -> BatchResults:
+        """Dynamically serializes, sends, and parses the batch."""
+        if not self._pending:
+            return BatchResults([])
+
+        serializer = BatchSerializer(self._pending, self._batch_boundary)
+        body = serializer.serialize()
+
+        real_adapter = getattr(self._b1, "_adapter") 
+        headers = {"Content-Type": f"multipart/mixed; boundary={self._batch_boundary}"}
+        
+        response = await real_adapter.post_batch(body, headers)
+        
+        # IMPORTANT: Use the boundary that SAP returns in its response
+        resp_ct = response.headers.get("Content-Type", "")
+        resp_boundary = self._extract_response_boundary(resp_ct)
+
+        # Fallback: use the request boundary if SAP omits it in the response
+        boundary_to_use = resp_boundary or self._batch_boundary
+
+        parser = BatchParser(response.text, boundary_to_use)
+        expected_models = [req.model_type for req in self._pending]
+        raw_results = parser.parse(expected_models)
+        
+        return BatchResults(raw_results)
+
+    async def __aenter__(self) -> BatchClient:
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        # Reset internal state to prevent accidental reuse of a consumed BatchClient.
+        self._pending.clear()
+        self.active_changeset_id = None