Release/0.7.0 (#7)

* v0.7.0 - see CHANGELOG for details

Author: Thesephi

.gitignore

@@ -25,3 +25,5 @@ Icon
 Network Trash Folder
 Temporary Items
 .apdisk
+
+.env

CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.7.0] - 2025-03-28
+
+### Added
+
+- `create_reply()` lib fn
+- `get_oembed_html()` lib fn
+- `publish_media_container()` lib fn
+
 ## [0.6.1] - 2025-03-20
 
 ### Added

Cargo.toml

@@ -20,3 +20,4 @@ reqwest = { version = "0.12", features = ["json"] }
 serde = { version = "1.0.219", features = ["derive"] }
 log = "0.4.22"
 tokio = { version = "1.44.1", features = ["rt", "macros"] }
+env_logger = "0.11.7"

src/create_reply.rs

@@ -0,0 +1,77 @@
+use crate::posts::publish_media_container;
+use crate::retrieve_media::SimpleMediaObject;
+use std::time::Duration;
+
+pub async fn create_reply(
+    reply_to_id: &str,
+    text: Option<&str>,
+    image_url: Option<&str>,
+    video_url: Option<&str>,
+    token: &str,
+) -> Result<SimpleMediaObject, reqwest::Error> {
+    let mut url = format!(
+        "https://graph.threads.net/v1.0/me/threads\
+        ?reply_to_id={reply_to_id}\
+        &access_token={token}"
+    );
+
+    let mut publish_wait_time_ms = 300;
+    let mut media_type = "TEXT";
+    if let Some(text) = text {
+        url.push_str(format!("&text={text}").as_str());
+    }
+    if let Some(image_url) = image_url {
+        url.push_str(format!("&image_url={image_url}").as_str());
+        media_type = "IMAGE";
+        publish_wait_time_ms = 3000;
+    }
+    if let Some(video_url) = video_url {
+        url.push_str(format!("&video_url={video_url}").as_str());
+        media_type = "VIDEO";
+        publish_wait_time_ms = 30000;
+    }
+    url.push_str(format!("&media_type={media_type}").as_str());
+
+    let media_container = reqwest::Client::new()
+        .post(&url)
+        .send()
+        .await?
+        .json::<SimpleMediaObject>()
+        .await?;
+
+    // ideally we proceed as long as we have `id` in the media_container, or poll until we have it
+    // https://developers.facebook.com/docs/threads/troubleshooting#publishing-does-not-return-a-media-id
+    // but for now it's alright to stick with some hardcoded wait time
+    tokio::time::sleep(Duration::from_millis(publish_wait_time_ms)).await;
+
+    let res = publish_media_container(&media_container.id, token).await?;
+
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::read_dot_env;
+    use log::debug;
+    use urlencoding::encode;
+
+    #[tokio::test]
+    async fn test_create_reply() {
+        let should_log_verbose = true;
+        let _ = env_logger::builder()
+            .is_test(!should_log_verbose)
+            .try_init();
+
+        let env = read_dot_env();
+        let token = env.get("ACCESS_TOKEN").unwrap();
+
+        let reply_to_id = "17961951074882947";
+        let text = encode("you see me rollin' 🥁");
+        let image_url = "https://i.imgur.com/Cj33AKk.png";
+        let res = create_reply(reply_to_id, Some(&*text), Some(image_url), None, &token).await;
+
+        debug!("{:?}", res);
+        assert_eq!(true, res.is_ok());
+    }
+}

src/mentions.rs

@@ -31,13 +31,26 @@ pub async fn get_mentions(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::utils::read_dot_env;
+    use log::debug;
 
     #[tokio::test]
-    async fn it_works() {
-        let res = get_mentions("foo", None, "bar").await;
+    async fn test_get_mentions() {
+        let should_log_verbose = true;
+        let _ = env_logger::builder()
+            .is_test(!should_log_verbose)
+            .try_init();
+
+        let env = read_dot_env();
+        let token = env.get("ACCESS_TOKEN").unwrap();
+
+        let res = get_mentions("me", None, token).await;
         match res {
             Ok(val) => match val.data {
-                Some(dat) => assert_eq!(dat[0].id, "foo"),
+                Some(dat) => {
+                    debug!("mentions fetched: {:?}", dat);
+                    assert_eq!(dat[0].id, "foo")
+                }
                 None => panic!("unexpected result"),
             },
             Err(e) => panic!("unexpected result: {}", e),

src/mod.rs

@@ -1,8 +1,11 @@
+mod shared;
+pub use crate::shared::{MetaMediaResponse, Paging, ThreadsApiRespErrorPayload};
 pub mod auth;
+pub mod create_reply;
 pub mod mentions;
+pub mod oembed;
+pub mod posts;
 pub mod profiles;
 pub mod reply_management;
 pub mod retrieve_media;
-pub use crate::shared::{MetaMediaResponse, Paging, ThreadsApiRespErrorPayload};
-mod shared;
 pub mod utils;

src/oembed.rs

@@ -0,0 +1,60 @@
+use log::debug;
+use serde::Deserialize;
+use urlencoding::encode;
+
+#[derive(Deserialize, Debug)]
+pub struct OembedResponse {
+    pub version: String,
+    pub provider_name: String,
+    pub provider_url: String,
+    pub width: u64,
+    pub html: String,
+}
+
+pub async fn get_oembed_html(
+    post_url: &str,
+    token: &str,
+) -> Result<OembedResponse, reqwest::Error> {
+    let the_post_url = encode(post_url);
+    let url = format!(
+        "https://graph.threads.net/v1.0/oembed?url={the_post_url}\
+        &access_token={token}"
+    );
+
+    debug!("requesting oembed for: {:?}", &url);
+
+    let res = reqwest::Client::new()
+        .get(&url)
+        .send()
+        .await?
+        .json::<OembedResponse>()
+        .await?;
+
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::read_dot_env;
+    use log::debug;
+
+    #[tokio::test]
+    async fn test_get_oembed_html() {
+        let should_log_verbose = true;
+        let _ = env_logger::builder()
+            .is_test(!should_log_verbose)
+            .try_init();
+
+        let env = read_dot_env();
+        let token = env.get("ACCESS_TOKEN").unwrap();
+
+        let res =
+            get_oembed_html("https://www.threads.net/@dkode___/post/DHwBylVNThs", token).await;
+
+        debug!("oembed response fetched: {:?}", res);
+
+        assert_eq!(true, res.is_ok());
+        assert_eq!(res.unwrap().html, "");
+    }
+}

src/posts.rs

@@ -0,0 +1,21 @@
+use crate::retrieve_media::SimpleMediaObject;
+
+pub async fn publish_media_container(
+    media_container_id: &str,
+    token: &str,
+) -> Result<SimpleMediaObject, reqwest::Error> {
+    let url = format!(
+        "https://graph.threads.net/v1.0/me/threads_publish\
+        ?creation_id={media_container_id}\
+        &access_token={token}"
+    );
+
+    let res = reqwest::Client::new()
+        .post(&url)
+        .send()
+        .await?
+        .json::<SimpleMediaObject>()
+        .await?;
+
+    Ok(res)
+}

src/profiles.rs

@@ -42,3 +42,25 @@ pub async fn get_profile_info(bearer_token: &str) -> Result<ThreadsUserProfile,
         None => Ok(res),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::read_dot_env;
+    #[tokio::test]
+    async fn test_get_profile_info() {
+        let should_log_verbose = true;
+        let _ = env_logger::builder()
+            .is_test(!should_log_verbose)
+            .try_init();
+
+        let env = read_dot_env();
+        let token = env.get("ACCESS_TOKEN").unwrap();
+
+        let res = get_profile_info(token).await;
+
+        debug!("profile fetched {:?}", res);
+
+        assert_eq!(true, res.is_ok());
+    }
+}

src/shared.rs

@@ -9,21 +9,27 @@ pub struct MetaMediaResponse<T> {
 
 #[derive(Deserialize, Debug)]
 pub struct Paging {
+    #[allow(dead_code)]
     cursors: Cursors,
     pub next: Option<String>,
 }
 
 #[derive(Deserialize, Debug)]
 pub struct Cursors {
+    #[allow(dead_code)]
     before: String,
+    #[allow(dead_code)]
     after: String,
 }
 
 #[derive(Deserialize, Debug)]
 pub struct ThreadsApiRespErrorPayload {
     #[allow(dead_code)]
     pub message: String,
+    #[allow(dead_code)]
     code: u32,
+    #[allow(dead_code)]
     error_subcode: Option<u32>,
+    #[allow(dead_code)]
     fbtrace_id: String,
 }