Firts Commit: new app

src/client.rs

@@ -0,0 +1,93 @@
+use crate::models::{CreateMemoRequest, CreateMemoResponse, ListMemosResponse, Memo};
+use anyhow::Result;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone)]
+pub struct MemosClient {
+    client: Client,
+    base_url: String,
+    user_token: String,
+}
+
+impl MemosClient {
+    pub fn new(base_url: &str, user_token: &str) -> Result<Self> {
+        let base_url = base_url.trim_end_matches('/');
+        Ok(Self {
+            client: Client::new(),
+            base_url: base_url.to_string(),
+            user_token: user_token.to_string(),
+        })
+    }
+
+    pub async fn create_memo(&self, content: &str, visibility: Option<&str>) -> Result<Memo> {
+        let url = format!("{}/api/v1/memos", self.base_url);
+        
+        let request = CreateMemoRequest {
+            content: content.to_string(),
+            visibility: visibility.map(|s| s.to_string()),
+        };
+
+        let response = self.client
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", self.user_token))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Failed to create memo: {} - {}", status, error_text);
+        }
+
+        let result: CreateMemoResponse = response.json().await?;
+        
+        self.get_memo(result.id).await
+    }
+
+    pub async fn get_memo(&self, id: i64) -> Result<Memo> {
+        let url = format!("{}/api/v1/memos/{}", self.base_url, id);
+        
+        let response = self.client
+            .get(&url)
+            .header("Authorization", format!("Bearer {}", self.user_token))
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Failed to get memo: {} - {}", status, error_text);
+        }
+
+        Ok(response.json().await?)
+    }
+
+    pub async fn list_memos(&self, limit: Option<i32>, offset: Option<i32>) -> Result<Vec<Memo>> {
+        let url = format!("{}/api/v1/memos", self.base_url);
+        
+        let mut request = self.client
+            .get(&url)
+            .header("Authorization", format!("Bearer {}", self.user_token));
+
+        if let Some(l) = limit {
+            request = request.query(&[("limit", l.to_string())]);
+        }
+        if let Some(o) = offset {
+            request = request.query(&[("offset", o.to_string())]);
+        }
+
+        let response = request.send().await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Failed to list memos: {} - {}", status, error_text);
+        }
+
+        let result: ListMemosResponse = response.json().await?;
+        Ok(result.memos)
+    }
+}