Struct Field 

pub struct Field {
    pub name: String,
    pub kind: InputKind,
    pub required: bool,
    pub validators: Vec<Box<dyn Validator>>,
    pub options: Vec<(String, String)>,
}

A single form field: name + kind + validators. The field doesn’t own its parsed value; validate reads from the form-data map and pushes errors onto the accumulator.

Fields

name: String

kind: InputKind

required: bool

validators: Vec<Box<dyn Validator>>

options: Vec<(String, String)>

(value, label) pairs for Select fields. Empty for every other kind. For ModelChoice / ModelMultiChoice the options are fetched async at render time (Task 6), so they stay empty here too.

Implementations

impl Field

pub fn text(name: impl Into<String>) -> Self

New text field. Caller adds validators via builder methods.

pub fn email(name: impl Into<String>) -> Self

New email field. Carries EmailFormat by default.

pub fn regex(self, pattern: &str, message: impl Into<String>) -> Self

Attach a regex-pattern validator to an existing field. Composes with Required, MinLength, MaxLength, etc. — the regex check fires after the others, so empty / missing values surface the right “is required” error rather than a confusing “doesn’t match pattern” error.

The pattern is compiled eagerly — an invalid regex panics at construction time. The derive macro short-circuits this by emitting the literal pattern, so a malformed #[form(regex = "...")] surfaces as a panic in tests rather than silently passing every input.

Use {field} in the message to interpolate the field name.

let f = Field::text("invoice_id")
    .regex(r"^INV-\d{6}$", "{field} must look like `INV-123456`");

pub fn phone(name: impl Into<String>) -> Self

New phone field — E.164 international format (+<country><subscriber>, e.g. +14155551234). Catches the common typo’d-phone cases (“07065”, “+0…”, letters mixed in, dashes / spaces / parens that proper E.164 doesn’t allow). Renders as <input type="tel"> so mobile browsers pop the number keypad.

Soft-validation case (“accept anything phone-ish, even without country code”): use Field::text + your own .regex(...). The strict E.164 pattern here is the right default because every form that asks for a phone number SHOULD be storing them in E.164 (the only shape that round-trips across providers / SMS gateways / address books).

pub fn url(name: impl Into<String>) -> Self

New URL field — http(s) only, requires a host. Conservative: ftp:// / mailto: / etc. get rejected so a form that promises “URL” doesn’t persist a non-web scheme.

pub fn password(name: impl Into<String>) -> Self

New password field. Identical validation rules to text; the difference is the rendered <input type="password"> so the browser masks input.

pub fn file(name: impl Into<String>) -> Self

New file field — renders <input type="file">. One kind covers both FileField and ImageField: the Form-side input is just a file input (the admin’s image-preview is a column-widget concern, not a form-input concern).

The submitted value is the opaque storage key the admin’s multipart handler stored after the upload; there’s nothing to validate about a key string beyond required/optional, so the only validator is Required (dropped via .optional() for a nullable field). Length / regex / format validators don’t apply.

pub fn integer(name: impl Into<String>) -> Self

New integer field. Validates that the value parses as i64.

pub fn float(name: impl Into<String>) -> Self

New floating-point field. Renders as <input type="number"> (no step set; HTML’s default accepts decimals). Validates only Required; the macro’s parse step is what catches non-numeric input — the field-level validator would reject integer literals which is the wrong shape for an f64 field.

pub fn boolean(name: impl Into<String>) -> Self

New boolean field. Required-by-default would be wrong here (HTML emits the field key only when the box is checked), so boolean fields skip Required.

pub fn select( name: impl Into<String>, options: Vec<(String, String)>, nullable: bool, ) -> Self

New closed-set select field. options are (value, label) pairs from a ChoiceField’s VALUES/LABELS. nullable prepends a leading empty option and drops Required.

pub fn model_choice( name: impl Into<String>, target_table: &'static str, label_field: Option<&'static str>, pk_kind: PkKind, nullable: bool, ) -> Self

New single-select FK field. options are fetched async at render time (Task 6); at validate time only pk_kind is used to parse the submitted id.

pub fn model_multi_choice( name: impl Into<String>, target_table: &'static str, label_field: Option<&'static str>, pk_kind: PkKind, ) -> Self

New multi-select M2M field. Options are fetched async at render time; submission is a list of child ids written to the junction table after the parent insert.

pub fn optional(self) -> Self

Mark the field as optional. The validate method short-circuits when required is false and the value is empty, so the Required validator (if any) doesn’t fire on an empty optional field. Validators that wrap non-empty values (MinLength, Pattern, …) still run when there’s something to check.

pub fn min_length(self, n: usize) -> Self

Add a MinLength(n) validator. Builder method, returns self.

pub fn max_length(self, n: usize) -> Self

Add a MaxLength(n) validator. Builder method, returns self.

pub fn with_validator(self, v: impl Validator + 'static) -> Self

Add a custom validator. Named with_validator rather than add so it doesn’t shadow std::ops::Add::add for clippy.

pub fn validate(&self, value: &str, errors: &mut ValidationErrors)

Run every validator over value. Errors push onto errors. An empty value on a non-required field skips validation entirely (an optional empty input is valid).

pub fn render_html(&self, value: &str) -> String

Render the field as a single HTML <input> element. The value is the form’s prefill (empty for a fresh form, the raw user input on a re-render after validation failed).

pub async fn render_html_async(&self, value: &str) -> String

Async render entry point. ModelChoice / ModelMultiChoice fetch their options first, then render the <select>; every other kind defers to the sync render_html.