Enum CommerceError 

#[non_exhaustive]
pub enum CommerceError {
    OrderNotFound(Uuid),
    OrderCannotBeCancelled(String),
    OrderCannotBeRefunded(String),
    InvalidOrderStatusTransition {
        from: String,
        to: String,
    },
    InventoryItemNotFound(String),
    InsufficientStock {
        sku: String,
        requested: String,
        available: String,
    },
    ReservationNotFound(Uuid),
    ReservationExpired(Uuid),
    DuplicateSku(String),
    CustomerNotFound(Uuid),
    EmailAlreadyExists(String),
    CustomerNotActive,
    ProductNotFound(Uuid),
    ProductVariantNotFound(Uuid),
    DuplicateSlug(String),
    ProductNotPurchasable,
    ReturnNotFound(Uuid),
    ReturnCannotBeApproved(String),
    ReturnPeriodExpired,
    ItemNotEligibleForReturn,
    ValidationError(String),
    InvalidInput {
        field: String,
        message: String,
    },
    DatabaseError(String),
    Database(DbError),
    NotFound,
    Conflict(String),
    OptimisticLockFailure,
    VersionConflict {
        entity: String,
        id: String,
        expected_version: i32,
    },
    ExternalServiceError(String),
    Order(OrderError),
    Inventory(InventoryError),
    Customer(CustomerError),
    Product(ProductError),
    Return(ReturnError),
    Payment(PaymentError),
    Shipping(ShippingError),
    Internal(String),
    NotPermitted(String),
}

Main error type for commerce operations.

This is the top-level error that all public APIs return. Domain-specific sub-errors (OrderError, InventoryError, etc.) convert into this type via From impls, so callers can work with a uniform result type while domain code uses precise error types internally.

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.

OrderNotFound(Uuid)

Order with given ID was not found.

OrderCannotBeCancelled(String)

Order cannot be cancelled in its current status.

OrderCannotBeRefunded(String)

Order cannot be refunded.

InvalidOrderStatusTransition

Invalid status transition for an order.

Fields

from: String

The current status.

to: String

The requested new status.

InventoryItemNotFound(String)

Inventory item not found by SKU or ID.

InsufficientStock

Insufficient stock for the requested quantity.

Fields

sku: String

The SKU that has insufficient stock.

requested: String

The quantity that was requested.

available: String

The quantity that is available.

ReservationNotFound(Uuid)

Inventory reservation not found.

ReservationExpired(Uuid)

Inventory reservation has expired.

DuplicateSku(String)

Duplicate SKU already exists.

CustomerNotFound(Uuid)

Customer with given ID was not found.

EmailAlreadyExists(String)

Email address is already registered.

CustomerNotActive

Customer account is not active.

ProductNotFound(Uuid)

Product with given ID was not found.

ProductVariantNotFound(Uuid)

Product variant with given ID was not found.

DuplicateSlug(String)

Duplicate product slug already exists.

ProductNotPurchasable

Product is not available for purchase.

ReturnNotFound(Uuid)

Return with given ID was not found.

ReturnCannotBeApproved(String)

Return cannot be approved in its current status.

ReturnPeriodExpired

Return period has expired.

ItemNotEligibleForReturn

Item is not eligible for return.

ValidationError(String)

General validation error.

InvalidInput

Invalid input for a specific field.

Fields

field: String

The field that has invalid input.

message: String

The validation error message.

DatabaseError(String)

Legacy database error (for backwards compatibility).

Database(DbError)

Typed database error with context.

NotFound

Generic record not found.

Conflict(String)

Conflict during operation.

OptimisticLockFailure

Optimistic locking failure.

VersionConflict

Version conflict during update.

Fields

entity: String

The entity type (e.g., “order”, “customer”).

id: String

The entity ID.

expected_version: i32

The expected version that was not found.

ExternalServiceError(String)

External service (payment, shipping, etc.) failed.

Order(OrderError)

Order-domain error.

Inventory(InventoryError)

Inventory-domain error.

Customer(CustomerError)

Customer-domain error.

Product(ProductError)

Product-domain error.

Return(ReturnError)

Return-domain error.

Payment(PaymentError)

Payment-domain error.

Shipping(ShippingError)

Shipping-domain error.

Internal(String)

Internal error.

NotPermitted(String)

Operation not permitted.

Implementations

impl CommerceError

pub const fn is_not_found(&self) -> bool

Check if error is a not found error.

pub const fn is_validation(&self) -> bool

Check if error is a validation error.

pub const fn is_conflict(&self) -> bool

Check if error is a conflict error.

pub const fn is_database(&self) -> bool

Check if error is a database error.

pub const fn is_external_service(&self) -> bool

Check if error is an external service error.

pub const fn is_retryable(&self) -> bool

Check if error is retryable.

Retryable errors include:

• Connection failures
• Pool exhaustion
• Transaction failures (some)
• Optimistic lock failures

pub const fn is_transient(&self) -> bool

Check if error is transient (temporary failures that may resolve on retry).

This is a superset of is_retryable — it also includes external service failures which may recover after a delay.

pub const fn is_client_error(&self) -> bool

Check if error is a client error (bad input from the caller).

Client errors include not-found, validation, conflict, and permission errors.

pub const fn is_server_error(&self) -> bool

Check if error is a server error (internal / infrastructure failures).

Server errors include database errors, internal errors, and external service failures.

pub const fn is_not_permitted(&self) -> bool

Check if this is a permission-denied error.

pub const fn suggested_status_code(&self) -> u16

Suggest an HTTP status code for this error.

Useful for API layers that need to map domain errors to HTTP responses.

Example

use stateset_core::CommerceError;

let err = CommerceError::NotFound;
assert_eq!(err.suggested_status_code(), 404);

let err = CommerceError::ValidationError("bad".into());
assert_eq!(err.suggested_status_code(), 400);

pub const fn as_db_error(&self) -> Option<&DbError>

Get the underlying database error if this is a database error.

pub const fn as_order_error(&self) -> Option<&OrderError>

Get the underlying order error if this is an order error.

pub const fn as_inventory_error(&self) -> Option<&InventoryError>

Get the underlying inventory error if this is an inventory error.

pub const fn as_customer_error(&self) -> Option<&CustomerError>

Get the underlying customer error if this is a customer error.

pub const fn as_product_error(&self) -> Option<&ProductError>

Get the underlying product error if this is a product error.

pub const fn db(error: DbError) -> CommerceError

Create a database error from a typed DbError.

pub fn query_failed( table: &'static str, operation: &'static str, message: impl Into<String>, ) -> CommerceError

Create a query failed error with context.

pub fn constraint_violation( table: &'static str, constraint: impl Into<String>, message: impl Into<String>, ) -> CommerceError

Create a constraint violation error.

pub fn connection_failed( url: impl Into<String>, message: impl Into<String>, ) -> CommerceError

Create a connection failed error.

Trait Implementations

impl Debug for CommerceError

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

Formats the value using the given formatter.

impl Display for CommerceError

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

Formats the value using the given formatter.

impl Error for CommerceError

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 #99301)

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

impl From<CustomerError> for CommerceError

fn from(source: CustomerError) -> CommerceError

Converts to this type from the input type.

impl From<DbError> for CommerceError

fn from(source: DbError) -> CommerceError

Converts to this type from the input type.

impl From<InventoryError> for CommerceError

fn from(source: InventoryError) -> CommerceError

Converts to this type from the input type.

impl From<MaintenanceError> for CommerceError

fn from(err: MaintenanceError) -> CommerceError

Converts to this type from the input type.

impl From<OrderError> for CommerceError

fn from(source: OrderError) -> CommerceError

Converts to this type from the input type.

impl From<PaymentError> for CommerceError

fn from(source: PaymentError) -> CommerceError

Converts to this type from the input type.

impl From<ProductError> for CommerceError

fn from(source: ProductError) -> CommerceError

Converts to this type from the input type.

impl From<ReturnError> for CommerceError

fn from(source: ReturnError) -> CommerceError

Converts to this type from the input type.

impl From<ShippingError> for CommerceError

fn from(source: ShippingError) -> CommerceError

Converts to this type from the input type.