reflow_api_services 0.2.0

#![allow(clippy::all, unused_imports, dead_code)]

//! Auto-generated API actors for Supabase
//!
//! Service: Supabase (supabase)
//! Open source Firebase alternative with PostgreSQL database
//!
//! Required env var: SUPABASE_API_KEY (API key)
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, Message, Port};
use anyhow::{Error, Result};
use reflow_actor::{message::EncodableValue, ActorContext};
use reflow_actor_macro::actor;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::time::Duration;

const BASE_URL: &str = "https://{project_ref}.supabase.co/rest/v1";
const ENV_KEY: &str = "SUPABASE_API_KEY";

/// Apply authentication to the request builder.
fn apply_auth(
    config: &reflow_actor::ActorConfig,
    mut builder: reqwest::RequestBuilder,
) -> Result<reqwest::RequestBuilder> {
    let credential = config
        .get_config_or_env(ENV_KEY)
        .ok_or_else(|| anyhow::anyhow!("Missing env var: {}", ENV_KEY))?;
    builder = builder.header("apikey", &credential);
    Ok(builder)
}

/// create record via Supabase API
///
/// Method: POST /{table}
#[actor(
    SupabaseCreateRecordActor,
    inports::<100>(table),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_record(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// read records via Supabase API
///
/// Method: GET /{table}
#[actor(
    SupabaseReadRecordsActor,
    inports::<100>(table, select),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_read_records(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("select") {
        query_pairs.push(("select", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Query rows from a table with filtering, ordering, and pagination
///
/// Method: GET /{table}
#[actor(
    SupabaseListRowsActor,
    inports::<100>(table, select, order, limit, offset, apikey, Authorization),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_list_rows(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("select") {
        query_pairs.push(("select", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("order") {
        query_pairs.push(("order", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("Authorization") {
        builder = builder.header("Authorization", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Insert one or more rows into a table
///
/// Method: POST /{table}
#[actor(
    SupabaseCreateRowActor,
    inports::<100>(table, Prefer, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_row(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Prefer") {
        builder = builder.header("Prefer", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update rows in a table matching the filter conditions
///
/// Method: PATCH /{table}
#[actor(
    SupabaseUpdateRowActor,
    inports::<100>(table, Prefer, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_update_row(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.patch(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Prefer") {
        builder = builder.header("Prefer", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PATCH /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete rows from a table matching the filter conditions
///
/// Method: DELETE /{table}
#[actor(
    SupabaseDeleteRowActor,
    inports::<100>(table, Prefer, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_delete_row(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/{table}".to_string();
    if let Some(val) = inputs.get("table") {
        endpoint = endpoint.replace("{{table}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Prefer") {
        builder = builder.header("Prefer", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("DELETE /{{table}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Register a new user with email and password
///
/// Method: POST /auth/v1/signup
#[actor(
    SupabaseCreateAuthUserActor,
    inports::<100>(email, password, data, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_auth_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/signup".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("password") {
        body.insert("password".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("data") {
        body.insert("data".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/signup failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sign in a user and get an access token
///
/// Method: POST /auth/v1/token
#[actor(
    SupabaseCreateAuthSessionActor,
    inports::<100>(grant_type, email, password, refresh_token, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_auth_session(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/token".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("grant_type") {
        query_pairs.push(("grant_type", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("password") {
        body.insert("password".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("refresh_token") {
        body.insert("refresh_token".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/token failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sign out a user and invalidate their session
///
/// Method: POST /auth/v1/logout
#[actor(
    SupabaseDeleteAuthSessionActor,
    inports::<100>(Authorization, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_delete_auth_session(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/logout".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Authorization") {
        builder = builder.header("Authorization", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/logout failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get the current authenticated user
///
/// Method: GET /auth/v1/user
#[actor(
    SupabaseReadAuthUserActor,
    inports::<100>(Authorization, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_read_auth_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/user".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Authorization") {
        builder = builder.header("Authorization", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /auth/v1/user failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update the current user's data
///
/// Method: PUT /auth/v1/user
#[actor(
    SupabaseUpdateAuthUserActor,
    inports::<100>(email, password, data, Authorization, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_update_auth_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/user".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Authorization") {
        builder = builder.header("Authorization", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("password") {
        body.insert("password".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("data") {
        body.insert("data".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /auth/v1/user failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Send a password recovery email
///
/// Method: POST /auth/v1/recover
#[actor(
    SupabaseCreatePasswordRecoveryActor,
    inports::<100>(email, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_password_recovery(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/recover".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/recover failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Send a magic link email for passwordless sign-in
///
/// Method: POST /auth/v1/magiclink
#[actor(
    SupabaseCreateMagicLinkActor,
    inports::<100>(email, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_magic_link(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/magiclink".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/magiclink failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Send OTP for phone or email authentication
///
/// Method: POST /auth/v1/otp
#[actor(
    SupabaseCreateOtpActor,
    inports::<100>(phone, email, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_otp(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/otp".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("phone") {
        body.insert("phone".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /auth/v1/otp failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List all storage buckets
///
/// Method: GET /storage/v1/bucket
#[actor(
    SupabaseListStorageBucketsActor,
    inports::<100>(Authorization, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_list_storage_buckets(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/storage/v1/bucket".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Authorization") {
        builder = builder.header("Authorization", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /storage/v1/bucket failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a new storage bucket
///
/// Method: POST /storage/v1/bucket
#[actor(
    SupabaseCreateStorageBucketActor,
    inports::<100>(id, name, public, file_size_limit, allowed_mime_types, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_storage_bucket(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/storage/v1/bucket".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("id") {
        body.insert("id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("public") {
        body.insert("public".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("file_size_limit") {
        body.insert("file_size_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("allowed_mime_types") {
        body.insert("allowed_mime_types".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /storage/v1/bucket failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get details of a specific storage bucket
///
/// Method: GET /storage/v1/bucket/{bucket_id}
#[actor(
    SupabaseReadStorageBucketActor,
    inports::<100>(bucket_id, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_read_storage_bucket(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/bucket/{bucket_id}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /storage/v1/bucket/{{bucket_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Update a storage bucket
///
/// Method: PUT /storage/v1/bucket/{bucket_id}
#[actor(
    SupabaseUpdateStorageBucketActor,
    inports::<100>(bucket_id, public, file_size_limit, allowed_mime_types, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_update_storage_bucket(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/bucket/{bucket_id}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("public") {
        body.insert("public".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("file_size_limit") {
        body.insert("file_size_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("allowed_mime_types") {
        body.insert("allowed_mime_types".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("PUT /storage/v1/bucket/{{bucket_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete a storage bucket
///
/// Method: DELETE /storage/v1/bucket/{bucket_id}
#[actor(
    SupabaseDeleteStorageBucketActor,
    inports::<100>(bucket_id, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_delete_storage_bucket(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/bucket/{bucket_id}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("DELETE /storage/v1/bucket/{{bucket_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Upload a file to a storage bucket
///
/// Method: POST /storage/v1/object/{bucket_id}/{object_path}
#[actor(
    SupabaseUploadStorageObjectActor,
    inports::<100>(bucket_id, object_path, Content_Type, x_upsert, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_upload_storage_object(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/object/{bucket_id}/{object_path}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("object_path") {
        endpoint = endpoint.replace("{{object_path}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("Content_Type") {
        builder = builder.header("Content-Type", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("x_upsert") {
        builder = builder.header("x-upsert", super::message_to_str(val));
    }
    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "POST /storage/v1/object/{{bucket_id}}/{{object_path}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Download a file from a storage bucket
///
/// Method: GET /storage/v1/object/{bucket_id}/{object_path}
#[actor(
    SupabaseDownloadStorageObjectActor,
    inports::<100>(bucket_id, object_path, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_download_storage_object(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/object/{bucket_id}/{object_path}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("object_path") {
        endpoint = endpoint.replace("{{object_path}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /storage/v1/object/{{bucket_id}}/{{object_path}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete one or more files from a storage bucket
///
/// Method: DELETE /storage/v1/object/{bucket_id}
#[actor(
    SupabaseDeleteStorageObjectActor,
    inports::<100>(bucket_id, prefixes, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_delete_storage_object(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/object/{bucket_id}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("DELETE /storage/v1/object/{{bucket_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// List all objects in a storage bucket
///
/// Method: POST /storage/v1/object/list/{bucket_id}
#[actor(
    SupabaseListStorageObjectsActor,
    inports::<100>(bucket_id, prefix, limit, offset, sortBy, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_list_storage_objects(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/object/list/{bucket_id}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("prefix") {
        body.insert("prefix".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("limit") {
        body.insert("limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("offset") {
        body.insert("offset".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("sortBy") {
        body.insert("sortBy".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /storage/v1/object/list/{{bucket_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create a signed URL to access a private object
///
/// Method: POST /storage/v1/object/sign/{bucket_id}/{object_path}
#[actor(
    SupabaseCreateStorageSignedUrlActor,
    inports::<100>(bucket_id, object_path, expiresIn, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_storage_signed_url(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/storage/v1/object/sign/{bucket_id}/{object_path}".to_string();
    if let Some(val) = inputs.get("bucket_id") {
        endpoint = endpoint.replace("{{bucket_id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("object_path") {
        endpoint = endpoint.replace("{{object_path}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("expiresIn") {
        body.insert("expiresIn".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "POST /storage/v1/object/sign/{{bucket_id}}/{{object_path}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Call a stored PostgreSQL function
///
/// Method: POST /rpc/{function_name}
#[actor(
    SupabaseCreateRpcActor,
    inports::<100>(function_name, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_create_rpc(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/rpc/{function_name}".to_string();
    if let Some(val) = inputs.get("function_name") {
        endpoint = endpoint.replace("{{function_name}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /rpc/{{function_name}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List all users (admin only)
///
/// Method: GET /auth/v1/admin/users
#[actor(
    SupabaseListAuthUsersActor,
    inports::<100>(page, per_page, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_list_auth_users(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/auth/v1/admin/users".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /auth/v1/admin/users failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete a user (admin only)
///
/// Method: DELETE /auth/v1/admin/users/{uid}
#[actor(
    SupabaseDeleteAuthUserActor,
    inports::<100>(uid, apikey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn supabase_delete_auth_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/auth/v1/admin/users/{uid}".to_string();
    if let Some(val) = inputs.get("uid") {
        endpoint = endpoint.replace("{{uid}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    if let Some(val) = inputs.get("apikey") {
        builder = builder.header("apikey", super::message_to_str(val));
    }
    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("DELETE /auth/v1/admin/users/{{uid}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}