neuroglia-python 0.6.18__tar.gz → 0.6.21__tar.gz

{neuroglia_python-0.6.18 → neuroglia_python-0.6.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroglia-python
-Version: 0.6.18
+Version: 0.6.21
 Summary: Port from .NET to Python of the Neuroglia Framework
 License: Apache
 License-File: LICENSE

{neuroglia_python-0.6.18 → neuroglia_python-0.6.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.6.18"
+version = "0.6.21"
 description = "Port from .NET to Python of the Neuroglia Framework"
 authors = ["Charles d'Avernas <charles.davernas@neuroglia.io>", "Bruno van de Werve <bvandewe@gmail.com>"]
 license = "Apache"

{neuroglia_python-0.6.18 → neuroglia_python-0.6.21}/src/neuroglia/data/infrastructure/event_sourcing/__init__.py

@@ -4,14 +4,16 @@ Event sourcing infrastructure for Neuroglia.
 Provides event store implementations and aggregate root support.
 """
 
+# Apply runtime patches for third-party library bugs
+from . import patches  # noqa: F401
 from .abstractions import (
-    EventStore,
-    EventRecord,
+    Aggregator,
     EventDescriptor,
+    EventRecord,
+    EventStore,
+    EventStoreOptions,
     StreamDescriptor,
     StreamReadDirection,
-    EventStoreOptions,
-    Aggregator
 )
 from .event_sourcing_repository import EventSourcingRepository
 
@@ -19,9 +21,9 @@ __all__ = [
     "EventStore",
     "EventSourcingRepository",
     "EventRecord",
-    "EventDescriptor", 
+    "EventDescriptor",
     "StreamDescriptor",
     "StreamReadDirection",
     "EventStoreOptions",
     "Aggregator",
-]
+]

{neuroglia_python-0.6.18 → neuroglia_python-0.6.21}/src/neuroglia/data/infrastructure/event_sourcing/event_sourcing_repository.py

@@ -127,7 +127,8 @@ class EventSourcingRepository(Generic[TAggregate, TKey], Repository[TAggregate,
         encoded_events = [self._encode_event(e) for e in events]
         await self._eventstore.append_async(stream_id, encoded_events)
         aggregate.state.state_version = events[-1].aggregate_version
-        aggregate.clear_pending_events()
+        # DON'T clear pending events here - let base class do it after publishing!
+        # aggregate.clear_pending_events()
         return aggregate
 
     async def _do_update_async(self, aggregate: TAggregate) -> TAggregate:
@@ -139,7 +140,8 @@ class EventSourcingRepository(Generic[TAggregate, TKey], Repository[TAggregate,
         encoded_events = [self._encode_event(e) for e in events]
         await self._eventstore.append_async(stream_id, encoded_events, aggregate.state.state_version)
         aggregate.state.state_version = events[-1].aggregate_version
-        aggregate.clear_pending_events()
+        # DON'T clear pending events here - let base class do it after publishing!
+        # aggregate.clear_pending_events()
         return aggregate
 
     async def _do_remove_async(self, id: TKey) -> None:

{neuroglia_python-0.6.18 → neuroglia_python-0.6.21}/src/neuroglia/data/infrastructure/event_sourcing/event_store/event_store.py

@@ -253,7 +253,9 @@ class ESEventStore(EventStore):
                     logging.debug(f"Skipping tombstone event from stream: {e.stream_name}")
                     # Acknowledge tombstone to continue processing
                     if is_persistent:
-                        await subscription.ack(e.id)
+                        # Use ack_id for resolved link events, fall back to id
+                        ack_id = getattr(e, "ack_id", e.id)
+                        await subscription.ack(ack_id)
                     continue
 
                 # Skip system event types (prefixed with $)
@@ -262,7 +264,9 @@ class ESEventStore(EventStore):
                     logging.debug(f"Skipping system event type '{e.type}' from stream: {e.stream_name}")
                     # Acknowledge system event to continue processing
                     if is_persistent:
-                        await subscription.ack(e.id)
+                        # Use ack_id for resolved link events, fall back to id
+                        ack_id = getattr(e, "ack_id", e.id)
+                        await subscription.ack(ack_id)
                     continue
 
                 try:
@@ -271,12 +275,16 @@ class ESEventStore(EventStore):
                     logging.warning(f"Could not decode event with offset '{e.stream_position}' from stream '{e.stream_name}': {ex}")
                     # Acknowledge failed decode to continue processing (don't park/retry invalid events)
                     if is_persistent:
-                        await subscription.ack(e.id)
+                        # Use ack_id for resolved link events, fall back to id
+                        ack_id = getattr(e, "ack_id", e.id)
+                        await subscription.ack(ack_id)
                     continue
 
                 # Convert to AckableEventRecord if subscription supports ack/nack
                 if is_persistent:
-                    event_id = e.id
+                    # Use ack_id for resolved link events (resolveLinktos=true), fall back to id
+                    # This is critical for persistent subscriptions to category streams ($ce-*)
+                    event_id = getattr(e, "ack_id", e.id)
 
                     async def ack_delegate(eid=event_id, sub=subscription):
                         """

neuroglia_python-0.6.21/src/neuroglia/data/infrastructure/event_sourcing/patches.py

@@ -0,0 +1,74 @@
+"""
+Runtime patches for third-party library bugs affecting Neuroglia event sourcing.
+
+This module contains monkey-patches that fix critical bugs in dependencies.
+Patches are applied automatically when this module is imported.
+"""
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def patch_esdbclient_async_subscription_id():
+    """
+    Fix esdbclient bug: AsyncPersistentSubscription.init() doesn't propagate
+    subscription_id to _read_reqs, causing ACKs to be sent with empty subscription ID.
+
+    **Bug Description**:
+    The sync version (PersistentSubscription.__init__) has this line:
+        self._read_reqs.subscription_id = subscription_id.encode()
+
+    But the async version (AsyncPersistentSubscription.init) is missing it!
+    This causes ACKs to fail silently because EventStoreDB doesn't know which
+    subscription the ACK is for.
+
+    **Symptoms**:
+    - Events are redelivered every message_timeout seconds despite being processed
+    - Checkpoint never advances in EventStoreDB
+    - Events eventually get parked after maxRetryCount attempts
+    - Read models may process the same event multiple times
+
+    **Root Cause**:
+    BaseSubscriptionReadReqs.__init__() initializes subscription_id = b"" (empty bytes).
+    The sync version overwrites this with the correct value in __init__, but the async
+    version only sets self._subscription_id without propagating it to _read_reqs.
+
+    **Affected Versions**:
+    - esdbclient: 1.1.7 (and likely all earlier versions with async support)
+    - kurrentdbclient: Likely affected (same codebase, rebranded)
+
+    **Upstream Issue**:
+    Bug report to be filed with esdbclient/kurrentdbclient maintainers.
+
+    **Verification**:
+    After applying this patch, check EventStoreDB admin UI:
+    - Navigate to Persistent Subscriptions → your subscription
+    - lastCheckpointedEventPosition should advance after processing events
+    - totalInFlightMessages should decrease after successful ACKs
+    """
+    try:
+        from esdbclient.persistent import (
+            AsyncPersistentSubscription,  # type: ignore[import-not-found]
+        )
+
+        original_init = AsyncPersistentSubscription.init
+
+        async def patched_init(self) -> None:
+            await original_init(self)
+            # Propagate subscription_id to _read_reqs (missing in esdbclient async version)
+            if hasattr(self, "_subscription_id") and hasattr(self, "_read_reqs"):
+                self._read_reqs.subscription_id = self._subscription_id.encode()
+                log.debug(f"🔧 Patched: propagated subscription_id to _read_reqs: {self._subscription_id}")
+
+        AsyncPersistentSubscription.init = patched_init
+        log.info("🔧 Patched esdbclient AsyncPersistentSubscription.init() to propagate subscription_id")
+
+    except ImportError:
+        log.debug("esdbclient not installed, skipping AsyncPersistentSubscription patch")
+    except Exception as e:
+        log.warning(f"Failed to apply esdbclient AsyncPersistentSubscription patch: {e}")
+
+
+# Auto-apply patches when this module is imported
+patch_esdbclient_async_subscription_id()

neuroglia_python-0.6.21/src/neuroglia/hosting/configuration/data_access_layer.py

@@ -0,0 +1,169 @@
+import inspect
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Optional
+
+from neuroglia.core import ModuleLoader, TypeFinder
+from neuroglia.data.abstractions import AggregateRoot
+from neuroglia.data.infrastructure.event_sourcing.read_model_reconciliator import (
+    ReadModelConciliationOptions,
+    ReadModelReconciliator,
+)
+from neuroglia.data.queries.generic import GetByIdQueryHandler, ListQueryHandler
+from neuroglia.hosting.abstractions import ApplicationBuilderBase, HostedService
+from neuroglia.mediation.mediator import RequestHandler
+
+if TYPE_CHECKING:
+    from neuroglia.data.infrastructure.event_sourcing.event_sourcing_repository import (
+        EventSourcingRepositoryOptions,
+    )
+
+
+class DataAccessLayer:
+    class WriteModel:
+        """Represents a helper class used to configure an application's Write Model DAL
+
+        Supports two configuration patterns:
+        1. Simplified: Pass options directly to constructor
+        2. Custom: Pass custom repository_setup function to configure()
+
+        Examples:
+            # Simple configuration with default options
+            DataAccessLayer.WriteModel().configure(builder, ["domain.entities"])
+
+            # With custom delete mode
+            from neuroglia.data.infrastructure.event_sourcing.abstractions import DeleteMode
+            from neuroglia.data.infrastructure.event_sourcing.event_sourcing_repository import (
+                EventSourcingRepositoryOptions
+            )
+
+            DataAccessLayer.WriteModel(
+                options=EventSourcingRepositoryOptions(delete_mode=DeleteMode.HARD)
+            ).configure(builder, ["domain.entities"])
+
+            # Custom factory (advanced, backwards compatible)
+            def custom_setup(builder_, entity_type, key_type):
+                # Custom configuration logic
+                pass
+            DataAccessLayer.WriteModel().configure(
+                builder, ["domain.entities"], custom_setup
+            )
+        """
+
+        def __init__(self, options: Optional["EventSourcingRepositoryOptions"] = None):
+            """Initialize WriteModel configuration
+
+            Args:
+                options: Optional repository options (e.g., delete_mode).
+                        If not provided, default options will be used.
+            """
+            self._options = options
+
+        def configure(self, builder: ApplicationBuilderBase, modules: list[str], repository_setup: Optional[Callable[[ApplicationBuilderBase, type, type], None]] = None) -> ApplicationBuilderBase:
+            """Configures the application's Write Model DAL, scanning for aggregate root types within the specified modules
+
+            Args:
+                builder (ApplicationBuilderBase): the application builder to configure
+                modules (List[str]): a list containing the names of the modules to scan for aggregate root types
+                repository_setup (Optional[Callable[[ApplicationBuilderBase, Type, Type], None]]):
+                    Optional custom function to setup repositories. If provided, takes precedence over options.
+                    If not provided, uses simplified configuration with options (if any).
+
+            Returns:
+                ApplicationBuilderBase: The configured builder
+
+            Raises:
+                ImportError: If EventSourcingRepository cannot be imported
+            """
+            # If custom setup provided, use it (backwards compatible)
+            if repository_setup is not None:
+                for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                    for aggregate_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and issubclass(cls, AggregateRoot) and not cls == AggregateRoot):
+                        key_type = str  # todo: reflect from DTO base type
+                        repository_setup(builder, aggregate_type, key_type)
+                return builder
+
+            # Otherwise use simplified configuration with options
+            return self._configure_with_options(builder, modules)
+
+        def _configure_with_options(self, builder: ApplicationBuilderBase, modules: list[str]) -> ApplicationBuilderBase:
+            """Configure repositories using simplified options pattern
+
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for aggregates
+
+            Returns:
+                The configured builder
+            """
+            from neuroglia.data.infrastructure.abstractions import Repository
+            from neuroglia.data.infrastructure.event_sourcing.abstractions import (
+                Aggregator,
+                EventStore,
+            )
+            from neuroglia.data.infrastructure.event_sourcing.event_sourcing_repository import (
+                EventSourcingRepository,
+                EventSourcingRepositoryOptions,
+            )
+            from neuroglia.dependency_injection import ServiceProvider
+            from neuroglia.mediation import Mediator
+
+            # Discover and configure each aggregate type
+            for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                for aggregate_type in TypeFinder.get_types(
+                    module,
+                    lambda cls: inspect.isclass(cls) and issubclass(cls, AggregateRoot) and not cls == AggregateRoot,
+                ):
+                    key_type = str  # todo: reflect from DTO base type
+
+                    # Create type-specific options if global options provided
+                    typed_options = None
+                    if self._options:
+                        typed_options = EventSourcingRepositoryOptions[aggregate_type, key_type](  # type: ignore
+                            delete_mode=self._options.delete_mode,
+                            soft_delete_method_name=self._options.soft_delete_method_name,
+                        )
+
+                    # Create factory function with proper closure
+                    def make_factory(et, kt, opts):
+                        def repository_factory(sp: ServiceProvider):
+                            return EventSourcingRepository[et, kt](  # type: ignore
+                                eventstore=sp.get_required_service(EventStore),
+                                aggregator=sp.get_required_service(Aggregator),
+                                mediator=sp.get_service(Mediator),
+                                options=opts,
+                            )
+
+                        return repository_factory
+
+                    # Register repository with factory
+                    builder.services.add_singleton(
+                        Repository[aggregate_type, key_type],  # type: ignore
+                        implementation_factory=make_factory(aggregate_type, key_type, typed_options),
+                    )
+
+            return builder
+
+    class ReadModel:
+        """Represents an helper class used to configure an application's Read Model DAL"""
+
+        @staticmethod
+        def configure(builder: ApplicationBuilderBase, modules: list[str], repository_setup: Callable[[ApplicationBuilderBase, type, type], None]) -> ApplicationBuilderBase:
+            """Configures the application's Read Model DAL, scanning for types marked with the 'queryable' decorator within the specified modules
+
+            Args:
+                builder (ApplicationBuilderBase): the application builder to configure
+                modules (List[str]): a list containing the names of the modules to scan for types decorated with 'queryable'
+                repository_setup (Callable[[ApplicationBuilderBase, Type, Type], None]): a function used to setup the repository for the specified entity and key types
+            """
+            consumer_group = builder.settings.consumer_group
+            if not consumer_group:
+                raise ValueError("Cannot configure Read Model DAL: consumer group not specified in application settings")
+            builder.services.add_singleton(ReadModelConciliationOptions, singleton=ReadModelConciliationOptions(consumer_group))
+            builder.services.add_singleton(HostedService, ReadModelReconciliator)
+            for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                for queryable_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__queryable__")):
+                    key_type = str  # todo: reflect from DTO base type
+                    repository_setup(builder, queryable_type, key_type)
+                    builder.services.add_transient(RequestHandler, GetByIdQueryHandler[queryable_type, key_type])  # type: ignore
+                    builder.services.add_transient(RequestHandler, ListQueryHandler[queryable_type, key_type])  # type: ignore
+            return builder

neuroglia_python-0.6.18/src/neuroglia/hosting/configuration/data_access_layer.py

@@ -1,57 +0,0 @@
-import inspect
-from collections.abc import Callable
-
-from neuroglia.core import ModuleLoader, TypeFinder
-from neuroglia.data.abstractions import AggregateRoot
-from neuroglia.data.infrastructure.event_sourcing.read_model_reconciliator import (
-    ReadModelConciliationOptions,
-    ReadModelReconciliator,
-)
-from neuroglia.data.queries.generic import GetByIdQueryHandler, ListQueryHandler
-from neuroglia.hosting.abstractions import ApplicationBuilderBase, HostedService
-from neuroglia.mediation.mediator import RequestHandler
-
-
-class DataAccessLayer:
-    class WriteModel:
-        """Represents an helper class used to configure an application's Write Model DAL"""
-
-        @staticmethod
-        def configure(builder: ApplicationBuilderBase, modules: list[str], repository_setup: Callable[[ApplicationBuilderBase, type, type], None]) -> ApplicationBuilderBase:
-            """Configures the application's Write Model DAL, scanning for aggregate root types within the specified modules
-
-            Args:
-                builder (ApplicationBuilderBase): the application builder to configure
-                modules (List[str]): a list containing the names of the modules to scan for aggregate root types
-                repository_setup (Callable[[ApplicationBuilderBase, Type, Type], None]): a function used to setup the repository for the specified entity and key types
-            """
-            for module in [ModuleLoader.load(module_name) for module_name in modules]:
-                for aggregate_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and issubclass(cls, AggregateRoot) and not cls == AggregateRoot):
-                    key_type = str  # todo: reflect from DTO base type
-                    repository_setup(builder, aggregate_type, key_type)
-            return builder
-
-    class ReadModel:
-        """Represents an helper class used to configure an application's Read Model DAL"""
-
-        @staticmethod
-        def configure(builder: ApplicationBuilderBase, modules: list[str], repository_setup: Callable[[ApplicationBuilderBase, type, type], None]) -> ApplicationBuilderBase:
-            """Configures the application's Read Model DAL, scanning for types marked with the 'queryable' decorator within the specified modules
-
-            Args:
-                builder (ApplicationBuilderBase): the application builder to configure
-                modules (List[str]): a list containing the names of the modules to scan for types decorated with 'queryable'
-                repository_setup (Callable[[ApplicationBuilderBase, Type, Type], None]): a function used to setup the repository for the specified entity and key types
-            """
-            consumer_group = builder.settings.consumer_group
-            if not consumer_group:
-                raise ValueError("Cannot configure Read Model DAL: consumer group not specified in application settings")
-            builder.services.add_singleton(ReadModelConciliationOptions, singleton=ReadModelConciliationOptions(consumer_group))
-            builder.services.add_singleton(HostedService, ReadModelReconciliator)
-            for module in [ModuleLoader.load(module_name) for module_name in modules]:
-                for queryable_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__queryable__")):
-                    key_type = str  # todo: reflect from DTO base type
-                    repository_setup(builder, queryable_type, key_type)
-                    builder.services.add_transient(RequestHandler, GetByIdQueryHandler[queryable_type, key_type])
-                    builder.services.add_transient(RequestHandler, ListQueryHandler[queryable_type, key_type])
-            return builder