Enum Error 

pub enum Error {
    DynamoDB(Box<Error>),
    Serde(Error),
    FailedBatchWrite(Vec<WriteRequest>),
    Other(Box<dyn Error + Send>),
    Custom(String),
}

The error type for all dynamodb-facade operations.

Wraps the various failure modes that can occur when interacting with DynamoDB: SDK-level transport and service errors, serialization failures, and application-defined errors.

Variants

• Error::DynamoDB — an error originating from the AWS SDK, such as a ConditionalCheckFailedException, a throttling error, or a network failure. Use Error::as_dynamodb_error to inspect the underlying aws_sdk_dynamodb::Error.
• Error::Serde — a (de)serialization failure produced by serde_dynamo when converting between Rust types and DynamoDB items.
• Error::Other — any other boxed core::error::Error. Useful for wrapping domain errors via Error::other.
• Error::FailedBatchWrite — a batch write that could not complete after all retry attempts. Contains the unprocessed WriteRequests.
• Error::Custom — a plain string error message. Useful for quick ad-hoc errors via Error::custom.

Examples

Matching on error variants:

use dynamodb_facade::Error;

fn handle(err: Error) {
    match err {
        Error::DynamoDB(_)          => eprintln!("AWS SDK error"),
        Error::Serde(_)             => eprintln!("serialization error"),
        Error::FailedBatchWrite(r)  => eprintln!("{} items unprocessed", r.len()),
        Error::Other(_)             => eprintln!("other error"),
        Error::Custom(msg)          => eprintln!("custom error: {msg}"),
    }
}

Variants

DynamoDB(Box<Error>)

An error returned by the AWS DynamoDB SDK.

This variant is produced automatically via the From impls for aws_sdk_dynamodb::error::SdkError and aws_sdk_dynamodb::Error. Use Error::as_dynamodb_error to borrow the inner error for pattern-matching on specific service errors such as ConditionalCheckFailedException.

Serde(Error)

A (de)serialization error from serde_dynamo.

Produced when converting a Rust struct to or from a DynamoDB item map fails — for example, when a required attribute is missing or has an unexpected type.

FailedBatchWrite(Vec<WriteRequest>)

A batch write that did not complete after all retry attempts.

Returned by dynamodb_batch_write when some WriteRequests remain unprocessed after the maximum number of retries. The contained vector holds the requests that were never acknowledged by DynamoDB, allowing the caller to inspect or retry them.

Other(Box<dyn Error + Send>)

Any other boxed error.

Use Error::other to wrap an arbitrary core::error::Error value into this variant.

Custom(String)

A plain string error message.

Use Error::custom to construct this variant.

Implementations

impl Error

pub fn custom(message: impl Into<String>) -> Self

Creates an Error::Custom from any value that converts into a String.

This is a convenience constructor for quick ad-hoc errors without needing to define a dedicated error type.

Examples

use dynamodb_facade::Error;

let err = Error::custom("enrollment limit reached");
assert!(matches!(err, Error::Custom(_)));
assert_eq!(err.to_string(), "Custom Error: enrollment limit reached");

pub fn other(error: impl Error + Send + Sync + 'static) -> Self

Creates an Error::Other by boxing any core::error::Error value.

Use this to wrap domain-specific or standard-library errors when implementing fallible methods from this crate — for example, a FromStr parse error inside a manual DynamoDBItem::try_from_item implementation.

Examples

Wrapping a ParseIntError when deserializing a DynamoDB string attribute into a numeric field:

use dynamodb_facade::Error;

fn parse_credits(raw: &str) -> dynamodb_facade::Result<u32> {
    raw.parse::<u32>().map_err(Error::other)
}

assert!(parse_credits("42").is_ok());
assert!(matches!(parse_credits("not-a-number"), Err(Error::Other(_))));

pub fn as_dynamodb_error(&self) -> Option<&Error>

Returns a reference to the inner aws_sdk_dynamodb::Error if this error is the Error::DynamoDB variant, or None otherwise.

Use this to inspect or pattern-match on specific DynamoDB service errors (e.g. ConditionalCheckFailedException, ResourceNotFoundException) without unwrapping the full error chain.

Examples

Distinguishing a “not found” condition failure from other errors when deleting an enrollment that must already exist:

match Enrollment::delete_by_id(client, KeyId::pk(user_id).sk(course_id))
    .exists()
    .await
{
    Ok(enrollment) => Ok(enrollment.expect("exists guard guarantees a return value")),
    Err(e) if matches!(
        e.as_dynamodb_error(),
        Some(DynamoDBError::ConditionalCheckFailedException(_))
    ) => Err(format!("enrollment for user {user_id} / course {course_id} not found")),
    Err(e) => Err(format!("unexpected error: {e}")),
}

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Box<dyn Error + Send>> for Error

fn from(source: Box<dyn Error + Send>) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

Converts an aws_sdk_dynamodb::Error into Error::DynamoDB.

Boxes the SDK error and wraps it in the Error::DynamoDB variant.

fn from(value: Error) -> Self

Converts to this type from the input type.

impl<T, R> From<SdkError<T, R>> for Error

where Error: From<SdkError<T, R>>,

Converts an aws_sdk_dynamodb::error::SdkError into Error::DynamoDB.

This impl is provided for all SdkError<T, R> where the SDK can convert the operation-specific error into the generic aws_sdk_dynamodb::Error. It allows the ? operator to be used directly on SDK call results.

fn from(value: SdkError<T, R>) -> Self

Converts to this type from the input type.