Enum WriteError 

pub enum WriteError {
    RequiredFieldMissing {
        field: String,
    },
    BlankNotAllowed {
        field: String,
    },
    ForeignKeyNotFound {
        field: String,
        target_table: String,
        value: Value,
    },
    UniqueViolation {
        field: Option<String>,
        value: Option<Value>,
    },
    NotNullViolation {
        field: Option<String>,
    },
    CheckViolation {
        constraint: Option<String>,
    },
    ForeignKeyViolation {
        field: Option<String>,
    },
    Multiple {
        errors: Vec<WriteError>,
    },
    TypeMismatch {
        field: String,
        expected: SqlType,
        got: String,
    },
    Validator {
        field: String,
        message: String,
    },
    NotAnObject,
    SerializeFailed(Error),
    Sqlx(Error),
    UnknownColumn {
        field: String,
    },
}

Errors that can surface when converting JSON values to bindable sea-query values, when pre-validating against the schema, or when the write itself fails. Every variant that the REST / admin plugins surface as a per-field error has its own structured shape so the boundary translation is a match, not a string parse.

Variants

RequiredFieldMissing

A non-nullable field received a JSON null (or was absent on create). Names the offending field.

Fields

field: String

BlankNotAllowed

A non-nullable text field received an empty string where a meaningful value was required (a non-blank text column). Surfaced by pre-validation in insert_json.

Fields

field: String

ForeignKeyNotFound

A foreign-key column references a row that doesn’t exist in the target table. Pre-validated against the live DB before the INSERT/UPDATE so the response keys the error under the FK column with the offending value.

Fields

field: String

target_table: String

value: Value

UniqueViolation

DB-side UNIQUE constraint failure. field is Some(col) when the message / constraint name names the column (SQLite always; Postgres via the <table>_<col>_key convention); None for unparseable cases. value carries the offending JSON value when the original body is still available.

Fields

field: Option<String>

value: Option<Value>

NotNullViolation

DB-side NOT NULL constraint failure (caller bypassed pre- validation, e.g. via a raw transaction).

Fields

field: Option<String>

CheckViolation

DB-side CHECK constraint failure. Carries the constraint name when the engine surfaces it (Postgres does; SQLite gives just a generic message).

Fields

constraint: Option<String>

ForeignKeyViolation

DB-side foreign-key constraint failure that pre-validation missed (rare — typically a race where the target row was deleted between the existence check and the INSERT).

Fields

field: Option<String>

Multiple

Multiple validation errors at once. Surfaced by insert_json when required + FK checks both fire, so the caller can render every problem in one response.

Fields

errors: Vec<WriteError>

TypeMismatch

The JSON value couldn’t be coerced to the column’s SqlType. e.g. a string body where an integer was expected.

Fields

field: String

expected: SqlType

got: String

Validator

Format validator (#[umbral(slug)] / email / url / min = N / max = N) rejected the value.

Fields

field: String

message: String

NotAnObject

serde_json couldn’t serialize the instance to a JSON object (the only shape Manager::create accepts).

SerializeFailed(Error)

The model isn’t Serialize. Surfaced by the trait bound on Manager::create; not actually constructable from runtime. Kept here for completeness so the variant exists in the docs.

Sqlx(Error)

sqlx error during the write. Wraps the driver-level cause.

UnknownColumn

update_values received a column name that doesn’t exist on the model. Caught early before SQL is built.

Fields

field: String

Implementations

impl WriteError

pub fn field_errors(&self) -> BTreeMap<String, Vec<String>>

Flatten into a {field: [messages, ...]} map. Used by the REST plugin to render the 400 body; the admin plugin will use the same shape for inline form errors. Variants that aren’t tied to a specific field (raw sqlx, NotAnObject, etc.) produce empty maps — the caller’s non-field-error envelope covers those.

pub fn non_field_errors(&self) -> Vec<String>

Non-field-level errors, for the non_field_errors array. Only populated for the parseable-but-non-keyed constraint variants and the multi-error wrapper.

pub fn code(&self) -> &'static str

Stable machine-readable code for the boundary layer. REST puts this in the code field of the 400 body; admin uses it to pick an inline error style.

pub fn is_validation(&self) -> bool

true for the variants that represent user-fixable input problems (renderable as a 400). false for genuine infrastructure / serialization failures (which should surface as 500s).

Trait Implementations

impl Debug for WriteError

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

Formats the value using the given formatter.

impl Display for WriteError

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

Formats the value using the given formatter.

impl Error for WriteError

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 WriteError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for WriteError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<ValidationErrors> for WriteError

Lift the form-primitive ValidationErrors into the canonical WriteError. Each per-field message becomes a WriteError::Validator { field, message }; non-field messages become an Anonymous validator carrying the bare message. Wrapped under WriteError::Multiple when there’s more than one.

fn from(e: ValidationErrors) -> Self

Converts to this type from the input type.

impl From<WriteError> for FormErrors

fn from(e: WriteError) -> Self

Converts to this type from the input type.

impl From<WriteError> for DynError

fn from(e: WriteError) -> Self

Converts to this type from the input type.

impl From<WriteError> for SaveError

fn from(e: WriteError) -> Self

Converts to this type from the input type.