evidentsource_core/domain/

state_change.rs

//! State change types.
//!
//! State changes are commands that produce events. They encapsulate
//! business logic for validating and processing requests.

use super::identifiers::StateChangeName;

/// State change version number.
pub type StateChangeVersion = u64;

/// A summary of a state change definition.
///
/// This is returned when listing state changes registered with the database.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StateChangeDefinitionSummary {
    /// The name of the state change.
    pub name: StateChangeName,
    /// The version of the state change.
    pub version: StateChangeVersion,
}

impl StateChangeDefinitionSummary {
    /// Create a new state change definition summary.
    pub fn new(name: StateChangeName, version: StateChangeVersion) -> Self {
        Self { name, version }
    }
}

/// A command received by a state change.
///
/// This mirrors the WIT Command type and can be used by domain crates
/// to implement TryFrom conversions without depending on the SDK.
///
/// The SDK is format-agnostic: users implement `TryFrom<Command>` with their
/// preferred deserializer (serde_json, prost, rmp-serde, etc.).
///
/// # Example
///
/// ```rust,ignore
/// use evidentsource_core::domain::{Command, CommandParseError};
///
/// impl TryFrom<Command> for MyDomainCommand {
///     type Error = CommandParseError;
///
///     fn try_from(cmd: Command) -> Result<Self, Self::Error> {
///         let bytes = cmd.body.as_deref().ok_or(CommandParseError::NoBody)?;
///         // Use your preferred deserializer
///         serde_json::from_slice(bytes)
///             .map_err(|e| CommandParseError::DeserializationFailed(e.to_string()))
///     }
/// }
/// ```
#[derive(Debug, Clone)]
pub struct Command {
    /// Optional request body as raw bytes.
    pub body: Option<Vec<u8>>,
    /// Content type of the body (e.g., "application/json").
    pub content_type: String,
    /// Optional content schema URI.
    pub content_schema: Option<String>,
}

impl Command {
    /// Create a new command with the given body and content type.
    pub fn new(body: Option<Vec<u8>>, content_type: impl Into<String>) -> Self {
        Command {
            body,
            content_type: content_type.into(),
            content_schema: None,
        }
    }

    /// Create a command with a JSON body.
    pub fn json(body: Vec<u8>) -> Self {
        Command {
            body: Some(body),
            content_type: "application/json".to_string(),
            content_schema: None,
        }
    }

    /// Set the content schema.
    pub fn with_schema(mut self, schema: impl Into<String>) -> Self {
        self.content_schema = Some(schema.into());
        self
    }

    /// Get a reference to the body bytes if present.
    pub fn body(&self) -> Option<&[u8]> {
        self.body.as_deref()
    }

    /// Get the content type.
    pub fn content_type(&self) -> &str {
        &self.content_type
    }

    /// Get the content schema if present.
    pub fn content_schema(&self) -> Option<&str> {
        self.content_schema.as_deref()
    }

    /// Check if the content type is JSON.
    pub fn is_json(&self) -> bool {
        self.content_type == "application/json" || self.content_type.ends_with("+json")
    }
}

/// Error when parsing a command body.
#[derive(Debug, Clone, thiserror::Error)]
pub enum CommandParseError {
    /// Command body is required but was not provided.
    #[error("command body is required")]
    NoBody,
    /// Failed to deserialize the command body.
    #[error("deserialization failed: {0}")]
    DeserializationFailed(String),
}

/// Error when creating a command request.
#[derive(Debug, Clone, thiserror::Error)]
pub enum CommandRequestError {
    /// Failed to serialize the request body.
    #[error("serialization failed: {0}")]
    SerializationFailed(String),
}

/// A command request to execute a state change.
#[derive(Debug, Clone)]
pub struct CommandRequest {
    /// HTTP-style headers for the request.
    pub headers: Vec<(String, String)>,
    /// Optional request body.
    pub body: Option<Vec<u8>>,
    /// Content type of the body (e.g., "application/json").
    pub content_type: Option<String>,
    /// Optional content schema URL for validation.
    pub content_schema: Option<String>,
}

impl CommandRequest {
    /// Create a new empty command request.
    pub fn new() -> Self {
        CommandRequest {
            headers: Vec::new(),
            body: None,
            content_type: None,
            content_schema: None,
        }
    }

    /// Create a command request with a body.
    pub fn with_body(body: Vec<u8>) -> Self {
        CommandRequest {
            headers: Vec::new(),
            body: Some(body),
            content_type: None,
            content_schema: None,
        }
    }

    /// Create a command request with a JSON-serialized body.
    ///
    /// This serializes the value to JSON and sets the appropriate Content-Type header.
    ///
    /// # Example
    ///
    /// ```
    /// use evidentsource_core::domain::CommandRequest;
    /// use serde::Serialize;
    ///
    /// #[derive(Serialize)]
    /// struct CreateAccount {
    ///     account_id: String,
    ///     initial_balance: u64,
    /// }
    ///
    /// let cmd = CreateAccount {
    ///     account_id: "acc-123".to_string(),
    ///     initial_balance: 1000,
    /// };
    ///
    /// let request = CommandRequest::json(&cmd).unwrap();
    /// assert_eq!(request.get_header("Content-Type"), Some("application/json"));
    /// ```
    pub fn json<T: serde::Serialize>(value: &T) -> Result<Self, CommandRequestError> {
        let body = serde_json::to_vec(value)
            .map_err(|e| CommandRequestError::SerializationFailed(e.to_string()))?;
        Ok(CommandRequest {
            headers: vec![("Content-Type".to_string(), "application/json".to_string())],
            body: Some(body),
            content_type: Some("application/json".to_string()),
            content_schema: None,
        })
    }

    /// Add a header to the request.
    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
        self.headers.push((name.into(), value.into()));
        self
    }

    /// Set the request body.
    pub fn body(mut self, body: Vec<u8>) -> Self {
        self.body = Some(body);
        self
    }

    /// Set the content type.
    ///
    /// # Example
    ///
    /// ```
    /// use evidentsource_core::domain::CommandRequest;
    ///
    /// let request = CommandRequest::new()
    ///     .body(b"<xml>data</xml>".to_vec())
    ///     .content_type("application/xml");
    /// ```
    pub fn content_type(mut self, content_type: impl Into<String>) -> Self {
        self.content_type = Some(content_type.into());
        self
    }

    /// Set the content schema URL.
    ///
    /// # Example
    ///
    /// ```
    /// use evidentsource_core::domain::CommandRequest;
    ///
    /// let request = CommandRequest::new()
    ///     .body(b"{}".to_vec())
    ///     .content_type("application/json")
    ///     .content_schema("https://example.com/schemas/command.json");
    /// ```
    pub fn content_schema(mut self, schema_url: impl Into<String>) -> Self {
        self.content_schema = Some(schema_url.into());
        self
    }

    /// Get a header value by name.
    pub fn get_header(&self, name: &str) -> Option<&str> {
        self.headers
            .iter()
            .find(|(k, _)| k.eq_ignore_ascii_case(name))
            .map(|(_, v)| v.as_str())
    }
}

impl Default for CommandRequest {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::Serialize;

    #[test]
    fn test_command_request_builder() {
        let request = CommandRequest::new()
            .header("Content-Type", "application/json")
            .body(b"{}".to_vec());

        assert_eq!(request.get_header("content-type"), Some("application/json"));
        assert_eq!(request.body, Some(b"{}".to_vec()));
    }

    #[test]
    fn test_command_request_json() {
        #[derive(Serialize)]
        struct TestCmd {
            name: String,
            value: i32,
        }

        let cmd = TestCmd {
            name: "test".to_string(),
            value: 42,
        };

        let request = CommandRequest::json(&cmd).unwrap();

        assert_eq!(request.get_header("Content-Type"), Some("application/json"));
        assert!(request.body.is_some());

        // Verify the JSON is valid
        let body = request.body.unwrap();
        let parsed: serde_json::Value = serde_json::from_slice(&body).unwrap();
        assert_eq!(parsed["name"], "test");
        assert_eq!(parsed["value"], 42);
    }

    #[test]
    fn test_state_change_definition_summary() {
        let name = StateChangeName::new("my-state-change").unwrap();
        let summary = StateChangeDefinitionSummary::new(name.clone(), 1);

        assert_eq!(summary.name, name);
        assert_eq!(summary.version, 1);
    }
}