neuroglia-python 0.6.15__tar.gz → 0.6.16__tar.gz

{neuroglia_python-0.6.15 → neuroglia_python-0.6.16}/PKG-INFO

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

{neuroglia_python-0.6.15 → neuroglia_python-0.6.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.6.15"
+version = "0.6.16"
 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.15 → neuroglia_python-0.6.16}/src/neuroglia/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
 ]
 
 # Framework metadata
-__version__ = "0.6.15"
+__version__ = "0.6.16"
 __author__ = "Neuroglia Team"
 __email__ = "team@neuroglia.io"
 __license__ = "Apache"

{neuroglia_python-0.6.15 → neuroglia_python-0.6.16}/src/neuroglia/data/infrastructure/event_sourcing/abstractions.py

@@ -109,11 +109,11 @@ class AckableEventRecord(EventRecord):
 
     async def ack_async(self) -> None:
         """Acks the event record"""
-        self._ack_delegate()
+        await self._ack_delegate()
 
     async def nack_async(self) -> None:
         """Nacks the event record"""
-        self._nack_delegate()
+        await self._nack_delegate()
 
 
 class StreamReadDirection(Enum):

{neuroglia_python-0.6.15 → neuroglia_python-0.6.16}/src/neuroglia/data/infrastructure/event_sourcing/event_store/event_store.py

@@ -1,11 +1,12 @@
+import asyncio
 import inspect
 import logging
 import sys
-import threading
 from typing import Any, Dict, Optional
 
 import rx
-from esdbclient import EventStoreDBClient, NewEvent, RecordedEvent, StreamState
+from esdbclient import AsyncioEventStoreDBClient as AsyncClientFactory
+from esdbclient import NewEvent, RecordedEvent, StreamState
 from esdbclient.exceptions import AlreadyExists
 from rx.core.observable.observable import Observable
 from rx.disposable.disposable import Disposable
@@ -35,7 +36,10 @@ class ESEventStore(EventStore):
     _eventstore_options: EventStoreOptions
     """ Gets the options used to configure the EventStore """
 
-    _eventstore_client: EventStoreDBClient
+    _connection_string: str
+    """ Gets the connection string for EventStoreDB """
+
+    _eventstore_client: Optional[Any]  # _AsyncioEventStoreDBClient
     """ Gets the service used to interact with the EventStore DB"""
 
     _serializer: JsonSerializer
@@ -44,17 +48,34 @@ class ESEventStore(EventStore):
     def __init__(
         self,
         options: EventStoreOptions,
-        eventstore_client: EventStoreDBClient,
+        connection_string_or_client: str | Any,  # Can be connection string or pre-initialized client (for testing)
         serializer: JsonSerializer,
     ):
         self._eventstore_options = options
-        self._eventstore_client = eventstore_client
         self._serializer = serializer
 
+        # Check if we got a connection string or an already-initialized client
+        if isinstance(connection_string_or_client, str):
+            self._connection_string = connection_string_or_client
+            self._eventstore_client = None  # Will be lazily initialized
+        else:
+            # Pre-initialized client (typically for testing)
+            self._connection_string = None
+            self._eventstore_client = connection_string_or_client
+
+    async def _ensure_client(self) -> Any:
+        """Lazily initialize the async EventStoreDB client on first use"""
+        if self._eventstore_client is None:
+            if self._connection_string is None:
+                raise RuntimeError("Neither connection string nor client provided")
+            self._eventstore_client = await AsyncClientFactory(uri=self._connection_string)
+        return self._eventstore_client
+
     async def contains_async(self, stream_id: str) -> bool:
         return await self.get_async(stream_id) is not None
 
     async def append_async(self, stream_id: str, events: list[EventDescriptor], expected_version: Optional[int] = None):
+        client = await self._ensure_client()
         if expected_version is not None:
             expected_version = expected_version - 1
         stream_name = self._get_stream_name(stream_id)
@@ -70,31 +91,34 @@ class ESEventStore(EventStore):
                     metadata=bytes(self._serializer.serialize(self._build_event_metadata(e.data, e.metadata))),
                 )
             )
-        self._eventstore_client.append_to_stream(stream_name=stream_name, current_version=stream_state, events=formatted_events)
+        await client.append_to_stream(stream_name=stream_name, current_version=stream_state, events=formatted_events)
 
     async def get_async(self, stream_id: str) -> Optional[StreamDescriptor]:
+        client = await self._ensure_client()
         stream_name = self._get_stream_name(stream_id)
-        metadata, metadata_version = self._eventstore_client.get_stream_metadata(stream_name)
+        metadata, metadata_version = await client.get_stream_metadata(stream_name)
         if metadata_version == StreamState.NO_STREAM:
             return None
         truncate_before = metadata.get("$tb")
         offset = 0 if truncate_before is None else truncate_before
-        read_response = self._eventstore_client.read_stream(
+        read_response = client.read_stream(
             stream_name=stream_name,
             stream_position=offset,
             backwards=False,
             resolve_links=True,
             limit=1,
         )
-        recorded_events = tuple(read_response)
-        read_response = self._eventstore_client.read_stream(
+        recorded_events = [event async for event in read_response]
+        read_response = client.read_stream(
             stream_name=stream_name,
             stream_position=offset,
             backwards=True,
             resolve_links=True,
             limit=1,
         )
-        recorded_events = tuple(read_response)
+        recorded_events = [event async for event in read_response]
+        if not recorded_events:
+            return None
         last_event = recorded_events[0]
         return StreamDescriptor(stream_id, last_event.stream_position, None, None)  # todo: esdbclient does not provide timestamps
 
@@ -105,15 +129,16 @@ class ESEventStore(EventStore):
         offset: int,
         length: Optional[int] = None,
     ) -> list[EventRecord]:
+        client = await self._ensure_client()
         stream_name = self._get_stream_name(stream_id)
-        read_response = self._eventstore_client.read_stream(
+        read_response = client.read_stream(
             stream_name=stream_name,
             stream_position=offset,
             backwards=True if read_direction == StreamReadDirection.BACKWARDS else False,
             resolve_links=True,
             limit=sys.maxsize if length is None else length,
         )
-        recorded_events = tuple(read_response)
+        recorded_events = [event async for event in read_response]
         return [self._decode_recorded_event(stream_id, recorded_event) for recorded_event in recorded_events]
 
     async def observe_async(
@@ -122,36 +147,42 @@ class ESEventStore(EventStore):
         consumer_group: Optional[str] = None,
         offset: Optional[int] = None,
     ) -> Observable:
+        client = await self._ensure_client()
         if stream_id is None:
             raise ValueError("stream_id cannot be None")
         stream_name = self._get_stream_name(stream_id)
         subscription = None
         if consumer_group is None:
             stream_position = offset if offset is not None else 0
-            subscription = self._eventstore_client.subscribe_to_stream(stream_name=stream_name, resolve_links=True, stream_position=stream_position)
+            subscription = client.subscribe_to_stream(stream_name=stream_name, resolve_links=True, stream_position=stream_position)
         else:
             try:
-                self._eventstore_client.create_subscription_to_stream(
+                await client.create_subscription_to_stream(
                     group_name=consumer_group,
                     stream_name=stream_name,
                     resolve_links=True,
                     consumer_strategy="RoundRobin",
+                    # Checkpoint configuration for reliable ACK delivery
                     min_checkpoint_count=1,
                     max_checkpoint_count=1,
+                    # Set message timeout to 60s (default is 30s)
+                    message_timeout=60.0,
                 )
             except AlreadyExists:
                 pass
-            subscription = self._eventstore_client.read_subscription_to_stream(
+            subscription = client.read_subscription_to_stream(
                 group_name=consumer_group,
                 stream_name=stream_name,
             )
         subject = Subject()
-        thread = threading.Thread(
-            target=self._consume_events_async,
-            kwargs={"stream_id": stream_id, "subject": subject, "subscription": subscription},
-        )
-        thread.start()
-        return rx.using(lambda: Disposable(lambda: subscription.stop() if subscription is not None else None), lambda s: subject)
+        # Start async task to consume events
+        asyncio.create_task(self._consume_events_async(stream_id, subject, subscription))
+
+        async def stop_subscription():
+            if subscription is not None:
+                await subscription.stop()
+
+        return rx.using(lambda: Disposable(lambda: asyncio.create_task(stop_subscription())), lambda s: subject)
 
     def _build_event_metadata(self, e: DomainEvent, additional_metadata: Optional[Any]) -> dict[str, Any]:
         module = inspect.getmodule(e)
@@ -200,33 +231,96 @@ class ESEventStore(EventStore):
         """Converts the specified stream id to a qualified stream id, which is prefixed with the current database name, if any"""
         return stream_id if self._eventstore_options.database_name is None or stream_id.startswith("$ce-") else f"{self._eventstore_options.database_name}-{stream_id}"
 
-    def _consume_events_async(self, stream_id: str, subject: Subject, subscription):
-        """Asynchronously enumerate events returned by a subscription"""
+    async def _consume_events_async(self, stream_id: str, subject: Subject, subscription):
+        """
+        Asynchronously enumerate events returned by a subscription using native async iteration.
+
+        With AsyncioEventStoreDBClient, subscriptions are async generators that properly handle
+        gRPC bidirectional streaming. ACKs are sent immediately without queuing issues.
+
+        For persistent subscriptions, events are wrapped in AckableEventRecord with async
+        ack/nack delegates that directly call the subscription's async methods.
+        """
+        # Check if this is a persistent subscription (has ack/nack methods)
+        is_persistent = hasattr(subscription, "ack") and hasattr(subscription, "nack")
+
         try:
             e: RecordedEvent
-            for e in subscription:
+            async for e in subscription:
+                # Skip tombstone events (streams prefixed with $$)
+                # Tombstones are created by EventStoreDB when streams are hard-deleted
+                if e.stream_name.startswith("$$"):
+                    logging.debug(f"Skipping tombstone event from stream: {e.stream_name}")
+                    # Acknowledge tombstone to continue processing
+                    if is_persistent:
+                        await subscription.ack(e.id)
+                    continue
+
+                # Skip system event types (prefixed with $)
+                # System events are internal EventStoreDB metadata events
+                if e.type.startswith("$"):
+                    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)
+                    continue
+
                 try:
                     decoded_event = self._decode_recorded_event(stream_id, e)
                 except Exception as ex:
-                    logging.error(f"An exception occurred while decoding event with offset '{e.stream_position}' from stream '{e.stream_name}': {ex}")
-                    # Negative acknowledge (park) on decoding failure
-                    if hasattr(subscription, "nack"):
-                        subscription.nack(e.id, action="park")
-                    raise
+                    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)
+                    continue
 
                 # Convert to AckableEventRecord if subscription supports ack/nack
-                if hasattr(subscription, "ack") and hasattr(subscription, "nack"):
+                if is_persistent:
                     event_id = e.id
-                    ackable_event = AckableEventRecord(stream_id=decoded_event.stream_id, id=decoded_event.id, offset=decoded_event.offset, position=decoded_event.position, timestamp=decoded_event.timestamp, type=decoded_event.type, data=decoded_event.data, metadata=decoded_event.metadata, replayed=decoded_event.replayed, _ack_delegate=lambda eid=event_id: subscription.ack(eid), _nack_delegate=lambda eid=event_id, action="retry": subscription.nack(eid, action=action))
+
+                    async def ack_delegate(eid=event_id, sub=subscription):
+                        """
+                        Acknowledge event to EventStoreDB persistent subscription.
+
+                        With async API, ACKs are sent immediately through the gRPC stream.
+                        """
+                        await sub.ack(eid)
+                        logging.debug(f"ACK sent for event: {eid}")
+
+                    async def nack_delegate(eid=event_id, sub=subscription, action="retry"):
+                        """
+                        Negative acknowledge event with specified action.
+
+                        Actions:
+                        - "retry": Retry event delivery (default)
+                        - "park": Move event to parked messages
+                        - "skip": Skip event without retry
+                        """
+                        await sub.nack(eid, action=action)
+                        logging.debug(f"NACK sent for event: {eid} with action: {action}")
+
+                    ackable_event = AckableEventRecord(
+                        stream_id=decoded_event.stream_id,
+                        id=decoded_event.id,
+                        offset=decoded_event.offset,
+                        position=decoded_event.position,
+                        timestamp=decoded_event.timestamp,
+                        type=decoded_event.type,
+                        data=decoded_event.data,
+                        metadata=decoded_event.metadata,
+                        replayed=decoded_event.replayed,
+                        _ack_delegate=ack_delegate,
+                        _nack_delegate=nack_delegate,
+                    )
                     subject.on_next(ackable_event)
                 else:
-                    # No ack/nack support, send regular EventRecord
+                    # No ack/nack support (catchup subscription), send regular EventRecord
                     subject.on_next(decoded_event)
 
             subject.on_completed()
         except Exception as ex:
-            logging.error(f"An exception occurred while consuming events from stream '{stream_id}', consequently to which the related subscription will be stopped: {ex}")  # todo: improve feedback
-            subscription.stop()
+            logging.error(f"An exception occurred while consuming events from stream '{stream_id}': {ex}")
+            await subscription.stop()
 
     async def delete_async(self, stream_id: str) -> None:
         """
@@ -241,10 +335,11 @@ class ESEventStore(EventStore):
         Raises:
             Exception: If the stream does not exist or deletion fails
         """
+        client = await self._ensure_client()
         stream_name = self._get_stream_name(stream_id)
         try:
             # Delete the stream from EventStoreDB
-            self._eventstore_client.delete_stream(stream_name=stream_name, current_version=StreamState.ANY)
+            await client.delete_stream(stream_name=stream_name, current_version=StreamState.ANY)
         except Exception as ex:
             raise Exception(f"Failed to delete stream '{stream_name}': {ex}") from ex
 
@@ -253,14 +348,24 @@ class ESEventStore(EventStore):
         """Registers and configures an EventStore implementation of the EventStore class.
 
         Args:
-            services (ServiceCollection): the service collection to configure
+            builder: The application builder to configure
+            options: EventStore configuration options
         """
         connection_string_name = "eventstore"
         connection_string = builder.settings.connection_strings.get(connection_string_name, None)
         if connection_string is None:
             raise Exception(f"Missing '{connection_string_name}' connection string")
+
+        # Register dependencies
         builder.services.try_add_singleton(Aggregator)
         builder.services.try_add_singleton(EventStoreOptions, singleton=options)
-        builder.services.try_add_singleton(EventStoreDBClient, singleton=EventStoreDBClient(uri=connection_string))
-        builder.services.try_add_singleton(EventStore, ESEventStore)
+
+        # Factory function to create ESEventStore with connection string
+        def create_event_store(service_provider) -> ESEventStore:
+            from neuroglia.serialization.json import JsonSerializer
+
+            serializer = service_provider.get_service(JsonSerializer)
+            return ESEventStore(options, connection_string, serializer)
+
+        builder.services.try_add_singleton(EventStore, factory=create_event_store)
         return builder