refactor(tests): reformat code and update dependency management

- Reorganized import statements in adapter tests for better readability
- Replaced or_insert_with(Vec::new) with or_default() in test closures
- Updated Cargo.lock with new dependency versions and checksums
- Added TLS features to tonic dependency configuration
- Included sqlx, chrono, and uuid dependencies with specific features
- Added jsonwebtoken and arc-swap as project dependencies
- Reformatted assertion statements to comply with line length limits
- Adjusted base64 import order in engine codec module
- Updated protobuf include statement formatting

repo/message_notification.rs

@@ -0,0 +1,140 @@
+//! Notification CRUD operations on `MessageRepo`.
+
+use chrono::Utc;
+use uuid::Uuid;
+
+use crate::ImksResult;
+use crate::models::message_notification::MessageNotification;
+
+use super::message_repo::MessageRepo;
+use super::pagination::{CursorPage, clamp_limit};
+
+impl MessageRepo {
+    /// Create a notification for a user triggered by a message.
+    pub async fn create_notification(
+        &self,
+        message_id: Uuid,
+        channel_id: Uuid,
+        user_id: Uuid,
+        reason: &str,
+        delivery_channel: Option<&str>,
+    ) -> ImksResult<MessageNotification> {
+        let id = Uuid::now_v7();
+        let now = Utc::now();
+
+        sqlx::query_as::<_, MessageNotification>(
+            r#"
+            INSERT INTO message_notification (
+                id, message_id, channel_id, user_id, reason, status, delivery_channel, created_at
+            ) VALUES ($1, $2, $3, $4, $5, 'pending', $6, $7)
+            RETURNING *
+            "#,
+        )
+        .bind(id)
+        .bind(message_id)
+        .bind(channel_id)
+        .bind(user_id)
+        .bind(reason)
+        .bind(delivery_channel)
+        .bind(now)
+        .fetch_one(self.pool())
+        .await
+        .map_err(Into::into)
+    }
+
+    /// Mark a notification as read.
+    pub async fn mark_notification_read(&self, notification_id: Uuid) -> ImksResult<()> {
+        let now = Utc::now();
+        sqlx::query(
+            r#"
+            UPDATE message_notification
+            SET status = 'read', read_at = $1
+            WHERE id = $2
+            "#,
+        )
+        .bind(now)
+        .bind(notification_id)
+        .execute(self.pool())
+        .await?;
+
+        Ok(())
+    }
+
+    /// Mark all of a user's notifications as read.
+    pub async fn mark_all_notifications_read(&self, user_id: Uuid) -> ImksResult<u64> {
+        let now = Utc::now();
+        let result = sqlx::query(
+            r#"
+            UPDATE message_notification
+            SET status = 'read', read_at = $1
+            WHERE user_id = $2 AND status != 'read'
+            "#,
+        )
+        .bind(now)
+        .bind(user_id)
+        .execute(self.pool())
+        .await?;
+
+        Ok(result.rows_affected())
+    }
+
+    /// List notifications for a user, newest first.
+    pub async fn list_notifications(
+        &self,
+        user_id: Uuid,
+        before: Option<Uuid>,
+        limit: Option<i64>,
+    ) -> ImksResult<CursorPage<MessageNotification>> {
+        let effective_limit = clamp_limit(limit);
+        let fetch_limit = effective_limit + 1;
+
+        let rows = match before {
+            Some(cursor) => {
+                sqlx::query_as::<_, MessageNotification>(
+                    r#"
+                    SELECT * FROM message_notification
+                    WHERE user_id = $1 AND id < $2
+                    ORDER BY id DESC
+                    LIMIT $3
+                    "#,
+                )
+                .bind(user_id)
+                .bind(cursor)
+                .bind(fetch_limit)
+                .fetch_all(self.pool())
+                .await?
+            }
+            None => {
+                sqlx::query_as::<_, MessageNotification>(
+                    r#"
+                    SELECT * FROM message_notification
+                    WHERE user_id = $1
+                    ORDER BY id DESC
+                    LIMIT $2
+                    "#,
+                )
+                .bind(user_id)
+                .bind(fetch_limit)
+                .fetch_all(self.pool())
+                .await?
+            }
+        };
+
+        Ok(CursorPage::from_raw(rows, effective_limit, |n| n.id))
+    }
+
+    /// Get unread notification count for a user.
+    pub async fn get_unread_notification_count(&self, user_id: Uuid) -> ImksResult<i64> {
+        let count: i64 = sqlx::query_scalar(
+            r#"
+            SELECT COUNT(*)::BIGINT FROM message_notification
+            WHERE user_id = $1 AND status = 'pending'
+            "#,
+        )
+        .bind(user_id)
+        .fetch_one(self.pool())
+        .await?;
+
+        Ok(count)
+    }
+}