d365fo-client 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

d365fo_client/crud.py

@@ -1,13 +1,14 @@
 """CRUD operations for D365 F&O client."""
 
-from typing import Any, Dict, List, Optional, Union
-
-import aiohttp
+from typing import Any, Dict, Optional, Union, TYPE_CHECKING
 
 from .models import QueryOptions
 from .query import QueryBuilder
 from .session import SessionManager
 
+if TYPE_CHECKING:
+    from .models import PublicEntityInfo
+
 
 class CrudOperations:
     """Handles CRUD operations for F&O entities"""
@@ -23,13 +24,17 @@ class CrudOperations:
         self.base_url = base_url
 
     async def get_entities(
-        self, entity_name: str, options: Optional[QueryOptions] = None
+        self,
+        entity_name: str,
+        options: Optional[QueryOptions] = None,
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> Dict[str, Any]:
         """Get entities with OData query options
 
         Args:
             entity_name: Name of the entity set
             options: OData query options
+            entity_schema: Optional entity schema for validation/optimization
 
         Returns:
             Response containing entities
@@ -52,6 +57,7 @@ class CrudOperations:
         entity_name: str,
         key: Union[str, Dict[str, Any]],
         options: Optional[QueryOptions] = None,
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> Dict[str, Any]:
         """Get single entity by key
 
@@ -59,13 +65,15 @@ class CrudOperations:
             entity_name: Name of the entity set
             key: Entity key value (string for simple keys, dict for composite keys)
             options: OData query options
+            entity_schema: Optional entity schema for type-aware key encoding
 
         Returns:
             Entity data
         """
         session = await self.session_manager.get_session()
         query_string = QueryBuilder.build_query_string(options)
-        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key)
+        # Use schema-aware URL building for proper key encoding
+        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key, entity_schema)
         url += query_string
 
         async with session.get(url) as response:
@@ -78,13 +86,17 @@ class CrudOperations:
                 )
 
     async def create_entity(
-        self, entity_name: str, data: Dict[str, Any]
+        self,
+        entity_name: str,
+        data: Dict[str, Any],
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> Dict[str, Any]:
         """Create new entity
 
         Args:
             entity_name: Name of the entity set
             data: Entity data to create
+            entity_schema: Optional entity schema for validation
 
         Returns:
             Created entity data
@@ -107,6 +119,7 @@ class CrudOperations:
         key: Union[str, Dict[str, Any]],
         data: Dict[str, Any],
         method: str = "PATCH",
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> Dict[str, Any]:
         """Update existing entity
 
@@ -115,12 +128,14 @@ class CrudOperations:
             key: Entity key value (string for simple keys, dict for composite keys)
             data: Updated entity data
             method: HTTP method (PATCH or PUT)
+            entity_schema: Optional entity schema for type-aware key encoding and validation
 
         Returns:
             Updated entity data
         """
         session = await self.session_manager.get_session()
-        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key)
+        # Use schema-aware URL building for proper key encoding
+        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key, entity_schema)
 
         async with session.request(method, url, json=data) as response:
             if response.status in [200, 204]:
@@ -134,19 +149,24 @@ class CrudOperations:
                 )
 
     async def delete_entity(
-        self, entity_name: str, key: Union[str, Dict[str, Any]]
+        self,
+        entity_name: str,
+        key: Union[str, Dict[str, Any]],
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> bool:
         """Delete entity
 
         Args:
             entity_name: Name of the entity set
             key: Entity key value (string for simple keys, dict for composite keys)
+            entity_schema: Optional entity schema for type-aware key encoding
 
         Returns:
             True if successful
         """
         session = await self.session_manager.get_session()
-        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key)
+        # Use schema-aware URL building for proper key encoding
+        url = QueryBuilder.build_entity_url(self.base_url, entity_name, key, entity_schema)
 
         async with session.delete(url) as response:
             if response.status in [200, 204]:
@@ -163,6 +183,7 @@ class CrudOperations:
         parameters: Optional[Dict[str, Any]] = None,
         entity_name: Optional[str] = None,
         entity_key: Optional[Union[str, Dict[str, Any]]] = None,
+        entity_schema: Optional["PublicEntityInfo"] = None
     ) -> Any:
         """Call OData action method
 
@@ -171,13 +192,15 @@ class CrudOperations:
             parameters: Action parameters
             entity_name: Entity name for bound actions
             entity_key: Entity key for bound actions (string for simple keys, dict for composite keys)
+            entity_schema: Optional entity schema for type-aware key encoding in bound actions
 
         Returns:
             Action result
         """
         session = await self.session_manager.get_session()
+        # Use schema-aware URL building for entity-bound actions
         url = QueryBuilder.build_action_url(
-            self.base_url, action_name, entity_name, entity_key
+            self.base_url, action_name, entity_name, entity_key, entity_schema
         )
 
         # Prepare request body

d365fo_client/main.py

@@ -236,6 +236,7 @@ def create_argument_parser() -> argparse.ArgumentParser:
     _add_metadata_commands(subparsers)
     _add_entity_commands(subparsers)
     _add_action_commands(subparsers)
+    _add_service_commands(subparsers)
     _add_config_commands(subparsers)
 
     return parser
@@ -449,6 +450,63 @@ def _add_config_commands(subparsers) -> None:
     default_parser.add_argument("profile_name", help="Profile name")
 
 
+def _add_service_commands(subparsers) -> None:
+    """Add JSON service commands."""
+    service_parser = subparsers.add_parser("service", help="JSON service operations")
+    service_subs = service_parser.add_subparsers(
+        dest="service_subcommand", help="Service subcommands"
+    )
+
+    # call subcommand - generic service call
+    call_parser = service_subs.add_parser(
+        "call", help="Call a generic JSON service endpoint"
+    )
+    call_parser.add_argument(
+        "service_group", help="Service group name (e.g., 'SysSqlDiagnosticService')"
+    )
+    call_parser.add_argument(
+        "service_name", 
+        help="Service name (e.g., 'SysSqlDiagnosticServiceOperations')"
+    )
+    call_parser.add_argument(
+        "operation_name", help="Operation name (e.g., 'GetAxSqlExecuting')"
+    )
+    call_parser.add_argument(
+        "--parameters",
+        help="JSON string with parameters to send in POST body",
+    )
+
+    # sql-diagnostic subcommand - convenience wrapper for SQL diagnostic operations
+    sql_parser = service_subs.add_parser(
+        "sql-diagnostic", help="Call SQL diagnostic service operations"
+    )
+    sql_parser.add_argument(
+        "operation",
+        choices=[
+            "GetAxSqlExecuting",
+            "GetAxSqlResourceStats",
+            "GetAxSqlBlocking", 
+            "GetAxSqlLockInfo",
+            "GetAxSqlDisabledIndexes",
+        ],
+        help="SQL diagnostic operation to execute",
+    )
+    sql_parser.add_argument(
+        "--since-minutes",
+        type=int,
+        default=10,
+        help="For GetAxSqlResourceStats: get stats for last N minutes (default: 10)",
+    )
+    sql_parser.add_argument(
+        "--start-time",
+        help="For GetAxSqlResourceStats: start time (ISO format)",
+    )
+    sql_parser.add_argument(
+        "--end-time",
+        help="For GetAxSqlResourceStats: end time (ISO format)",
+    )
+
+
 def main() -> None:
     """Enhanced main entry point with CLI support."""
     parser = create_argument_parser()

d365fo_client/mcp/fastmcp_main.py

@@ -341,7 +341,7 @@ if is_remote_transport:
 # Initialize FastMCP server with configuration
 mcp = FastMCP(
     name=server_config.get("name", "d365fo-mcp-server"),
-    auth_server_provider=auth_provider if isinstance(auth_provider, AzureProvider) else None,
+    auth_server_provider=auth_provider if isinstance(auth_provider, AzureProvider) else None,# type: ignore
     token_verifier=auth_provider if isinstance(auth_provider, APIKeyVerifier) else None,
     auth=auth,
     instructions=server_config.get(

d365fo_client/mcp/fastmcp_utils.py

@@ -144,6 +144,10 @@ def create_default_profile_if_needed(profile_manager:"ProfileManager", config:Di
         if not base_url:
             logger.warning("Cannot create default profile - D365FO_BASE_URL not set")
             return False
+        
+        if base_url.startswith("https://usnconeboxax1aos.cloud.onebox.dynamics.com"):
+            logger.warning("D365FO_BASE_URL is set to the default onebox URL - please set it to your actual environment URL")
+            return False
 
         # Determine authentication mode based on startup mode
         startup_mode = config.get("startup_mode", "profile_only")

d365fo_client/mcp/mixins/base_tools_mixin.py

@@ -1,7 +1,6 @@
 """Base mixin class for FastMCP tool categories."""
 
 import logging
-from typing import Optional
 
 from d365fo_client.client import FOClient
 from d365fo_client.profile_manager import ProfileManager
@@ -13,30 +12,32 @@ logger = logging.getLogger(__name__)
 
 class BaseToolsMixin:
     """Base mixin for FastMCP tool categories.
-    
+
     Provides common functionality and client access patterns
     for all tool category mixins.
     """
-    
+
     # These will be injected by the main server class
     client_manager: D365FOClientManager
-    mcp: FastMCP  
-    profile_manager:  ProfileManager
-    
+    mcp: FastMCP
+    profile_manager: ProfileManager
+
     async def _get_client(self, profile: str = "default") -> FOClient:
         """Get D365FO client for specified profile.
-        
+
         Args:
             profile: Profile name to use
-            
+
         Returns:
             Configured D365FO client instance
         """
-        if not hasattr(self, 'client_manager') or not self.client_manager:
+        if not hasattr(self, "client_manager") or not self.client_manager:
             raise RuntimeError("Client manager not initialized")
         return await self.client_manager.get_client(profile)
-    
-    def _create_error_response(self, error: Exception, tool_name: str, arguments: dict) -> dict:
+
+    def _create_error_response(
+        self, error: Exception, tool_name: str, arguments: dict
+    ) -> dict:
         """Create standardized error response.
 
         Args:
@@ -52,4 +53,4 @@ class BaseToolsMixin:
             "tool": tool_name,
             "arguments": arguments,
             "error_type": type(error).__name__,
-        }
+        }

d365fo_client/mcp/mixins/crud_tools_mixin.py

@@ -10,10 +10,10 @@ logger = logging.getLogger(__name__)
 
 class CrudToolsMixin(BaseToolsMixin):
     """CRUD (Create, Read, Update, Delete) tools for FastMCP server."""
-    
+
     def register_crud_tools(self):
         """Register all CRUD tools with FastMCP."""
-        
+
         @self.mcp.tool()
         async def d365fo_query_entities(
             entity_name: str,
@@ -67,7 +67,7 @@ class CrudToolsMixin(BaseToolsMixin):
                     expand=expand,
                 )
 
-                # Execute query
+                # FOClient now handles validation and schema fetching
                 result = await client.get_entities(entity_name, options=options)
 
                 return {
@@ -109,6 +109,18 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with the entity record
             """
             try:
+                # Validate key_fields and key_values match
+                if len(key_fields) != len(key_values):
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                    }
+
+                # Build key dict
+                key = {k: v for k, v in zip(key_fields, key_values)}
+
                 client = await self._get_client(profile)
 
                 # Build query options
@@ -120,19 +132,32 @@ class CrudToolsMixin(BaseToolsMixin):
                     else None
                 )
 
-                # Construct key field=value mapping
-                if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-                key = {k: v for k, v in zip(key_fields, key_values)}
-
-                # Get entity record
-                result = await client.get_entity_by_key(entity_name, key, options)  # type: ignore
+                # FOClient now handles:
+                # - Schema lookup via get_public_entity_schema_by_entityset()
+                # - Entity validation (raises FOClientError if not found)
+                # - Schema-aware key encoding via QueryBuilder
+                result = await client.get_entity(entity_name, key, options)
 
                 return {"entityName": entity_name, "key": key, "data": result}
 
             except Exception as e:
                 logger.error(f"Get entity record failed: {e}")
-                return {"error": str(e), "entityName": entity_name, "key_fields": key_fields, "key_values": key_values, "key": key}
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
+                return {
+                    "error": str(e),
+                    "entityName": entity_name,
+                    "key_fields": key_fields,
+                    "key_values": key_values,
+                    "key": key,
+                }
 
         @self.mcp.tool()
         async def d365fo_create_entity_record(
@@ -155,10 +180,12 @@ class CrudToolsMixin(BaseToolsMixin):
             try:
                 client = await self._get_client(profile)
 
-                # Create entity record
-                result = await client.create_entity(
-                    entity_name, data
-                )
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - OData serialization via crud_ops
+                result = await client.create_entity(entity_name, data)
 
                 return {
                     "entityName": entity_name,
@@ -193,18 +220,27 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with update result
             """
             try:
-                client = await self._get_client(profile)
-
-                # Construct key field=value mapping
+                # Validate key_fields and key_values match
                 if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                        "updated": False,
+                    }
+
+                # Build key dict
                 key = {k: v for k, v in zip(key_fields, key_values)}
 
-                # Update entity record
-                result = await client.update_entity(
-                    entity_name, key, data
-                )
+                client = await self._get_client(profile)
+
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - Schema-aware key encoding via QueryBuilder
+                result = await client.update_entity(entity_name, key, data)
 
                 return {
                     "entityName": entity_name,
@@ -215,10 +251,19 @@ class CrudToolsMixin(BaseToolsMixin):
 
             except Exception as e:
                 logger.error(f"Update entity record failed: {e}")
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
                 return {
                     "error": str(e),
                     "entityName": entity_name,
-                    "key": key, # type: ignore
+                    "key": key,
                     "updated": False,
                 }
 
@@ -227,7 +272,7 @@ class CrudToolsMixin(BaseToolsMixin):
             entity_name: str,
             key_fields: List[str],
             key_values: List[str],
-            profile: str = "default"
+            profile: str = "default",
         ) -> dict:
             """Delete a record from a D365 Finance & Operations data entity.
 
@@ -241,35 +286,55 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with deletion result
             """
             try:
-                client = await self._get_client(profile)
-
-                # Construct key field=value mapping
+                # Validate key_fields and key_values match
                 if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                        "deleted": False,
+                    }
+
+                # Build key dict
                 key = {k: v for k, v in zip(key_fields, key_values)}
 
-                # Delete entity record
+                client = await self._get_client(profile)
+
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - Schema-aware key encoding via QueryBuilder
                 await client.delete_entity(entity_name, key)
 
                 return {"entityName": entity_name, "key": key, "deleted": True}
 
             except Exception as e:
                 logger.error(f"Delete entity record failed: {e}")
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
                 return {
                     "error": str(e),
                     "entityName": entity_name,
-                    "key": key, # type: ignore
+                    "key": key,
                     "deleted": False,
                 }
 
         @self.mcp.tool()
         async def d365fo_call_action(
             action_name: str,
-            entity_name: str = None,# type: ignore
-            parameters: dict = None,# type: ignore
-            key_fields: List[str] = None,# type: ignore
-            key_values: List[str] = None,# type: ignore
+            entity_name: str = None,  # type: ignore
+            parameters: dict = None,  # type: ignore
+            key_fields: List[str] = None,  # type: ignore
+            key_values: List[str] = None,  # type: ignore
             profile: str = "default",
         ) -> dict:
             """Execute an OData action method in D365 Finance & Operations.
@@ -297,15 +362,91 @@ class CrudToolsMixin(BaseToolsMixin):
                     key = {k: v for k, v in zip(key_fields, key_values)}
 
                 result = await client.call_action(
-                    action_name=action_name,# type: ignore
+                    action_name=action_name,  # type: ignore
                     parameters=parameters or {},
                     entity_name=entity_name,
                     entity_key=key,
-                    
                 )
 
                 return {"actionName": action_name, "success": True, "result": result}
 
             except Exception as e:
                 logger.error(f"Call action failed: {e}")
-                return {"error": str(e), "actionName": action_name, "success": False}
+                return {"error": str(e), "actionName": action_name, "success": False}
+
+        @self.mcp.tool()
+        async def d365fo_call_json_service(
+            service_group: str,
+            service_name: str,
+            operation_name: str,
+            parameters: Optional[dict] = None,
+            profile: str = "default",
+        ) -> dict:
+            """Call a D365 F&O JSON service endpoint using the /api/services pattern.
+
+            This provides a generic way to invoke any JSON service operation in D365 F&O.
+
+            Args:
+                service_group: Service group name (e.g., 'SysSqlDiagnosticService')
+                service_name: Service name (e.g., 'SysSqlDiagnosticServiceOperations')
+                operation_name: Operation name (e.g., 'GetAxSqlExecuting')
+                parameters: Optional parameters to send in the POST body
+                profile: Configuration profile to use
+
+            Returns:
+                Dictionary with service response data and metadata
+
+            Example:
+                Call a service without parameters:
+                {
+                    "service_group": "SysSqlDiagnosticService",
+                    "service_name": "SysSqlDiagnosticServiceOperations",
+                    "operation_name": "GetAxSqlExecuting"
+                }
+
+                Call a service with parameters:
+                {
+                    "service_group": "SysSqlDiagnosticService",
+                    "service_name": "SysSqlDiagnosticServiceOperations",
+                    "operation_name": "GetAxSqlResourceStats",
+                    "parameters": {
+                        "start": "2023-01-01T00:00:00Z",
+                        "end": "2023-01-02T00:00:00Z"
+                    }
+                }
+            """
+            try:
+                client = await self._get_client(profile)
+
+                # Call the JSON service
+                response = await client.post_json_service(
+                    service_group=service_group,
+                    service_name=service_name,
+                    operation_name=operation_name,
+                    parameters=parameters,
+                )
+
+                # Format response
+                result = {
+                    "success": response.success,
+                    "statusCode": response.status_code,
+                    "data": response.data,
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }
+
+                if response.error_message:
+                    result["errorMessage"] = response.error_message
+
+                return result
+
+            except Exception as e:
+                logger.error(f"JSON service call failed: {e}")
+                return {
+                    "success": False,
+                    "error": str(e),
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }

d365fo_client/mcp/server.py

@@ -25,7 +25,7 @@ from .resources import (
     MetadataResourceHandler,
     QueryResourceHandler,
 )
-from .tools import ConnectionTools, CrudTools, DatabaseTools, LabelTools, MetadataTools, ProfileTools, SyncTools
+from .tools import ConnectionTools, CrudTools, DatabaseTools, JsonServiceTools, LabelTools, MetadataTools, ProfileTools, SyncTools
 
 logger = logging.getLogger(__name__)
 
@@ -59,6 +59,7 @@ class D365FOMCPServer:
         self.profile_tools = ProfileTools(self.client_manager)
         self.database_tools = DatabaseTools(self.client_manager)
         self.sync_tools = SyncTools(self.client_manager)
+        self.json_service_tools = JsonServiceTools(self.client_manager)
 
         # Tool registry for execution
         self.tool_registry = {}
@@ -222,6 +223,10 @@ class D365FOMCPServer:
                 sync_tools = self.sync_tools.get_tools()
                 tools.extend(sync_tools)
 
+                # Add JSON service tools
+                json_service_tools = self.json_service_tools.get_tools()
+                tools.extend(json_service_tools)
+
                 # Register tools for execution
                 for tool in tools:
                     self.tool_registry[tool.name] = tool
@@ -327,6 +332,10 @@ class D365FOMCPServer:
                     return await self.sync_tools.execute_list_sync_sessions(arguments)
                 elif name == "d365fo_get_sync_history":
                     return await self.sync_tools.execute_get_sync_history(arguments)
+                elif name == "d365fo_call_json_service":
+                    return await self.json_service_tools.execute_call_json_service(arguments)
+                elif name == "d365fo_call_sql_diagnostic_service":
+                    return await self.json_service_tools.execute_call_sql_diagnostic_service(arguments)
                 else:
                     raise ValueError(f"Unknown tool: {name}")