Enum KevyError 

#[non_exhaustive]
pub enum KevyError {
    Store(StoreError),
    Io(Error),
    Protocol(String),
    ReadOnly,
    InvalidInput(String),
    NotFound(String),
    Unsupported(String),
    TimedOut,
    Closed,
}

The error type of the embeddable stack: kevy_embedded::Store and kevy_client::Connection surfaces return Result<_, KevyError>.

Structured errors stay structured — a wrong-type write arrives as KevyError::Store(StoreError::WrongType), not as stringly io::Error text. From<io::Error> / From<StoreError> keep ? ergonomic at both the OS boundary and the store boundary.

use kevy_store::{KevyError, StoreError};
let e = KevyError::from(StoreError::WrongType);
assert_eq!(e.to_string(), "store error: wrong type for this operation");
assert!(std::error::Error::source(&e).is_some());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Store(StoreError)

Structured store-semantic error (wrong type, non-integer, overflow, out-of-memory, …).

use kevy_store::{KevyError, SetCondition, Store, StoreError};
let mut s = Store::new();
s.set(b"k", b"text".to_vec(), None, SetCondition::Always);
let e = KevyError::from(s.incr_by(b"k", 1).unwrap_err());
assert!(matches!(e, KevyError::Store(StoreError::NotInteger)));

Io(Error)

Operating-system / transport failure (file, socket, AOF).

use kevy_store::KevyError;
let e: KevyError = std::fs::read("/nonexistent/kevy/file").unwrap_err().into();
let KevyError::Io(io) = &e else { panic!("expected Io") };
assert_eq!(io.kind(), std::io::ErrorKind::NotFound);

Protocol(String)

RESP-level failure on a client link: a server error reply (-ERR … text preserved verbatim) or a malformed / unexpected reply shape.

use kevy_store::KevyError;
let e = KevyError::Protocol("ERR unknown command".into());
assert_eq!(e.to_string(), "protocol error: ERR unknown command");

ReadOnly

Write rejected: the target is a read-only replica.

use kevy_store::KevyError;
let io: std::io::Error = KevyError::ReadOnly.into();
assert_eq!(io.kind(), std::io::ErrorKind::PermissionDenied);

InvalidInput(String)

Invalid argument to a typed API (bad flag combination, empty prefix, malformed URL, …). Rejected before touching any state.

use kevy_store::KevyError;
let e = KevyError::InvalidInput("empty prefix".into());
assert_eq!(e.to_string(), "invalid input: empty prefix");

NotFound(String)

A named object (index, view, required key) doesn’t exist.

use kevy_store::KevyError;
let io: std::io::Error = KevyError::NotFound("idx:users".into()).into();
assert_eq!(io.kind(), std::io::ErrorKind::NotFound);

Unsupported(String)

The operation isn’t available on this backend or build.

use kevy_store::KevyError;
let e = KevyError::Unsupported("tiering on wasm".into());
assert_eq!(e.to_string(), "unsupported: tiering on wasm");

TimedOut

A bounded blocking call ran out its timeout.

use kevy_store::KevyError;
let io: std::io::Error = KevyError::TimedOut.into();
assert_eq!(io.kind(), std::io::ErrorKind::TimedOut);

Closed

The connection / in-process bus is gone (EOF).

use kevy_store::KevyError;
assert_eq!(KevyError::Closed.to_string(), "connection closed");

Trait Implementations

impl Debug for KevyError

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

Formats the value using the given formatter.

impl Display for KevyError

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

Formats the value using the given formatter.

impl Error for KevyError

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<Error> for KevyError

Available on crate feature std only.

fn from(e: Error) -> KevyError

Converts to this type from the input type.

impl From<StoreError> for KevyError

fn from(e: StoreError) -> KevyError

Converts to this type from the input type.