Enum CoreError 

pub enum CoreError {
    Domain(DomainError),
    Io {
        context: String,
        source: Error,
    },
    Validation(String),
    Parse(String),
    Process(String),
    Sqlite(String),
    NotFound(String),
    Serde {
        context: String,
        message: String,
    },
}

Canonical error type for the core orchestration layer.

Variants cover the major failure categories encountered by core use-cases. None of the variants carry presentation logic — that belongs in the adapter.

Variants

Domain(DomainError)

An error propagated from the domain layer.

Io

Filesystem or other I/O failure.

Fields

context: String

Short description of the operation that failed.

source: Error

Underlying I/O error.

Validation(String)

Input validation failure (bad arguments, constraint violations).

Parse(String)

Parse failure (duration strings, JSON, YAML, etc.).

Process(String)

Process execution failure (git, shell commands).

Sqlite(String)

SQLite operation failure.

NotFound(String)

An expected asset or resource was not found.

Serde

Serialization or deserialization failure.

Fields

context: String

Short description of the operation.

message: String

Error detail.

Implementations

impl CoreError

pub fn io(context: impl Into<String>, source: Error) -> Self

Build an I/O error with context.

pub fn validation(msg: impl Into<String>) -> Self

Build a validation error.

pub fn parse(msg: impl Into<String>) -> Self

Build a parse error.

pub fn process(msg: impl Into<String>) -> Self

Build a process error.

pub fn not_found(msg: impl Into<String>) -> Self

Build a not-found error.

pub fn serde(context: impl Into<String>, message: impl Into<String>) -> Self

Create a CoreError::Serde containing a context and a message describing a serialization or deserialization failure.

Examples

use ito_core::errors::CoreError;

let err = CoreError::serde("load config", "missing field `name`");
match err {
    CoreError::Serde { context, message } => {
        assert_eq!(context, "load config");
        assert_eq!(message, "missing field `name`");
    }
    _ => panic!("expected Serde variant"),
}

pub fn sqlite(msg: impl Into<String>) -> Self

Wraps a human-readable SQLite error message into a CoreError::Sqlite.

Returns a CoreError::Sqlite containing the provided message.

Examples

use ito_core::errors::CoreError;

let err = CoreError::sqlite("database locked");
let CoreError::Sqlite(msg) = err else {
    panic!("expected Sqlite variant");
};
assert_eq!(msg, "database locked");

Trait Implementations

impl Debug for CoreError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for CoreError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for CoreError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<DomainError> for CoreError

fn from(source: DomainError) -> Self

Converts to this type from the input type.