Struct Context 

pub struct Context<'a, 'h, C> { /* private fields */ }

The handle a function receives for one invocation.

It carries the function’s typed, already-deserialized config, the caller’s id, and a borrow of the host so you can query the database. Construct it via the function! macro — you won’t build one yourself.

Implementations

impl<'a, 'h, C> Context<'a, 'h, C>

pub fn hook(&self) -> Option<&Hook>

The lifecycle-hook context when this call came from a resource hook, or None when the function was invoked directly over HTTP.

This is where the data around the operation lives: the row that was created, fetched or deleted, the rows a list returned, the request URL, and the caller’s auth status.

match ctx.hook() {
    Some(h) if h.is_before() => validate(h.data()),
    Some(h) => audit(&h.event, h.row()),
    None => {} // plain HTTP call
}

pub fn config(&self) -> &C

The function’s resolved, typed configuration (functions/<name>.toml).

pub fn principal_id(&self) -> &str

The authenticated caller’s user id, or "" when the endpoint is public and the caller is anonymous.

pub fn query(&self, sql: &str, params: &[Value]) -> Result<Vec<Value>, String>

Run a SELECT (or WITH) and get the rows as JSON objects.

pub fn query_one( &self, sql: &str, params: &[Value], ) -> Result<Option<Value>, String>

Run a query expected to return at most one row.

pub fn execute(&self, sql: &str, params: &[Value]) -> Result<u64, String>

Run an INSERT/UPDATE/DELETE and get the number of affected rows.

pub fn send_email(&self, email: Email) -> Result<Sent, String>

Send an email through whichever provider the app configured in [email], and get the provider’s receipt back.

The function doesn’t know or care which provider that is: the same call goes out through SES, SendGrid, Brevo, Mailjet or a plain SMTP relay depending on one line of main.toml.

ctx.send_email(
    Email::to("ann@example.com")
        .subject("Welcome")
        .text("Glad you're here.")
        .html("<p>Glad you're here.</p>"),
)?;

Errors when no provider is configured, when the message has no recipient, or when the provider refuses it. Whether that should fail the request is the caller’s decision — a failed welcome email usually shouldn’t undo the signup that triggered it.

pub fn cache_get(&self, key: &str) -> Result<Option<Value>, String>

Read a value from the app’s Redis cache. None for a miss.

if let Some(hit) = ctx.cache_get("rates:eur")? {
    return Ok(hit);
}
let rates = fetch();
ctx.cache_set("rates:eur", &rates, Some(900))?;

Errors when the app configured no cache, or when Redis is unreachable. Since a cache holds only what can be recomputed, treating an error like a miss (ctx.cache_get(k).ok().flatten()) is a reasonable choice — and the one that keeps the endpoint working while Redis restarts.

pub fn cache_get_as<T: DeserializeOwned>( &self, key: &str, ) -> Result<Option<T>, String>

Read a value and deserialize it. A miss and a value of the wrong shape both come back as None, because a cache entry written by an older version of the function is a miss in every way that matters.

pub fn cache_set<T: Serialize>( &self, key: &str, value: &T, ttl_secs: Option<u64>, ) -> Result<(), String>

Write a value, expiring after ttl_secs. None uses the app’s [cache] default_ttl_secs; Some(0) means “keep it until deleted”.

pub fn cache_delete(&self, key: &str) -> Result<bool, String>

Drop a key. true when it was there.

pub fn cache_incr( &self, key: &str, by: i64, ttl_secs: Option<u64>, ) -> Result<i64, String>

Add by to a counter and return its new value, starting from zero.

The increment happens on the server, so this counts correctly across every worker and every host — which is what makes it usable for rate limiting, and what a get + set pair could not do. ttl_secs is applied only when the counter is created, so a window doesn’t extend itself on every hit.

pub fn cache_ttl(&self, key: &str) -> Result<Option<i64>, String>

Seconds until key expires; None when it is absent or set to persist.

pub fn log(&self, level: LogLevel, message: &str)

Log through the host’s tracing subscriber.

pub fn info(&self, message: &str)

Log at INFO.

pub fn warn(&self, message: &str)

Log at WARN.

pub fn error(&self, message: &str)

Log at ERROR.

pub fn debug(&self, message: &str)

Log at DEBUG.