Optimize recent transactions with 30-day date filter

Performance improvement for large ledgers:
- Added optional 'days' parameter to get_journal_entries()
- User dashboard now fetches only last 30 days of entries
- Dramatically reduces data transfer for ledgers with 100+ entries
- Filters in Python after fetching from Fava API

Example impact: 229 entries → ~20-50 entries (typical 30-day activity)

This is a "quick win" optimization as recommended for accounting systems
with growing transaction history. Admin endpoints still fetch all entries.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

fava_client.py

@@ -855,16 +855,23 @@ class FavaClient:
             logger.error(f"Failed to fetch accounts via BQL: {e}")
             raise
 
-    async def get_journal_entries(self) -> List[Dict[str, Any]]:
+    async def get_journal_entries(self, days: int = None) -> List[Dict[str, Any]]:
         """
-        Get all journal entries from Fava (with entry hashes).
+        Get journal entries from Fava (with entry hashes), optionally filtered by date.
+
+        Args:
+            days: If provided, only return entries from the last N days.
+                  If None, returns all entries (default behavior).
 
         Returns:
-            List of all entries (transactions, opens, closes, etc.) with entry_hash field.
+            List of entries (transactions, opens, closes, etc.) with entry_hash field.
 
         Example:
+            # Get all entries
             entries = await fava.get_journal_entries()
-            # Each entry has: entry_hash, date, flag, narration, tags, links, etc.
+
+            # Get only last 30 days
+            recent = await fava.get_journal_entries(days=30)
         """
         try:
             async with httpx.AsyncClient(timeout=self.timeout) as client:
@@ -874,6 +881,24 @@ class FavaClient:
                 entries = result.get("data", [])
                 logger.info(f"Fava /journal returned {len(entries)} entries")
 
+                # Filter by date if requested
+                if days is not None:
+                    from datetime import datetime, timedelta
+                    cutoff_date = (datetime.now() - timedelta(days=days)).date()
+                    filtered_entries = []
+                    for e in entries:
+                        entry_date_str = e.get("date")
+                        if entry_date_str:
+                            try:
+                                entry_date = datetime.strptime(entry_date_str, "%Y-%m-%d").date()
+                                if entry_date >= cutoff_date:
+                                    filtered_entries.append(e)
+                            except (ValueError, TypeError):
+                                # Include entries with invalid dates (shouldn't happen)
+                                filtered_entries.append(e)
+                    logger.info(f"Filtered to {len(filtered_entries)} entries from last {days} days (cutoff: {cutoff_date})")
+                    entries = filtered_entries
+
                 # Log transactions with "Lightning payment" in narration
                 lightning_entries = [e for e in entries if "Lightning payment" in e.get("narration", "")]
                 logger.info(f"Found {len(lightning_entries)} Lightning payment entries in journal")

views_api.py

@@ -377,8 +377,9 @@ async def api_get_user_entries(
         # Regular user can only see their own entries
         target_user_id = wallet.wallet.user
 
-    # Get all journal entries from Fava (full transaction objects)
+    # Get journal entries from Fava (last 30 days for performance)
-    all_entries = await fava.get_journal_entries()
+    # This drastically reduces data fetched for users with large ledgers
+    all_entries = await fava.get_journal_entries(days=30)
 
     # Filter and transform entries
     filtered_entries = []