From 469613872f6fb19f4579b387e19b2bc38fa52f51 Mon Sep 17 00:00:00 2001
From: Owen Jacobson <owen@grimoire.ca>
Date: Wed, 2 Oct 2024 01:31:43 -0400
Subject: Package up common event fields as Instant

---
 src/channel/repo.rs | 74 ++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 51 insertions(+), 23 deletions(-)

(limited to 'src/channel/repo.rs')

diff --git a/src/channel/repo.rs b/src/channel/repo.rs
index 18cd81f..c000b56 100644
--- a/src/channel/repo.rs
+++ b/src/channel/repo.rs
@@ -3,7 +3,7 @@ use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 use crate::{
     channel::{Channel, Id},
     clock::DateTime,
-    event::{types, Sequence},
+    event::{types, Instant, Sequence},
 };
 
 pub trait Provider {
@@ -19,15 +19,9 @@ impl<'c> Provider for Transaction<'c, Sqlite> {
 pub struct Channels<'t>(&'t mut SqliteConnection);
 
 impl<'c> Channels<'c> {
-    pub async fn create(
-        &mut self,
-        name: &str,
-        created_at: &DateTime,
-        created_sequence: Sequence,
-    ) -> Result<Channel, sqlx::Error> {
+    pub async fn create(&mut self, name: &str, created: &Instant) -> Result<Channel, sqlx::Error> {
         let id = Id::generate();
-        let channel = sqlx::query_as!(
-            Channel,
+        let channel = sqlx::query!(
             r#"
                 insert
                 into channel (id, name, created_at, created_sequence)
@@ -40,9 +34,17 @@ impl<'c> Channels<'c> {
             "#,
             id,
             name,
-            created_at,
-            created_sequence,
+            created.at,
+            created.sequence,
         )
+        .map(|row| Channel {
+            id: row.id,
+            name: row.name,
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+        })
         .fetch_one(&mut *self.0)
         .await?;
 
@@ -50,8 +52,7 @@ impl<'c> Channels<'c> {
     }
 
     pub async fn by_id(&mut self, channel: &Id) -> Result<Channel, sqlx::Error> {
-        let channel = sqlx::query_as!(
-            Channel,
+        let channel = sqlx::query!(
             r#"
                 select
                     id as "id: Id",
@@ -63,6 +64,14 @@ impl<'c> Channels<'c> {
             "#,
             channel,
         )
+        .map(|row| Channel {
+            id: row.id,
+            name: row.name,
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+        })
         .fetch_one(&mut *self.0)
         .await?;
 
@@ -73,8 +82,7 @@ impl<'c> Channels<'c> {
         &mut self,
         resume_point: Option<Sequence>,
     ) -> Result<Vec<Channel>, sqlx::Error> {
-        let channels = sqlx::query_as!(
-            Channel,
+        let channels = sqlx::query!(
             r#"
                 select
                     id as "id: Id",
@@ -87,6 +95,14 @@ impl<'c> Channels<'c> {
             "#,
             resume_point,
         )
+        .map(|row| Channel {
+            id: row.id,
+            name: row.name,
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+        })
         .fetch_all(&mut *self.0)
         .await?;
 
@@ -97,8 +113,7 @@ impl<'c> Channels<'c> {
         &mut self,
         resume_at: Option<Sequence>,
     ) -> Result<Vec<Channel>, sqlx::Error> {
-        let channels = sqlx::query_as!(
-            Channel,
+        let channels = sqlx::query!(
             r#"
                 select
                     id as "id: Id",
@@ -110,6 +125,14 @@ impl<'c> Channels<'c> {
             "#,
             resume_at,
         )
+        .map(|row| Channel {
+            id: row.id,
+            name: row.name,
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+        })
         .fetch_all(&mut *self.0)
         .await?;
 
@@ -119,8 +142,7 @@ impl<'c> Channels<'c> {
     pub async fn delete(
         &mut self,
         channel: &Channel,
-        deleted_at: &DateTime,
-        deleted_sequence: Sequence,
+        deleted: &Instant,
     ) -> Result<types::ChannelEvent, sqlx::Error> {
         let channel = channel.id.clone();
         sqlx::query_scalar!(
@@ -135,15 +157,13 @@ impl<'c> Channels<'c> {
         .await?;
 
         Ok(types::ChannelEvent {
-            sequence: deleted_sequence,
-            at: *deleted_at,
+            instant: *deleted,
             data: types::DeletedEvent { channel }.into(),
         })
     }
 
     pub async fn expired(&mut self, expired_at: &DateTime) -> Result<Vec<Channel>, sqlx::Error> {
-        let channels = sqlx::query_as!(
-            Channel,
+        let channels = sqlx::query!(
             r#"
                 select
                     channel.id as "id: Id",
@@ -157,6 +177,14 @@ impl<'c> Channels<'c> {
             "#,
             expired_at,
         )
+        .map(|row| Channel {
+            id: row.id,
+            name: row.name,
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+        })
         .fetch_all(&mut *self.0)
         .await?;
 
-- 
cgit v1.2.3