Struct AuthToken 

pub struct AuthToken {
    pub id: i64,
    pub user_id: ForeignKey<AuthUser>,
    pub key_hash: String,
    pub name: String,
    pub created_at: DateTime<Utc>,
    pub last_used_at: Option<DateTime<Utc>>,
}

One row per active bearer token. A user can hold any number of these (one per device / per environment / per CI runner). The name column is the human label shown in admin / management listings; it has no functional role.

The key_hash column carries base64(sha256(plaintext)) (43 chars, URL-safe, no padding) under a UNIQUE index so a digest collision is forbidden. The plaintext lives only in memory at creation time and in whatever client storage the caller chose.

last_used_at is updated best-effort on every successful lookup (a failure to write does not fail the auth). Useful for “this token has not been used in 90 days, prune it” cleanup jobs.

Fields

id: i64

user_id: ForeignKey<AuthUser>

Owning user. FK against auth_user.id. ON DELETE CASCADE — when a user row is deleted, every token they hold goes with them. Otherwise revoking a user would leave orphan tokens that no longer match any user via the auth lookup, silently failing 401 instead of cleanly disappearing.

key_hash: String

base64(sha256(plaintext)) — 43 chars, URL-safe, no pad. The UNIQUE constraint protects against the (cryptographically negligible) chance of two random keys hashing to the same digest, and lets the lookup path stop at the first match.

name: String

Human label. Shown in admin listings and the management CLI; never used for lookup. Defaults to “default” when the caller does not name the token.

created_at: DateTime<Utc>

last_used_at: Option<DateTime<Utc>>

Last time this token authenticated a request. NULL until the first successful lookup.

Implementations

impl AuthToken

pub fn objects() -> Manager<Self>

impl AuthToken

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

pub const USER_ID: ForeignKeyCol<Self> = auth_token::USER_ID

pub const KEY_HASH: StrCol<Self> = auth_token::KEY_HASH

pub const NAME: StrCol<Self> = auth_token::NAME

pub const CREATED_AT: DateTimeCol<Self> = auth_token::CREATED_AT

pub const LAST_USED_AT: NullableDateTimeCol<Self> = auth_token::LAST_USED_AT

impl AuthToken

pub async fn create_for( user: &AuthUser, name: &str, ) -> Result<(Self, PlaintextToken), AuthError>

Mint a new bearer token for user. Returns the persisted row plus the plaintext key — the caller is responsible for surfacing the plaintext to whoever needs it (response body, admin “copy this” UI). The plaintext is not recoverable from the row alone after this call returns.

name is a free-form label shown in admin and management listings. Pass "" to default to "default".

pub async fn lookup(plaintext: &str) -> Result<Option<Self>, AuthError>

Look up the token row a plaintext key resolves to. Returns Ok(None) for an unrecognised token (the auth backend will then treat the request as anonymous); Err only on a DB failure.

pub async fn revoke(&self) -> Result<(), AuthError>

Revoke this token by deleting its row. The next request that carries this plaintext fails AuthToken::lookup and is treated as anonymous.

Trait Implementations

impl Clone for AuthToken

fn clone(&self) -> AuthToken

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthToken

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AuthToken

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 AuthToken

where &'a str: ColumnIndex<R>, i64: Decode<'a, R::Database> + Type<R::Database>, ForeignKey<AuthUser>: Decode<'a, R::Database> + Type<R::Database>, String: 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 AuthToken

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 AuthToken

const NAME: &'static str = "AuthToken"

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_token"

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 = "AuthToken"

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 AuthToken

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

where __S: Serializer,

Serialize this value into the given Serde serializer.