Rust SDK (auris)

[dependencies]
auris  = "0.1"
tokio  = { version = "1", features = ["full"] }

use auris::AurisClient;
 
#[tokio::main]
async fn main() -> auris::Result<()> {
    let client = AurisClient::new("https://auth.yourdomain.com", "your-client-id");
 
    let result = client.login("[email protected]", "password").await?;
    println!("Logged in as {}", result.user.email);
    println!("Access token: {}", result.access_token);
 
    Ok(())
}

let result = client.login("[email protected]", "password").await?;
// result.access_token   String
// result.refresh_token  Option<String>
// result.user           UserInfo
 
client.logout().await?;

if let Some(user) = client.get_user().await? {
    println!("{} {} {:?}", user.id, user.email, user.roles);
}

let token: Option<String> = client.get_access_token().await;
// Use in Authorization: Bearer <token> headers

let result = client.refresh_token(refresh_token).await?;

let token = client.get_m2m_token("client-secret", &["read:users", "manage:roles"]).await?;
// token.access_token  String
// token.expires_in    u64

// Send magic link email
client.login_with_magic_link("[email protected]").await?;
 
// Verify the token from the link URL
let result = client.verify_magic_link("token-from-url").await?;

use auris::ManagementClient;
 
let mgmt = ManagementClient::new(
    "https://auth.yourdomain.com",
    "your-client-id",
    "your-client-secret",
).await?;

// List users
let users = mgmt.list_users().await?;
 
// Get a single user
let user = mgmt.get_user("user-id").await?;
 
// Create a user
let user = mgmt.create_user(serde_json::json!({
    "email": "[email protected]",
    "name":  "New User",
})).await?;
 
// Delete a user
mgmt.delete_user("user-id").await?;
 
// Assign roles
mgmt.assign_roles("user-id", &["role-id-1", "role-id-2"]).await?;
 
// Remove roles
mgmt.remove_roles("user-id", &["role-id-1"]).await?;

// List organizations
let orgs = mgmt.list_organizations().await?;
 
// Get an organization
let org = mgmt.get_organization("org-id").await?;
 
// Create an organization
let org = mgmt.create_organization(serde_json::json!({
    "name": "Acme Corp",
})).await?;
 
// Delete an organization
mgmt.delete_organization("org-id").await?;
 
// List members
let members = mgmt.list_members("org-id").await?;
 
// Add a member
mgmt.add_member("org-id", "user-id", "member").await?;
 
// Remove a member
mgmt.remove_member("org-id", "user-id").await?;

let roles = mgmt.list_roles().await?;

use auris::FgaClient;
 
let fga = FgaClient::new(
    "https://auth.yourdomain.com",
    "your-client-id",
    "your-client-secret",
).await?;

let allowed = fga.check_permission("user:alice", "read", "document:budget").await?;
println!("Allowed: {}", allowed);

let checks = vec![
    auris::PermissionCheck {
        user:     "user:alice".into(),
        relation: "read".into(),
        object:   "document:budget".into(),
    },
    auris::PermissionCheck {
        user:     "user:alice".into(),
        relation: "write".into(),
        object:   "document:budget".into(),
    },
];
let results = fga.check_permissions(&checks).await?;

fga.tuple_write(&[auris::PermissionCheck {
    user:     "user:bob".into(),
    relation: "viewer".into(),
    object:   "document:report".into(),
}]).await?;

use auris::verify_webhook_signature;
use axum::{
    body::Bytes,
    http::{HeaderMap, StatusCode},
};
 
async fn webhook_handler(headers: HeaderMap, body: Bytes) -> StatusCode {
    let signature = headers
        .get("X-Auris-Signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
 
    if !verify_webhook_signature(&body, signature, "your-webhook-secret") {
        return StatusCode::UNAUTHORIZED;
    }
 
    // Process webhook event...
    StatusCode::OK
}

use auris::{AurisClient, AurisError};
 
match client.login("[email protected]", "wrong-password").await {
    Ok(result) => {
        println!("Token: {}", result.access_token);
    }
    Err(AurisError::Http { status, message }) => {
        eprintln!("HTTP {status}: {message}");
    }
    Err(AurisError::Network(e)) => {
        eprintln!("Network error: {e}");
    }
    Err(e) => {
        eprintln!("Unexpected error: {e}");
    }
}