Struct User 

#[non_exhaustive]
pub struct User { /* private fields */ }

Who a request to a route of your own is, authenticated as REST does.

use axum::{extract::State, Json};
use postrust_server::{AppState, User};
use serde_json::{json, Value};
use std::sync::Arc;

async fn summary(
    user: User,
    State(state): State<Arc<AppState>>,
) -> Result<Json<Value>, postrust_server::Error> {
    let mut tx = state.begin_as(&user).await?;
    let n: i64 = sqlx::query_scalar("select count(*) from todos")
        .fetch_one(&mut *tx)
        .await?;
    tx.commit().await?;
    Ok(Json(json!({ "todos": n })))
}

As an extractor, User reads the Authorization header. A request with no token is the anonymous role (PGRST_DB_ANON_ROLE), or refused with PostgREST’s 401 where there is none; a token that does not verify is refused with the status and body the API gives it – PGRST301, PGRST303 and the rest, with the WWW-Authenticate challenge.

Option<User>

Option<User> is for a route that does something different for a caller who has not signed in, whatever the server’s anonymous role: it is None when the request sends no Authorization header at all, and Some with the token’s user when it sends one that verifies. A token that does not verify is still refused, not read as None: a client whose token has expired should be told so, not quietly answered as somebody else. A route that wants the anonymous role for a request with no token takes User itself; see User::is_anonymous.

What else it carries

What REST tells the database about a request besides who sent it, so that a policy or function reading request.headers, request.cookies, request.method, request.path or request.trace_id sees the same thing in a transaction of yours that it sees in REST’s:

• the method, and the path as the client sent it – with the prefix your router was nested at, where REST’s request.path is without /api, since that prefix is the API’s mount rather than part of the resource;
• every header, by its lowercase name, and the cookies;
• the trace the request belongs to, from the server’s request span.

Not the schema a Accept-Profile header names, nor the time zone a Prefer: timezone asks for: those are REST’s request syntax, and a route of yours has its own. Its transaction’s search_path starts at the default schema.

Implementations

impl User

pub fn role(&self) -> &str

The database role the request runs as: the token’s role claim, or the anonymous role.

pub fn claims(&self) -> &HashMap<String, Value>

The token’s claims, every one of them, as request.jwt.claims carries them. Empty for an anonymous request.

pub fn claim(&self, name: &str) -> Option<&Value>

One of the token’s claims, where it has it.

pub fn is_anonymous(&self) -> bool

Whether the request sent no token, and runs as the anonymous role.

pub fn trace_id(&self) -> Option<TraceId>

The trace the request belongs to, where the server’s request span gave it one.

Trait Implementations

impl Clone for User

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for User

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

Formats the value using the given formatter.

impl FromRequestParts<Arc<AppState>> for User

type Rejection = Error

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_parts( parts: &mut Parts, state: &Arc<AppState>, ) -> Result<Self, Self::Rejection>

Perform the extraction.

impl OptionalFromRequestParts<Arc<AppState>> for User

type Rejection = Error

If the extractor fails, it will use this “rejection” type.

async fn from_request_parts( parts: &mut Parts, state: &Arc<AppState>, ) -> Result<Option<Self>, Self::Rejection>

Perform the extraction.