Struct Functions

pub struct Functions { /* private fields */ }

Edge Functions client for invoking serverless functions

Examples

Basic function invocation:

use supabase::Client;
use serde_json::json;

let client = Client::new("your-project-url", "your-anon-key")?;

// Invoke a function with parameters
let result = client.functions()
    .invoke("hello-world", Some(json!({"name": "World"})))
    .await?;

println!("Function result: {}", result);

Streaming function responses:

use supabase::Client;
use serde_json::json;
use tokio_stream::StreamExt;

let client = Client::new("your-project-url", "your-anon-key")?;

// Stream function responses
let mut stream = client.functions()
    .invoke_stream("data-processor", Some(json!({"batch_size": 100})))
    .await?;

while let Some(chunk) = stream.next().await {
    match chunk {
        Ok(data) => println!("Received: {:?}", data),
        Err(e) => println!("Stream error: {}", e),
    }
}

Implementations

impl Functions

pub fn new( config: Arc<SupabaseConfig>, http_client: Arc<HttpClient>, ) -> Result<Self>

Create a new Functions instance

pub async fn invoke( &self, function_name: &str, body: Option<Value>, ) -> Result<Value>

Invoke an Edge Function

Parameters

• function_name - Name of the function to invoke
• body - Optional JSON body to send to the function

Examples

use serde_json::json;

// Simple function call
let result = functions.invoke("hello", None).await?;

// Function with parameters
let result = functions.invoke("process-data", Some(json!({
    "user_id": 123,
    "action": "update_profile"
}))).await?;

pub async fn invoke_with_options( &self, function_name: &str, body: Option<Value>, headers: Option<HashMap<String, String>>, ) -> Result<Value>

Invoke an Edge Function with custom options

Parameters

• function_name - Name of the function to invoke
• body - Optional JSON body to send to the function
• headers - Optional additional headers to send

Examples

use supabase::Client;
use serde_json::json;
use std::collections::HashMap;

let client = Client::new("your-project-url", "your-anon-key")?;

let mut headers = HashMap::new();
headers.insert("X-Custom-Header".to_string(), "custom-value".to_string());

let result = client.functions()
    .invoke_with_options("my-function", Some(json!({"data": "value"})), Some(headers))
    .await?;

pub async fn invoke_stream( &self, function_name: &str, body: Option<Value>, ) -> Result<impl Stream<Item = Result<StreamChunk>>>

Invoke an Edge Function with streaming response (native only)

This method enables server-sent events or streaming responses from functions. Only available on native platforms (not WASM).

Parameters

• function_name - Name of the function to invoke
• body - Optional JSON body to send to the function

Examples

use serde_json::json;
use tokio_stream::StreamExt;

let mut stream = functions.invoke_stream("streaming-function", Some(json!({
    "mode": "realtime",
    "duration": 60
}))).await?;

while let Some(chunk) = stream.next().await {
    match chunk {
        Ok(data) => println!("Received chunk: {}", data.data),
        Err(e) => println!("Stream error: {}", e),
    }
}

pub async fn get_function_metadata( &self, function_name: &str, ) -> Result<FunctionMetadata>

Get metadata for a specific function

Parameters

• function_name - Name of the function to introspect

Examples

let metadata = functions.get_function_metadata("my-function").await?;
println!("Function: {}", metadata.name);
println!("Status: {:?}", metadata.status);
println!("Memory: {:?} MB", metadata.memory_limit);

pub async fn list_functions(&self) -> Result<Vec<FunctionMetadata>>

List all available functions with their metadata

Examples

let functions_list = functions.list_functions().await?;
for func in functions_list {
    println!("Function: {} - Status: {:?}", func.name, func.status);
}

pub async fn invoke_with_advanced_options( &self, function_name: &str, body: Option<Value>, options: InvokeOptions, ) -> Result<Value>

Invoke a function with advanced options

Parameters

• function_name - Name of the function to invoke
• body - Optional JSON body to send to the function
• options - Invocation options (headers, timeout, retry, etc.)

Examples

use supabase::functions::{InvokeOptions, RetryConfig};
use serde_json::json;
use std::{collections::HashMap, time::Duration};

let mut headers = HashMap::new();
headers.insert("X-Priority".to_string(), "high".to_string());

let options = InvokeOptions {
    headers: Some(headers),
    timeout: Some(Duration::from_secs(30)),
    retry: Some(RetryConfig::default()),
    streaming: false,
};

let result = functions.invoke_with_advanced_options(
    "critical-function",
    Some(json!({"data": "important"})),
    options
).await?;

pub async fn test_local( &self, function_name: &str, body: Option<Value>, local_config: LocalConfig, ) -> Result<Value>

Test a function locally (for development)

Parameters

• function_name - Name of the function to test
• body - Optional JSON body to send to the function
• local_config - Local development configuration

Examples

use supabase::functions::LocalConfig;
use serde_json::json;

let local_config = LocalConfig {
    local_url: "http://localhost:54321".to_string(),
    functions_dir: Some("./functions".to_string()),
    port: Some(54321),
};

let result = functions.test_local(
    "my-function",
    Some(json!({"test": true})),
    local_config
).await?;

pub fn functions_url(&self) -> String

Get the base Functions URL

Trait Implementations

impl Clone for Functions

fn clone(&self) -> Functions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Functions

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

Formats the value using the given formatter.