golgi/examples/ssb-stream-example.rs

use std::process;

use golgi::error::GolgiError;

use golgi::sbot::Sbot;
use async_std::stream::{Stream, StreamExt};
use futures::{pin_mut, TryStreamExt};
use golgi::messages::{SsbMessageContentType, SsbMessageValue};


async fn run() -> Result<(), GolgiError> {
    let mut sbot_client = Sbot::init(None, None).await?;

    let id = sbot_client.whoami().await?;
    println!("{}", id);

    let author = "@L/z54cbc8V1kL1/MiBhpEKuN3QJkSoZYNaukny3ghIs=.ed25519";

    // create a history stream
    let mut history_stream = sbot_client.create_history_stream(author.to_string()).await?;

    // loop through the results until the end of the stream
    pin_mut!(history_stream); // needed for iteration
    println!("looping through stream");
    while let Some(res) = history_stream.next().await {
        match res {
            Ok(value) => {
                println!("value: {:?}", value);
            },
            Err(err) => {
                println!("err: {:?}", err);
            }
        }
    }
    println!("reached end of stream");

    // // create a history stream and convert it into a Vec<SsbMessageValue> using try_collect
    // //  (if there is any error in the results, it will be raised)
    // let mut history_stream = sbot_client.create_history_stream(author.to_string()).await?;
    // let results : Vec<SsbMessageValue> = history_stream.try_collect().await?;
    // for x in results {
    //     println!("x: {:?}", x);
    // }
    //
    // // example to create a history stream and use a map to convert stream of SsbMessageValue
    // // into a stream of KeyTypeTuple (local struct for storing message_key and message_type)
    // #[derive(Debug)]
    // struct KeyTypeTuple {
    //     message_key: String,
    //     message_type: SsbMessageContentType,
    // };
    // let mut history_stream = sbot_client.create_history_stream(author.to_string()).await?;
    // let type_stream = history_stream.map(|msg| {
    //     match msg {
    //         Ok(val) => {
    //             let message_type = val.get_message_type()?;
    //             let tuple = KeyTypeTuple {
    //                 message_key: val.signature,
    //                 message_type: message_type,
    //             };
    //             Ok(tuple)
    //         }
    //         Err(err) => {
    //             Err(err)
    //         }
    //     }
    // });
    // pin_mut!(type_stream); // needed for iteration
    // println!("looping through type stream");
    // while let Some(res) = type_stream.next().await {
    //     match res {
    //         Ok(value) => {
    //             println!("value: {:?}", value);
    //         },
    //         Err(err) => {
    //             println!("err: {:?}", err);
    //         }
    //     }
    // }
    // println!("reached end of type stream");
    //
    // // return Ok
    // Ok(())
}

#[async_std::main]
async fn main() {
    if let Err(e) = run().await {
        eprintln!("Application error: {}", e);
        process::exit(1);
    }
}