fix: tags mapping (#2)

Author: dineshdb

Cargo.lock

@@ -17,6 +17,7 @@ serde_json = "1.0.139"
 serde = { version = "1.0", features = ["derive"] }
 figment = { version = "0.10", features = ["toml", "env"] }
 directories = "6.0.0"
+chrono = "0.4.39"
 
 [workspace]
 members = [ "pkg/localdb",

Cargo.toml

@@ -31,8 +31,9 @@ CREATE TABLE [tags] (
 );
 
 CREATE TABLE [items_tags] (
-	[item_id] INTEGER REFERENCES items(id),
-	[tag_id] INTEGER REFERENCES tags(id)
+	[item_id] INTEGER NOT NULL REFERENCES items(id),
+	[tag_id] INTEGER NOT NULL REFERENCES tags(id),
+   PRIMARY KEY (tag_id, item_id)
 );
 
 CREATE TABLE [authors] (

pkg/localdb/migrations/20250205102710_init.sql

@@ -42,12 +42,41 @@ struct ItemRow {
 }
 
 impl LocalDb {
-    pub fn new(pool: SqlitePool) -> crate::Result<Self> {
-        Ok(Self { pool })
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
     }
 
-    pub async fn add(&mut self, item: &item::Item) -> crate::Result<()> {
+    pub async fn add_tag(&mut self, tag: &item::Tag) -> crate::Result<i32> {
+        let res = sqlx::query(
+            "INSERT INTO tags (name, tag) VALUES (?, ?) ON CONFLICT(tag) DO NOTHING RETURNING id",
+        )
+        .bind(&tag.name)
+        .bind(&tag.tag)
+        .execute(&self.pool)
+        .await?;
+        Ok(res.last_insert_rowid() as i32)
+    }
+
+    pub async fn get_tags(&mut self) -> crate::Result<Vec<item::Tag>> {
+        let res: Vec<item::Tag> = sqlx::query_as("SELECT id, tag, name FROM tags")
+            .fetch_all(&self.pool)
+            .await?;
+        Ok(res)
+    }
+
+    pub async fn link_tag(&mut self, tag: i32, item: i32) -> crate::Result<()> {
         sqlx::query(
+            "INSERT INTO items_tags (item_id, tag_id) VALUES (?, ?) ON CONFLICT(item_id, tag_id) DO NOTHING",
+        )
+        .bind(item)
+        .bind(tag)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+
+    pub async fn add(&mut self, item: &item::Item) -> crate::Result<i32> {
+        let resutl = sqlx::query(
             "INSERT INTO items (
             pocket_id, 
             title, 
@@ -97,7 +126,16 @@ impl LocalDb {
         .bind(item.time_favorited)
         .execute(&self.pool)
         .await?;
-        Ok(())
+
+        let tem_id = resutl.last_insert_rowid() as i32;
+
+        let tags = item.tags.iter().collect_vec();
+        for tag in tags {
+            let tag_id = self.add_tag(tag).await?;
+            self.link_tag(tag_id, tem_id).await?;
+        }
+
+        Ok(tem_id as i32)
     }
 
     pub async fn get_items(&self) -> crate::Result<Vec<item::Item>> {
@@ -155,9 +193,18 @@ impl LocalDb {
 
 #[cfg(test)]
 mod test {
-    use crate::item::ItemStatus;
+    use std::collections::HashSet;
 
     use super::*;
+    use crate::{
+        item::{ItemStatus, Tag},
+        Item,
+    };
+
+    async fn get_db() -> LocalDb {
+        let pool = open_database(":memory:").await.unwrap();
+        LocalDb::new(pool)
+    }
 
     #[tokio::test]
     async fn test_open_in_memory() {
@@ -167,23 +214,68 @@ mod test {
 
     #[tokio::test]
     async fn test_get_items() {
-        let pool = open_database(":memory:").await.unwrap();
-        let db = LocalDb::new(pool).unwrap();
+        let db = get_db().await;
         let items = db.get_items().await.unwrap();
         assert!(items.is_empty());
     }
 
     #[tokio::test]
     async fn test_add_item() {
-        let pool = open_database(":memory:").await.unwrap();
-        let mut db = LocalDb::new(pool).unwrap();
-        let item = Default::default();
+        let mut db = get_db().await;
+
+        let tag = Tag {
+            id: 0,
+            tag: "tag".to_string(),
+            name: None,
+        };
+
+        let item = Item {
+            tags: HashSet::from([Tag::default(), tag]),
+            ..Default::default()
+        };
+
         db.add(&item).await.unwrap();
+
         let items = db.get_items().await.unwrap();
         assert_eq!(items.len(), 1);
         assert_eq!(items[0].title, item.title);
         assert_eq!(items[0].url, item.url);
         assert_eq!(items[0].id, 1);
         assert_eq!(items[0].status, ItemStatus::Unread);
+
+        assert_eq!(items[0].tags.len(), 2);
+        assert!(items[0].tags.iter().any(|t| t.tag == "tag"));
+        assert!(items[0].tags.iter().any(|t| t.tag == "example"));
+    }
+
+    #[tokio::test]
+    async fn test_add_tag() {
+        let mut db = get_db().await;
+        let result = db.add_tag(&Default::default()).await;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_add_duplicate_tag() {
+        let mut db = get_db().await;
+        db.add_tag(&Default::default())
+            .await
+            .expect("add_tag failed");
+        db.add_tag(&Default::default())
+            .await
+            .expect("add tag failed");
+
+        let tags = db.get_tags().await.unwrap();
+        assert_eq!(tags.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_link_tag() {
+        let mut db = get_db().await;
+        let tag_id = db.add_tag(&Tag::default()).await.unwrap();
+        let item_id = db.add(&Default::default()).await.unwrap();
+        let res = db.link_tag(tag_id, item_id).await;
+        assert!(res.is_ok());
     }
 }

pkg/localdb/src/db.rs

@@ -80,7 +80,6 @@ impl Default for Item {
             time_read: None,
             time_favorited: None,
             tags: HashSet::new(),
-
             is_article: None,
             is_index: None,
             has_video: None,
@@ -101,6 +100,16 @@ pub struct Tag {
     pub name: Option<String>,
 }
 
+impl Default for Tag {
+    fn default() -> Self {
+        Tag {
+            id: 0,
+            tag: "example".to_string(),
+            name: Some("Example Tag".to_string()),
+        }
+    }
+}
+
 #[derive(Deserialize, Debug, sqlx::Type, PartialEq, Eq, Clone, Copy)]
 #[repr(i32)]
 pub enum ItemStatus {

pkg/localdb/src/item.rs

@@ -9,7 +9,7 @@ pub enum PocketError {
     #[error("Request error for URL <{url}>: {source}")]
     Reqwest { url: String, source: reqwest::Error },
     #[error("Pocket protocol error: {1} ({0})")]
-    Proto(String, String, Option<String>),
+    Proto(i32, String, Option<String>),
     #[error("X-Error-Code is malformed UTF-8")]
     ReqwwestStrError(#[from] reqwest::header::ToStrError),
 

pkg/pocket/src/error.rs

@@ -71,7 +71,12 @@ impl<'a> PocketClient<'a> {
             })?;
 
         if let Some(code) = res.headers().get(X_ERROR_CODE) {
-            let code = code.to_str().expect("X-Error-Code is malformed").into();
+            let code = code
+                .to_str()
+                .expect("X-Error-Code is malformed")
+                .parse()
+                .expect("X-Error-Code is malformed integer");
+
             return Err(PocketError::Proto(
                 code,
                 res.headers()

pkg/pocket/src/lib.rs

@@ -21,6 +21,7 @@ pub fn get_config() -> anyhow::Result<Config> {
     let config_dir = project_dirs.config_dir();
     std::fs::create_dir_all(project_dirs.config_local_dir())?;
     std::fs::create_dir_all(project_dirs.data_local_dir())?;
+    std::fs::File::open(project_dirs.data_local_dir().join("readlater.sqlite"))?;
 
     let config_file = config_dir.join("config.toml");
     let config: Config = Figment::new()

src/config.rs

@@ -1,5 +1,4 @@
-use std::{collections::HashMap, path::PathBuf};
-
+use chrono::DateTime;
 use clap::{Parser, Subcommand};
 use localdb::KvDB;
 use pocket::{modify::AddUrlRequest, GetOptions, PocketClient};
@@ -10,6 +9,7 @@ use readlater::{
         native_host_handler,
     },
 };
+use std::{collections::HashMap, path::PathBuf};
 use url::Url;
 #[derive(Parser)]
 #[command(author, version, about)]
@@ -87,19 +87,29 @@ async fn main() {
                     )
                     .await
                     .unwrap();
-                    let mut db = localdb::LocalDb::new(pool.clone()).unwrap();
+                    let mut db = localdb::LocalDb::new(pool.clone());
                     let mut kv_db = KvDB::new(pool.clone());
                     let since = kv_db
                         .get_kv::<i32>("pocket_since")
                         .await
                         .map(|k| k.value)
-                        .unwrap_or(0);
+                        .ok();
 
-                    let mut offset = kv_db
+                    let offset = kv_db
                         .get_kv::<i32>("pocket_offset")
                         .await
                         .map(|k| k.value)
-                        .unwrap_or(0);
+                        .ok();
+
+                    let (since, mut offset) = match (since, offset) {
+                        (Some(since), _) => (since, 0),
+                        (_, Some(offset)) => (0, offset),
+                        _ => (0, 0),
+                    };
+
+                    let datetime =
+                        DateTime::from_timestamp(since as i64, 0).expect("unexpected date time");
+                    println!("Syncing data since {} with offset {}", datetime, offset);
 
                     loop {
                         let response = pocket
@@ -112,21 +122,20 @@ async fn main() {
                             .await
                             .unwrap();
 
-                        offset += 30;
-                        kv_db
-                            .set_kv(&("pocket_offset", offset).into())
-                            .await
-                            .unwrap();
-
                         for article in response.list.values() {
                             let article: localdb::Item = article.into();
                             db.add(&article).await.unwrap();
                             println!("{} {}", article.id, article.title);
                         }
 
+                        offset += 30;
+                        kv_db
+                            .set_kv(&("pocket_offset", offset).into())
+                            .await
+                            .unwrap();
+
                         let has_more = response.has_more().expect("invalid request");
                         if response.list.is_empty() || !has_more {
-                            println!("Since {}", response.since);
                             kv_db
                                 .set_kv(
                                     &("pocket_since".to_string(), response.since.to_string())