golgi/examples/basic.rs

use std::process;

use golgi::{messages::SsbMessageContent, sbot::Keystore, GolgiError, Sbot};

// Golgi is an asynchronous library so we must call it from within an
// async function. The `GolgiError` type encapsulates all possible
// error variants for the library.
async fn run() -> Result<(), GolgiError> {
    // Attempt to initialise a connection to an sbot instance using the
    // secret file at the Patchwork path and the default IP address, port
    // and network key (aka. capabilities key).
    let mut sbot_client = Sbot::init(Keystore::Patchwork, None, None).await?;

    // Alternatively, we could specify a non-standard IP and port.
    // let ip_port = "127.0.0.1:8021".to_string();
    // let mut sbot_client = Sbot::init(Some(ip_port), None).await?;

    // Call the `whoami` RPC method to retrieve the public key for the sbot
    // identity. This is our 'local' public key.
    let id = sbot_client.whoami().await?;

    // Print the public key (identity) to `stdout`.
    println!("whoami: {}", id);

    // Compose an SSB `about` message type.
    // The `SsbMessageContent` type has many variants and allows for a high
    // degree of control when creating messages.
    let name = SsbMessageContent::About {
        about: id.clone(),
        name: Some("golgi".to_string()),
        title: None,
        branch: None,
        image: None,
        description: None,
        location: None,
        start_datetime: None,
    };

    // Publish the name message. The `publish` method returns a reference to
    // the published message.
    let name_msg_ref = sbot_client.publish(name).await?;

    // Print the message reference to `stdout`.
    println!("name_msg_ref: {}", name_msg_ref);

    // Compose an SSB `post` message type.
    let post = SsbMessageContent::Post {
        text: "golgi go womp womp".to_string(),
        mentions: None,
    };

    // Publish the post.
    let post_msg_ref = sbot_client.publish(post).await?;

    // Print the post reference to `stdout`.
    println!("post_msg_ref: {}", post_msg_ref);

    // Golgi also exposes convenience methods for some of the most common
    // message types. Here we see an example of a convenience method for
    // posting a description message. The description is for the local
    // identity, ie. we are publishing this about "ourself".
    let post_msg_ref = sbot_client
        .publish_description("this is a description")
        .await?;

    // Print the description message reference to `stdout`.
    println!("description: {}", post_msg_ref);

    let author: String = id.clone();
    println!("author: {:?}", author);

    // Retrieve the description for the given public key (identity).
    let description = sbot_client.get_description(&author).await?;

    // Print the description to `stdout`.
    println!("found description: {:?}", description);

    // Compose and publish another `post` message type.
    let post = SsbMessageContent::Post {
        text: "golgi go womp womp2".to_string(),
        mentions: None,
    };

    let post_msg_ref = sbot_client.publish(post).await?;
    println!("post_msg_ref2: {}", post_msg_ref);

    Ok(())
}

// Enable an async main function and execute the `run()` function,
// catching any errors and printing them to `stderr` before exiting the
// process.
#[async_std::main]
async fn main() {
    if let Err(e) = run().await {
        eprintln!("Application error: {}", e);
        process::exit(1);
    }
}