feat: Firebase integration — Firestore persistence, firebase.json hosting + Cloud Run rewrite

.env.example

@@ -12,7 +12,7 @@ REDIS_URL=redis://localhost:6379/0
 APP_ENV=development                 # development | production
 DEBUG=true
 LOG_LEVEL=INFO
-ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173
+ALLOWED_ORIGINS=["http://localhost:3000","http://localhost:5173"]
 
 # ── Model Settings ────────────────────────────────────────────────────────────
 # Options: xlm-roberta-base | joelito/roberta-tagalog-base | bert-base-multilingual-cased

.firebaserc

@@ -0,0 +1,5 @@
+{
+  "projects": {},
+  "targets": {},
+  "etags": {}
+}

.gitignore

@@ -26,3 +26,5 @@ build/
 ml/models/*.pkl
 ml/models/*.bin
 ml/models/*.pt
+serviceAccountKey.json
+*.json.key

api/routes/history.py

@@ -22,7 +22,7 @@ def record_verification(entry: dict) -> None:
     "",
     response_model=HistoryResponse,
     summary="Get verification history",
-    description="Returns past verifications ordered by most recent. Supports pagination.",
+    description="Returns past verifications ordered by most recent. Reads from Firestore when configured, falls back to in-memory store.",
 )
 async def get_history(
     page: int = Query(1, ge=1, description="Page number"),
@@ -31,14 +31,39 @@ async def get_history(
 ) -> HistoryResponse:
     logger.info("GET /history | page=%d limit=%d", page, limit)
 
-    entries = list(reversed(_HISTORY))  # Most recent first
+    # Try Firestore first
+    try:
+        from firebase_client import get_verifications, get_verification_count
+        vf = verdict_filter.value if verdict_filter else None
+        offset = (page - 1) * limit
+        entries_raw = await get_verifications(limit=limit, offset=offset, verdict_filter=vf)
+        total = await get_verification_count(verdict_filter=vf)
+        if entries_raw or total > 0:
+            return HistoryResponse(
+                total=total,
+                entries=[
+                    HistoryEntry(
+                        id=e["id"],
+                        timestamp=e["timestamp"],
+                        input_type=e.get("input_type", "text"),
+                        text_preview=e.get("text_preview", "")[:120],
+                        verdict=Verdict(e["verdict"]),
+                        confidence=e["confidence"],
+                        final_score=e["final_score"],
+                    )
+                    for e in entries_raw
+                ],
+            )
+    except Exception as e:
+        logger.debug("Firestore history read failed (%s) — using in-memory store", e)
+
+    # In-memory fallback
+    entries = list(reversed(_HISTORY))
     if verdict_filter:
         entries = [e for e in entries if e.get("verdict") == verdict_filter.value]
-
     total = len(entries)
     start = (page - 1) * limit
     paginated = entries[start : start + limit]
-
     return HistoryResponse(
         total=total,
         entries=[

config.py

@@ -28,10 +28,11 @@ class Settings(BaseSettings):
     app_env: str = "development"
     debug: bool = True
     log_level: str = "INFO"
-    allowed_origins: list[str] = [
-        "http://localhost:3000",
-        "http://localhost:5173",
-    ]
+    allowed_origins: str = "http://localhost:3000,http://localhost:5173"
+
+    @property
+    def allowed_origins_list(self) -> list[str]:
+        return [o.strip() for o in self.allowed_origins.split(",") if o.strip()]
 
     # ── ML Models ─────────────────────────────────────────────────────────────
     ml_model_name: str = "xlm-roberta-base"

firebase.json

@@ -0,0 +1,39 @@
+{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "hosting": {
+    "site": "philverify",
+    "public": "frontend/dist",
+    "ignore": [
+      "firebase.json",
+      "**/.*",
+      "**/node_modules/**"
+    ],
+    "rewrites": [
+      {
+        "source": "/api/**",
+        "run": {
+          "serviceId": "philverify-api",
+          "region": "asia-southeast1"
+        }
+      },
+      {
+        "source": "**",
+        "destination": "/index.html"
+      }
+    ],
+    "headers": [
+      {
+        "source": "/api/**",
+        "headers": [
+          {
+            "key": "Access-Control-Allow-Origin",
+            "value": "*"
+          }
+        ]
+      }
+    ]
+  }
+}

firebase_client.py

@@ -0,0 +1,123 @@
+"""
+PhilVerify — Firebase / Firestore Client
+Initializes firebase-admin SDK and provides typed helpers for persistence.
+
+Setup:
+  1. Go to Firebase Console → Project Settings → Service Accounts
+  2. Click "Generate new private key" → save as `serviceAccountKey.json`
+     in the PhilVerify project root (already in .gitignore)
+  3. Set FIREBASE_PROJECT_ID in .env
+
+Collections:
+  verifications/   — one doc per verification run
+  trends/summary   — aggregated entity/topic counters
+"""
+import logging
+import os
+from functools import lru_cache
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_SERVICEACCOUNT_PATH = Path(__file__).parent / "serviceAccountKey.json"
+_db = None  # Firestore client singleton
+
+
+def get_firestore():
+    """Return the Firestore client, or None if Firebase is not configured."""
+    global _db
+    if _db is not None:
+        return _db
+
+    try:
+        import firebase_admin
+        from firebase_admin import credentials, firestore
+
+        if firebase_admin._DEFAULT_APP_NAME in firebase_admin._apps:
+            _db = firestore.client()
+            return _db
+
+        if _SERVICEACCOUNT_PATH.exists():
+            # Service account key file available (local dev + CI)
+            cred = credentials.Certificate(str(_SERVICEACCOUNT_PATH))
+            firebase_admin.initialize_app(cred)
+            logger.info("Firebase initialized via service account key")
+        elif os.getenv("GOOGLE_APPLICATION_CREDENTIALS"):
+            # Cloud Run / GCE default credentials
+            cred = credentials.ApplicationDefault()
+            firebase_admin.initialize_app(cred)
+            logger.info("Firebase initialized via Application Default Credentials")
+        else:
+            logger.warning(
+                "Firebase not configured — no serviceAccountKey.json and no "
+                "GOOGLE_APPLICATION_CREDENTIALS env var. History will use in-memory store."
+            )
+            return None
+
+        _db = firestore.client()
+        return _db
+
+    except ImportError:
+        logger.warning("firebase-admin not installed — Firestore disabled")
+        return None
+    except Exception as e:
+        logger.error("Firebase init error: %s — falling back to in-memory store", e)
+        return None
+
+
+async def save_verification(data: dict) -> bool:
+    """
+    Persist a verification result to Firestore.
+    Returns True on success, False if Firebase is unavailable.
+    """
+    db = get_firestore()
+    if db is None:
+        return False
+    try:
+        db.collection("verifications").document(data["id"]).set(data)
+        logger.debug("Verification %s saved to Firestore", data["id"])
+        return True
+    except Exception as e:
+        logger.error("Firestore write error: %s", e)
+        return False
+
+
+async def get_verifications(
+    limit: int = 20,
+    offset: int = 0,
+    verdict_filter: str | None = None,
+) -> list[dict]:
+    """Fetch verification history from Firestore ordered by timestamp desc."""
+    db = get_firestore()
+    if db is None:
+        return []
+    try:
+        query = (
+            db.collection("verifications")
+            .order_by("timestamp", direction="DESCENDING")
+        )
+        if verdict_filter:
+            query = query.where("verdict", "==", verdict_filter)
+        docs = query.limit(limit + offset).stream()
+        results = [doc.to_dict() for doc in docs]
+        return results[offset : offset + limit]
+    except Exception as e:
+        logger.error("Firestore read error: %s", e)
+        return []
+
+
+async def get_verification_count(verdict_filter: str | None = None) -> int:
+    """Return total count of verifications (with optional verdict filter)."""
+    db = get_firestore()
+    if db is None:
+        return 0
+    try:
+        query = db.collection("verifications")
+        if verdict_filter:
+            query = query.where("verdict", "==", verdict_filter)
+        # Use aggregation query (Firestore native count)
+        result = query.count().get()
+        return result[0][0].value
+    except Exception as e:
+        logger.error("Firestore count error: %s", e)
+        return 0

firestore.indexes.json

@@ -0,0 +1,51 @@
+{
+  // Example (Standard Edition):
+  //
+  // "indexes": [
+  //   {
+  //     "collectionGroup": "widgets",
+  //     "queryScope": "COLLECTION",
+  //     "fields": [
+  //       { "fieldPath": "foo", "arrayConfig": "CONTAINS" },
+  //       { "fieldPath": "bar", "mode": "DESCENDING" }
+  //     ]
+  //   },
+  //
+  //  "fieldOverrides": [
+  //    {
+  //      "collectionGroup": "widgets",
+  //      "fieldPath": "baz",
+  //      "indexes": [
+  //        { "order": "ASCENDING", "queryScope": "COLLECTION" }
+  //      ]
+  //    },
+  //   ]
+  // ]
+  //
+  // Example (Enterprise Edition):
+  //
+  // "indexes": [
+  //   {
+  //     "collectionGroup": "reviews",
+  //     "queryScope": "COLLECTION_GROUP",
+  //     "apiScope": "MONGODB_COMPATIBLE_API",
+  //     "density": "DENSE",
+  //     "multikey": false,
+  //     "fields": [
+  //       { "fieldPath": "baz", "mode": "ASCENDING" }
+  //     ]
+  //   },
+  //   {
+  //     "collectionGroup": "items",
+  //     "queryScope": "COLLECTION_GROUP",
+  //     "apiScope": "MONGODB_COMPATIBLE_API",
+  //     "density": "SPARSE_ANY",
+  //     "multikey": true,
+  //     "fields": [
+  //       { "fieldPath": "baz", "mode": "ASCENDING" }
+  //     ]
+  //   },
+  // ]
+  "indexes": [],
+  "fieldOverrides": []
+}

firestore.rules

@@ -0,0 +1,9 @@
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    match /verifications/{docId} {
+      allow read: if true;
+      allow write: if false;
+    }
+  }
+}

main.py

@@ -72,7 +72,7 @@ app = FastAPI(
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=settings.allowed_origins,
+    allow_origins=settings.allowed_origins_list,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],

requirements.txt

@@ -5,6 +5,9 @@ python-multipart==0.0.17          # File upload support
 pydantic==2.9.2
 pydantic-settings==2.6.1
 
+# ── Firebase ──────────────────────────────────────────────────────────────────
+firebase-admin==6.6.0             # Firestore + Admin SDK
+
 # ── NLP & ML ──────────────────────────────────────────────────────────────────
 transformers==4.46.3
 torch==2.5.1

scoring/engine.py

@@ -192,21 +192,44 @@ async def run_verification(
         input_type=input_type,
     )
 
-    # ── Record to history ─────────────────────────────────────────────────────
+    # ── Record to Firestore (falls back to in-memory if Firebase not configured) ─
+    history_entry = {
+        "id": str(uuid.uuid4()),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "input_type": input_type,
+        "text_preview": text[:120],
+        "verdict": verdict.value,
+        "confidence": result.confidence,
+        "final_score": final_score,
+        "entities": ner_result.to_dict(),
+        "claim_used": claim_result.claim,
+        "layer1": {
+            "verdict": layer1.verdict.value,
+            "confidence": layer1.confidence,
+            "triggered_features": layer1.triggered_features,
+        },
+        "layer2": {
+            "verdict": layer2.verdict.value,
+            "evidence_score": layer2.evidence_score,
+            "claim_used": layer2.claim_used,
+        },
+        "sentiment": sentiment_result.sentiment,
+        "emotion": sentiment_result.emotion,
+        "language": language.value,
+    }
     try:
-        from api.routes.history import record_verification
-        record_verification({
-            "id": str(uuid.uuid4()),
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "input_type": input_type,
-            "text_preview": text[:120],
-            "verdict": verdict.value,
-            "confidence": result.confidence,
-            "final_score": final_score,
-            "entities": ner_result.to_dict(),
-            "claim_used": claim_result.claim,
-        })
+        from firebase_client import save_verification
+        saved = await save_verification(history_entry)
+        if not saved:
+            # Firestore unavailable — fall back to in-memory store
+            from api.routes.history import record_verification
+            record_verification(history_entry)
     except Exception as e:
         logger.warning("Failed to record history: %s", e)
+        try:
+            from api.routes.history import record_verification
+            record_verification(history_entry)
+        except Exception:
+            pass
 
     return result