Enum BackendError 

#[non_exhaustive]
pub enum BackendError {
    NotADatabase,
    Locked,
    Constraint(String),
    Io(String),
    Validation(String),
    Unsupported {
        capability: &'static str,
    },
    OpfsUnavailable(String),
    Other(String),
}

Backend-neutral error variants surfaced by the StorageBackend trait.

Marked #[non_exhaustive]: a future backend may surface failure modes the native one cannot, so downstream code must not assume the variant set is closed. Added before the trait’s first release so later additions stay non-breaking.

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.

NotADatabase

The opened file is not a valid SQLite database, or is encrypted with the wrong key.

Locked

The database or a table within it is locked or busy.

Constraint(String)

A backend-level constraint (uniqueness, check, foreign key) was violated.

Io(String)

An I/O error from the backend.

Validation(String)

A client-facing validation failure raised by a backend method (for example the tag-count limit in set_tags). Carries the original message so From<BackendError> for DynoxideError can restore it as a ValidationException rather than collapsing it to a 500.

Unsupported

A capability the active backend does not implement (for example streams, TTL, or the cross-item TransactWriteItems action on the wasm backend). Carries a static tag so callers can distinguish which capability was refused. Surfaces as DynoxideError::UnsupportedCapability (HTTP 501 with the UnsupportedOperation envelope) through From<BackendError> for DynoxideError.

Fields

capability: &'static str

Static identifier for the unsupported capability, e.g. "streams".

OpfsUnavailable(String)

OPFS is present but its pool could not be acquired - typically another tab holds the database’s sync access handles. wasm backend only; restored by From<BackendError> for DynoxideError to a stable com.dynoxide.wasm#OpfsUnavailable envelope a browser client can react to.

Other(String)

Any other backend failure. Carries the original error’s Display output.

Trait Implementations

impl Debug for BackendError

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

Formats the value using the given formatter.

impl Display for BackendError

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

Formats the value using the given formatter.

impl Error for BackendError

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<BackendError> for DynoxideError

Most backend failures (BackendError) are storage-level faults: a locked database, an I/O error, a constraint the application layer did not anticipate. None of those is part of DynamoDB’s client-facing error contract, so they surface as InternalServerError (HTTP 500), matching how a raw rusqlite::Error surfaces via SqliteError.

There are two exceptions. The first is BackendError::Validation: a backend method such as set_tags enforces a client-facing limit (the 50-tag cap) and raises a ValidationException. That crosses the trait boundary as BackendError::Validation and is restored here to its ValidationException (HTTP 400) so the envelope is unchanged from calling Storage directly. The second is BackendError::Unsupported, which maps to DynoxideError::UnsupportedCapability (HTTP 501, the com.dynoxide.wasm#UnsupportedOperation envelope) so a capability gap reads as scope, not a server fault.

A one-way From is deliberate rather than merging the two types: BackendError is the narrow storage vocabulary, DynoxideError the wider API vocabulary. A merge is deferred.

fn from(err: BackendError) -> Self

Converts to this type from the input type.