use crate::domain::{MCard, MCardPayload};
use crate::error::{ClmError, Result, StorageErrorCode};
use crate::types::{AgentDid, ContentHash};
use rusqlite::{params, Connection};
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MCardStat {
pub uri: String,
pub hash: ContentHash,
pub size_bytes: usize,
pub created_at: String,
pub updated_at: String,
}
#[derive(Clone)]
pub struct MCardFileSystem {
conn: Arc<Mutex<Connection>>,
context_prefix: String,
}
impl MCardFileSystem {
pub fn new_in_memory() -> Result<Self> {
let conn = Connection::open_in_memory()?;
Self::init_schema(&conn)?;
Ok(Self {
conn: Arc::new(Mutex::new(conn)),
context_prefix: String::new(),
})
}
pub fn new_in_memory_scoped(prefix: &str) -> Result<Self> {
let mut fs = Self::new_in_memory()?;
fs.context_prefix = prefix.trim_matches('/').to_string();
Ok(fs)
}
pub fn new(conn: Arc<Mutex<Connection>>, context_prefix: &str) -> Self {
Self {
conn,
context_prefix: context_prefix.trim_matches('/').to_string(),
}
}
pub fn with_connection(conn: Arc<Mutex<Connection>>) -> Result<Self> {
{
let locked = conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
Self::init_schema(&locked)?;
}
Ok(Self {
conn,
context_prefix: String::new(),
})
}
pub fn with_prefix(&self, prefix: &str) -> Self {
Self {
conn: self.conn.clone(),
context_prefix: prefix.trim_matches('/').to_string(),
}
}
pub fn context_prefix(&self) -> &str {
&self.context_prefix
}
pub fn canonicalize_uri(&self, path: &str) -> String {
let clean = path.trim_start_matches('/');
if let Some(rest) = clean.strip_prefix("mcard:") {
let rest_clean = rest.trim_start_matches('/');
if self.context_prefix.is_empty() {
format!("mcard:{}", rest_clean)
} else if rest_clean.starts_with(&self.context_prefix) {
format!("mcard:{}", rest_clean)
} else {
format!("mcard:{}/{}", self.context_prefix, rest_clean)
}
} else if self.context_prefix.is_empty() {
format!("mcard:{}", clean)
} else {
format!("mcard:{}/{}", self.context_prefix, clean)
}
}
pub fn ephemeral_mount(&self, fiber: &crate::fiber::context::Fiber, prefix: &str) -> Result<Self> {
let scoped_fs = self.with_prefix(prefix);
let prefix_clean = prefix.trim_matches('/').to_string();
let handle_pattern = if prefix_clean.is_empty() {
"mcard:%".to_string()
} else {
format!("mcard:{}/%", prefix_clean)
};
let conn_clone = self.conn.clone();
fiber.register_disposable(move || {
let conn = conn_clone.lock().map_err(|e| e.to_string())?;
conn.execute(
"DELETE FROM handle_registry WHERE handle LIKE ?1",
rusqlite::params![&handle_pattern],
)
.map_err(|e| e.to_string())?;
Ok(())
});
Ok(scoped_fs)
}
fn init_schema(conn: &Connection) -> Result<()> {
conn.execute_batch(
r#"
CREATE TABLE IF NOT EXISTS card (
hash TEXT PRIMARY KEY,
content TEXT NOT NULL,
g_time TEXT
);
CREATE TABLE IF NOT EXISTS handle_registry (
handle TEXT PRIMARY KEY,
current_hash TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS handle_history (
handle TEXT NOT NULL,
previous_hash TEXT NOT NULL,
changed_at TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_handle_reg_prefix ON handle_registry(handle);
"#,
)?;
Ok(())
}
pub fn write_file(&self, uri: &str, payload: MCardPayload, author: AgentDid) -> Result<MCard> {
let canonical_uri = self.canonicalize_uri(uri);
let now = crate::utils::now_iso8601();
let mut conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
let existing: Option<String> = {
let mut stmt = tx.prepare_cached(
"SELECT current_hash FROM handle_registry WHERE handle = ?1",
)?;
stmt.query_row(params![&canonical_uri], |row| row.get(0))
.ok()
};
let seq = match &existing {
Some(_) => {
let mut count_stmt = tx.prepare_cached(
"SELECT count(*) FROM handle_history WHERE handle = ?1",
)?;
let count: i64 = count_stmt.query_row(params![&canonical_uri], |row| row.get(0))?;
(count as u64) + 2
}
None => 1,
};
let mcard = MCard::new(&canonical_uri, payload, author, seq);
let serialized_card = serde_json::to_string(&mcard)?;
let hash_str = mcard.hash.as_str();
{
let mut stmt_card = tx.prepare_cached(
"INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?1, ?2, ?3)",
)?;
stmt_card.execute(params![hash_str, serialized_card, now])?;
}
if let Some(prev_hash) = existing.as_ref().filter(|prev| **prev != hash_str) {
let mut stmt_hist = tx.prepare_cached(
"INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?1, ?2, ?3)",
)?;
stmt_hist.execute(params![&canonical_uri, prev_hash, now])?;
}
{
let mut stmt_reg = tx.prepare_cached(
"INSERT OR REPLACE INTO handle_registry (handle, current_hash, updated_at) \
VALUES (?1, ?2, ?3)",
)?;
stmt_reg.execute(params![&canonical_uri, hash_str, now])?;
}
tx.commit()?;
Ok(mcard)
}
pub fn read_file(&self, uri: &str) -> Result<MCard> {
let canonical_uri = self.canonicalize_uri(uri);
let conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let current_hash: String = {
let mut stmt = conn.prepare_cached(
"SELECT current_hash FROM handle_registry WHERE handle = ?1",
)?;
stmt.query_row(params![&canonical_uri], |row| row.get(0)).map_err(|_| {
ClmError::storage(
StorageErrorCode::CardNotFound,
format!("Handle '{}' not found in MCardFs", canonical_uri),
)
})?
};
let content: String = {
let mut stmt = conn.prepare_cached("SELECT content FROM card WHERE hash = ?1")?;
stmt.query_row(params![current_hash], |row| row.get(0))
.map_err(|_| {
ClmError::storage(
StorageErrorCode::CorruptedContent,
format!("Card content for hash '{}' not found", current_hash),
)
})?
};
let mcard: MCard = serde_json::from_str(&content)?;
let expected_payload_bytes = serde_json::to_vec(&mcard.payload)?;
let expected_hash = ContentHash::compute(&expected_payload_bytes);
if expected_hash.as_str() != current_hash {
return Err(ClmError::storage(
StorageErrorCode::CorruptedContent,
format!(
"Cryptographic mismatch for handle '{}': registry={} computed={}",
canonical_uri, current_hash, expected_hash
),
));
}
Ok(mcard)
}
pub fn exists(&self, uri: &str) -> Result<bool> {
let canonical_uri = self.canonicalize_uri(uri);
let conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let mut stmt = conn.prepare_cached(
"SELECT count(*) FROM handle_registry WHERE handle = ?1",
)?;
let count: i64 = stmt.query_row(params![&canonical_uri], |row| row.get(0))?;
Ok(count > 0)
}
pub fn stat_file(&self, uri: &str) -> Result<MCardStat> {
let canonical_uri = self.canonicalize_uri(uri);
let conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let (hash_str, updated_at): (String, String) = {
let mut stmt = conn.prepare_cached(
"SELECT current_hash, updated_at FROM handle_registry WHERE handle = ?1",
)?;
stmt.query_row(params![&canonical_uri], |row| {
Ok((row.get(0)?, row.get(1)?))
})
.map_err(|_| {
ClmError::storage(
StorageErrorCode::CardNotFound,
format!("Handle '{}' not found", canonical_uri),
)
})?
};
let created_at: String = {
let mut stmt = conn.prepare_cached(
"SELECT changed_at FROM handle_history WHERE handle = ?1 ORDER BY rowid ASC LIMIT 1",
)?;
stmt.query_row(params![&canonical_uri], |row| row.get(0))
.unwrap_or_else(|_| updated_at.clone())
};
let size_bytes: usize = {
let mut stmt = conn.prepare_cached("SELECT length(content) FROM card WHERE hash = ?1")?;
stmt.query_row(params![hash_str], |row| row.get::<_, i64>(0))
.unwrap_or(0) as usize
};
let hash = ContentHash::parse(&hash_str)?;
Ok(MCardStat {
uri: canonical_uri,
hash,
size_bytes,
created_at,
updated_at,
})
}
pub fn list_dir(&self, prefix: &str) -> Result<Vec<String>> {
let conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let canonical_prefix = self.canonicalize_uri(prefix);
let pattern = if canonical_prefix.ends_with('/') {
format!("{}%", canonical_prefix)
} else if canonical_prefix == "mcard:" {
"mcard:%".to_string()
} else {
format!("{}/%", canonical_prefix)
};
let mut stmt = conn.prepare_cached(
"SELECT handle FROM handle_registry WHERE handle LIKE ?1 ORDER BY handle ASC",
)?;
let rows = stmt.query_map(params![pattern], |row| row.get(0))?;
let mut handles = Vec::new();
for handle in rows {
handles.push(handle?);
}
Ok(handles)
}
pub fn delete_file(&self, uri: &str) -> Result<()> {
let canonical_uri = self.canonicalize_uri(uri);
let now = crate::utils::now_iso8601();
let mut conn = self
.conn
.lock()
.map_err(|e| ClmError::storage(StorageErrorCode::TransactionFailed, e.to_string()))?;
let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
{
let mut stmt_hist = tx.prepare_cached(
"INSERT INTO handle_history (handle, previous_hash, changed_at) \
SELECT handle, current_hash, ?1 FROM handle_registry WHERE handle = ?2",
)?;
stmt_hist.execute(params![now, &canonical_uri])?;
let mut stmt_del = tx.prepare_cached("DELETE FROM handle_registry WHERE handle = ?1")?;
let affected = stmt_del.execute(params![&canonical_uri])?;
if affected == 0 {
return Err(ClmError::storage(
StorageErrorCode::CardNotFound,
format!("Handle '{}' not found for deletion", canonical_uri),
));
}
}
tx.commit()?;
Ok(())
}
}