yeti_types/error/

domain.rs

//! Domain-specific error types that compose into [`YetiError`](super::YetiError).
//!
//! Each enum captures failures from one subsystem (storage, query parser,
//! schema loader, encoder, backend manager, index). `YetiError` wraps them
//! via `#[from]` so callers can return a subsystem error directly from
//! crate-level APIs.

use std::io;

/// Storage layer errors.
#[derive(Debug, thiserror::Error)]
pub enum StorageError {
    /// Key not found in storage
    #[error("Key not found: {0}")]
    KeyNotFound(String),

    /// Write conflict (optimistic locking failure)
    #[error("Write conflict for key: {0}")]
    WriteConflict(String),

    /// Data corruption detected
    #[error("Corruption detected: {0}")]
    Corruption(String),

    /// I/O error (disk full, permissions, etc.)
    #[error("I/O error: {0}")]
    Io(#[from] io::Error),

    /// RocksDB-specific error
    #[error("RocksDB error: {0}")]
    RocksDb(String),

    /// Storage initialization failed
    #[error("Failed to initialize storage: {0}")]
    InitializationFailed(String),

    /// Write-ahead log error
    #[error("WAL error: {0}")]
    Wal(String),
}

/// Query parsing and evaluation errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum QueryError {
    /// FIQL query parsing failed
    #[error("Failed to parse FIQL query: {0}")]
    ParseError(String),

    /// Invalid select field syntax
    #[error("Invalid select field: {0}")]
    InvalidSelectField(String),

    /// Sort parameter error
    #[error("Invalid sort parameter: {0}")]
    InvalidSort(String),

    /// Pagination parameter error
    #[error("Invalid pagination: {0}")]
    InvalidPagination(String),

    /// Query too complex (security limit)
    #[error("Query too complex: {reason}")]
    TooComplex {
        /// Description of why the query is too complex
        reason: String,
    },
}

/// Schema validation and definition errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum SchemaError {
    /// GraphQL schema parsing failed
    #[error("Failed to parse GraphQL schema: {0}")]
    ParseError(String),

    /// Missing required table definition
    #[error("Table definition not found: {0}")]
    TableNotFound(String),

    /// Missing required field definition
    #[error("Field definition not found: {table}.{field}")]
    FieldNotFound {
        /// Table containing the missing field
        table: String,
        /// Name of the missing field
        field: String,
    },

    /// Invalid type definition
    #[error("Invalid type definition: {0}")]
    InvalidType(String),

    /// Invalid directive
    #[error("Invalid directive: {0}")]
    InvalidDirective(String),

    /// Schema file I/O error
    #[error("Failed to read schema file: {0}")]
    FileError(String),

    /// Duplicate definition
    #[error("Duplicate definition: {0}")]
    Duplicate(String),
}

impl From<io::Error> for SchemaError {
    fn from(err: io::Error) -> Self {
        Self::FileError(err.to_string())
    }
}

/// Encoding and decoding errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum EncodingError {
    /// JSON serialization error
    #[error("JSON serialization error: {0}")]
    Json(String),

    /// Key encoding error
    #[error("Key encoding error: {0}")]
    KeyEncoding(String),

    /// Value encoding error
    #[error("Value encoding error: {0}")]
    ValueEncoding(String),

    /// UTF-8 decoding error
    #[error("UTF-8 decoding error: {0}")]
    Utf8(String),

    /// Invalid binary format
    #[error("Invalid binary format: {0}")]
    InvalidFormat(String),

    /// `MessagePack` encoding/decoding error
    #[error("MessagePack error: {0}")]
    MessagePack(String),

    /// Invalid data during decoding
    #[error("Invalid data: {0}")]
    InvalidData(String),

    /// Invalid type for operation
    #[error("Invalid type: {0}")]
    InvalidType(String),

    /// Unsupported type
    #[error("Unsupported type: {0}")]
    UnsupportedType(String),
}

impl From<serde_json::Error> for EncodingError {
    fn from(err: serde_json::Error) -> Self {
        Self::Json(err.to_string())
    }
}

impl From<std::str::Utf8Error> for EncodingError {
    fn from(err: std::str::Utf8Error) -> Self {
        Self::Utf8(err.to_string())
    }
}

/// Backend management errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum BackendError {
    /// Backend type not supported or not initialized
    #[error("Backend not available: {backend_type}")]
    NotAvailable {
        /// Backend type that is not available
        backend_type: String,
    },

    /// Backend initialization failed
    #[error("Failed to initialize backend '{backend_type}': {reason}")]
    InitializationFailed {
        /// Backend type that failed to initialize
        backend_type: String,
        /// Reason for the initialization failure
        reason: String,
    },

    /// Backend configuration error
    #[error("Backend configuration error: {0}")]
    ConfigError(String),

    /// Table-to-backend mapping not found
    #[error("No backend mapping found for table: {0}")]
    MappingNotFound(String),
}

/// Index-related errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum IndexError {
    /// Index not found
    #[error("Index not found: {table}.{attribute}")]
    NotFound {
        /// Table containing the missing index
        table: String,
        /// Attribute that was expected to be indexed
        attribute: String,
    },

    /// Index corruption detected
    #[error("Index corruption detected: {0}")]
    Corruption(String),

    /// Index update failed
    #[error("Failed to update index: {0}")]
    UpdateFailed(String),

    /// Index scan error
    #[error("Index scan error: {0}")]
    ScanError(String),
}

// StorageError carries an io::Error which isn't Clone, so we hand-roll Clone.
impl Clone for StorageError {
    fn clone(&self) -> Self {
        match self {
            Self::KeyNotFound(s) => Self::KeyNotFound(s.clone()),
            Self::WriteConflict(s) => Self::WriteConflict(s.clone()),
            Self::Corruption(s) => Self::Corruption(s.clone()),
            Self::Io(e) => Self::Io(io::Error::new(e.kind(), e.to_string())),
            Self::RocksDb(s) => Self::RocksDb(s.clone()),
            Self::InitializationFailed(s) => Self::InitializationFailed(s.clone()),
            Self::Wal(s) => Self::Wal(s.clone()),
        }
    }
}