Struct Identity 

pub struct Identity {
    pub user_id: String,
    pub is_staff: bool,
    pub is_superuser: bool,
    pub extras: HashMap<String, Value>,
}

Who the request belongs to, after authentication.

The shape is intentionally narrow: user_id, is_staff, and is_superuser cover most permission checks. An extras map carries app-specific bits (role names, organisation id, scope strings) for custom permission impls.

Fields

user_id: String

The authenticated user’s primary key, stringified so the same Identity shape works whether the active user model has an i64, String, or UUID primary key. The framework’s own permissions plugin and session store speak strings.

To get the typed key back, use Identity::pk — not .parse(). This doc-comment used to say “parse on demand (identity.user_id.parse::<i64>())”, and a live consumer duly wrote that expression ~19 times, each with its own bespoke error branch for a failure that cannot happen. Documentation that hands you a snippet is documentation that decides your code; this one was teaching the boilerplate it should have been replacing. (gaps3 #57.)

In a handler, prefer not to touch this field at all — the RequireAuth<T> / RequireStaff extractors hand you the typed key in the signature, so a handler that forgot to authenticate cannot be written.

is_staff: bool

Staff flag. Used by the built-in IsStaff permission class in umbral-rest.

is_superuser: bool

Superuser flag. A superuser bypasses all permission checks in the built-in permission classes; custom permission impls can consult this field to grant unconditional access.

extras: HashMap<String, Value>

App-specific extras a permission check might want to consult. umbral-auth doesn’t populate this; user-defined auth backends can stuff role names, organisation ids, etc. here.

Implementations

impl Identity

pub fn pk<T: FromStr>(&self) -> Result<T, IdentityPkError>

The user’s primary key, typed (gaps3 #57).

user_id is a String because the framework supports i64, String and UUID primary keys behind one Identity shape. This converts it back:

let uid: i64 = identity.pk()?;

Err carries the unparseable value, which is the only useful thing to say about it — but note that in a correctly-configured app this cannot fail: the string was produced by Display on that very key type. That is precisely why hand-writing .parse::<i64>().map_err(|_| some_500())? at every call site is waste: it is an error branch for an impossible state, repeated once per handler.

pub fn user(user_id: impl ToString) -> Self

Convenience constructor for a non-staff user. Accepts any stringifiable PK — Identity::user(42), Identity::user("42"), or Identity::user(uuid.to_string()) all work because the argument is impl ToString.

pub fn staff(self) -> Self

Promote to staff. Chainable.

pub fn with_staff(self, is_staff: bool) -> Self

Set the staff flag explicitly. Chainable.

pub fn with_superuser(self, is_superuser: bool) -> Self

Set the superuser flag explicitly. Chainable.

pub fn with_extra(self, key: impl Into<String>, value: Value) -> Self

Insert an extras entry. Chainable.

pub fn user_pk<T: FromStr>(&self) -> Result<T, T::Err>

Parse the stringified user_id back into the caller’s primary-key type.

Identity::user_id is a String — the lowest common denominator across i64 / String / UUID user models. Rather than hand-roll identity.user_id.parse::<i64>().map_err(|_| /* 401 */)? in every scoped handler (the pattern a live consumer repeated ~8×), call identity.user_pk::<i64>()?. Generic over any T: FromStr, so it works for numeric, string, and UUID keys alike; a parse mismatch is returned as T::Err so the caller owns the HTTP shape (usually a 401/400).

Trait Implementations

impl Clone for Identity

fn clone(&self) -> Identity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Identity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Identity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Identity

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

where __S: Serializer,

Serialize this value into the given Serde serializer.