feat(torrent): add date sorting and display

- Sort torrents by added date (newest first) by default
- Add Date column to desktop table (after ETA)
- Add Date to mobile card view
- Add Date option to mobile sort dropdown
- Display dates in DD/MM/YYYY HH:mm format

backend/.env

@@ -1,8 +0,0 @@
-# Database
-DATABASE_URL=sqlite:vibetorrent.db
-
-# VAPID Keys for Push Notifications
-# Generate new keys for production using: cargo run --bin web-push --features web-push -- generate-vapid-keys
-VAPID_PUBLIC_KEY=BEdPj6XQR7MGzM28Nev9wokF5upHoydNDahouJbQ9ZdBJpEFAN1iNfANSEvY0ItasNY5zcvvqN_tjUt64Rfd0gU
-VAPID_PRIVATE_KEY=aUcCYJ7kUd9UClCaWwad0IVgbYJ6svwl19MjSX7GH10
-VAPID_EMAIL=mailto:admin@vibetorrent.app

backend/migrations/001_init.sql

@@ -1,16 +0,0 @@
--- 001_init.sql
--- Initial schema for users and sessions
-
-CREATE TABLE IF NOT EXISTS users (
-    id INTEGER PRIMARY KEY,
-    username TEXT NOT NULL UNIQUE,
-    password_hash TEXT NOT NULL,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS sessions (
-    token TEXT PRIMARY KEY,
-    user_id INTEGER NOT NULL,
-    expires_at DATETIME NOT NULL,
-    FOREIGN KEY(user_id) REFERENCES users(id)
-);

backend/migrations/002_push_subscriptions.sql

@@ -1,13 +0,0 @@
--- 002_push_subscriptions.sql
--- Push notification subscriptions storage
-
-CREATE TABLE IF NOT EXISTS push_subscriptions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    endpoint TEXT NOT NULL UNIQUE,
-    p256dh TEXT NOT NULL,
-    auth TEXT NOT NULL,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
--- Index for faster lookups by endpoint
-CREATE INDEX IF NOT EXISTS idx_push_subscriptions_endpoint ON push_subscriptions(endpoint);

backend/src/db.rs

@@ -16,27 +16,35 @@ impl Db {
             .await?;
 
         let db = Self { pool };
-        db.run_migrations().await?;
+        db.init().await?;
         Ok(db)
     }
 
-    async fn run_migrations(&self) -> Result<()> {
-        // WAL mode - enables concurrent reads while writing
-        sqlx::query("PRAGMA journal_mode=WAL")
-            .execute(&self.pool)
-            .await?;
+    async fn init(&self) -> Result<()> {
+        // Create users table
+        sqlx::query(
+            "CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY,
+                username TEXT NOT NULL UNIQUE,
+                password_hash TEXT NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )",
+        )
+        .execute(&self.pool)
+        .await?;
 
-        // NORMAL synchronous - faster than FULL, still safe enough
-        sqlx::query("PRAGMA synchronous=NORMAL")
-            .execute(&self.pool)
-            .await?;
+        // Create sessions table
+        sqlx::query(
+            "CREATE TABLE IF NOT EXISTS sessions (
+                token TEXT PRIMARY KEY,
+                user_id INTEGER NOT NULL,
+                expires_at DATETIME NOT NULL,
+                FOREIGN KEY(user_id) REFERENCES users(id)
+            )",
+        )
+        .execute(&self.pool)
+        .await?;
 
-        // 5 second busy timeout - reduces "database locked" errors
-        sqlx::query("PRAGMA busy_timeout=5000")
-            .execute(&self.pool)
-            .await?;
-
-        sqlx::migrate!("./migrations").run(&self.pool).await?;
         Ok(())
     }
 
@@ -51,24 +59,23 @@ impl Db {
         Ok(())
     }
 
-    pub async fn get_user_by_username(&self, username: &str) -> Result<Option<(i64, String)>> {
-        let row = sqlx::query("SELECT id, password_hash FROM users WHERE username = ?")
-            .bind(username)
-            .fetch_optional(&self.pool)
-            .await?;
+        pub async fn get_user_by_username(&self, username: &str) -> Result<Option<(i64, String)>> {
+            let row = sqlx::query("SELECT id, password_hash FROM users WHERE username = ?")
+                .bind(username)
+                .fetch_optional(&self.pool)
+                .await?;
 
-        Ok(row.map(|r| (r.get(0), r.get(1))))
-    }
+            Ok(row.map(|r| (r.get(0), r.get(1))))
+        }
 
-    pub async fn get_username_by_id(&self, id: i64) -> Result<Option<String>> {
-        let row = sqlx::query("SELECT username FROM users WHERE id = ?")
-            .bind(id)
-            .fetch_optional(&self.pool)
-            .await?;
-
-        Ok(row.map(|r| r.get(0)))
-    }
+        pub async fn get_username_by_id(&self, id: i64) -> Result<Option<String>> {
+            let row = sqlx::query("SELECT username FROM users WHERE id = ?")
+                .bind(id)
+                .fetch_optional(&self.pool)
+                .await?;
 
+            Ok(row.map(|r| r.get(0)))
+        }
     pub async fn has_users(&self) -> Result<bool> {
         let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
             .fetch_one(&self.pool)
@@ -121,36 +128,4 @@ impl Db {
             .await?;
         Ok(())
     }
-
-    // --- Push Subscription Operations ---
-
-    pub async fn save_push_subscription(&self, endpoint: &str, p256dh: &str, auth: &str) -> Result<()> {
-        sqlx::query(
-            "INSERT INTO push_subscriptions (endpoint, p256dh, auth) VALUES (?, ?, ?)
-             ON CONFLICT(endpoint) DO UPDATE SET p256dh = EXCLUDED.p256dh, auth = EXCLUDED.auth"
-        )
-        .bind(endpoint)
-        .bind(p256dh)
-        .bind(auth)
-        .execute(&self.pool)
-        .await?;
-        Ok(())
-    }
-
-    pub async fn remove_push_subscription(&self, endpoint: &str) -> Result<()> {
-        sqlx::query("DELETE FROM push_subscriptions WHERE endpoint = ?")
-            .bind(endpoint)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    pub async fn get_all_push_subscriptions(&self) -> Result<Vec<(String, String, String)>> {
-        let rows = sqlx::query_as::<_, (String, String, String)>(
-            "SELECT endpoint, p256dh, auth FROM push_subscriptions"
-        )
-        .fetch_all(&self.pool)
-        .await?;
-        Ok(rows)
-    }
 }

backend/src/main.rs

@@ -320,25 +320,13 @@ async fn main() {
     // Channel for Events (Diffs)
     let (event_bus, _) = broadcast::channel::<AppEvent>(1024);
 
-    #[cfg(feature = "push-notifications")]
-    let push_store = match push::PushSubscriptionStore::with_db(&db).await {
-        Ok(store) => store,
-        Err(e) => {
-            tracing::error!("Failed to initialize push store: {}", e);
-            push::PushSubscriptionStore::new()
-        }
-    };
-
-    #[cfg(not(feature = "push-notifications"))]
-    let push_store = ();
-
     let app_state = AppState {
         tx: tx.clone(),
         event_bus: event_bus.clone(),
         scgi_socket_path: args.socket.clone(),
         db: db.clone(),
         #[cfg(feature = "push-notifications")]
-        push_store,
+        push_store: push::PushSubscriptionStore::new(),
     };
 
     // Spawn background task to poll rTorrent

backend/src/push.rs

@@ -6,7 +6,10 @@ use web_push::{
     HyperWebPushClient, SubscriptionInfo, VapidSignatureBuilder, WebPushClient, WebPushMessageBuilder,
 };
 
-use crate::db::Db;
+// VAPID keys - PRODUCTION'DA ENVIRONMENT VARIABLE'DAN ALINMALI!
+const VAPID_PUBLIC_KEY: &str = "BEdPj6XQR7MGzM28Nev9wokF5upHoydNDahouJbQ9ZdBJpEFAN1iNfANSEvY0ItasNY5zcvvqN_tjUt64Rfd0gU";
+const VAPID_PRIVATE_KEY: &str = "aUcCYJ7kUd9UClCaWwad0IVgbYJ6svwl19MjSX7GH10";
+const VAPID_EMAIL: &str = "mailto:admin@vibetorrent.app";
 
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 pub struct PushSubscription {
@@ -20,72 +23,34 @@ pub struct PushKeys {
     pub auth: String,
 }
 
-#[derive(Clone)]
+/// In-memory store for push subscriptions
+/// TODO: Replace with database in production
+#[derive(Default, Clone)]
 pub struct PushSubscriptionStore {
-    db: Option<Db>,
     subscriptions: Arc<RwLock<Vec<PushSubscription>>>,
 }
 
 impl PushSubscriptionStore {
     pub fn new() -> Self {
         Self {
-            db: None,
             subscriptions: Arc::new(RwLock::new(Vec::new())),
         }
     }
 
-    pub async fn with_db(db: &Db) -> Result<Self, Box<dyn std::error::Error>> {
-        let mut subscriptions_vec: Vec<PushSubscription> = Vec::new();
-
-        // Load existing subscriptions from DB
-        let subs = db.get_all_push_subscriptions().await?;
-        for (endpoint, p256dh, auth) in subs {
-            subscriptions_vec.push(PushSubscription {
-                endpoint,
-                keys: PushKeys { p256dh, auth },
-            });
-        }
-        tracing::info!("Loaded {} push subscriptions from database", subscriptions_vec.len());
-
-        Ok(Self {
-            db: Some(db.clone()),
-            subscriptions: Arc::new(RwLock::new(subscriptions_vec)),
-        })
-    }
-
     pub async fn add_subscription(&self, subscription: PushSubscription) {
-        // Add to memory
         let mut subs = self.subscriptions.write().await;
-
+        
         // Remove duplicate endpoint if exists
         subs.retain(|s| s.endpoint != subscription.endpoint);
-        subs.push(subscription.clone());
+        
+        subs.push(subscription);
         tracing::info!("Added push subscription. Total: {}", subs.len());
-
-        // Save to DB if available
-        if let Some(db) = &self.db {
-            if let Err(e) = db.save_push_subscription(
-                &subscription.endpoint,
-                &subscription.keys.p256dh,
-                &subscription.keys.auth,
-            ).await {
-                tracing::error!("Failed to save push subscription to DB: {}", e);
-            }
-        }
     }
 
     pub async fn remove_subscription(&self, endpoint: &str) {
-        // Remove from memory
         let mut subs = self.subscriptions.write().await;
         subs.retain(|s| s.endpoint != endpoint);
         tracing::info!("Removed push subscription. Total: {}", subs.len());
-
-        // Remove from DB if available
-        if let Some(db) = &self.db {
-            if let Err(e) = db.remove_push_subscription(endpoint).await {
-                tracing::error!("Failed to remove push subscription from DB: {}", e);
-            }
-        }
     }
 
     pub async fn get_all_subscriptions(&self) -> Vec<PushSubscription> {
@@ -100,7 +65,7 @@ pub async fn send_push_notification(
     body: &str,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let subscriptions = store.get_all_subscriptions().await;
-
+    
     if subscriptions.is_empty() {
         tracing::debug!("No push subscriptions to send to");
         return Ok(());
@@ -118,9 +83,6 @@ pub async fn send_push_notification(
 
     let client = HyperWebPushClient::new();
 
-    let vapid_private_key = std::env::var("VAPID_PRIVATE_KEY").expect("VAPID_PRIVATE_KEY must be set in .env");
-    let vapid_email = std::env::var("VAPID_EMAIL").expect("VAPID_EMAIL must be set in .env");
-
     for subscription in subscriptions {
         let subscription_info = SubscriptionInfo {
             endpoint: subscription.endpoint.clone(),
@@ -131,18 +93,18 @@ pub async fn send_push_notification(
         };
 
         let mut sig_builder = VapidSignatureBuilder::from_base64(
-            &vapid_private_key,
+            VAPID_PRIVATE_KEY,
             web_push::URL_SAFE_NO_PAD,
             &subscription_info,
         )?;
-
-        sig_builder.add_claim("sub", vapid_email.as_str());
-        sig_builder.add_claim("aud", subscription.endpoint.as_str());
+        
+        sig_builder.add_claim("sub", VAPID_EMAIL);
+        sig_builder.add_claim("aud", subscription.endpoint.clone());
         let signature = sig_builder.build()?;
 
         let mut builder = WebPushMessageBuilder::new(&subscription_info);
         builder.set_vapid_signature(signature);
-
+        
         let payload_str = payload.to_string();
         builder.set_payload(web_push::ContentEncoding::Aes128Gcm, payload_str.as_bytes());
 
@@ -160,6 +122,6 @@ pub async fn send_push_notification(
     Ok(())
 }
 
-pub fn get_vapid_public_key() -> String {
-    std::env::var("VAPID_PUBLIC_KEY").expect("VAPID_PUBLIC_KEY must be set in .env")
+pub fn get_vapid_public_key() -> &'static str {
+    VAPID_PUBLIC_KEY
 }

frontend/src/components/torrent/table.rs

@@ -46,9 +46,6 @@ fn format_duration(seconds: i64) -> String {
 }
 
 fn format_date(timestamp: i64) -> String {
-    if timestamp <= 0 {
-        return "N/A".to_string();
-    }
     let dt = chrono::DateTime::from_timestamp(timestamp, 0);
     match dt {
         Some(dt) => dt.format("%d/%m/%Y %H:%M").to_string(),
@@ -342,6 +339,14 @@ pub fn TorrentTable() -> impl IntoView {
             </div>
 
                         <div class="md:hidden flex flex-col h-full bg-base-200 relative">
+                            // Transparent overlay to close sort dropdown
+                            <Show when=move || sort_open.get()>
+                                <div
+                                    class="fixed inset-0 z-[98] cursor-default"
+                                    on:pointerdown=move |_| set_sort_open.set(false)
+                                ></div>
+                            </Show>
+
                             <div class="px-3 py-2 border-b border-base-200 flex justify-between items-center bg-base-100/95 backdrop-blur z-10 shrink-0">
                                 <span class="text-xs font-bold opacity-50 uppercase tracking-wider">"Torrents"</span>
 
@@ -363,6 +368,7 @@ pub fn TorrentTable() -> impl IntoView {
                                     <ul
                                         class="absolute top-full right-0 z-[100] menu p-2 shadow bg-base-100 rounded-box w-48 mt-1 border border-base-200 text-xs"
                                         style=move || if sort_open.get() { "display: block" } else { "display: none" }
+                                        on:pointerdown=move |e| e.stop_propagation()
                                     >
                                          <li class="menu-title px-2 py-1 opacity-50 text-[10px] uppercase font-bold">"Sort By"</li>
                                          {
@@ -377,21 +383,20 @@ pub fn TorrentTable() -> impl IntoView {
                                                   (SortColumn::AddedDate, "Date"),
                                               ];
 
-                                              columns.into_iter().map(|(col, label)| {
-                                                  let is_active = move || sort_col.get() == col;
-                                                  let current_dir = move || sort_dir.get();
+                                             columns.into_iter().map(|(col, label)| {
+                                                 let is_active = move || sort_col.get() == col;
+                                                 let current_dir = move || sort_dir.get();
 
-                                                  view! {
-                                                      <li>
-                                                          <button
-                                                              type="button"
-                                                              class=move || if is_active() { "bg-primary/10 text-primary font-bold flex justify-between" } else { "flex justify-between" }
-                                                              on:pointerdown=move |e| {
-                                                                  e.stop_propagation();
-                                                                  handle_sort(col);
-                                                                  set_sort_open.set(false);
-                                                              }
-                                                          >
+                                                 view! {
+                                                     <li>
+                                                         <button
+                                                             class=move || if is_active() { "bg-primary/10 text-primary font-bold flex justify-between" } else { "flex justify-between" }
+                                                             on:pointerdown=move |e| {
+                                                                 e.stop_propagation();
+                                                                 handle_sort(col);
+                                                                 set_sort_open.set(false);
+                                                             }
+                                                         >
                                                              {label}
                                                              <Show when=is_active fallback=|| ()>
                                                                  <span class="opacity-70 text-[10px]">

frontend/src/lib.rs

@@ -11,15 +11,11 @@ use app::App;
 #[wasm_bindgen(start)]
 pub fn main() {
     console_error_panic_hook::set_once();
-    console_log::init_with_level(log::Level::Debug)
-        .expect("Failed to initialize logging");
+    console_log::init_with_level(log::Level::Debug).unwrap();
 
-    let window = web_sys::window()
-        .expect("Failed to access window - browser may not be fully loaded");
-    let document = window.document()
-        .expect("Failed to access document");
-    let body = document.body()
-        .expect("Failed to access document body");
+    let window = web_sys::window().unwrap();
+    let document = window.document().unwrap();
+    let body = document.body().unwrap();
     
     // Add app-loaded class to body to hide spinner via CSS
     let _ = body.class_list().add_1("app-loaded");