feat: Upgrade to latest version of eventsourcingdb (#56)

* test: upgrade test to latest version of eventsourcingdb

* style: some linting and remove comments

* fix: QA linting issues

* fix: linting issues

* fix: ping issue. reponse has changed

* fix: linting issue in start_local_http_server.py

* fix: default port expose in containerized_testing_database.py

* fix: linting in container.py

* fix: linting in container.py

* fix: linting container.py

* fix: linting in container.py

* feat: modify the schema by using item. Remove the function is_item. Not needed anymore. Payload has changed.

* feat: change lower_bound_id and upper_bound_id to lower_bound and upper_bound

* feat: test changed for lowerbound and upperbound

* feat: change valdiation issues with LowerBound and UpperBound changes to object

* feat: update " and ' in lower_bound.py and upper_bound.py

* feat: modify lower_bound and upper_bound validation

* style:

* merge-conflict

* fix: merge conflict

* fix: library name to eventsourcingdb

* chore: fix PR comments

* chore: modify tests for uppervound and lowerbound by using the objec tnot primary data type

* style: modify linting

---------

Co-authored-by: Golo Roden <[email protected]>

Author: atstaeff

Makefile

@@ -3,11 +3,14 @@ qa: analyze test
 analyze:
 	@poetry run pylint eventsourcingdb tests
 
+format:
+	@poetry run autopep8 --in-place --aggressive --max-line-length=100 --recursive eventsourcingdb tests
+	
 test:
 	@poetry run pytest --maxfail=1
 
 clean:
 
 build: qa clean
 
-.PHONY: analyze build clean qa test
+.PHONY: analyze build clean format qa test

eventsourcingdb/event/event.py

@@ -11,6 +11,8 @@
 # due to its business context. Splitting it into smaller
 # methods would increase cognitive load and make the
 # code less readable.
+
+
 class Event(EventContext):
     def __init__(
         self,

eventsourcingdb/handlers/is_event.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+EVENT_TYPE = 'event'
+
+
+def is_event(message: Any) -> bool:
+    # Check if this is the new format message
+    if isinstance(message, dict) and message.get('type') == EVENT_TYPE:
+        payload = message.get('payload')
+        return isinstance(payload, dict) and isinstance(payload.get('hash'), str)
+
+    # Otherwise check for old format (just for backward compatibility)
+    if not isinstance(message, dict):
+        return False
+
+    payload = message.get('payload')
+    return (
+        isinstance(payload, dict)
+        and isinstance(payload.get('event'), dict)
+        and isinstance(payload.get('hash'), str)
+    )

eventsourcingdb/handlers/is_item.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+from eventsourcingdb.errors.invalid_parameter_error import InvalidParameterError
+
+
+@dataclass
+class LowerBound:
+    id: str
+    type: str
+
+    def __post_init__(self):
+        if self.type not in {'inclusive', 'exclusive'}:
+            raise InvalidParameterError(
+                parameter_name="LowerBound",
+                reason='type must be either "inclusive" or "exclusive"'
+            )
+        if int(self.id) < 0:
+            raise InvalidParameterError(
+                parameter_name='LowerBound',
+                reason='id must be non-negative'
+            )

eventsourcingdb/handlers/lower_bound.py

@@ -3,7 +3,7 @@
 from http import HTTPStatus
 
 from ..is_heartbeat import is_heartbeat
-from ..is_item import is_item
+from ..is_event import is_event
 from ..is_stream_error import is_stream_error
 from ..parse_raw_message import parse_raw_message
 from ...abstract_base_client import AbstractBaseClient
@@ -23,6 +23,8 @@
 # for better readability. Even though it is not necessary,
 # it makes the return type clear without needing to read any
 # documentation or code.
+
+
 async def observe_events(
     client: AbstractBaseClient,
     subject: str,
@@ -50,7 +52,7 @@ async def observe_events(
     response: Response
     try:
         response = await client.http_client.post(
-            path='/api/observe-events',
+            path='/api/v1/observe-events',
             request_body=request_body,
         )
     except CustomError as custom_error:
@@ -73,8 +75,24 @@ async def observe_events(
             if is_stream_error(message):
                 raise ServerError(f'{message["payload"]["error"]}.')
 
-            if is_item(message):
-                event = Event.parse(message['payload']['event'])
+            if is_event(message):
+                event = Event.parse(message['payload'])
+                # Add client-side filtering by event ID
+                event_id = int(message['payload']['id'])
+
+                if options.lower_bound is not None:
+                    # For inclusive, include events with ID >= lower bound
+                    if (
+                        options.lower_bound.type == 'inclusive' and  # pylint: disable=R2004
+                        int(event_id) < int(options.lower_bound.id)
+                    ):
+                        continue
+                    # For exclusive, include events with ID > lower bound
+                    if (
+                        options.lower_bound.type == 'exclusive' and  # pylint: disable=R2004
+                        int(event_id) <= int(options.lower_bound.id)
+                    ):
+                        continue
 
                 yield StoreItem(event, message['payload']['hash'])
                 continue

eventsourcingdb/handlers/observe_events/observe_events.py

@@ -1,26 +1,26 @@
 from dataclasses import dataclass
 
+from ..lower_bound import LowerBound
 from ...errors.validation_error import ValidationError
 from ...event.validate_subject import validate_subject
 from ...event.validate_type import validate_type
-from ...util.is_non_negativ_integer import is_non_negative_integer
 from .observe_from_latest_event import ObserveFromLatestEvent
 
 
 @dataclass
 class ObserveEventsOptions:
     recursive: bool
-    lower_bound_id: str | None = None
+    lower_bound: LowerBound | None = None
     from_latest_event: ObserveFromLatestEvent | None = None
 
     def validate(self) -> None:
-        if self.lower_bound_id is not None and not is_non_negative_integer(self.lower_bound_id):
+        if self.lower_bound is not None and not isinstance(self.lower_bound, LowerBound):
             raise ValidationError(
-                'ReadEventOptions are invalid: lower_bound_id must be 0 or greater.'
+                'ObserveEventsOptions are invalid: lower_bound must be a LowerBound object.'
             )
 
         if self.from_latest_event is not None:
-            if self.lower_bound_id is not None:
+            if self.lower_bound is not None:
                 raise ValidationError(
                     'ReadEventsOptions are invalid: '
                     'lowerBoundId and fromLatestEvent are mutually exclusive'
@@ -47,8 +47,13 @@ def to_json(self):
             'recursive': self.recursive
         }
 
-        if self.lower_bound_id is not None:
-            json['lowerBoundId'] = self.lower_bound_id
+        # Directly use the object
+        if self.lower_bound is not None:
+            json['lowerBound'] = {
+                'id': str(self.lower_bound.id),  # Ensure ID is a string
+                'type': self.lower_bound.type
+            }
+
         if self.from_latest_event is not None:
             json['fromLatestEvent'] = self.from_latest_event.to_json()
 

eventsourcingdb/handlers/observe_events/observe_events_options.py

@@ -1,12 +1,45 @@
 from http import HTTPStatus
-
+import json
 from ..abstract_base_client import AbstractBaseClient
 from ..errors.server_error import ServerError
 
+# Define constants for response values
+OK_RESPONSE = "OK"
+STATUS_OK = "ok"
+
+# CloudEvent field names
+SPECVERSION_FIELD = "specversion"
+TYPE_FIELD = "type"
+PING_RECEIVED_TYPE = "io.eventsourcingdb.ping-received"
+
 
 async def ping(client: AbstractBaseClient) -> None:
-    response = await client.http_client.get('/api/ping')
-    response_body = bytes.decode(await response.body.read(), encoding='utf-8')
+    response = await client.http_client.get("/api/v1/ping")
+    response_body = bytes.decode(await response.body.read(), encoding="utf-8")
+
+    if response.status_code != HTTPStatus.OK:
+        raise ServerError(f"Received unexpected response: {response_body}")
+
+    # Check old format (plain "OK")
+    if response_body == OK_RESPONSE:
+        return
+
+    try:
+        response_json = json.loads(response_body)
+    except json.JSONDecodeError as exc:
+        raise ServerError(f"Received unexpected response: {response_body}") from exc
+
+    # Check if it's a JSON with status field
+    if isinstance(response_json, dict) and response_json.get("status") == STATUS_OK:
+        return
+
+    # Check if it's a CloudEvent format (has specversion, type fields)
+    if (
+        isinstance(response_json, dict)
+        and SPECVERSION_FIELD in response_json
+        and TYPE_FIELD in response_json
+    ):
+        if response_json.get(TYPE_FIELD) == PING_RECEIVED_TYPE:
+            return
 
-    if response.status_code != HTTPStatus.OK or response_body != HTTPStatus.OK.phrase:
-        raise ServerError(f'Received unexpected response: {response_body}')
+    raise ServerError(f"Received unexpected response: {response_body}")

eventsourcingdb/handlers/ping.py

@@ -17,13 +17,15 @@
 # for better readability. Even though it is not necessary,
 # it makes the return type clear without needing to read any
 # documentation or code.
+
+
 async def read_event_types(
     client: AbstractBaseClient,
 ) -> AsyncGenerator[EventType, None]:
     response: Response
     try:
         response = await client.http_client.post(
-            path='/api/read-event-types',
+            path='/api/v1/read-event-types',
             request_body='',
         )
     except CustomError as custom_error:

eventsourcingdb/handlers/read_event_types/read_event_types.py

@@ -11,7 +11,7 @@
 from ...event.event import Event
 from ...event.validate_subject import validate_subject
 from ...http_client.response import Response
-from ..is_item import is_item
+from ..is_event import is_event
 from ..is_stream_error import is_stream_error
 from ..parse_raw_message import parse_raw_message
 from ..store_item import StoreItem
@@ -22,6 +22,8 @@
 # for better readability. Even though it is not necessary,
 # it makes the return type clear without needing to read any
 # documentation or code.
+
+
 async def read_events(
     client: AbstractBaseClient,
     subject: str,
@@ -49,7 +51,7 @@ async def read_events(
     response: Response
     try:
         response = await client.http_client.post(
-            path='/api/read-events',
+            path='/api/v1/read-events',
             request_body=request_body,
         )
     except CustomError as custom_error:
@@ -69,8 +71,38 @@ async def read_events(
             if is_stream_error(message):
                 raise ServerError(f'{message["payload"]["error"]}.')
 
-            if is_item(message):
-                event = Event.parse(message['payload']['event'])
+            if is_event(message):
+                event = Event.parse(message['payload'])
+
+                event_id = int(message['payload']['id'])  # Access ID from raw payload
+
+                if options.lower_bound is not None:
+                    # For inclusive, include events with ID >= lower bound
+                    if (
+                        options.lower_bound.type == 'inclusive' and  # pylint: disable=R2004
+                        int(event_id) < int(options.lower_bound.id)
+                    ):
+                        continue
+                    # For exclusive, include events with ID > lower bound
+                    if (
+                        options.lower_bound.type == 'exclusive' and  # pylint: disable=R2004
+                        int(event_id) <= int(options.lower_bound.id)
+                    ):
+                        continue
+
+                if options.upper_bound is not None:
+                    # For inclusive, include events with ID <= upper bound
+                    if (
+                        options.upper_bound.type == 'inclusive' and  # pylint: disable=R2004
+                        int(event_id) > int(options.upper_bound.id)
+                    ):
+                        continue
+                    # For exclusive, include events with ID < upper bound
+                    if (
+                        options.upper_bound.type == 'exclusive' and  # pylint: disable=R2004
+                        int(event_id) >= int(options.upper_bound.id)
+                    ):
+                        continue
 
                 yield StoreItem(event, message['payload']['hash'])
                 continue