sdk-connection-rust.rs

// Couchbase SDK connection singleton — Rust
// Copy and adapt for your application.
//
// Dependencies (Cargo.toml):
//   couchbase = "1"
//   tokio = { version = "1", features = ["full"] }
//   serde_json = "1"

use couchbase::{
    authenticator::{Authenticator, PasswordAuthenticator},
    cluster::Cluster,
    collection::Collection,
    options::cluster_options::ClusterOptions,
};
use std::sync::OnceLock;

// --- Configuration ---
const CB_HOST: &str       = "localhost";          // or "cb.xxxxx.cloud.couchbase.com" for Capella
const CB_USER: &str       = "app-service-user";
const CB_PASSWORD: &str   = "AppSecret123!";
const CB_BUCKET: &str     = "myapp";
const CB_SCOPE: &str      = "_default";
const CB_COLLECTION: &str = "_default";
// Use "couchbases://" for TLS (required for Capella, recommended for production)
const CB_SCHEME: &str     = "couchbase";

static CLUSTER: OnceLock<Cluster> = OnceLock::new();

/// Returns the singleton Cluster, initializing it on first call.
/// Call once at application startup (e.g. in main before spawning tasks).
pub async fn get_cluster() -> &'static Cluster {
    if let Some(c) = CLUSTER.get() {
        return c;
    }

    let cluster = Cluster::connect(
        &format!("{}://{}", CB_SCHEME, CB_HOST),
        ClusterOptions::new(Authenticator::PasswordAuthenticator(
            PasswordAuthenticator::new(CB_USER, CB_PASSWORD),
        )),
    )
    .await
    .expect("Couchbase connect failed");

    let bucket = cluster.bucket(CB_BUCKET);
    bucket
        .wait_until_ready(None)
        .await
        .expect("Bucket not ready");

    CLUSTER.set(cluster).ok();
    CLUSTER.get().unwrap()
}

/// Convenience: returns the default Collection from the singleton Cluster.
pub async fn get_collection() -> Collection {
    get_cluster()
        .await
        .bucket(CB_BUCKET)
        .scope(CB_SCOPE)
        .collection(CB_COLLECTION)
}

// --- Usage example ---
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let collection = get_collection().await;
    let cluster = get_cluster().await;

    // KV upsert
    collection.upsert(
        "doc_1",
        serde_json::json!({"type": "example", "value": 42}),
        None,
    ).await?;

    // KV get
    let result = collection.get("doc_1", None).await?;
    let doc: serde_json::Value = result.content_as()?;
    println!("{doc}");

    // SQL++ query
    let mut rows = cluster.query(
        "SELECT * FROM `myapp`._default._default WHERE type = $type LIMIT 5",
        couchbase::options::query_options::QueryOptions::new()
            .add_named_parameter("type", "example")?,
    ).await?;

    let mut stream = rows.rows();
    while let Some(row) = stream.next().await {
        let row: serde_json::Value = row?;
        println!("{row}");
    }

    Ok(())
}