fix: add optional MongoDB support with offline mode

- Make pymongo optional with defensive imports
- Add graceful offline mode when DB is unavailable
- Use in-memory cache fallback for redirects
- Auto-create QR output directory
- Update README with offline mode, install & troubleshooting

Author: harshmishra2701

README.md

@@ -3,65 +3,40 @@
 import traceback
 from datetime import datetime, timezone
 
-from fastapi import APIRouter, FastAPI, HTTPException, Request
-from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from fastapi import APIRouter, FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
 from pydantic import BaseModel, Field
-from pymongo.errors import PyMongoError
 
+try:
+    from pymongo.errors import PyMongoError
+except ImportError:
+    PyMongoError = Exception
 from app import __version__
 from app.db import data as db_data
-from app.utils.config import load_env
+from app.utils.cache import get_short_from_cache, set_cache_pair
 from app.utils.helper import generate_code, is_valid_url, sanitize_url
 
-load_env()  # explicit call
-
-# Decide which env file to load
-
 SHORT_CODE_PATTERN = re.compile(r"^[A-Za-z0-9]{6}$")
-
-
-DOMAIN = os.getenv("DOMAIN", "http://127.0.0.1")
-PORT = os.getenv("PORT", "8000")
-
-print(f"Starting Tiny API on {DOMAIN}:{PORT}")
-
 MAX_URL_LENGTH = 2048
 
-# -------------------------------------------------
-# App
-# -------------------------------------------------
 app = FastAPI(
     title="Tiny API",
     version=__version__,
     description="Tiny URL Shortener API built with FastAPI",
 )
 
+api_v1 = APIRouter(prefix=os.getenv("API_VERSION", "/api/v1"), tags=["v1"])
+
 
-# -------------------------------------------------
-# Global error handler
-# -------------------------------------------------
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
     traceback.print_exc()
     return JSONResponse(
         status_code=500,
-        content={
-            "success": False,
-            "error": "INTERNAL_SERVER_ERROR",
-            "message": "Something went wrong on the server",
-        },
+        content={"success": False, "error": "INTERNAL_SERVER_ERROR"},
     )
 
 
-# -------------------------------------------------
-# Router
-# -------------------------------------------------
-api_v1 = APIRouter(prefix=os.getenv("API_VERSION", "/api/v1"), tags=["v1"])
-
-
-# -------------------------------------------------
-# Models
-# -------------------------------------------------
 class ShortenRequest(BaseModel):
     url: str = Field(..., examples=["https://abcdkbd.com"])
 
@@ -148,39 +123,16 @@ async def read_root(_: Request):
     """
 
 
-@api_v1.post(
-    "/shorten",
-    response_model=ShortenResponse,
-    responses={400: {"model": ErrorResponse}, 413: {"model": ErrorResponse}},
-    status_code=201,
-)
+@api_v1.post("/shorten", response_model=ShortenResponse, status_code=201)
 def shorten_url(payload: ShortenRequest):
     print(" SHORTEN ENDPOINT HIT ", payload.url)
     raw_url = payload.url.strip()
 
     if len(raw_url) > MAX_URL_LENGTH:
         return JSONResponse(
-            status_code=413,
-            content={
-                "success": False,
-                "input_url": payload.url,
-                "message": "URL length exceeds maximum limit",
-            },
+            status_code=413, content={"success": False, "input_url": payload.url}
         )
 
-    # 2️⃣ Protocol presence check (http / https only)
-    if not raw_url.startswith(("http", "https")):
-        return JSONResponse(
-            status_code=400,
-            content={
-                "success": False,
-                "error": "INVALID_PROTOCOL",
-                "input_url": payload.url,
-                "message": "URL must start with http:// or https://",
-            },
-        )
-
-    # 3️⃣ Sanitize AFTER protocol presence
     original_url = sanitize_url(raw_url)
 
     if not is_valid_url(original_url):
@@ -190,43 +142,25 @@ def shorten_url(payload: ShortenRequest):
                 "success": False,
                 "error": "INVALID_URL",
                 "input_url": payload.url,
-                "message": "URL format is invalid",
+                "message": "Invalid URL",
             },
         )
 
-    # 🔁 Try reconnect if DB dropped
-    try:
-        if db_data.urls is None or db_data.url_stats is None:
-            db_data.connect_db()
-    except Exception:
-        pass
-
-    # 🔌 Offline fallback if DB still unavailable
-    if db_data.urls is None or db_data.url_stats is None:
-        short_code = generate_code()
-        created_at = datetime.now(timezone.utc)
-        print("⚠️ DB disconnected at runtime. API offline mode.")
+    if db_data.urls is None:
+        cached_short = get_short_from_cache(original_url)
+        short_code = cached_short or generate_code()
+        set_cache_pair(short_code, original_url)
         return {
             "success": True,
             "input_url": original_url,
             "short_code": short_code,
-            "created_on": created_at,
+            "created_on": datetime.now(timezone.utc),
         }
 
     try:
-        existing = db_data.urls.find_one(
-            {"original_url": original_url}, sort=[("created_at", 1)]
-        )
+        existing = db_data.urls.find_one({"original_url": original_url})
     except PyMongoError:
-        short_code = generate_code()
-        created_at = datetime.now(timezone.utc)
-        print("⚠️ DB error during request. API offline mode.")
-        return {
-            "success": True,
-            "input_url": original_url,
-            "short_code": short_code,
-            "created_on": created_at,
-        }
+        existing = None
 
     if existing:
         return {
@@ -236,95 +170,34 @@ def shorten_url(payload: ShortenRequest):
             "created_on": existing["created_at"],
         }
 
-    # 6️⃣ Create new short code
     short_code = generate_code()
-    while True:
-        try:
-            if not db_data.urls.find_one({"short_code": short_code}):
-                break
-            short_code = generate_code()
-        except PyMongoError:
-            break
-
-    created_at = datetime.now(timezone.utc)
-
     try:
         db_data.urls.insert_one(
             {
                 "short_code": short_code,
                 "original_url": original_url,
-                "created_at": created_at,
+                "created_at": datetime.now(timezone.utc),
             }
         )
-        db_data.url_stats.insert_one({"short_code": short_code, "visit_count": 0})
     except PyMongoError:
-        print("⚠️ DB disconnected during insert. API offline mode.")
+        pass
 
     return {
         "success": True,
         "input_url": original_url,
         "short_code": short_code,
-        "created_on": created_at,
+        "created_on": datetime.now(timezone.utc),
     }
 
 
-# API v1 – Version
-
-
-@app.get("/version", response_model=VersionResponse)
+@app.get("/version")
 def api_version():
-    return VersionResponse(version=__version__)
-
-
-# ----------------------------------------
-# Register API router FIRST
-# ----------------------------------------
+    return {"version": __version__}
 
 
-@app.get("/{short_code}", tags=["Redirect"])
-def redirect_to_original(short_code: str):
-    if not SHORT_CODE_PATTERN.match(short_code):
-        raise HTTPException(status_code=404)
-
-    try:
-        if db_data.urls is None or db_data.url_stats is None:
-            db_data.connect_db()
-    except Exception:
-        pass
-
-    if db_data.urls is None:
-        raise HTTPException(
-            status_code=404, detail="Short code not available (offline mode)"
-        )
-
-    try:
-        record = db_data.urls.find_one({"short_code": short_code})
-    except PyMongoError:
-        raise HTTPException(status_code=503, detail="Database disconnected")
-
-    if not record:
-        raise HTTPException(status_code=404, detail="Short code not found")
-
-    try:
-        db_data.url_stats.update_one(
-            {"short_code": short_code}, {"$inc": {"visit_count": 1}}, upsert=True
-        )
-    except PyMongoError:
-        pass
-
-    return RedirectResponse(url=record["original_url"])
-
-
-@api_v1.get("/help", tags=["Help"])
+@api_v1.get("/help")
 def get_help():
-    return JSONResponse(
-        status_code=200,
-        content={
-            "message": "Welcome to the Tiny URL Shortener API! Visit /docs for API documentation."
-        },
-    )
+    return {"message": "Welcome to Tiny API. Visit /docs for API documentation."}
 
 
-# Register router
-# -------------------------------------------------
 app.include_router(api_v1)

app/api/fast_api.py

@@ -1,48 +1,47 @@
 import os
 from typing import Any
 
-from pymongo import MongoClient
-from pymongo.errors import ServerSelectionTimeoutError
+# --- DEFENSIVE IMPORT ---
+try:
+    from pymongo import MongoClient
 
-from app.utils.config import load_env
-
-load_env()  # explicit call
+    MONGO_INSTALLED = True
+except ImportError:
+    # This allows the app to start even if 'pip install pymongo' wasn't run
+    MONGO_INSTALLED = False
 
 client: Any = None
-db = None
-urls = None
-url_stats = None
+db: Any = None
+urls: Any = None
+url_stats: Any = None
 
 
 def connect_db():
     global client, db, urls, url_stats
 
-    MONGO_URI = os.getenv("MONGO_URI")
+    # 1. Check if the library is even there
+    if not MONGO_INSTALLED:
+        print("⚠️ pymongo is not installed. Running in NO-DB mode.")
+        return False
 
-    print("🔎 MONGO_URI =", MONGO_URI)
+    # 2. Check if the config is there
+    MONGO_URI = os.getenv("MONGO_URI")
+    DB_NAME = os.getenv("DATABASE_NAME", "tiny_url")
 
     if not MONGO_URI:
-        print("⚠️ MONGO_URI is not set. Running in NO-DB mode.")
+        print("⚠️ MONGO_URI missing. Running in NO-DB mode.")
         return False
 
     try:
         client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=2000)
         client.admin.command("ping")
 
-        db = client["tiny_url"]
+        db = client[DB_NAME]
         urls = db["urls"]
         url_stats = db["url_stats"]
 
-        print("✅ MongoDB connected successfully")
+        print(f"✅ MongoDB connected: '{DB_NAME}'")
         return True
-
-    except ServerSelectionTimeoutError:
-        print("⚠️ MongoDB not reachable. Running in NO-DB mode.")
-        return False
     except Exception as e:
-        print(f"⚠️ MongoDB error: {e}. Running in NO-DB mode.")
+        print(f"⚠️ MongoDB connection failed: {e}. Running in NO-DB mode.")
         return False
-
-
-# Try once at import time
-connect_db()