solid_mcp 0.2.3 → 0.5.0

data/ext/solid_mcp_native/core/src/db/sqlite.rs

@@ -0,0 +1,276 @@
+//! SQLite database backend for solid-mcp-core
+
+use crate::{Message, Result};
+use async_trait::async_trait;
+use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
+use sqlx::{Pool, Sqlite};
+use std::str::FromStr;
+use std::time::Duration;
+
+/// SQLite connection pool
+#[derive(Clone)]
+pub struct SqlitePool {
+    pool: Pool<Sqlite>,
+}
+
+impl SqlitePool {
+    /// Create a new SQLite pool from a database URL
+    ///
+    /// The database and tables must already exist (created by Ruby migrations).
+    pub async fn new(database_url: &str) -> Result<Self> {
+        // Parse the URL and configure for WAL mode (better concurrency)
+        let options = SqliteConnectOptions::from_str(database_url)?
+            .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
+            .synchronous(sqlx::sqlite::SqliteSynchronous::Normal)
+            .busy_timeout(Duration::from_secs(30));
+
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1) // SQLite works best with single writer
+            .connect_with(options)
+            .await?;
+
+        Ok(Self { pool })
+    }
+
+    /// Create tables for testing purposes only
+    #[cfg(test)]
+    pub(crate) async fn setup_test_schema(&self) -> Result<()> {
+        sqlx::query(
+            r#"
+            CREATE TABLE IF NOT EXISTS solid_mcp_messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                data TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                delivered_at TEXT
+            )
+            "#,
+        )
+        .execute(&self.pool)
+        .await?;
+
+        sqlx::query(
+            r#"
+            CREATE INDEX IF NOT EXISTS idx_solid_mcp_messages_session_id
+            ON solid_mcp_messages(session_id, id)
+            "#,
+        )
+        .execute(&self.pool)
+        .await?;
+
+        sqlx::query(
+            r#"
+            CREATE INDEX IF NOT EXISTS idx_solid_mcp_messages_delivered
+            ON solid_mcp_messages(delivered_at, created_at)
+            "#,
+        )
+        .execute(&self.pool)
+        .await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl super::Database for SqlitePool {
+    async fn insert_batch(&self, messages: &[Message]) -> Result<()> {
+        if messages.is_empty() {
+            return Ok(());
+        }
+
+        // Build batch insert query
+        let mut query = String::from(
+            "INSERT INTO solid_mcp_messages (session_id, event_type, data, created_at) VALUES ",
+        );
+
+        let mut params: Vec<String> = Vec::with_capacity(messages.len() * 4);
+
+        for (i, msg) in messages.iter().enumerate() {
+            if i > 0 {
+                query.push_str(", ");
+            }
+            let base = i * 4 + 1;
+            query.push_str(&format!(
+                "(${}, ${}, ${}, ${})",
+                base,
+                base + 1,
+                base + 2,
+                base + 3
+            ));
+            params.push(msg.session_id.clone());
+            params.push(msg.event_type.clone());
+            params.push(msg.data.clone());
+            params.push(msg.created_at.to_rfc3339());
+        }
+
+        // Execute with parameters
+        let mut q = sqlx::query(&query);
+        for param in &params {
+            q = q.bind(param);
+        }
+        q.execute(&self.pool).await?;
+
+        Ok(())
+    }
+
+    async fn fetch_after(
+        &self,
+        session_id: &str,
+        after_id: i64,
+        limit: i64,
+    ) -> Result<Vec<Message>> {
+        let rows = sqlx::query_as::<_, (i64, String, String, String, String, Option<String>)>(
+            r#"
+            SELECT id, session_id, event_type, data, created_at, delivered_at
+            FROM solid_mcp_messages
+            WHERE session_id = $1 AND delivered_at IS NULL AND id > $2
+            ORDER BY id
+            LIMIT $3
+            "#,
+        )
+        .bind(session_id)
+        .bind(after_id)
+        .bind(limit)
+        .fetch_all(&self.pool)
+        .await?;
+
+        let messages = rows
+            .into_iter()
+            .map(
+                |(id, session_id, event_type, data, created_at, delivered_at)| Message {
+                    id,
+                    session_id,
+                    event_type,
+                    data,
+                    created_at: chrono::DateTime::parse_from_rfc3339(&created_at)
+                        .unwrap_or_default()
+                        .with_timezone(&chrono::Utc),
+                    delivered_at: delivered_at.and_then(|d| {
+                        chrono::DateTime::parse_from_rfc3339(&d)
+                            .ok()
+                            .map(|dt| dt.with_timezone(&chrono::Utc))
+                    }),
+                },
+            )
+            .collect();
+
+        Ok(messages)
+    }
+
+    async fn mark_delivered(&self, ids: &[i64]) -> Result<()> {
+        if ids.is_empty() {
+            return Ok(());
+        }
+
+        // $1 is for the timestamp, ids start from $2
+        let placeholders: Vec<String> = (2..=ids.len() + 1).map(|i| format!("${}", i)).collect();
+        let query = format!(
+            "UPDATE solid_mcp_messages SET delivered_at = $1 WHERE id IN ({})",
+            placeholders.join(", ")
+        );
+
+        let now = chrono::Utc::now().to_rfc3339();
+        let mut q = sqlx::query(&query).bind(&now);
+        for id in ids {
+            q = q.bind(id);
+        }
+        q.execute(&self.pool).await?;
+
+        Ok(())
+    }
+
+    async fn cleanup_delivered(&self, older_than: Duration) -> Result<u64> {
+        let cutoff =
+            (chrono::Utc::now() - chrono::Duration::from_std(older_than).unwrap()).to_rfc3339();
+
+        let result = sqlx::query(
+            r#"
+            DELETE FROM solid_mcp_messages
+            WHERE delivered_at IS NOT NULL AND delivered_at < $1
+            "#,
+        )
+        .bind(&cutoff)
+        .execute(&self.pool)
+        .await?;
+
+        Ok(result.rows_affected())
+    }
+
+    async fn cleanup_undelivered(&self, older_than: Duration) -> Result<u64> {
+        let cutoff =
+            (chrono::Utc::now() - chrono::Duration::from_std(older_than).unwrap()).to_rfc3339();
+
+        let result = sqlx::query(
+            r#"
+            DELETE FROM solid_mcp_messages
+            WHERE delivered_at IS NULL AND created_at < $1
+            "#,
+        )
+        .bind(&cutoff)
+        .execute(&self.pool)
+        .await?;
+
+        Ok(result.rows_affected())
+    }
+
+    async fn max_id(&self) -> Result<i64> {
+        let row: (Option<i64>,) = sqlx::query_as("SELECT MAX(id) FROM solid_mcp_messages")
+            .fetch_one(&self.pool)
+            .await?;
+
+        Ok(row.0.unwrap_or(0))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::Database;
+
+    async fn create_test_pool() -> SqlitePool {
+        let pool = SqlitePool::new("sqlite::memory:").await.unwrap();
+        pool.setup_test_schema().await.unwrap();
+        pool
+    }
+
+    #[tokio::test]
+    async fn test_sqlite_pool_creation() {
+        let pool = create_test_pool().await;
+        assert_eq!(pool.max_id().await.unwrap(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_insert_and_fetch() {
+        let pool = create_test_pool().await;
+
+        let messages = vec![
+            Message::new("session-1", "message", r#"{"test":1}"#),
+            Message::new("session-1", "message", r#"{"test":2}"#),
+        ];
+
+        pool.insert_batch(&messages).await.unwrap();
+
+        let fetched = pool.fetch_after("session-1", 0, 100).await.unwrap();
+        assert_eq!(fetched.len(), 2);
+        assert_eq!(fetched[0].data, r#"{"test":1}"#);
+        assert_eq!(fetched[1].data, r#"{"test":2}"#);
+    }
+
+    #[tokio::test]
+    async fn test_mark_delivered() {
+        let pool = create_test_pool().await;
+
+        let messages = vec![Message::new("session-1", "message", r#"{}"#)];
+        pool.insert_batch(&messages).await.unwrap();
+
+        let fetched = pool.fetch_after("session-1", 0, 100).await.unwrap();
+        assert_eq!(fetched.len(), 1);
+
+        pool.mark_delivered(&[fetched[0].id]).await.unwrap();
+
+        // Should not fetch delivered messages
+        let fetched = pool.fetch_after("session-1", 0, 100).await.unwrap();
+        assert_eq!(fetched.len(), 0);
+    }
+}

data/ext/solid_mcp_native/core/src/error.rs

@@ -0,0 +1,38 @@
+//! Error types for solid-mcp-core
+
+use thiserror::Error;
+
+/// Result type alias using our Error type
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Errors that can occur in solid-mcp-core
+#[derive(Error, Debug)]
+pub enum Error {
+    /// Database operation failed
+    #[error("database error: {0}")]
+    Database(#[from] sqlx::Error),
+
+    /// JSON serialization/deserialization failed
+    #[error("json error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    /// Channel send failed (queue full or shutdown)
+    #[error("channel send error: queue full or shutdown")]
+    ChannelSend,
+
+    /// Channel receive failed (shutdown)
+    #[error("channel receive error: shutdown")]
+    ChannelRecv,
+
+    /// Configuration error
+    #[error("configuration error: {0}")]
+    Config(String),
+
+    /// Shutdown requested
+    #[error("shutdown requested")]
+    Shutdown,
+
+    /// Session not found
+    #[error("session not found: {0}")]
+    SessionNotFound(String),
+}

data/ext/solid_mcp_native/core/src/lib.rs

@@ -0,0 +1,25 @@
+//! # solid-mcp-core
+//!
+//! High-performance async pub/sub engine for MCP (Model Context Protocol).
+//!
+//! This crate provides the core functionality for solid_mcp:
+//! - Async message writing with batching
+//! - Session-based subscriptions with PostgreSQL LISTEN/NOTIFY or SQLite polling
+//! - Database-backed message persistence
+//!
+//! ## Features
+//! - `sqlite` - Enable SQLite backend (default)
+//! - `postgres` - Enable PostgreSQL backend with LISTEN/NOTIFY (default)
+
+pub mod config;
+pub mod db;
+pub mod error;
+pub mod message;
+pub mod pubsub;
+pub mod subscriber;
+pub mod writer;
+
+pub use config::Config;
+pub use error::{Error, Result};
+pub use message::Message;
+pub use pubsub::PubSub;

data/ext/solid_mcp_native/core/src/message.rs

@@ -0,0 +1,191 @@
+//! Message type for solid-mcp-core
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+/// A message in the pub/sub system
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Message {
+    /// Unique message ID (database primary key)
+    #[serde(default)]
+    pub id: i64,
+
+    /// Session ID this message belongs to (UUID format, 36 chars)
+    pub session_id: String,
+
+    /// Event type (e.g., "message", "ping", "notification")
+    pub event_type: String,
+
+    /// JSON payload
+    pub data: String,
+
+    /// When the message was created
+    pub created_at: DateTime<Utc>,
+
+    /// When the message was delivered (None = undelivered)
+    #[serde(default)]
+    pub delivered_at: Option<DateTime<Utc>>,
+}
+
+impl Message {
+    /// Create a new message (id will be set by database)
+    pub fn new(
+        session_id: impl Into<String>,
+        event_type: impl Into<String>,
+        data: impl Into<String>,
+    ) -> Self {
+        Self {
+            id: 0,
+            session_id: session_id.into(),
+            event_type: event_type.into(),
+            data: data.into(),
+            created_at: Utc::now(),
+            delivered_at: None,
+        }
+    }
+
+    /// Create a message with JSON data
+    pub fn with_json<T: Serialize>(
+        session_id: impl Into<String>,
+        event_type: impl Into<String>,
+        data: &T,
+    ) -> Result<Self, serde_json::Error> {
+        let json = serde_json::to_string(data)?;
+        Ok(Self::new(session_id, event_type, json))
+    }
+
+    /// Check if this message has been delivered
+    pub fn is_delivered(&self) -> bool {
+        self.delivered_at.is_some()
+    }
+
+    /// Mark this message as delivered now
+    pub fn mark_delivered(&mut self) {
+        self.delivered_at = Some(Utc::now());
+    }
+}
+
+/// Batch of messages for efficient database operations
+#[derive(Debug, Default)]
+pub struct MessageBatch {
+    messages: Vec<Message>,
+}
+
+impl MessageBatch {
+    /// Create a new empty batch
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create a batch with pre-allocated capacity
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            messages: Vec::with_capacity(capacity),
+        }
+    }
+
+    /// Add a message to the batch
+    pub fn push(&mut self, message: Message) {
+        self.messages.push(message);
+    }
+
+    /// Get the number of messages in the batch
+    pub fn len(&self) -> usize {
+        self.messages.len()
+    }
+
+    /// Check if the batch is empty
+    pub fn is_empty(&self) -> bool {
+        self.messages.is_empty()
+    }
+
+    /// Clear the batch
+    pub fn clear(&mut self) {
+        self.messages.clear();
+    }
+
+    /// Get the messages as a slice
+    pub fn as_slice(&self) -> &[Message] {
+        &self.messages
+    }
+
+    /// Take ownership of the messages
+    pub fn into_vec(self) -> Vec<Message> {
+        self.messages
+    }
+
+    /// Iterate over messages
+    pub fn iter(&self) -> impl Iterator<Item = &Message> {
+        self.messages.iter()
+    }
+}
+
+impl IntoIterator for MessageBatch {
+    type Item = Message;
+    type IntoIter = std::vec::IntoIter<Message>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.messages.into_iter()
+    }
+}
+
+impl FromIterator<Message> for MessageBatch {
+    fn from_iter<T: IntoIterator<Item = Message>>(iter: T) -> Self {
+        Self {
+            messages: iter.into_iter().collect(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_message_new() {
+        let msg = Message::new("session-123", "message", r#"{"hello":"world"}"#);
+        assert_eq!(msg.session_id, "session-123");
+        assert_eq!(msg.event_type, "message");
+        assert_eq!(msg.data, r#"{"hello":"world"}"#);
+        assert!(!msg.is_delivered());
+    }
+
+    #[test]
+    fn test_message_with_json() {
+        #[derive(Serialize)]
+        struct Payload {
+            hello: String,
+        }
+
+        let payload = Payload {
+            hello: "world".to_string(),
+        };
+        let msg = Message::with_json("session-123", "message", &payload).unwrap();
+        assert_eq!(msg.data, r#"{"hello":"world"}"#);
+    }
+
+    #[test]
+    fn test_mark_delivered() {
+        let mut msg = Message::new("session-123", "message", "{}");
+        assert!(!msg.is_delivered());
+
+        msg.mark_delivered();
+        assert!(msg.is_delivered());
+        assert!(msg.delivered_at.is_some());
+    }
+
+    #[test]
+    fn test_message_batch() {
+        let mut batch = MessageBatch::with_capacity(10);
+        assert!(batch.is_empty());
+
+        batch.push(Message::new("s1", "msg", "{}"));
+        batch.push(Message::new("s2", "msg", "{}"));
+
+        assert_eq!(batch.len(), 2);
+        assert!(!batch.is_empty());
+
+        let messages: Vec<_> = batch.into_iter().collect();
+        assert_eq!(messages.len(), 2);
+    }
+}