Remove whitenoise methods

src/bin/integration_test.rs

@@ -1,12 +1,11 @@
-use anyhow::Result;
-use clap::Parser;
-use nostr_mls::groups::NostrGroupConfigData;
 use std::path::PathBuf;
 
-use nostr_mls::prelude::*;
+use anyhow::Result;
+use clap::Parser;
+use nostr_mls::{groups::NostrGroupConfigData, prelude::*};
 use nostr_sdk::prelude::*;
-use whitenoise::ThemeMode;
-use whitenoise::{Whitenoise, WhitenoiseConfig, WhitenoiseError};
+
+use whitenoise::{RelayType, ThemeMode, Whitenoise, WhitenoiseConfig, WhitenoiseError};
 
 /// Test backend for Whitenoise
 #[derive(Parser, Debug)]
@@ -140,7 +139,7 @@ async fn main() -> Result<(), WhitenoiseError> {
 
     // Test metadata fetching
     tracing::info!("Testing metadata fetching...");
-    let metadata = whitenoise.user_metadata(&account3.pubkey).await.unwrap();
+    let metadata = account3.metadata(whitenoise).await.unwrap();
     assert_eq!(metadata.name, Some("Known User".to_string()));
     tracing::info!("✓ Metadata fetched correctly");
 
@@ -158,8 +157,8 @@ async fn main() -> Result<(), WhitenoiseError> {
         ..Default::default()
     };
 
-    whitenoise
-        .update_account_metadata(&account3, &updated_metadata)
+    account3
+        .update_metadata(&updated_metadata, whitenoise)
         .await
         .unwrap();
     tracing::info!("✓ Metadata updated successfully");
@@ -332,7 +331,7 @@ async fn main() -> Result<(), WhitenoiseError> {
     test_client2.disconnect().await;
 
     // Assert metadata was updated via event processor
-    let updated_via_sub = whitenoise.user_metadata(&account3.pubkey).await.unwrap();
+    let updated_via_sub = account3.metadata(whitenoise).await.unwrap();
     assert_eq!(
         updated_via_sub.name,
         Some("Known User Sub Update".to_string()),
@@ -341,14 +340,7 @@ async fn main() -> Result<(), WhitenoiseError> {
     tracing::info!("✓ Subscription-driven metadata update applied");
 
     // Assert relay list was updated via event processor
-    let user3 = whitenoise
-        .find_user_by_pubkey(&account3.pubkey)
-        .await
-        .unwrap();
-    let nip65_relays_after = whitenoise
-        .user_relays(&user3, whitenoise::RelayType::Nip65)
-        .await
-        .unwrap();
+    let nip65_relays_after = account3.relays(RelayType::Nip65, whitenoise).await.unwrap();
     let parsed_new = RelayUrl::parse(&new_relay_url).unwrap();
     let has_new = nip65_relays_after.iter().any(|r| r.url == parsed_new);
     assert!(

src/lib.rs

@@ -1,26 +1,26 @@
-use std::sync::OnceLock;
+use std::sync::{Mutex, OnceLock};
+
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::{filter::EnvFilter, fmt::Layer, prelude::*, registry::Registry};
 
-use std::sync::Mutex;
-
 // mod media;
 mod nostr_manager;
 mod types;
 pub mod whitenoise;
 
 // Re-export main types for library users
-pub use crate::nostr_manager::parser::SerializableToken;
-pub use crate::types::ImageType;
-pub use crate::types::MessageWithTokens;
-pub use crate::whitenoise::accounts::Account;
-pub use crate::whitenoise::app_settings::{AppSettings, ThemeMode};
-pub use crate::whitenoise::error::WhitenoiseError;
-pub use crate::whitenoise::message_aggregator::{
+pub use nostr_manager::parser::SerializableToken;
+pub use nostr_mls::groups::NostrGroupConfigData;
+pub use types::ImageType;
+pub use types::MessageWithTokens;
+pub use whitenoise::accounts::Account;
+pub use whitenoise::app_settings::{AppSettings, ThemeMode};
+pub use whitenoise::error::WhitenoiseError;
+pub use whitenoise::message_aggregator::{
     ChatMessage, EmojiReaction, ReactionSummary, UserReaction,
 };
-pub use crate::whitenoise::relays::{Relay, RelayType};
-pub use nostr_mls::groups::NostrGroupConfigData;
+pub use whitenoise::relays::{Relay, RelayType};
+pub use whitenoise::users::User;
 pub use whitenoise::{Whitenoise, WhitenoiseConfig};
 
 // Re-export nostr types with documentation

src/media/cache.rs

@@ -1,16 +1,22 @@
 //! This module contains functions for managing cached media files.
 
-use std::fs;
-use std::path::Path;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::{
+    fs,
+    path::Path,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use nostr_mls::prelude::*;
 use sha2::{Digest, Sha256};
 
 use super::sanitizer::SafeMediaMetadata;
-use crate::database::Database;
-use crate::media::errors::MediaError;
-use crate::media::types::{CachedMediaFile, MediaFile};
+use crate::{
+    database::Database,
+    media::{
+        errors::MediaError,
+        types::{CachedMediaFile, MediaFile},
+    },
+};
 
 const MEDIA_CACHE_DIR: &str = "media_cache";
 

src/media/encryption.rs

@@ -2,12 +2,13 @@
 //! It uses ChaCha20-Poly1305 encryption, which provides authenticated encryption
 //! with better cross-platform performance characteristics compared to AES-GCM.
 
-use crate::media::errors::MediaError;
 use chacha20poly1305::{
     aead::{Aead, KeyInit},
     ChaCha20Poly1305, Key, Nonce,
 };
 use rand::RngCore;
+
+use crate::media::errors::MediaError;
 /// Encrypts file data using ChaCha20-Poly1305 encryption.
 ///
 /// # Arguments

src/media/sanitizer.rs

@@ -16,12 +16,13 @@
 //! - Software used to create/edit the file
 //! - Thumbnails and previews
 
-use crate::media::errors::MediaError;
-use crate::media::types::FileUpload;
+use std::io::Cursor;
+
 use image::{GenericImageView, ImageFormat, ImageOutputFormat};
 use serde::{Deserialize, Serialize};
 use sqlx::{Decode, Encode, Type};
-use std::io::Cursor;
+
+use crate::media::{errors::MediaError, types::FileUpload};
 
 #[derive(Debug, Serialize, Deserialize, Type, Encode, Decode)]
 #[sqlx(type_name = "jsonb")]

src/media/types.rs

@@ -1,9 +1,9 @@
-use crate::media::blossom::BlobDescriptor;
-use crate::media::sanitizer::SafeMediaMetadata;
 use nostr_mls::prelude::*;
 use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Row};
 
+use crate::media::{blossom::BlobDescriptor, sanitizer::SafeMediaMetadata};
+
 /// Represents a file upload received from the frontend application.
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct FileUpload {

src/nostr_manager/mod.rs

@@ -1,18 +1,16 @@
-// use crate::media::blossom::BlossomClient;
-use crate::types::ProcessableEvent;
-use crate::whitenoise::accounts::Account;
-use crate::whitenoise::database::DatabaseError;
-use crate::whitenoise::relays::Relay;
-use crate::whitenoise::Whitenoise;
+use std::{collections::HashSet, time::Duration};
 
 use ::rand::RngCore;
 use nostr_sdk::prelude::*;
-use std::collections::HashSet;
-
-use std::time::Duration;
 use thiserror::Error;
 use tokio::sync::mpsc::Sender;
 
+// use crate::media::blossom::BlossomClient;
+use crate::{
+    types::ProcessableEvent,
+    whitenoise::{accounts::Account, database::DatabaseError, relays::Relay, Whitenoise},
+};
+
 pub mod parser;
 pub mod query;
 // pub mod search;

src/nostr_manager/parser.rs

@@ -1,9 +1,10 @@
 //! This module contains the logic for parsing Nostr events into tokens.
 
-use crate::nostr_manager::NostrManager;
 use nostr::parser::{NostrParser, Token};
 use serde::{Deserialize, Serialize};
 
+use crate::nostr_manager::NostrManager;
+
 /// Parser trait for parsing content into tokens
 /// This trait is designed to be thread-safe for use with Flutter Rust Bridge (FRB)
 pub trait Parser: Send + Sync {

src/nostr_manager/query.rs

@@ -1,13 +1,15 @@
 //! Query functions for NostrManager
 //! This handles fetching events from the database cache.
 
-use crate::whitenoise::relays::Relay;
+use std::collections::HashSet;
+
+use nostr_sdk::prelude::*;
+
 use crate::{
     nostr_manager::{NostrManager, Result},
+    whitenoise::relays::Relay,
     RelayType,
 };
-use nostr_sdk::prelude::*;
-use std::collections::HashSet;
 
 impl NostrManager {
     pub(crate) async fn fetch_metadata_from(

src/nostr_manager/subscriptions.rs

@@ -1,11 +1,14 @@
 //! Subscription functions for NostrManager
 //! This mostly handles subscribing and processing events as they come in while the user is active.
 
-use crate::nostr_manager::{NostrManager, Result};
-use crate::whitenoise::relays::Relay;
 use nostr_sdk::prelude::*;
 use sha2::{Digest, Sha256};
 
+use crate::{
+    nostr_manager::{NostrManager, Result},
+    whitenoise::relays::Relay,
+};
+
 impl NostrManager {
     /// Create a short hash from a pubkey for use in subscription IDs
     /// Uses first 12 characters of SHA256 hash for privacy and collision resistance, salted per session