Seems to work!

src/db.rs

@@ -0,0 +1,103 @@
+use crate::Result;
+
+use anyhow::anyhow;
+use sqlx::{self, ConnectOptions, SqliteConnection};
+use sqlx::sqlite::SqliteConnectOptions;
+
+pub(crate) type Id = i64;
+
+#[derive(sqlx::FromRow)]
+pub struct Bookmark {
+    #[sqlx(rename="rowid")]
+    pub id: Id,
+    pub link: String,
+    pub comment: String,
+}
+
+impl Bookmark {
+    pub fn new(link: String, comment: String) -> Self {
+        Bookmark { id: 0, link, comment }
+    }
+}
+
+pub struct Store {
+    conn: SqliteConnection,
+    table: &'static str,
+}
+
+impl Store {
+    pub async fn new(location: &str, is_reading_list: bool) -> Result<Self> {
+        let conn = location.parse::<SqliteConnectOptions>()?
+            .connect().await?;
+        let table = {
+            if is_reading_list { "reading_list" } else { "bookmarks" }
+        };
+        let mut result = Self { conn, table };
+        result.create_tables().await?;
+        Ok(result)
+    }
+    
+    pub async fn list(&mut self) -> Result<Vec<Bookmark>> {
+        let query = format!(
+            "SELECT rowid, link, comment
+             FROM {}
+             ORDER BY timestamp",
+             self.table
+        );
+        Ok(sqlx::query_as(&query)
+            .fetch_all(&mut self.conn)
+            .await?)
+    }
+
+    pub async fn add(&mut self, bookmark: Bookmark) -> Result<()> {
+        let query = format!(
+            "INSERT INTO {} VALUES
+             ($1, $2, unixepoch('now'))",
+             self.table
+        );
+        sqlx::query(&query)
+            .bind(bookmark.link)
+            .bind(bookmark.comment)
+            .execute(&mut self.conn).await?;
+        Ok(())
+    }
+
+
+    pub async fn get(&mut self, id: Id)
+        -> Result<Bookmark> {
+        let query = format!(
+            "SELECT rowid, link, comment
+             FROM {}
+             WHERE rowid = $1",
+             self.table
+        );
+        let result = sqlx::query_as(&query)
+            .bind(id)
+            .fetch_optional(&mut self.conn)
+            .await?
+            .ok_or(anyhow!("Could not find a bookmark with that ID!"))?;
+        Ok(result)
+    }
+
+    pub async fn rm(&mut self, id: Id) -> Result<()> {
+        let query = format!(
+            "DELETE FROM {}
+             WHERE rowid = $1",
+            self.table
+        );
+        sqlx::query(&query).bind(id).execute(&mut self.conn).await?;
+        Ok(())
+    }
+
+    async fn create_tables(&mut self) -> Result<()> {
+        for table in ["bookmarks", "reading_list"] {
+            let query = format!(
+                "CREATE TABLE IF NOT EXISTS {}
+                 (link TEXT, comment TEXT, timestamp DATETIME)",
+                table
+            );
+            sqlx::query(&query).execute(&mut self.conn).await?;
+        }
+        Ok(())
+    }
+}