zesdex/crates/zesdex-cms/src/infrastructure/persistence/conversation_repo.rs

//! JSON file–backed `ConversationRepository`.
//!
//! Path: `<session_dir>/conversation.json`
//!
//! Uses write-then-rename with fsync for crash safety.

#![allow(
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    clippy::cast_precision_loss,
    clippy::cast_possible_wrap
)]

use std::io::Write;
use std::path::Path;

use anyhow::{Context, Result};

use crate::domain::conversation::Conversation;
use crate::domain::repository::ConversationRepository;

/// Persists `Conversation` as pretty-printed JSON at `<session_dir>/conversation.json`.
#[derive(Debug, Clone, Default)]
pub struct JsonConversationRepository;

impl JsonConversationRepository {
    /// Create a new repository instance.
    pub fn new() -> Self {
        Self
    }
}

impl ConversationRepository for JsonConversationRepository {
    fn load(&self, session_dir: &Path) -> Result<Conversation> {
        let path = session_dir.join("conversation.json");
        let data = std::fs::read_to_string(&path)
            .with_context(|| format!("failed to read conversation at '{}'", path.display()))?;
        let conv: Conversation = serde_json::from_str(&data)
            .with_context(|| format!("failed to parse conversation at '{}'", path.display()))?;
        Ok(conv)
    }

    fn save(&self, session_dir: &Path, conversation: &Conversation) -> Result<()> {
        std::fs::create_dir_all(session_dir)
            .with_context(|| format!("failed to create session dir '{}'", session_dir.display()))?;
        let path = session_dir.join("conversation.json");
        let tmp = session_dir.join("conversation.json.tmp");
        let json = serde_json::to_string_pretty(conversation)
            .context("failed to serialize conversation")?;
        {
            let mut f = std::fs::OpenOptions::new()
                .create(true)
                .truncate(true)
                .write(true)
                .open(&tmp)
                .with_context(|| format!("failed to write temp file '{}'", tmp.display()))?;
            f.write_all(json.as_bytes())?;
            f.sync_all()?;
        }
        std::fs::rename(&tmp, &path).with_context(|| {
            format!(
                "failed to rename '{}' -> '{}'",
                tmp.display(),
                path.display()
            )
        })?;
        if let Some(parent) = path.parent() {
            if let Ok(d) = std::fs::File::open(parent) {
                let _ = d.sync_all();
            }
        }
        tracing::debug!("conversation saved to '{}'", path.display());
        Ok(())
    }
}