Struct AuthUser 

pub struct AuthUser {
    pub id: i64,
    pub username: String,
    pub email: String,
    pub password_hash: String,
    pub is_active: bool,
    pub is_staff: bool,
    pub is_superuser: bool,
    pub date_joined: DateTime<Utc>,
    pub last_login: Option<DateTime<Utc>>,
    pub email_verified_at: Option<DateTime<Utc>>,
}

The canonical authentication user. #[derive(Model)] snake_cases the struct name into the table name auth_user; the M3 derive doesn’t yet accept #[umbral(table = ...)] so the snake_case round-trip is the only way to get a plugin-prefixed table name until the attribute lands.

Fields

id: i64

username: String

email: String

Shown read-only on edit forms; never on create forms (use the admin’s password field mechanism for changes).

password_hash: String

Never shown on any form — password management goes through the dedicated Change Password flow in the admin.

is_active: bool

is_staff: bool

is_superuser: bool

date_joined: DateTime<Utc>

last_login: Option<DateTime<Utc>>

email_verified_at: Option<DateTime<Utc>>

When this user’s email was verified, NULL until they complete the verification flow. Tracked always; only enforced when the plugin is built with require_verified_email().

Implementations

impl AuthUser

pub fn objects() -> Manager<Self>

impl AuthUser

pub const ID: IntCol<Self> = auth_user::ID

pub const USERNAME: StrCol<Self> = auth_user::USERNAME

pub const EMAIL: StrCol<Self> = auth_user::EMAIL

pub const PASSWORD_HASH: StrCol<Self> = auth_user::PASSWORD_HASH

pub const IS_ACTIVE: BoolCol<Self> = auth_user::IS_ACTIVE

pub const IS_STAFF: BoolCol<Self> = auth_user::IS_STAFF

pub const IS_SUPERUSER: BoolCol<Self> = auth_user::IS_SUPERUSER

pub const DATE_JOINED: DateTimeCol<Self> = auth_user::DATE_JOINED

pub const LAST_LOGIN: NullableDateTimeCol<Self> = auth_user::LAST_LOGIN

pub const EMAIL_VERIFIED_AT: NullableDateTimeCol<Self> = auth_user::EMAIL_VERIFIED_AT

Trait Implementations

impl AuthChallengeUserIdReverse for AuthUser

fn auth_challenge_set(&self) -> QuerySet<AuthChallenge>

impl AuthTokenUserIdReverse for AuthUser

fn auth_token_set(&self) -> QuerySet<AuthToken>

impl Clone for AuthUser

fn clone(&self) -> AuthUser

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AuthUser

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AuthUser

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, R: Row> FromRow<'a, R> for AuthUser

where &'a str: ColumnIndex<R>, i64: Decode<'a, R::Database> + Type<R::Database>, String: Decode<'a, R::Database> + Type<R::Database>, bool: Decode<'a, R::Database> + Type<R::Database>, DateTime<Utc>: Decode<'a, R::Database> + Type<R::Database>, Option<DateTime<Utc>>: Decode<'a, R::Database> + Type<R::Database>,

fn from_row(__row: &'a R) -> Result<Self>

impl HydrateRelated for AuthUser

fn fk_id_for(&self, field_name: &str) -> Option<Value>

Return the raw FK value stored in the field named field_name, or None if the field doesn’t exist on this model or is not a FK.

fn hydrate_fk(&mut self, field_name: &str, row: &Value)

Set ForeignKey<U>.resolved for the field named field_name by deserialising row as the target model type.

fn set_m2m_parent_ids(&mut self)

Set the parent_id cache on every M2M<U> field this model owns. Closes the second BUG-16 gap: without this, m2m.add(&t) silently writes a junction row with parent_id = 0 because the macro skips M2M fields in the FromRow decode path.

fn pk_as_json(&self) -> Option<Value>

Return this row’s primary key as a serde_json::Value, whatever the PK type — i64, String, uuid::Uuid, a custom newtype. The relation-hydration paths (prefetch_related, reverse-FK and reverse-OneToOne collection) bucket children by the parent’s PK, and keying those buckets on a Value (canonicalised via crate::orm::pk_key) lets UUID- and slug-PK models flow through too, not just i64.

fn set_m2m_resolved_json(&mut self, field_name: &str, rows: Vec<Value>)

Attach a list of pre-fetched child rows to the named M2M<U> field’s resolved slot. Called by QuerySet::prefetch_related (gap #19) after a batched JOIN through the junction table returns one Vec per parent.

fn set_reverse_fk_resolved_json(&mut self, field_name: &str, rows: Vec<Value>)

Gap #44 — attach a list of pre-fetched child rows to the named ReverseSet<C> field’s resolved slot. Counterpart to set_m2m_resolved_json but for reverse-FK collections (one parent, many children pointing at it via a FK column).

fn set_one_to_one_resolved_json(&mut self, field_name: &str, row: Option<Value>)

Reverse-OneToOne counterpart to set_reverse_fk_resolved_json. Called by prefetch_related with Some(child_json) when the runtime FK lookup found exactly one matching child, or None when no child matched (the slot still flips is_loaded() to true).

fn take_pending_m2m_into(&mut self, _dest: &mut Self)

Move form-staged M2M pending ids from self into dest, field by field. The typed create() builds its INSERT from the caller’s instance, then reads a fresh row back from the DB (carrying the autoincremented PK) — the pending ids staged by the Form derive live on the caller’s instance, not the readback row. This hook transfers them across so write_pending_m2m on the readback row (which has the real parent_id seeded) finds them. Default: no-op for models with no M2M fields.

fn write_pending_m2m<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>

Flush form-staged M2M selections to their junction tables after the parent row was inserted. The macro emits a body that walks this model’s M2M fields, reads parent_id + junction_table (seeded by set_m2m_parent_ids) and the pending child ids, and calls set_junction_dynamic. Default: no-op for models with no M2M fields.

impl Model for AuthUser

const NAME: &'static str = "AuthUser"

The struct name, used by the migration engine (M5) to label snapshot entries and to map autodetected operations back to the model that produced them. The M3 derive emits the struct ident verbatim (“Post”, “Comment”, etc.).

const TABLE: &'static str = "auth_user"

The SQL table name. M3’s derive defaults this to the snake_case of the struct name unless #[umbral(table = "...")] overrides it.

const APP_LABEL: &'static str = "app"

The app label (the owning plugin’s name) this model belongs to.

const FIELDS: &'static [FieldSpec]

Static metadata for every field on the model.

const DISPLAY: &'static str = "AuthUser"

Human-readable display name for this model, used by the admin sidebar as the default label. Defaults to Self::NAME.

const ICON: &'static str = "database"

Lucide icon slug shown next to this model in the admin sidebar. Defaults to "database". Any valid Lucide icon name works; unknown names are silently ignored by Lucide at render time.

const DATABASE: Option<&'static str> = ::core::option::Option::None

Database alias this model lives on, when the app registers more than one pool via AppBuilder::database(...). None (the default) means “use whatever the owning plugin chose via Plugin::database(), or \"default\" if neither side overrode.”

const SINGLETON: bool = false

Single-row-marker. When true, the admin auto-redirects the list view to the (sole) row’s edit form, hides the “+ New” button, and surfaces the model as a settings-style screen. The single-row settings model pattern. Set via #[umbral(singleton)] on the struct. Closes BUG-9 in bugs/tests/testBugs.md.

const SOFT_DELETE: bool = false

Feature #72 — soft-delete marker. Set via #[umbral(soft_delete)] on the struct. When true, the framework treats this model as having a deleted_at: Option<DateTime<Utc>> column (which the user MUST declare — derive macros can’t add fields to the input struct), and:

const UNIQUE_TOGETHER: &'static [&'static [&'static str]]

Composite-UNIQUE constraints. Each inner slice names a constraint over the listed column names. Set via #[umbral(unique_together = [["a", "b"]])]. Closes BUG-6 in bugs/tests/testBugs.md. Default empty; the migration engine emits one UNIQUE (col1, col2) clause per inner group on CREATE TABLE.

const INDEXES: &'static [&'static [&'static str]]

Multi-column indexes. Each inner slice names an index over the listed columns. Set via #[umbral(indexes = [["tenant_id", "created_at"]])]. Closes BUG-7. Default empty; the migration engine emits CREATE INDEX IF NOT EXISTS idx_<table>_<col1>_<col2> after the CREATE TABLE. Single-column indexes stay on the field attribute (#[umbral(index)]).

const ORDERING: &'static [(&'static str, bool)]

Default ORDER BY clause, applied when a QuerySet terminates without an explicit order_by. Each tuple is (column_name, is_descending). Set via #[umbral(ordering = ["-published_at", "id"])] (leading - flips to DESC). Closes BUG-8. Default empty.

const M2M_RELATIONS: &'static [M2MRelationSpec]

Many-to-many relations declared on this model. Each entry names a field and its target model. The migration engine uses this to auto-generate junction tables; the admin uses it to render M2M pickers. Default empty.

const REVERSE_FK_RELATIONS: &'static [ReverseFkRelationSpec]

Gap #44 — reverse-FK collections declared on this model via #[umbral(reverse_fk = "<fk_col>")] pub <name>: ReverseSet<C>. Each entry tells prefetch_related how to fetch the children: SELECT * FROM <target_table> WHERE <fk_column> IN (parent_pks) then group by <fk_column> value, populate each parent’s ReverseSet.resolved. Default empty; the macro emits one entry per declared ReverseSet<C> field.

const ONE_TO_ONE_RELATIONS: &'static [OneToOneRelationSpec]

Reverse OneToOne accessors declared on this model via pub <name>: OneToOne<C> (no umbral attribute required). Unlike REVERSE_FK_RELATIONS, the FK column on the child is not named at macro time — prefetch_related looks it up at runtime by scanning the child’s FIELDS for the UNIQUE FK pointing back at this model’s table. Exactly one match required; 0 or 2+ matches surface a loud error naming the ambiguity.

type PrimaryKey = i64

The primary-key type. M2 supports i64 only; UUID lands later.

fn primary_key(&self) -> i64

Return the primary key of this instance.

impl Serialize for AuthUser

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UserModel for AuthUser

fn id(&self) -> <Self as Model>::PrimaryKey

The row’s typed primary key. set_password uses this in the UPDATE WHERE clause; bearer-token / session backends use it to filter on auth_user::ID.eq(user.id()) style predicates.

fn username(&self) -> &str

The unique login handle. Matched against the username column in authenticate’s SELECT query.

fn password_hash(&self) -> &str

The argon2 PHC-encoded password hash stored in the DB column. authenticate reads this, verifies it, and moves on.

fn set_password_hash(&mut self, hash: String)

Replace the in-memory password hash. Called by set_password after writing the new hash to the database, so the caller’s &mut U reflects the update without a re-fetch.

fn is_active(&self) -> bool

Whether this account is active. authenticate rejects inactive users with InvalidCredentials (same error as wrong password - no account enumeration). Default: true.

fn is_staff(&self) -> bool

Whether this account has staff-level access to the admin interface. Default: false.

fn is_superuser(&self) -> bool

Whether this account has superuser rights. Default: false.

fn id_string(&self) -> String

The PK as a string. Used by umbral_sessions (which stores user_id as text) and by the REST identity contract’s Identity::user_id (which is uniform across user models).