Struct FormErrors 

pub struct FormErrors { /* private fields */ }

Form-validation error envelope. Wraps the ORM’s WriteError so every surface (REST 400 bodies, admin form spans, HTML form renders) sees the same structured shape. The template helper as_template_ctx produces the flat single-string-per-field view that most form templates ask for.

Not Clone because WriteError carries a sqlx::Error variant that’s also not Clone. If you need a cheap copyable bundle of rendered messages, use Self::as_template_ctx which returns an owned serde_json::Map.

Implementations

impl FormErrors

pub fn new(err: WriteError) -> Self

Wrap any WriteError. Use From for free conversion in ? chains. The raw values default to empty — call Self::with_raw when you have the submitted pairs in scope (typically only inside an axum extractor).

pub fn with_raw(err: WriteError, raw: HashMap<String, String>) -> Self

Construct a FormErrors carrying both the validation failure AND the raw form pairs the user submitted. The raw pairs let the handler re-render the form pre-filled with what the user typed instead of falling back to T::default() (which loses every keystroke).

pub fn raw_values(&self) -> &HashMap<String, String>

Borrow the raw form pairs the user submitted, if the extractor captured them. Empty when the FormErrors was constructed via Self::new or any From impl that doesn’t see the request body.

pub fn raw_as_json(&self) -> Value

JSON-shaped view of the raw values, ready to drop straight into a template context as the form key so existing {{ form.<field> }} references repopulate the user’s input. The map is String → String so every value serialises to a JSON string — templates that need typed access should call Self::raw_values and convert per field.

pub fn as_write_error(&self) -> &WriteError

Borrow the underlying WriteError — keeps every accessor available (field_errors(), non_field_errors(), error_code()).

pub fn into_write_error(self) -> WriteError

Move out the underlying WriteError (e.g. to feed a REST-style error-body builder).

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

Per-field error map — see WriteError::field_errors.

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

Cross-field / non-field error list — see WriteError::non_field_errors.

pub fn as_template_ctx(&self) -> Map<String, Value>

Template-friendly flat view: each field maps to its FIRST error message (string), plus the FIRST non-field error under the form key. Renders directly under the errors context key — templates write {{ errors.name }} or {% if errors.form %}.

For templates that need to render EVERY error per field (rare), call [field_errors] / [non_field_errors] directly and pass the maps as-is.

pub fn render(&self, template: &str) -> Response

Render template with this failed submission bound into scope and return the complete HTTP response. The one-liner for a form handler’s Err arm:

let msg = match form.into_result() {
    Ok(v) => v,
    Err(errs) => return Ok(errs.render("contact.html")),
};

What the template sees:

• form — the raw pairs the user submitted, so {{ form.<field> }} repopulates every keystroke.
• errors — the flat per-field view from Self::as_template_ctx, plus a default form-level summary under errors.form (“Please fix the highlighted fields and try again.”) when no non-field error supplied one — every form page wants the banner, so the framework defaults it.
• Anything ambient (csrf_token / csrf_input / user) via the normal render merge.

Status is 422 Unprocessable Entity. A template failure returns a plain 500 carrying the render error. Extra context keys (page flags, chrome): Self::render_with.

pub fn render_with(&self, template: &str, extra: Map<String, Value>) -> Response

Self::render plus caller-supplied top-level context keys. extra wins over the form / errors bindings on key collision — the caller is more specific than the default.

Trait Implementations

impl Debug for FormErrors

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

Formats the value using the given formatter.

impl Display for FormErrors

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

Formats the value using the given formatter.

impl Error for FormErrors

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<ValidationErrors> for FormErrors

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.