Separate core types into stable crate

Cargo.toml

@@ -1,6 +1,9 @@
+[workspace]
+members = ["hedwig_core"]
+
 [package]
 name = "hedwig"
-version = "7.0.0"
+version = "7.1.0"
 authors = [
     "Aniruddha Maru <[email protected]>",
     "Simonas Kazlauskas <[email protected]>",
@@ -38,6 +41,7 @@ async-trait = { version = "0.1" }
 bytes = "1"
 either = { version = "1", features = ["use_std"], default-features = false }
 futures-util = { version = "0.3.17", features = ["std", "sink"], default-features = false }
+hedwig_core = { version = "0.1", path = "./hedwig_core" }
 pin-project = "1"
 smallstr = { version = "0.3.0", features = ["union"] }
 thiserror = { version = "1", default-features = false }

hedwig_core/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "hedwig_core"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bytes = "1"
+smallstr = { version = "0.3.0", features = ["union"] }
+uuid = { version = "1.6", features = ["v4"], default-features = false }

hedwig_core/src/lib.rs

@@ -0,0 +1,16 @@
+//! The core set of traits and types used in the hedwig format.
+//!
+//! This crate aims to provide better version stability over the primary batteries-included
+//! `hedwig` crate. Top-level applications should typically use `hedwig`, while crates that define
+//! message types should use `hedwig_core`
+
+mod topic;
+pub use topic::Topic;
+pub mod message;
+
+/// Custom headers associated with a message.
+pub type Headers = std::collections::BTreeMap<String, String>;
+
+/// A validated message.
+pub type ValidatedMessage = message::ValidatedMessage<bytes::Bytes>;
+

src/message.rs → hedwig_core/src/message.rs

@@ -4,7 +4,7 @@ use bytes::Bytes;
 use std::{borrow::Cow, time::SystemTime};
 use uuid::Uuid;
 
-use crate::Headers;
+use crate::{Headers, Topic};
 
 /// A validated message.
 ///
@@ -87,3 +87,60 @@ impl<M> ValidatedMessage<M> {
         self.data
     }
 }
+
+/// Messages which can be decoded from a [`ValidatedMessage`] stream.
+pub trait DecodableMessage {
+    /// The error returned when a message fails to decode
+    type Error;
+
+    /// The decoder used to decode a validated message
+    type Decoder;
+
+    /// Decode the given message, using the given decoder, into its structured type
+    fn decode(msg: ValidatedMessage<Bytes>, decoder: &Self::Decoder) -> Result<Self, Self::Error>
+    where
+        Self: Sized;
+}
+
+impl<M> DecodableMessage for ValidatedMessage<M>
+where
+    M: DecodableMessage,
+{
+    /// The error returned when a message fails to decode
+    type Error = M::Error;
+
+    /// The decoder used to decode a validated message
+    type Decoder = M::Decoder;
+
+    /// Decode the given message, using the given decoder, into its structured type
+    fn decode(msg: ValidatedMessage<Bytes>, decoder: &Self::Decoder) -> Result<Self, Self::Error>
+    where
+        Self: Sized,
+    {
+        let message = M::decode(msg.clone(), decoder)?;
+        Ok(Self {
+            id: msg.id,
+            timestamp: msg.timestamp,
+            schema: msg.schema,
+            headers: msg.headers,
+            data: message,
+        })
+    }
+}
+
+/// Types that can be encoded and published.
+pub trait EncodableMessage {
+    /// The errors that can occur when calling the [`EncodableMessage::encode`] method.
+    ///
+    /// Will typically match the errors returned by the [`EncodableMessage::Validator`].
+    type Error;
+
+    /// The validator to use for this message.
+    type Validator;
+
+    /// Topic into which this message shall be published.
+    fn topic(&self) -> Topic;
+
+    /// Encode the message payload.
+    fn encode(&self, validator: &Self::Validator) -> Result<ValidatedMessage<Bytes>, Self::Error>;
+}

src/consumer.rs

@@ -13,6 +13,8 @@ use std::{
     task::{Context, Poll},
 };
 
+pub use hedwig_core::message::DecodableMessage;
+
 /// Message consumers ingest messages from a queue service and present them to the user application
 /// as a [`Stream`](futures_util::stream::Stream).
 ///
@@ -78,46 +80,6 @@ pub trait Consumer {
     }
 }
 
-/// Messages which can be decoded from a [`ValidatedMessage`] stream.
-pub trait DecodableMessage {
-    /// The error returned when a message fails to decode
-    type Error;
-
-    /// The decoder used to decode a validated message
-    type Decoder;
-
-    /// Decode the given message, using the given decoder, into its structured type
-    fn decode(msg: ValidatedMessage<Bytes>, decoder: &Self::Decoder) -> Result<Self, Self::Error>
-    where
-        Self: Sized;
-}
-
-impl<M> DecodableMessage for ValidatedMessage<M>
-where
-    M: DecodableMessage,
-{
-    /// The error returned when a message fails to decode
-    type Error = M::Error;
-
-    /// The decoder used to decode a validated message
-    type Decoder = M::Decoder;
-
-    /// Decode the given message, using the given decoder, into its structured type
-    fn decode(msg: ValidatedMessage<Bytes>, decoder: &Self::Decoder) -> Result<Self, Self::Error>
-    where
-        Self: Sized,
-    {
-        let message = M::decode(msg.clone(), decoder)?;
-        Ok(Self {
-            id: msg.id,
-            timestamp: msg.timestamp,
-            schema: msg.schema,
-            headers: msg.headers,
-            data: message,
-        })
-    }
-}
-
 /// A received message which can be acknowledged to prevent re-delivery by the backing message
 /// service.
 ///

src/lib.rs

@@ -75,20 +75,15 @@
 //! ```
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
-pub use topic::Topic;
-
-use bytes::Bytes;
-use std::collections::BTreeMap;
+pub use hedwig_core::{message, Headers, Topic, ValidatedMessage};
 
 mod backends;
 mod consumer;
-pub mod message;
 mod publisher;
 mod tests;
-mod topic;
 pub mod validators;
 
 pub use backends::*;
 pub use consumer::*;
 pub use publisher::*;
 
@@ -112,9 +107,3 @@
     #[error("Unable to encode message payload")]
     EncodeMessage(#[source] Box<dyn std::error::Error + Send + Sync>),
 }
-
-/// Custom headers associated with a message.
-pub type Headers = BTreeMap<String, String>;
-
-/// A validated message.
-pub type ValidatedMessage = message::ValidatedMessage<Bytes>;

src/publisher.rs

@@ -1,12 +1,13 @@
 //! Types, traits, and functions necessary to publish messages using hedwig
 
-use crate::{Topic, ValidatedMessage};
 use futures_util::sink;
 use std::{
     pin::Pin,
     task::{Context, Poll},
 };
 
+pub use hedwig_core::message::EncodableMessage;
+
 /// Message publishers.
 ///
 /// Message publishers validate, encode, and deliver messages to an endpoint, possibly a remote
@@ -45,23 +46,6 @@ pub trait Publisher<M: EncodableMessage, S: sink::Sink<M> = Drain<M>> {
     ) -> Self::PublishSink;
 }
 
-/// Types that can be encoded and published.
-pub trait EncodableMessage {
-    /// The errors that can occur when calling the [`EncodableMessage::encode`] method.
-    ///
-    /// Will typically match the errors returned by the [`EncodableMessage::Validator`].
-    type Error;
-
-    /// The validator to use for this message.
-    type Validator;
-
-    /// Topic into which this message shall be published.
-    fn topic(&self) -> Topic;
-
-    /// Encode the message payload.
-    fn encode(&self, validator: &Self::Validator) -> Result<ValidatedMessage, Self::Error>;
-}
-
 /// Like [`futures_util::sink::Drain`] but implements `Default`
 #[derive(Debug)]
 pub struct Drain<T>(std::marker::PhantomData<T>);

src/validators/prost.rs

@@ -1,4 +1,4 @@
-//! Validation and decoding for messages encoded with protobuf using [`prost`]
+//! Validation and decoding for messages encoded with protobuf using [`prost`](::prost)
 //!
 //! ```
 //! use hedwig::validators::prost::{ProstValidator, ProstDecoder, ExactSchemaMatcher};
@@ -120,7 +120,7 @@
             .try_match_schema(msg.schema())
             .map_err(ProstDecodeError::InvalidSchema)?;
 
-        Ok(M::decode(msg.data)?)
+        Ok(M::decode(msg.into_data())?)
     }
 }