chore(notifications): some settings entity boilerplate

core/notifications/migrations/20240111102028_notifications_setup.sql

@@ -0,0 +1,14 @@
+CREATE TABLE account_notification_settings (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    galoy_account_id VARCHAR UNIQUE NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE account_notification_settings_events (
+  id UUID REFERENCES account_notification_settings(id) NOT NULL,
+  sequence INT NOT NULL,
+  event_type VARCHAR NOT NULL,
+  event JSONB NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  UNIQUE(id, sequence)
+);

core/notifications/src/account_notification_settings/error.rs

@@ -0,0 +1,9 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum AccountNotificationSettingsError {
+    #[error("AccountNotificationSettingsError - Sqlx: {0}")]
+    Sqlx(#[from] sqlx::Error),
+    #[error("AccountNotificationSettingsError - EntityError: {0}")]
+    EntityError(#[from] es_entity::EntityError),
+}

core/notifications/src/account_notification_settings/mod.rs

@@ -1,4 +1,6 @@
 mod entity;
-// mod value;
+pub mod error;
+mod repo;
 
-pub use entity::*;
+// pub use entity::*;
+pub use repo::*;

core/notifications/src/account_notification_settings/repo.rs

@@ -0,0 +1,39 @@
+use sqlx::PgPool;
+
+use es_entity::*;
+
+use super::{entity::*, error::*};
+use crate::primitives::*;
+
+#[derive(Debug, Clone)]
+pub struct AccountNotificationSettingsRepo {
+    pool: PgPool,
+}
+
+impl AccountNotificationSettingsRepo {
+    pub fn new(pool: &PgPool) -> Self {
+        Self { pool: pool.clone() }
+    }
+
+    pub async fn find_for_account_id(
+        &self,
+        account_id: GaloyAccountId,
+    ) -> Result<Option<AccountNotificationSettings>, AccountNotificationSettingsError> {
+        let rows = sqlx::query_as!(
+            GenericEvent,
+            r#"SELECT a.id, e.sequence, e.event
+            FROM account_notification_settings a
+            JOIN account_notification_settings_events e ON a.id = e.id
+            WHERE a.galoy_account_id = $1
+            ORDER BY e.sequence"#,
+            account_id.as_ref(),
+        )
+        .fetch_all(&self.pool)
+        .await?;
+        let res = EntityEvents::load_first::<AccountNotificationSettings>(rows);
+        if matches!(res, Err(EntityError::NoEntityEventsPresent)) {
+            return Ok(None);
+        }
+        Ok(Some(res?))
+    }
+}

core/notifications/src/app/error.rs

@@ -1,4 +1,9 @@
 use thiserror::Error;
 
+use crate::account_notification_settings::error::*;
+
 #[derive(Error, Debug)]
-pub enum ApplicationError {}
+pub enum ApplicationError {
+    #[error("{0}")]
+    AccountNotificationSettingsError(#[from] AccountNotificationSettingsError),
+}

core/notifications/src/app/mod.rs

@@ -11,21 +11,29 @@ pub use error::*;
 #[derive(Clone)]
 pub struct NotificationsApp {
     _config: AppConfig,
+    settings: AccountNotificationSettingsRepo,
     _pool: Pool<Postgres>,
 }
 
 impl NotificationsApp {
     pub fn new(pool: Pool<Postgres>, config: AppConfig) -> Self {
+        let settings = AccountNotificationSettingsRepo::new(&pool);
         Self {
             _config: config,
             _pool: pool,
+            settings,
         }
     }
 
-    pub async fn notification_settings_for_account_id(
+    pub async fn disable_channel_on_account(
         &self,
-        _galoy_account_id: GaloyAccountId,
-    ) -> Result<AccountNotificationSettings, ApplicationError> {
-        unimplemented!()
+        account_id: GaloyAccountId,
+        _channel: NotificationChannel,
+    ) -> Result<(), ApplicationError> {
+        let _account_setting = self.settings.find_for_account_id(account_id).await?;
+        // settings.disable_channel(channel)
+        // repo.persist(settings)
+        // Ok(settings)
+        Ok(())
     }
 }

core/notifications/src/graphql/schema.rs

@@ -1,7 +1,7 @@
 use async_graphql::*;
 
 use super::types::*;
-use crate::app::NotificationsApp;
+use crate::{app::NotificationsApp, primitives::*};
 
 pub struct AuthSubject {
     pub id: String,
@@ -35,7 +35,7 @@ pub struct AccountUpdateNotificationSettingsPayloadAlt {
 
 #[derive(InputObject)]
 struct AccountDisableNotificationChannelInputAlt {
-    channel: NotificationChannelAlt,
+    channel: NotificationChannel,
 }
 
 pub struct Mutation;
@@ -45,13 +45,15 @@ impl Mutation {
     async fn account_disable_notification_channel_alt(
         &self,
         ctx: &Context<'_>,
-        _input: AccountDisableNotificationChannelInputAlt,
+        input: AccountDisableNotificationChannelInputAlt,
     ) -> async_graphql::Result<AccountUpdateNotificationSettingsPayloadAlt> {
-        let _app = ctx.data_unchecked::<NotificationsApp>();
         let subject = ctx.data::<AuthSubject>()?;
         if subject.read_only {
             return Err("Permission denied".into());
         }
+        let app = ctx.data_unchecked::<NotificationsApp>();
+        app.disable_channel_on_account(GaloyAccountId::from(subject.id.clone()), input.channel)
+            .await?;
         Ok(AccountUpdateNotificationSettingsPayloadAlt {
             notification_settings: NotificationSettingsAlt {
                 push: NotificationChannelSettingsAlt {

core/notifications/src/graphql/types.rs

@@ -1,22 +1,14 @@
 use async_graphql::*;
 
+use crate::primitives::*;
+
 #[derive(SimpleObject)]
 pub(super) struct NotificationSettingsAlt {
     pub push: NotificationChannelSettingsAlt,
 }
 
-#[derive(Enum, Copy, Clone, Eq, PartialEq)]
-pub(super) enum NotificationCategoryAlt {
-    Circles,
-}
-
 #[derive(SimpleObject)]
 pub(super) struct NotificationChannelSettingsAlt {
     pub enabled: bool,
-    pub disabled_categories: Vec<NotificationCategoryAlt>,
-}
-
-#[derive(Enum, Copy, Clone, Eq, PartialEq)]
-pub(super) enum NotificationChannelAlt {
-    Push,
+    pub disabled_categories: Vec<NotificationCategory>,
 }

core/notifications/src/primitives.rs

@@ -2,5 +2,28 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GaloyAccountId(String);
+impl From<String> for GaloyAccountId {
+    fn from(s: String) -> Self {
+        Self(s)
+    }
+}
+
+impl AsRef<str> for GaloyAccountId {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
 
 es_entity::entity_id! { AccountNotificationSettingsId }
+
+#[derive(async_graphql::Enum, Copy, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[graphql(name = "NotificationChannelAlt")]
+pub enum NotificationChannel {
+    Push,
+}
+
+#[derive(async_graphql::Enum, Copy, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[graphql(name = "NotificationCategoryAlt")]
+pub enum NotificationCategory {
+    Circles,
+}

lib/es-entity-rs/src/error.rs

@@ -2,8 +2,8 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum EntityError {
-    #[error("EntityError - NoEvents")]
-    NoEvents,
+    #[error("EntityError - NoEntityEventsPresent")]
+    NoEntityEventsPresent,
     #[error("EntityError - UninitializedFieldError: {0}")]
     UninitializedFieldError(#[from] derive_builder::UninitializedFieldError),
     #[error("EntityError - LoadEvent: {0}")]

lib/es-entity-rs/src/events.rs

@@ -103,7 +103,7 @@ where
         if let Some(current) = current {
             E::try_from(current)
         } else {
-            Err(EntityError::NoEvents)
+            Err(EntityError::NoEntityEventsPresent)
         }
     }
 
@@ -162,7 +162,7 @@ mod tests {
     fn load_zero_events() {
         let generic_events = vec![];
         let res = EntityEvents::load_first::<DummyEntity>(generic_events);
-        assert!(matches!(res, Err(EntityError::NoEvents)));
+        assert!(matches!(res, Err(EntityError::NoEntityEventsPresent)));
     }
 
     #[test]