Struct ChangesetForm 

pub struct ChangesetForm<T> {
    pub changeset: Changeset<T>,
    /* private fields */
}

Axum extractor that decodes a form body, runs validation, and captures the CSRF token — all in one step.

Supports both application/x-www-form-urlencoded (always) and multipart/form-data (when the multipart feature is enabled).

Unlike crate::validation::Valid, this extractor never rejects with 422 — errors live in the Changeset and the handler decides how to respond. Fails with 400 only when the body cannot be decoded into T at all.

CSRF — no extra developer action in POST handlers

The extractor reads the CsrfToken from request extensions (placed there by crate::security::CsrfLayer). Calling ChangesetForm::form_tag then emits the hidden _csrf input automatically — no separate CsrfToken parameter needed.

For GET handlers (new/edit), use ChangesetForm::blank and pass csrf.token() from a CsrfToken extractor.

Example

#[post("/users")]
async fn create(form: ChangesetForm<NewUser>) -> impl IntoResponse {
    match form.into_valid() {
        Ok(user) => { /* persist & redirect */ }
        Err(form) => (StatusCode::UNPROCESSABLE_ENTITY,
                      form.form_tag("/users", "post", html! {
                          (form.text_input("name", "Name"))
                          (form.submit_button("Save"))
                      })).into_response()
    }
}

Fields

changeset: Changeset<T>

The validated (or invalid) changeset.

Implementations

impl<T> ChangesetForm<T>

pub fn blank(data: T, csrf_token: &str) -> Self

Build a blank form context for GET handlers (new / edit).

Wraps data in a valid Changeset and stores csrf_token so that ChangesetForm::form_tag can emit the hidden input automatically.

#[get("/users/new")]
async fn new_user(csrf: CsrfToken) -> Markup {
    let ctx = ChangesetForm::blank(UserForm::default(), csrf.token());
    ctx.form_tag("/users", "post", html! { (ctx.text_input("name", "Name")) })
}

pub fn without_csrf(data: T) -> Self

Construct a display-only ChangesetForm with no CSRF token.

Use this on GET handlers where CSRF middleware is not active, or when the form will be re-rendered purely for display (e.g. an initial blank form on a page that does not enforce CSRF). form_tag will omit the hidden CSRF input when no token is stored.

pub fn from_changeset(changeset: Changeset<T>) -> Self

Wrap a pre-built Changeset (which may already carry validation errors) in a ChangesetForm without a CSRF token.

Useful in tests and cases where a Changeset was produced externally (e.g. via IntoChangeset) before constructing a form for rendering.

pub fn with_csrf_field(self, field: impl Into<String>) -> Self

Override the CSRF form-field name used by ChangesetForm::form_tag.

Call this when security.csrf.form_field is set to something other than "_csrf" (e.g. "authenticity_token"). The CsrfFormField extension populated by from_request sets this automatically for POST handlers; use this builder on GET handlers that construct a blank form with blank.

pub fn csrf_token(&self) -> Option<&str>

The CSRF token captured from the request, if the CSRF middleware is active.

pub fn into_changeset(self) -> Changeset<T>

Consume and return only the inner Changeset.

pub fn into_valid(self) -> Result<T, Self>

Return Ok(T) if the changeset is valid, Err(self) if not.

The Err branch returns the whole ChangesetForm (with its CSRF token) so the handler can immediately call form.form_tag() to re-render with inline errors.

Errors

Returns Err(self) when the inner changeset has field-level validation errors.

impl<T: Serialize> ChangesetForm<T>

Maud rendering methods — emit form HTML with automatic CSRF injection.

pub fn form_tag(&self, action: &str, method: &str, content: Markup) -> Markup

Render a <form> element with the stored CSRF token injected as a hidden input — the field name honours security.csrf.form_field from config, so no developer action is required even for non-default names.

pub fn text_input(&self, field: &str, label: &str) -> Markup

Render a labeled <input type="text"> for field using the stored changeset (value + errors).

pub fn submit_button(&self, label: &str) -> Markup

Render a <button type="submit"> with label.

Methods from Deref<Target = Changeset<T>>

pub fn is_valid(&self) -> bool

Returns true when there are no field-level errors.

pub fn errors_for(&self, field: &str) -> &[String]

Returns the validation messages for field, or an empty slice.

pub fn data(&self) -> &T

Shared reference to the inner data.

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

All field errors as a map (field name → list of messages).

pub fn field_value(&self, field: &str) -> Option<String>

Serialize the value of field from the inner data to a String.

Used by rendering helpers to re-populate <input value="…"> after a failed submission. Returns None for missing or non-scalar fields.

Trait Implementations

impl<T> Deref for ChangesetForm<T>

Dereferences to Changeset<T> so all changeset methods are available directly on ChangesetForm<T> — form.is_valid(), form.errors_for(…), etc.

type Target = Changeset<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S, T> FromRequest<S> for ChangesetForm<T>

where S: Send + Sync, T: DeserializeOwned + Validate,

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection>

Perform the extraction.