Enum BackendChangesError 

#[non_exhaustive]
pub enum BackendChangesError<E> {
    CannotCalculate,
    TooManyChanges {
        limit: u64,
    },
    Other(E),
}

Error type returned by JmapBackend::get_changes and JmapBackend::query_changes.

CannotCalculate vs TooManyChanges

The two non-Other variants map to two distinct JMAP wire errors (RFC 8620 §5.6). Previously a single TooManyChanges { limit: 0 } variant overloaded both meanings via a magic-zero sentinel; the CannotCalculate variant was added in bd:JMAP-jfia.31 to surface the distinction at the type level. TooManyChanges { limit: 0 } is preserved as a permanent legacy alias — it still maps to cannotCalculateChanges via the From and Display impls — but new backends SHOULD construct CannotCalculate directly. See the TooManyChanges variant docs for why the alias cannot be #[deprecated] at the type level (bd:JMAP-jfia.37).

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.

CannotCalculate

The server has no usable change log for the given sinceState and cannot supply incremental changes — the client MUST discard ALL locally cached objects for the affected type, reset its local state token to the empty string, and perform a full resync (/get with ids: null). Partial recovery is not permitted. Maps to cannotCalculateChanges (RFC 8620 §5.6; authoritative behavior documented in jmapio/jmap-js mail-model.js).

Added in bd:JMAP-jfia.31 to replace the TooManyChanges { limit: 0 } magic-zero overload. New backends SHOULD construct CannotCalculate directly; legacy backends that emit TooManyChanges { limit: 0 } still map to the same wire error via the permanent legacy alias (bd:JMAP-jfia.37).

TooManyChanges

The change window exceeds what the server can supply in a single /changes response. Maps to tooManyChanges with the limit as the suggested maximum — the client may retry with a smaller window.

Legacy sub-case (bd:JMAP-jfia.31, bd:JMAP-jfia.37): a limit of 0 historically meant “full state reset required” and is preserved as an alias for the new Self::CannotCalculate variant. New code SHOULD use CannotCalculate directly. The alias is permanent at the type level — Rust cannot #[deprecated] a single discriminator value of an enum variant without deprecating the variant itself, and removing the alias would silently break any backend still emitting TooManyChanges { limit: 0 } (their returns would stop mapping to cannotCalculateChanges and start emitting a malformed RFC 8620 §5.6 tooManyChanges with limit: 0). The From and Display impls below pin the alias semantics permanently. Match arms in extension servers SHOULD treat TooManyChanges { limit: 0 } and CannotCalculate as a single “full-resync required” case rather than branching them apart.

Fields

limit: u64

Maximum window size the server can supply in a single /changes response. A value of 0 is the permanent legacy alias for Self::CannotCalculate; any non-zero value is the suggested maximum the client may retry with.

Other(E)

An unexpected storage-layer error.

Trait Implementations

impl<E: Debug> Debug for BackendChangesError<E>

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

Formats the value using the given formatter.

impl<E: Display> Display for BackendChangesError<E>

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

Formats the value using the given formatter.

impl<E: Error + 'static> Error for BackendChangesError<E>

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<E: Error> From<BackendChangesError<E>> for JmapError

fn from(e: BackendChangesError<E>) -> Self

Converts to this type from the input type.

impl<E> From<E> for BackendChangesError<E>

fn from(e: E) -> Self

Converts to this type from the input type.