feat: Add seperate EventMissingStrategy for observing events

Author: dotKuro

README.md

@@ -37,7 +37,7 @@ if let Err(err) = result {
 }
 ```
 
-*Note that `Ping` does not require authentication, so the call may succeed even if the API token is invalid.*
+*Note that `ping` does not require authentication, so the call may succeed even if the API token is invalid.*
 
 If you want to verify the API token, call `verify_api_token`. If the token is invalid, the function will return an error:
 
@@ -54,7 +54,7 @@ Call the `write_events` function and hand over a vector with one or more events.
 
 Specify `source`, `subject`, `type` (using `ty`), and `data` according to the [CloudEvents](https://docs.eventsourcingdb.io/fundamentals/cloud-events/) format.
 
-For `data` provide a json object using a `serde_json:Value`.
+For `data` provide a JSON object using a `serde_json:Value`.
 
 The function returns the written events, including the fields added by the server:
 
@@ -79,7 +79,7 @@ match result {
 
 #### Using the `IsSubjectPristine` precondition
 
-If you only want to write events in case a subject (such as `/books/42`) does not yet have any events, use the `IsSubjectPristine` Precondition to create a precondition and pass it in a vector as the second argument:
+If you only want to write events in case a subject (such as `/books/42`) does not yet have any events, use the `IsSubjectPristine` precondition to create a precondition and pass it in a vector as the second argument:
 
 ```rust
 let result = client.write_events(
@@ -96,12 +96,12 @@ match result {
 
 #### Using the `IsSubjectOnEventId` precondition
 
-If you only want to write events in case the last event of a subject (such as `/books/42`) has a specific ID (e.g., `0`), use the `IsSubjectOnEventID` Precondition to create a precondition and pass it in a vector as the second argument:
+If you only want to write events in case the last event of a subject (such as `/books/42`) has a specific ID (e.g., `0`), use the `IsSubjectOnEventId` precondition to create a precondition and pass it in a vector as the second argument:
 
 ```rust
 let result = client.write_events(
   vec![event.clone()],
-  vec![Precondition::IsSubjectPristine {
+  vec![Precondition::IsSubjectOnEventId {
     subject: "/books/42".to_string(),
     event_id: "0".to_string(),
   }],
@@ -123,7 +123,7 @@ The function returns a stream from which you can retrieve one event at a time:
 ```rust
 let result = client
   .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+    ReadEventsOptions {
       recursive: false,
       from_latest_event: None,
       order: None,
@@ -150,7 +150,7 @@ If you want to read not only all the events of a subject, but also the events of
 ```rust
 let result = client
   .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+    ReadEventsOptions {
       recursive: true,
       ..Default::default(),
     }
@@ -167,7 +167,7 @@ By default, events are read in chronological order. To read in anti-chronologica
 ```rust
 let result = client
   .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+    ReadEventsOptions {
       recursive: false,
       order: Some(Ordering::Antichronological)
       ..Default::default(),
@@ -187,7 +187,7 @@ Specify the ID and whether to include or exclude it, for both the lower and uppe
 ```rust
 let result = client
   .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+    ReadEventsOptions {
       recursive: false,
       lower_bound: Some(Bound {
         bound_type: BoundType::Inclusive,
@@ -212,13 +212,13 @@ Possible options are `ReadNothing`, which skips reading entirely, or `ReadyEvery
 ```rust
 let result = client
   .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+    ReadEventsOptions {
       recursive: false,
       from_latest_event: Some(
         FromLatestEventOptions {
           subject: "/books/42",
           ty: "io.eventsourcingdb.library.book-borrowed",
-          if_event_is_missing: EventMissingStrategy::ReadEverything,
+          if_event_is_missing: ReadEventMissingStrategy::ReadEverything,
         }
       )
       ..Default::default(),
@@ -256,11 +256,10 @@ To observe all events of a subject, call the `observe_events` function with the
 
 The function returns a stream from which you can retrieve one event at a time:
 
-
 ```rust
 let result = client
   .observe_events("/books/42", Some(
-    ObserveEventsRequestOptions {
+    ObserveEventsOptions {
       recursive: false,
       from_latest_event: None,
       lower_bound: None,
@@ -285,7 +284,7 @@ If you want to observe not only all the events of a subject, but also the events
 ```rust
 let result = client
   .observe_events("/books/42", Some(
-    ObserveEventsRequestOptions {
+    ObserveEventsOptions {
       recursive: true,
       ..Default::default(),
     }
@@ -303,8 +302,8 @@ Specify the ID and whether to include or exclude it:
 
 ```rust
 let result = client
-  .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+  .observe_events("/books/42", Some(
+    ObserveEventsOptions {
       recursive: false,
       lower_bound: Some(Bound {
         bound_type: BoundType::Inclusive,
@@ -324,14 +323,14 @@ Possible options are `WaitForEvent`, which waits for an event of the given type
 
 ```rust
 let result = client
-  .read_events("/books/42", Some(
-    ReadEventsRequestOptions {
+  .observe_events("/books/42", Some(
+    ObserveEventsOptions {
       recursive: false,
       from_latest_event: Some(
         ObserveFromLatestEventOptions {
           subject: "/books/42",
           ty: "io.eventsourcingdb.library.book-borrowed",
-          if_event_is_missing: EventMissingStrategy::ObserveEverything,
+          if_event_is_missing: ObserveEventMissingStrategy::ObserveEverything,
         }
       )
       ..Default::default(),

examples/observing_events.rs

@@ -1,5 +1,5 @@
 use eventsourcingdb::{
-    client::{Client, request_options::ObserveEventsRequestOptions},
+    client::{Client, request_options::ObserveEventsOptions},
     container::Container,
 };
 use futures::StreamExt;
@@ -14,7 +14,7 @@ async fn main() {
     let result = client
         .observe_events(
             "/books/42",
-            Some(ObserveEventsRequestOptions {
+            Some(ObserveEventsOptions {
                 recursive: false,
                 from_latest_event: None,
                 lower_bound: None,

examples/reading_events.rs

@@ -1,5 +1,5 @@
 use eventsourcingdb::{
-    client::{Client, request_options::ReadEventsRequestOptions},
+    client::{Client, request_options::ReadEventsOptions},
     container::Container,
 };
 use futures::StreamExt;
@@ -14,7 +14,7 @@ async fn main() {
     let result = client
         .read_events(
             "/books/42",
-            Some(ReadEventsRequestOptions {
+            Some(ReadEventsOptions {
                 recursive: false,
                 from_latest_event: None,
                 order: None,

src/client.rs

@@ -203,7 +203,7 @@ impl Client {
     pub async fn read_events<'a>(
         &self,
         subject: &'a str,
-        options: Option<request_options::ReadEventsRequestOptions<'a>>,
+        options: Option<request_options::ReadEventsOptions<'a>>,
     ) -> Result<impl Stream<Item = Result<Event, ClientError>>, ClientError> {
         let response = self
             .request_streaming(ReadEventsRequest { subject, options })
@@ -249,7 +249,7 @@ impl Client {
     pub async fn observe_events<'a>(
         &self,
         subject: &'a str,
-        options: Option<request_options::ObserveEventsRequestOptions<'a>>,
+        options: Option<request_options::ObserveEventsOptions<'a>>,
     ) -> Result<impl Stream<Item = Result<Event, ClientError>>, ClientError> {
         let response = self
             .request_streaming(ObserveEventsRequest { subject, options })

src/client/client_request/observe_events.rs

@@ -1,17 +1,15 @@
 use reqwest::Method;
 use serde::Serialize;
 
-use crate::{
-    client::request_options::ObserveEventsRequestOptions, error::ClientError, event::Event,
-};
+use crate::{client::request_options::ObserveEventsOptions, error::ClientError, event::Event};
 
 use super::{ClientRequest, StreamingRequest};
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ObserveEventsRequest<'a> {
     pub subject: &'a str,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub options: Option<ObserveEventsRequestOptions<'a>>,
+    pub options: Option<ObserveEventsOptions<'a>>,
 }
 
 impl ClientRequest for ObserveEventsRequest<'_> {

src/client/client_request/read_events.rs

@@ -1,15 +1,15 @@
 use reqwest::Method;
 use serde::Serialize;
 
-use crate::{client::request_options::ReadEventsRequestOptions, error::ClientError, event::Event};
+use crate::{client::request_options::ReadEventsOptions, error::ClientError, event::Event};
 
 use super::{ClientRequest, StreamingRequest};
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ReadEventsRequest<'a> {
     pub subject: &'a str,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub options: Option<ReadEventsRequestOptions<'a>>,
+    pub options: Option<ReadEventsOptions<'a>>,
 }
 
 impl ClientRequest for ReadEventsRequest<'_> {

src/client/request_options.rs

@@ -5,10 +5,10 @@ use serde::Serialize;
 /// Options for reading events from the database
 #[derive(Debug, Default, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ReadEventsRequestOptions<'a> {
+pub struct ReadEventsOptions<'a> {
     /// Start reading events from this start event
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub from_latest_event: Option<FromLatestEventOptions<'a>>,
+    pub from_latest_event: Option<ReadFromLatestEventOptions<'a>>,
     /// Lower bound of events to read
     #[serde(skip_serializing_if = "Option::is_none")]
     pub lower_bound: Option<Bound<'a>>,
@@ -25,10 +25,10 @@ pub struct ReadEventsRequestOptions<'a> {
 /// Options for observing events from the database
 #[derive(Debug, Default, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ObserveEventsRequestOptions<'a> {
+pub struct ObserveEventsOptions<'a> {
     /// Start reading events from this start event
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub from_latest_event: Option<FromLatestEventOptions<'a>>,
+    pub from_latest_event: Option<ObserveFromLatestEventOptions<'a>>,
     /// Lower bound of events to read
     #[serde(skip_serializing_if = "Option::is_none")]
     pub lower_bound: Option<Bound<'a>>,
@@ -67,25 +67,48 @@ pub struct Bound<'a> {
     pub id: &'a str,
 }
 
-/// The strategy for handling missing events
+/// The strategy for handling missing events while reading
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "kebab-case")]
-pub enum EventMissingStrategy {
+pub enum ReadEventMissingStrategy {
     /// Read all events if the required one is missing
     ReadEverything,
     /// Read no events if the required one is missing
     ReadNothing,
 }
 
-/// Options for reading events from the start reading at
+/// The strategy for handling missing events while observing
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum ObserveEventMissingStrategy {
+    /// Observe all events if the required one is missing
+    ObserveEverything,
+    /// Wait for the event until observing
+    WaitForEvent,
+}
+
+/// Options for reading events from the latest event of certain type or subject
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FromLatestEventOptions<'a> {
+pub struct ReadFromLatestEventOptions<'a> {
     /// The strategy for handling missing events
-    pub if_event_is_missing: EventMissingStrategy,
+    pub if_event_is_missing: ReadEventMissingStrategy,
     /// The subject the event should be on
     pub subject: &'a str,
     /// The type of the event to read from
     #[serde(rename = "type")]
     pub ty: &'a str,
 }
+
+/// Options for observe events from the latest event of certain type or subject
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ObserveFromLatestEventOptions<'a> {
+    /// The strategy for handling missing events
+    pub if_event_is_missing: ObserveEventMissingStrategy,
+    /// The subject the event should be on
+    pub subject: &'a str,
+    /// The type of the event to observe from
+    #[serde(rename = "type")]
+    pub ty: &'a str,
+}