d365fo-client 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

d365fo_client/metadata_v2/database_v2.py

@@ -296,7 +296,6 @@ class DatabaseSchemaV2:
                 language TEXT NOT NULL DEFAULT 'en-US',
                 label_text TEXT,
                 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                expires_at TIMESTAMP,
                 hit_count INTEGER DEFAULT 0,
                 last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 UNIQUE(global_version_id, label_id, language)
@@ -345,7 +344,6 @@ class DatabaseSchemaV2:
             "CREATE INDEX IF NOT EXISTS idx_enumerations_version ON enumerations(global_version_id, name)",
             # Labels indexes
             "CREATE INDEX IF NOT EXISTS idx_labels_version_lookup ON labels_cache(global_version_id, label_id, language)",
-            "CREATE INDEX IF NOT EXISTS idx_labels_expires ON labels_cache(expires_at)",
             # Search performance indexes
             "CREATE INDEX IF NOT EXISTS idx_data_entities_search ON data_entities(global_version_id, data_service_enabled, entity_category)",
             "CREATE INDEX IF NOT EXISTS idx_public_entities_search ON public_entities(global_version_id, is_read_only)",
@@ -544,6 +542,99 @@ class MetadataDatabaseV2:
 
             return stats
 
+    async def get_statistics(self) -> Dict[str, Any]:
+        """Alias for get_database_statistics for backward compatibility
+
+        Returns:
+            Dictionary with database statistics
+        """
+        return await self.get_database_statistics()
+
+    async def get_environment_database_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get database statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped database statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get active global versions for this environment
+            cursor = await db.execute(
+                """SELECT DISTINCT global_version_id 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            active_versions = [row[0] for row in await cursor.fetchall()]
+            
+            if not active_versions:
+                # No active versions, return zero counts
+                return {
+                    "data_entities_count": 0,
+                    "public_entities_count": 0,
+                    "entity_properties_count": 0,
+                    "navigation_properties_count": 0,
+                    "entity_actions_count": 0,
+                    "enumerations_count": 0,
+                    "labels_cache_count": 0,
+                    "environment_statistics": {
+                        "total_environments": 1,
+                        "linked_versions": 0,
+                    },
+                    "database_size_bytes": None,
+                    "database_size_mb": None,
+                }
+
+            # Create placeholders for SQL IN clause
+            version_placeholders = ",".join("?" for _ in active_versions)
+
+            # Environment-scoped metadata counts
+            tables = [
+                ("data_entities", "entities"),
+                ("public_entities", "public_entities"),
+                ("entity_properties", "properties"),
+                ("navigation_properties", "navigation_properties"),
+                ("entity_actions", "actions"),
+                ("enumerations", "enumerations"),
+                ("labels_cache", "labels"),
+            ]
+
+            for table, key in tables:
+                cursor = await db.execute(
+                    f"SELECT COUNT(*) FROM {table} WHERE global_version_id IN ({version_placeholders})",
+                    active_versions
+                )
+                stats[f"{table}_count"] = (await cursor.fetchone())[0]
+
+            # Environment-specific statistics
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(DISTINCT ev.global_version_id) as linked_versions
+                   FROM environment_versions ev
+                   WHERE ev.environment_id = ? AND ev.is_active = 1""",
+                (environment_id,)
+            )
+            env_stats = await cursor.fetchone()
+            stats["environment_statistics"] = {
+                "total_environments": 1,  # Current environment only
+                "linked_versions": env_stats[0] or 0,
+            }
+
+            # Database file size (shared across all environments)
+            try:
+                db_size = self.db_path.stat().st_size
+                stats["database_size_bytes"] = db_size
+                stats["database_size_mb"] = round(db_size / (1024 * 1024), 2)
+            except Exception:
+                stats["database_size_bytes"] = None
+                stats["database_size_mb"] = None
+
+            return stats
+
     async def vacuum_database(self) -> bool:
         """Vacuum database to reclaim space
 

d365fo_client/metadata_v2/global_version_manager.py

@@ -571,3 +571,63 @@ class GlobalVersionManager:
             }
 
             return stats
+
+    async def get_environment_version_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get version statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped version statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get versions for this specific environment
+            cursor = await db.execute(
+                """SELECT COUNT(DISTINCT global_version_id) 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            stats["total_versions"] = (await cursor.fetchone())[0]
+
+            # This environment only
+            stats["total_environments"] = 1
+
+            # Reference statistics for this environment's versions
+            cursor = await db.execute(
+                """SELECT 
+                     SUM(gv.reference_count) as total_references,
+                     AVG(gv.reference_count) as avg_references,
+                     MAX(gv.reference_count) as max_references,
+                     COUNT(*) as versions_with_refs
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1 AND gv.reference_count > 0""",
+                (environment_id,)
+            )
+            ref_stats = await cursor.fetchone()
+            stats["reference_statistics"] = {
+                "total_references": ref_stats[0] or 0,
+                "avg_references": round(ref_stats[1] or 0, 2),
+                "max_references": ref_stats[2] or 0,
+                "versions_with_references": ref_stats[3] or 0,
+            }
+
+            # Version age statistics for this environment
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(*) as recent_versions
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1
+                   AND gv.last_used_at >= datetime('now', '-7 days')""",
+                (environment_id,)
+            )
+            stats["recent_activity"] = {
+                "versions_used_last_7_days": (await cursor.fetchone())[0]
+            }
+
+            return stats

d365fo_client/metadata_v2/label_utils.py

@@ -0,0 +1,107 @@
+"""Label processing utilities for metadata v2.
+
+This module provides utilities for processing D365 Finance & Operations labels
+with fallback logic for when label_id doesn't start with '@'.
+
+The main principle is:
+- If label_text is already set, preserve it
+- If label_id doesn't start with '@', it's already display text - use it as label_text  
+- If label_id starts with '@', it's a label reference that needs API resolution
+
+This ensures that direct text labels (like "Customer Groups") are properly
+converted to label_text, while label references (like "@SYS123") are preserved
+for later resolution through the label API.
+
+Functions:
+    process_label_fallback: Core label processing logic
+    process_data_entity_labels: Process DataEntityInfo labels
+    process_public_entity_labels: Process PublicEntityInfo and property labels
+    process_enumeration_labels: Process EnumerationInfo and member labels
+    apply_label_fallback: Alias for process_label_fallback (retrieval context)
+"""
+
+from typing import Optional
+
+from ..models import DataEntityInfo, EnumerationInfo, PublicEntityInfo
+
+
+def process_label_fallback(label_id: Optional[str], label_text: Optional[str]) -> Optional[str]:
+    """Process label text with fallback to label_id when it doesn't start with '@'
+    
+    This function implements the core logic for handling D365 F&O labels where:
+    - If label_text is already set, use it
+    - If label_id doesn't start with '@', it's already display text
+    - If label_id starts with '@', it needs resolution via label API
+    
+    Args:
+        label_id: Label identifier (may be actual text or @-prefixed ID)
+        label_text: Existing label text (may be None)
+        
+    Returns:
+        Processed label text with fallback applied
+    """
+    # If label_text is already set, use it
+    if label_text:
+        return label_text
+    
+    # If label_id doesn't start with '@', it's already the text
+    if label_id and not label_id.startswith('@'):
+        return label_id
+    
+    # Return None for @-prefixed labels without resolved text
+    return None
+
+
+def process_data_entity_labels(entity: DataEntityInfo) -> DataEntityInfo:
+    """Process data entity labels with fallback logic
+    
+    Args:
+        entity: Data entity info to process
+        
+    Returns:
+        Processed data entity info with label fallback applied
+    """
+    entity.label_text = process_label_fallback(entity.label_id, entity.label_text)
+    return entity
+
+
+def process_public_entity_labels(entity: PublicEntityInfo) -> PublicEntityInfo:
+    """Process public entity labels with fallback logic
+    
+    Args:
+        entity: Public entity info to process
+        
+    Returns:
+        Processed public entity info with label fallback applied
+    """
+    # Process entity label
+    entity.label_text = process_label_fallback(entity.label_id, entity.label_text)
+    
+    # Process property labels
+    for prop in entity.properties:
+        prop.label_text = process_label_fallback(prop.label_id, prop.label_text)
+    
+    return entity
+
+
+def process_enumeration_labels(enumeration: EnumerationInfo) -> EnumerationInfo:
+    """Process enumeration labels with fallback logic
+    
+    Args:
+        enumeration: Enumeration info to process
+        
+    Returns:
+        Processed enumeration info with label fallback applied
+    """
+    # Process enumeration label
+    enumeration.label_text = process_label_fallback(enumeration.label_id, enumeration.label_text)
+    
+    # Process member labels
+    for member in enumeration.members:
+        member.label_text = process_label_fallback(member.label_id, member.label_text)
+    
+    return enumeration
+
+
+# Alias for backward compatibility during data retrieval
+apply_label_fallback = process_label_fallback

d365fo_client/metadata_v2/sync_manager_v2.py

@@ -1,13 +1,11 @@
 """Smart sync manager with intelligent metadata synchronization strategies."""
 
-import asyncio
 import hashlib
 import json
 import logging
 import time
 from datetime import datetime, timezone
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional
 
 # Use TYPE_CHECKING to avoid circular import
 if TYPE_CHECKING:
@@ -19,7 +17,6 @@ from ..models import (
     LabelInfo,
     MetadataVersionInfo,
     PublicEntityInfo,
-    QueryOptions,
     SyncProgress,
     SyncResult,
     SyncStrategy,
@@ -509,14 +506,20 @@ class SmartSyncManagerV2:
         counts = {}
 
         async with aiosqlite.connect(self.cache.db_path) as db:
-            # Copy data entities
+            # Copy data entities with label processing
             await db.execute(
                 """INSERT INTO data_entities
                    (global_version_id, name, public_entity_name, public_collection_name,
                     label_id, label_text, entity_category, data_service_enabled,
                     data_management_enabled, is_read_only)
                    SELECT ?, name, public_entity_name, public_collection_name,
-                          label_id, label_text, entity_category, data_service_enabled,
+                          label_id, 
+                          CASE 
+                              WHEN label_text IS NOT NULL AND label_text != '' THEN label_text
+                              WHEN label_id IS NOT NULL AND label_id != '' AND NOT label_id LIKE '@%' THEN label_id
+                              ELSE label_text
+                          END as processed_label_text,
+                          entity_category, data_service_enabled,
                           data_management_enabled, is_read_only
                    FROM data_entities
                    WHERE global_version_id = ?""",
@@ -524,19 +527,90 @@ class SmartSyncManagerV2:
             )
             counts["entities"] = db.total_changes
 
-            # Copy enumerations
+            # Copy enumerations with label processing
             await db.execute(
                 """INSERT INTO enumerations
                    (global_version_id, name, label_id, label_text)
-                   SELECT ?, name, label_id, label_text
+                   SELECT ?, name, label_id,
+                          CASE 
+                              WHEN label_text IS NOT NULL AND label_text != '' THEN label_text
+                              WHEN label_id IS NOT NULL AND label_id != '' AND NOT label_id LIKE '@%' THEN label_id
+                              ELSE label_text
+                          END as processed_label_text
                    FROM enumerations
                    WHERE global_version_id = ?""",
                 (target_version_id, source_version_id),
             )
             counts["enumerations"] = db.total_changes
 
+            # Copy public entities with label processing
+            await db.execute(
+                """INSERT INTO public_entities
+                   (global_version_id, name, entity_set_name, label_id, label_text,
+                    is_read_only, configuration_enabled)
+                   SELECT ?, name, entity_set_name, label_id,
+                          CASE 
+                              WHEN label_text IS NOT NULL AND label_text != '' THEN label_text
+                              WHEN label_id IS NOT NULL AND label_id != '' AND NOT label_id LIKE '@%' THEN label_id
+                              ELSE label_text
+                          END as processed_label_text,
+                          is_read_only, configuration_enabled
+                   FROM public_entities
+                   WHERE global_version_id = ?""",
+                (target_version_id, source_version_id),
+            )
+
+            # Copy entity properties with label processing
+            # Note: We need to get the new entity IDs for the relationships
+            await db.execute(
+                """INSERT INTO entity_properties
+                   (entity_id, global_version_id, name, type_name, data_type,
+                    odata_xpp_type, label_id, label_text, is_key, is_mandatory,
+                    configuration_enabled, allow_edit, allow_edit_on_create,
+                    is_dimension, dimension_relation, is_dynamic_dimension,
+                    dimension_legal_entity_property, dimension_type_property,
+                    property_order)
+                   SELECT pe_new.id as entity_id, ?, ep.name, ep.type_name, ep.data_type,
+                          ep.odata_xpp_type, ep.label_id,
+                          CASE 
+                              WHEN ep.label_text IS NOT NULL AND ep.label_text != '' THEN ep.label_text
+                              WHEN ep.label_id IS NOT NULL AND ep.label_id != '' AND NOT ep.label_id LIKE '@%' THEN ep.label_id
+                              ELSE ep.label_text
+                          END as processed_label_text,
+                          ep.is_key, ep.is_mandatory,
+                          ep.configuration_enabled, ep.allow_edit, ep.allow_edit_on_create,
+                          ep.is_dimension, ep.dimension_relation, ep.is_dynamic_dimension,
+                          ep.dimension_legal_entity_property, ep.dimension_type_property,
+                          ep.property_order
+                   FROM entity_properties ep
+                   JOIN public_entities pe_old ON ep.entity_id = pe_old.id
+                   JOIN public_entities pe_new ON pe_new.name = pe_old.name AND pe_new.global_version_id = ?
+                   WHERE ep.global_version_id = ?""",
+                (target_version_id, target_version_id, source_version_id),
+            )
+
+            # Copy enumeration members with label processing  
+            await db.execute(
+                """INSERT INTO enumeration_members
+                   (enumeration_id, global_version_id, name, value,
+                    label_id, label_text, configuration_enabled, member_order)
+                   SELECT e_new.id as enumeration_id, ?, em.name, em.value,
+                          em.label_id,
+                          CASE 
+                              WHEN em.label_text IS NOT NULL AND em.label_text != '' THEN em.label_text
+                              WHEN em.label_id IS NOT NULL AND em.label_id != '' AND NOT em.label_id LIKE '@%' THEN em.label_id
+                              ELSE em.label_text
+                          END as processed_label_text,
+                          em.configuration_enabled, em.member_order
+                   FROM enumeration_members em
+                   JOIN enumerations e_old ON em.enumeration_id = e_old.id
+                   JOIN enumerations e_new ON e_new.name = e_old.name AND e_new.global_version_id = ?
+                   WHERE em.global_version_id = ?""",
+                (target_version_id, target_version_id, source_version_id),
+            )
+
             # Copy other metadata tables as needed...
-            # This is a simplified implementation
+            # This is a more comprehensive implementation with label processing
 
             await db.commit()
 

d365fo_client/models.py

@@ -4,7 +4,7 @@ import hashlib
 import json
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from enum import Enum
+from enum import Enum, StrEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
@@ -14,7 +14,16 @@ if TYPE_CHECKING:
     from typing import ForwardRef
 
 
-class EntityCategory(Enum):
+def _ensure_str_for_json(field):
+    """Ensure field is JSON-serializable as string.
+    
+    StrEnum fields automatically serialize as strings, but this handles
+    the edge case where a field might be None or already a string.
+    """
+    return field  # StrEnum automatically converts to string, None stays None
+
+
+class EntityCategory(StrEnum):
     """D365 F&O Entity Categories"""
 
     MASTER = "Master"
@@ -25,7 +34,7 @@ class EntityCategory(Enum):
     PARAMETERS = "Parameters"
 
 
-class ODataXppType(Enum):
+class ODataXppType(StrEnum):
     """D365 F&O OData XPP Types"""
 
     CONTAINER = "Container"
@@ -42,7 +51,7 @@ class ODataXppType(Enum):
     VOID = "Void"
 
 
-class ODataBindingKind(Enum):
+class ODataBindingKind(StrEnum):
     """D365 F&O Action Binding Types"""
 
     BOUND_TO_ENTITY_INSTANCE = "BoundToEntityInstance"
@@ -50,7 +59,7 @@ class ODataBindingKind(Enum):
     UNBOUND = "Unbound"
 
 
-class SyncStrategy(Enum):
+class SyncStrategy(StrEnum):
     """Metadata synchronization strategies"""
 
     FULL = "full"
@@ -59,7 +68,7 @@ class SyncStrategy(Enum):
     SHARING_MODE = "sharing_mode"
 
 
-class Cardinality(Enum):
+class Cardinality(StrEnum):
     """Navigation Property Cardinality"""
 
     SINGLE = "Single"
@@ -191,7 +200,7 @@ class PublicEntityActionInfo:
     def to_dict(self) -> Dict[str, Any]:
         return {
             "name": self.name,
-            "binding_kind": self.binding_kind.value,  # Convert enum to string value
+            "binding_kind": self.binding_kind,  # StrEnum automatically serializes as string
             "parameters": [param.to_dict() for param in self.parameters],
             "return_type": self.return_type.to_dict() if self.return_type else None,
             "field_lookup": self.field_lookup,
@@ -221,7 +230,7 @@ class DataEntityInfo:
             "label_text": self.label_text,
             "data_service_enabled": self.data_service_enabled,
             "data_management_enabled": self.data_management_enabled,
-            "entity_category": self.entity_category,
+            "entity_category": self.entity_category,  # StrEnum automatically serializes as string
             "is_read_only": self.is_read_only,
         }
 
@@ -438,7 +447,7 @@ class NavigationPropertyInfo:
             "name": self.name,
             "related_entity": self.related_entity,
             "related_relation_name": self.related_relation_name,
-            "cardinality": self.cardinality.value,  # Convert enum to string value
+            "cardinality": self.cardinality,  # StrEnum automatically serializes as string
             "constraints": [constraint.to_dict() for constraint in self.constraints],
         }
 
@@ -503,7 +512,7 @@ class ActionInfo:
     def to_dict(self) -> Dict[str, Any]:
         return {
             "name": self.name,
-            "binding_kind": self.binding_kind,
+            "binding_kind": self.binding_kind,  # StrEnum automatically serializes as string
             "entity_name": self.entity_name,
             "entity_set_name": self.entity_set_name,
             "parameters": [param.to_dict() for param in self.parameters],

d365fo_client/output.py

@@ -163,19 +163,19 @@ class OutputFormatter:
 
 def format_success_message(message: str) -> str:
     """Format a success message with checkmark."""
-    return f"✅ {message}"
+    return f"[OK] {message}"
 
 
 def format_error_message(message: str) -> str:
     """Format an error message with X mark."""
-    return f"❌ {message}"
+    return f"[ERROR] {message}"
 
 
 def format_info_message(message: str) -> str:
     """Format an info message with info icon."""
-    return f"ℹ️  {message}"
+    return f"[INFO] {message}"
 
 
 def format_warning_message(message: str) -> str:
     """Format a warning message with warning icon."""
-    return f"⚠️  {message}"
+    return f"[WARNING] {message}"

d365fo_client/profile_manager.py

@@ -195,6 +195,18 @@ class ProfileManager:
             logger.error(f"Error getting default profile: {e}")
             return None
 
+    def reload_config(self) -> None:
+        """Reload configuration from file.
+        
+        This is useful when profiles have been modified and we need
+        to refresh the in-memory configuration data.
+        """
+        try:
+            self.config_manager.reload_config()
+            logger.debug("Reloaded profile configuration")
+        except Exception as e:
+            logger.error(f"Error reloading configuration: {e}")
+
     def set_default_profile(self, profile_name: str) -> bool:
         """Set the default profile.
 

{d365fo_client-0.1.0.dist-info → d365fo_client-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d365fo-client
-Version: 0.1.0
+Version: 0.2.2
 Summary: Microsoft Dynamics 365 Finance & Operations client
 Author-email: Muhammad Afzaal <mo@thedataguy.pro>
 License-Expression: MIT
@@ -911,6 +911,8 @@ Add to your VS Code `mcp.json` for GitHub Copilot with MCP:
       "type": "stdio",
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {
@@ -932,6 +934,8 @@ For environments requiring service principal authentication:
       "type": "stdio", 
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {