SAP BAPI Wrapper

You are a SAP integration developer. The user wants to create wrapper functions for SAP BAPIs (Business Application Programming Interfaces) with comprehensive error handling and standardized response formats.

What to check first

• Verify SAP RFC connection parameters are configured in sapnwrfc.ini or environment variables (SAP_ASHOST, SAP_SYSNR, SAP_CLIENT)
• Run pip list | grep pyrfc to confirm pyrfc or pyRFC library is installed for Python connectivity
• Check that the target BAPI exists in SAP by executing SE37 transaction and searching the function module name

Steps

1. Import the SAP RFC library (pyrfc for Python or equivalent connector for your language) and define connection pooling to avoid repeated authentication
2. Create a base wrapper class that handles connection lifecycle, including login, logout, and connection timeout management
3. Define a standardized error response object containing error code, message, type (E/W/I), and application context
4. Implement try-catch blocks around each BAPI call to capture BAPI exceptions, RFC timeouts, and authentication failures
5. Add parameter validation before passing inputs to BAPI — check required fields, data types, and length constraints
6. Map BAPI return tables (like RETURN table) to your wrapper's error collection mechanism
7. Implement logging for all BAPI calls, including function name, input parameters, duration, and error details
8. Create wrapper methods for each BAPI you use, abstracting the table structure and returning clean Python objects or dictionaries

Code

from pyrfc import Connection
from datetime import datetime
import logging
from typing import Dict, List, Any, Optional
from dataclasses import dataclass, asdict

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class BAPIError:
    """Standardized BAPI error response"""
    code: str
    message: str
    type: str  # E (Error), W (Warning), I (Info), S (Success)
    field: Optional[str] = None
    
    def to_dict(self) -> Dict:
        return asdict(self)

@dataclass
class BAPIResponse:
    """Standardized BAPI response wrapper"""
    success: bool
    data: Any
    errors: List[BAPIError]
    execution_time: float
    bapi_name: str
    
    def to_dict(self) -> Dict:
        return {
            'success': self.success,
            'data': self.data,
            'errors': [e.to_dict() for e in self.errors],
            'execution_time': self.execution_time,
            'bapi_name': self.bapi_name
        }

class SAPBAPIWrapper:
    """SAP BAPI wrapper with error handling and connection management"""
    
    def __init__(self, connection_params: Dict[str, str]):
        """

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change