Some work on the sqlite store

crates/store/src/sqlite_store.rs

@@ -1,54 +1,113 @@
-use std::sync::Arc;
-
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use sqlx::SqlitePool;
 
-use crate::calendar::{Calendar, CalendarStore};
+use crate::{
+    calendar::{Calendar, CalendarStore},
+    event::Event,
+};
 
 #[derive(Debug)]
 pub struct SqliteCalendarStore {
-    db: Arc<SqlitePool>,
+    db: SqlitePool,
 }
 
 impl SqliteCalendarStore {
-    pub fn new(db: Arc<SqlitePool>) -> Self {
+    pub fn new(db: SqlitePool) -> Self {
         Self { db }
     }
 }
 
+#[derive(Debug, Clone)]
+struct EventRow {
+    uid: String,
+    ics: String,
+}
+
+impl TryFrom<EventRow> for Event {
+    type Error = anyhow::Error;
+
+    fn try_from(value: EventRow) -> Result<Self> {
+        Event::from_ics(value.uid, value.ics)
+    }
+}
+
 #[async_trait]
 impl CalendarStore for SqliteCalendarStore {
     async fn get_calendar(&self, id: &str) -> Result<Calendar> {
-        let a = sqlx::query_as!(
+        let cal = sqlx::query_as!(
             Calendar,
             "SELECT id, name, owner, description, color, timezone FROM calendars WHERE id = ?",
             id
-        );
-        Err(anyhow!("ok wow"))
+        )
+        .fetch_one(&self.db)
+        .await?;
+        Ok(cal)
     }
 
     async fn get_calendars(&self, _owner: &str) -> Result<Vec<Calendar>> {
-        Err(anyhow!("ok wow"))
+        let cals = sqlx::query_as!(
+            Calendar,
+            "SELECT id, name, owner, description, color, timezone FROM calendars"
+        )
+        .fetch_all(&self.db)
+        .await?;
+        Ok(cals)
     }
 
-    async fn insert_calendar(&mut self, _cid: String, _calendar: Calendar) -> Result<()> {
-        Err(anyhow!("ok wow"))
+    async fn insert_calendar(&mut self, cid: String, calendar: Calendar) -> Result<()> {
+        // TODO: :(
+        let name = calendar.name;
+        let description = calendar.description;
+        let owner = calendar.owner;
+        let color = calendar.color;
+        let timezone = calendar.timezone;
+        sqlx::query!("INSERT INTO calendars (id, name, description, owner, color, timezone) VALUES (?, ?, ?, ?, ?, ?)", cid, name, description, owner, color, timezone).execute(&self.db).await?;
+        Ok(())
     }
 
-    async fn get_events(&self, _cid: &str) -> Result<Vec<crate::event::Event>> {
-        Err(anyhow!("ok wow"))
+    async fn get_events(&self, cid: &str) -> Result<Vec<Event>> {
+        let events = sqlx::query_as!(EventRow, "SELECT uid, ics FROM events WHERE cid = ?", cid)
+            .fetch_all(&self.db)
+            .await?
+            .iter_mut()
+            // TODO: this is an ugly bodge :(
+            .filter_map(|row| row.clone().try_into().ok())
+            .collect();
+        Ok(events)
     }
 
-    async fn get_event(&self, _cid: &str, _uid: &str) -> Result<crate::event::Event> {
-        Err(anyhow!("ok wow"))
+    async fn get_event(&self, cid: &str, uid: &str) -> Result<Event> {
+        let event = sqlx::query_as!(
+            EventRow,
+            "SELECT uid, ics FROM events where cid = ? AND uid = ?",
+            cid,
+            uid
+        )
+        .fetch_one(&self.db)
+        .await?
+        .try_into()?;
+        Ok(event)
     }
 
-    async fn upsert_event(&mut self, _cid: String, _uid: String, _ics: String) -> Result<()> {
-        Err(anyhow!("ok wow"))
+    async fn upsert_event(&mut self, cid: String, uid: String, ics: String) -> Result<()> {
+        // Do this extra step to ensure that the input is actually valid
+        let _ = Event::from_ics(uid.to_owned(), ics.to_owned())?;
+        sqlx::query!(
+            "INSERT INTO events (cid, uid, ics) VALUES (?, ?, ?)",
+            cid,
+            uid,
+            ics,
+        )
+        .execute(&self.db)
+        .await?;
+        Ok(())
     }
 
-    async fn delete_event(&mut self, _cid: &str, _uid: &str) -> Result<()> {
-        Err(anyhow!("ok wow"))
+    async fn delete_event(&mut self, cid: &str, uid: &str) -> Result<()> {
+        sqlx::query!("DELETE FROM events WHERE cid = ? AND uid = ?", cid, uid)
+            .execute(&self.db)
+            .await?;
+        Ok(())
     }
 }