Generate UUID in Rust

// Cargo.toml: uuid = { version = "1", features = ["v4"] }
use uuid::Uuid;

let id = Uuid::new_v4();
println!("{}", id); // → "550e8400-e29b-41d4-a716-446655440000"

// Cargo.toml: uuid = { version = "1", features = ["v7"] }
use uuid::Uuid;

// Millisecond-precision timestamp prefix + random suffix
// IDs generated later always sort after earlier ones
let id = Uuid::now_v7();
println!("{}", id); // → "018e8f6a-1b2c-7d3e-9f4a-5b6c7d8e9f0a"

// Cargo.toml: uuid = { version = "1", features = ["v5"] }
use uuid::Uuid;

// SHA-1 hash of namespace + name - same inputs always produce the same UUID
let id = Uuid::new_v5(&Uuid::NAMESPACE_DNS, b"example.com");
println!("{}", id); // → always "cfbff0d1-9375-5685-968c-48ce8b15ae17"

// Custom namespace for your application
let my_ns = Uuid::new_v4(); // generate once, store as a constant
let record_id = Uuid::new_v5(&my_ns, b"user:42");

// Cargo.toml: uuid = { version = "1", features = ["v3"] }
use uuid::Uuid;

// MD5-based - prefer v5 (SHA-1) for new code
let id = Uuid::new_v3(&Uuid::NAMESPACE_DNS, b"example.com");
println!("{}", id);

use axum::{middleware::Next, response::Response, http::Request};
use uuid::Uuid;

// Axum middleware that injects a request ID into every response
pub async fn request_id_middleware<B>(
    mut req: Request<B>,
    next: Next<B>,
) -> Response {
    let request_id = Uuid::new_v4().to_string();
    req.headers_mut().insert(
        "x-request-id",
        request_id.parse().unwrap(),
    );
    let mut response = next.run(req).await;
    response.headers_mut().insert(
        "x-request-id",
        request_id.parse().unwrap(),
    );
    response
}

use sqlx::PgPool;
use uuid::Uuid;
use serde::{Deserialize, Serialize};

// Cargo.toml: uuid = { version = "1", features = ["v4", "serde"] }
#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: Uuid,   // Store as Uuid type, not String
    name: String,
}

async fn create_user(pool: &PgPool, name: &str) -> Result<User, sqlx::Error> {
    let user = sqlx::query_as!(
        User,
        "INSERT INTO users (id, name) VALUES ($1, $2) RETURNING id, name",
        Uuid::new_v4(),
        name
    )
    .fetch_one(pool)
    .await?;
    Ok(user)
}

use uuid::Uuid;

const EVENT_NAMESPACE: Uuid = Uuid::from_bytes([
    0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1,
    0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8,
]);

// Idempotent: same event always gets the same UUID
fn event_id(source: &str, event_type: &str, timestamp: &str) -> Uuid {
    let key = format!("{}:{}:{}", source, event_type, timestamp);
    Uuid::new_v5(&EVENT_NAMESPACE, key.as_bytes())
}

fn main() {
    let id1 = event_id("payments", "charge.created", "2026-05-01T12:00:00Z");
    let id2 = event_id("payments", "charge.created", "2026-05-01T12:00:00Z");
    assert_eq!(id1, id2); // always true - safe to retry
}