add sync version of trait; version bump

Author: DavidBM

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsmq_async"
-version = "14.0.0"
+version = "15.0.0"
 authors = ["David Bonet <webbonet@gmail.com>"]
 edition = "2021"
 license = "MIT"

src/lib.rs

@@ -8,6 +8,21 @@
 //! [![dependency status](https://deps.rs/crate/rsmq_async/4.0.0/status.svg)](https://deps.rs/crate/rsmq_async)
 //! [![Docs](https://img.shields.io/badge/docs-latest-blue.svg?style=flat-square)](https://docs.rs/rsmq_async)
 //!
+//! ## Traits
+//!
+//! This library provides two core traits for interacting with Redis message queues:
+//!
+//! - [`RsmqConnection`]: The async trait that defines all queue operations. Must be imported with `use rsmq_async::RsmqConnection;`
+//! - [`RsmqConnectionSync`]: The synchronous version of the trait, available with the "sync" feature. Must be imported with `use rsmq_async::RsmqConnectionSync;`
+//!
+//! ## Implementations
+//!
+//! Three main implementations are provided:
+//!
+//! - [`Rsmq`]: The preferred implementation using a multiplexed Redis connection
+//! - [`PooledRsmq`]: Uses a connection pool for large messages
+//! - [`RsmqSync`]: A synchronous wrapper (requires "sync" feature)
+//!
 //! ## Example
 //!
 //! ```rust
@@ -24,10 +39,6 @@
 //!
 //! ```
 //!
-//! Main object documentation are in: [`Rsmq`] and[`PooledRsmq`] and they both implement the trait
-//! [`RsmqConnection`] where you can see all the RSMQ methods. Make sure you always import the trait
-//! [`RsmqConnection`].
-//!
 //! ## Installation
 //!
 //! Check [https://crates.io/crates/rsmq_async](https://crates.io/crates/rsmq_async)
@@ -170,6 +181,8 @@ pub use multiplexed_facade::Rsmq;
 pub use pooled_facade::{PoolOptions, PooledRsmq, RedisConnectionManager};
 pub use r#trait::RsmqConnection;
 #[cfg(feature = "sync")]
+pub use r#trait::RsmqConnectionSync;
+#[cfg(feature = "sync")]
 pub use sync_facade::RsmqSync;
 pub use types::RedisBytes;
 pub use types::RsmqMessage;

src/sync_facade.rs

@@ -1,5 +1,5 @@
 use crate::functions::{CachedScript, RsmqFunctions};
-use crate::r#trait::RsmqConnection;
+use crate::r#trait::RsmqConnectionSync;
 use crate::types::{RedisBytes, RsmqMessage, RsmqOptions, RsmqQueueAttributes};
 use crate::{RsmqError, RsmqResult};
 use core::convert::TryFrom;
@@ -66,8 +66,8 @@ impl RsmqSync {
     }
 }
 
-impl RsmqConnection for RsmqSync {
-    async fn change_message_visibility(
+impl RsmqConnectionSync for RsmqSync {
+    fn change_message_visibility(
         &mut self,
         qname: &str,
         message_id: &str,
@@ -86,7 +86,7 @@ impl RsmqConnection for RsmqSync {
         })
     }
 
-    async fn create_queue(
+    fn create_queue(
         &mut self,
         qname: &str,
         hidden: Option<Duration>,
@@ -100,34 +100,34 @@ impl RsmqConnection for RsmqSync {
         })
     }
 
-    async fn delete_message(&mut self, qname: &str, id: &str) -> RsmqResult<bool> {
+    fn delete_message(&mut self, qname: &str, id: &str) -> RsmqResult<bool> {
         self.runner.block_on(async {
             self.functions
                 .delete_message(&mut self.connection.0, qname, id)
                 .await
         })
     }
-    async fn delete_queue(&mut self, qname: &str) -> RsmqResult<()> {
+    fn delete_queue(&mut self, qname: &str) -> RsmqResult<()> {
         self.runner.block_on(async {
             self.functions
                 .delete_queue(&mut self.connection.0, qname)
                 .await
         })
     }
-    async fn get_queue_attributes(&mut self, qname: &str) -> RsmqResult<RsmqQueueAttributes> {
+    fn get_queue_attributes(&mut self, qname: &str) -> RsmqResult<RsmqQueueAttributes> {
         self.runner.block_on(async {
             self.functions
                 .get_queue_attributes(&mut self.connection.0, qname)
                 .await
         })
     }
 
-    async fn list_queues(&mut self) -> RsmqResult<Vec<String>> {
+    fn list_queues(&mut self) -> RsmqResult<Vec<String>> {
         self.runner
             .block_on(async { self.functions.list_queues(&mut self.connection.0).await })
     }
 
-    async fn pop_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
+    fn pop_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
         &mut self,
         qname: &str,
     ) -> RsmqResult<Option<RsmqMessage<E>>> {
@@ -138,7 +138,7 @@ impl RsmqConnection for RsmqSync {
         })
     }
 
-    async fn receive_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
+    fn receive_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
         &mut self,
         qname: &str,
         hidden: Option<Duration>,
@@ -150,7 +150,7 @@ impl RsmqConnection for RsmqSync {
         })
     }
 
-    async fn send_message<E: Into<RedisBytes> + Send>(
+    fn send_message<E: Into<RedisBytes> + Send>(
         &mut self,
         qname: &str,
         message: E,
@@ -163,7 +163,7 @@ impl RsmqConnection for RsmqSync {
         })
     }
 
-    async fn set_queue_attributes(
+    fn set_queue_attributes(
         &mut self,
         qname: &str,
         hidden: Option<Duration>,

src/trait.rs

@@ -98,3 +98,109 @@ pub trait RsmqConnection {
         maxsize: Option<i64>,
     ) -> impl Future<Output = RsmqResult<RsmqQueueAttributes>> + Send;
 }
+
+pub trait RsmqConnectionSync {
+    /// Change the hidden time of a already sent message.
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    /// * `message_id` - ID of the message to modify
+    /// * `hidden` - New hidden duration. Has a max time of 9_999_999 for compatibility reasons with the JS version
+    fn change_message_visibility(
+        &mut self,
+        qname: &str,
+        message_id: &str,
+        hidden: Duration,
+    ) -> RsmqResult<()>;
+
+    /// Creates a new queue. Attributes can be later modified with "set_queue_attributes" method
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue to create
+    /// * `hidden` - Time the messages will be hidden when received. Max 9_999_999
+    /// * `delay` - Time messages will be delayed before delivery
+    /// * `maxsize` - Maximum message size in bytes (1024-65536 or -1 for unlimited)
+    fn create_queue(
+        &mut self,
+        qname: &str,
+        hidden: Option<Duration>,
+        delay: Option<Duration>,
+        maxsize: Option<i32>,
+    ) -> RsmqResult<()>;
+
+    /// Deletes a message from the queue.
+    ///
+    /// Important to use when you are using receive_message.
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    /// * `id` - ID of the message to delete
+    fn delete_message(&mut self, qname: &str, id: &str) -> RsmqResult<bool>;
+
+    /// Deletes the queue and all messages in it
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue to delete
+    fn delete_queue(&mut self, qname: &str) -> RsmqResult<()>;
+
+    /// Returns the queue attributes and statistics
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    fn get_queue_attributes(&mut self, qname: &str) -> RsmqResult<RsmqQueueAttributes>;
+
+    /// Returns a list of queues in the namespace
+    fn list_queues(&mut self) -> RsmqResult<Vec<String>>;
+
+    /// Deletes and returns a message. Be aware that using this you may end with deleted & unprocessed messages.
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    fn pop_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
+        &mut self,
+        qname: &str,
+    ) -> RsmqResult<Option<RsmqMessage<E>>>;
+
+    /// Returns a message. The message stays hidden for some time (defined by "hidden" argument or the queue
+    /// settings). After that time, the message will be redelivered. To avoid redelivery, use "delete_message"
+    /// after this function.
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    /// * `hidden` - Optional custom hidden duration. Max 9_999_999
+    fn receive_message<E: TryFrom<RedisBytes, Error = Vec<u8>>>(
+        &mut self,
+        qname: &str,
+        hidden: Option<Duration>,
+    ) -> RsmqResult<Option<RsmqMessage<E>>>;
+
+    /// Sends a message to the queue. The message will be delayed some time (controlled by the "delayed" argument or
+    /// the queue settings) before being delivered to a client.
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    /// * `message` - Message content to send
+    /// * `delay` - Optional custom delay duration
+    fn send_message<E: Into<RedisBytes> + Send>(
+        &mut self,
+        qname: &str,
+        message: E,
+        delay: Option<Duration>,
+    ) -> RsmqResult<String>;
+
+    /// Modify the queue attributes. Note that "hidden" and "delay" can be overwritten when sending messages.
+    /// "hidden" can be changed by the method "change_message_visibility"
+    ///
+    /// # Arguments
+    /// * `qname` - Name of the queue
+    /// * `hidden` - Time messages will be hidden when received. Max 9_999_999
+    /// * `delay` - Time messages will be delayed before delivery
+    /// * `maxsize` - Maximum message size in bytes (1024-65536 or -1 for unlimited)
+    fn set_queue_attributes(
+        &mut self,
+        qname: &str,
+        hidden: Option<Duration>,
+        delay: Option<Duration>,
+        maxsize: Option<i64>,
+    ) -> RsmqResult<RsmqQueueAttributes>;
+}