refactor: Remove MongoDB support, simplify to SQLite-only architecture

- Remove pymongo dependency from pyproject.toml and update lock file
- Delete leggen/database/mongo.py implementation file
- Simplify DatabaseService to SQLite-only operations with default enabled
- Update CLI database utilities to remove MongoDB logic and imports
- Update documentation and configuration examples to reflect SQLite-only approach
- Update test fixtures and configuration tests for simplified database setup
- Change SQLite default from false to true for better user experience

This simplification reduces complexity, removes external database dependencies,
and focuses on the robust built-in SQLite solution. All 46 tests passing.

Benefits:
- Simpler architecture with single database solution
- Reduced dependencies (removed pymongo and dnspython)
- Cleaner configuration with less complexity
- Easier maintenance with fewer code paths

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

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

leggen/database/mongo.py

@@ -1,54 +0,0 @@
-import click
-from pymongo import MongoClient
-from pymongo.errors import DuplicateKeyError
-
-from leggen.utils.text import success, warning
-
-
-def persist_balances(ctx: click.Context, balance: dict) -> None:
-    # Connect to MongoDB
-    mongo_uri = ctx.obj.get("database", {}).get("mongodb", {}).get("uri")
-    client = MongoClient(mongo_uri)
-    db = client["leggen"]
-    balances_collection = db["balances"]
-
-    # Insert balance into MongoDB
-    try:
-        balances_collection.insert_one(balance)
-        success(
-            f"[{balance['account_id']}] Inserted new balance if type {balance['type']}"
-        )
-    except DuplicateKeyError:
-        warning(f"[{balance['account_id']}] Skipped duplicate balance")
-
-    client.close()
-
-
-def persist_transactions(ctx: click.Context, account: str, transactions: list) -> list:
-    # Connect to MongoDB
-    mongo_uri = ctx.obj.get("database", {}).get("mongodb", {}).get("uri")
-    client = MongoClient(mongo_uri)
-    db = client["leggen"]
-    transactions_collection = db["transactions"]
-
-    # Create a unique index on internalTransactionId
-    transactions_collection.create_index("internalTransactionId", unique=True)
-
-    # Insert transactions into MongoDB
-    duplicates_count = 0
-
-    new_transactions = []
-
-    for transaction in transactions:
-        try:
-            transactions_collection.insert_one(transaction)
-            new_transactions.append(transaction)
-        except DuplicateKeyError:
-            # A transaction with the same ID already exists, skip insertion
-            duplicates_count += 1
-
-    success(f"[{account}] Inserted {len(new_transactions)} new transactions")
-    if duplicates_count:
-        warning(f"[{account}] Skipped {duplicates_count} duplicate transactions")
-
-    return new_transactions

leggen/utils/database.py

@@ -2,43 +2,33 @@ from datetime import datetime
 
 import click
 
-import leggen.database.mongo as mongodb_engine
 import leggen.database.sqlite as sqlite_engine
 from leggen.utils.network import get
 from leggen.utils.text import info, warning
 
 
 def persist_balance(ctx: click.Context, account: str, balance: dict) -> None:
-    sqlite = ctx.obj.get("database", {}).get("sqlite", False)
-    mongodb = ctx.obj.get("database", {}).get("mongodb", False)
+    sqlite = ctx.obj.get("database", {}).get("sqlite", True)
 
-    if not sqlite and not mongodb:
-        warning("No database engine is enabled, skipping balance saving")
+    if not sqlite:
+        warning("SQLite database is disabled, skipping balance saving")
+        return
 
-    if sqlite:
-        info(f"[{account}] Fetched balances, saving to SQLite")
-        sqlite_engine.persist_balances(ctx, balance)
-    else:
-        info(f"[{account}] Fetched balances, saving to MongoDB")
-        mongodb_engine.persist_balances(ctx, balance)
+    info(f"[{account}] Fetched balances, saving to SQLite")
+    sqlite_engine.persist_balances(ctx, balance)
 
 
 def persist_transactions(ctx: click.Context, account: str, transactions: list) -> list:
-    sqlite = ctx.obj.get("database", {}).get("sqlite", False)
-    mongodb = ctx.obj.get("database", {}).get("mongodb", False)
+    sqlite = ctx.obj.get("database", {}).get("sqlite", True)
 
-    if not sqlite and not mongodb:
-        warning("No database engine is enabled, skipping transaction saving")
+    if not sqlite:
+        warning("SQLite database is disabled, skipping transaction saving")
         # WARNING: This will return the transactions list as is, without saving it to any database
         # Possible duplicate notifications will be sent if the filters are enabled
         return transactions
 
-    if sqlite:
-        info(f"[{account}] Fetched {len(transactions)} transactions, saving to SQLite")
-        return sqlite_engine.persist_transactions(ctx, account, transactions)
-    else:
-        info(f"[{account}] Fetched {len(transactions)} transactions, saving to MongoDB")
-        return mongodb_engine.persist_transactions(ctx, account, transactions)
+    info(f"[{account}] Fetched {len(transactions)} transactions, saving to SQLite")
+    return sqlite_engine.persist_transactions(ctx, account, transactions)
 
 
 def save_transactions(ctx: click.Context, account: str) -> list: