Upload 62 files

app/api/routes/entities.py

@@ -1,18 +1,26 @@
 """
 Entity CRUD Routes
 """
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Query, Header, Cookie
 from sqlalchemy.orm import Session
 from sqlalchemy import or_
 from typing import List, Optional
 
-from app.core.database import get_db
+from app.core.database import get_db, get_db_for_session
 from app.models import Entity, Relationship
 from app.schemas import EntityCreate, EntityUpdate, EntityResponse, GraphData, GraphNode, GraphEdge
 
 router = APIRouter(prefix="/entities", tags=["Entities"])
 
 
+def get_session_or_default(
+    x_session_id: Optional[str] = Header(None),
+    numidium_session: Optional[str] = Cookie(None)
+) -> Optional[str]:
+    """Get session ID from header or cookie"""
+    return x_session_id or numidium_session
+
+
 @router.get("", response_model=List[EntityResponse])
 def list_entities(
     type: Optional[str] = None,
@@ -20,27 +28,39 @@ def list_entities(
     project_id: Optional[str] = None,
     limit: int = Query(default=50, le=200),
     offset: int = 0,
-    db: Session = Depends(get_db)
+    x_session_id: Optional[str] = Header(None),
+    numidium_session: Optional[str] = Cookie(None)
 ):
     """Lista todas as entidades com filtros opcionais"""
-    query = db.query(Entity)
+    session_id = x_session_id or numidium_session
     
-    if project_id:
-        query = query.filter(Entity.project_id == project_id)
+    # Use session-specific database if session exists
+    if session_id:
+        db = get_db_for_session(session_id)
+    else:
+        db = next(get_db())
     
-    if type:
-        query = query.filter(Entity.type == type)
-    
-    if search:
-        query = query.filter(
-            or_(
-                Entity.name.ilike(f"%{search}%"),
-                Entity.description.ilike(f"%{search}%")
+    try:
+        query = db.query(Entity)
+        
+        if project_id:
+            query = query.filter(Entity.project_id == project_id)
+        
+        if type:
+            query = query.filter(Entity.type == type)
+        
+        if search:
+            query = query.filter(
+                or_(
+                    Entity.name.ilike(f"%{search}%"),
+                    Entity.description.ilike(f"%{search}%")
+                )
             )
-        )
-    
-    query = query.order_by(Entity.created_at.desc())
-    return query.offset(offset).limit(limit).all()
+        
+        query = query.order_by(Entity.created_at.desc())
+        return query.offset(offset).limit(limit).all()
+    finally:
+        db.close()
 
 
 @router.get("/types")

app/api/routes/session.py

@@ -0,0 +1,37 @@
+"""
+Session management routes
+"""
+from fastapi import APIRouter, Header, Cookie, Response
+from typing import Optional
+import uuid
+
+from app.core.database import create_new_session_id
+
+router = APIRouter(prefix="/session", tags=["Session"])
+
+
+@router.post("/create")
+def create_session(response: Response):
+    """Create a new session and return session_id"""
+    session_id = create_new_session_id()
+    response.set_cookie(
+        key="numidium_session",
+        value=session_id,
+        max_age=60*60*24*365,  # 1 year
+        httponly=True,
+        samesite="none",
+        secure=True
+    )
+    return {"session_id": session_id}
+
+
+@router.get("/current")
+def get_current_session(
+    numidium_session: Optional[str] = Cookie(None),
+    x_session_id: Optional[str] = Header(None)
+):
+    """Get current session ID"""
+    session_id = x_session_id or numidium_session
+    if not session_id:
+        return {"session_id": None, "message": "No session. Call POST /session/create"}
+    return {"session_id": session_id}

app/core/database.py

@@ -1,31 +1,72 @@
 """
 Database configuration and session management
+Per-session databases - each user session gets its own SQLite file
 """
 from sqlalchemy import create_engine, text
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import sessionmaker, Session
+from typing import Optional
 import os
-
-from app.config import settings
+import uuid
 
 # Ensure data directory exists
-os.makedirs("data", exist_ok=True)
+os.makedirs("data/sessions", exist_ok=True)
+
+# Base class for models
+Base = declarative_base()
+
+# Cache for session engines
+_session_engines = {}
+_session_makers = {}
+
+
+def get_session_engine(session_id: str):
+    """Get or create engine for a specific session"""
+    if session_id not in _session_engines:
+        db_path = f"data/sessions/{session_id}.db"
+        engine = create_engine(
+            f"sqlite:///./{db_path}",
+            connect_args={"check_same_thread": False}
+        )
+        _session_engines[session_id] = engine
+        _session_makers[session_id] = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        
+        # Initialize tables for this session
+        Base.metadata.create_all(bind=engine)
+        _run_migrations(engine)
+        
+    return _session_engines[session_id]
+
+
+def get_session_db(session_id: str):
+    """Get database session for a specific user session"""
+    get_session_engine(session_id)  # Ensure engine exists
+    SessionLocal = _session_makers[session_id]
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
 
-# Create engine
+def get_db_for_session(session_id: str) -> Session:
+    """Direct session getter (non-generator) for routes"""
+    get_session_engine(session_id)
+    SessionLocal = _session_makers[session_id]
+    return SessionLocal()
+
+
+# Legacy - default database for backwards compatibility
+from app.config import settings
 engine = create_engine(
     settings.database_url,
-    connect_args={"check_same_thread": False}  # Needed for SQLite
+    connect_args={"check_same_thread": False}
 )
-
-# Session factory
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-# Base class for models
-Base = declarative_base()
-
 
 def get_db():
-    """Dependency to get database session"""
+    """Legacy: Default database session"""
     db = SessionLocal()
     try:
         yield db
@@ -33,40 +74,37 @@ def get_db():
         db.close()
 
 
-def init_db():
-    """Initialize database tables and run migrations"""
-    Base.metadata.create_all(bind=engine)
-    
-    # Run migrations for new columns
-    with engine.connect() as conn:
-        # Add event_date to entities if not exists
+def _run_migrations(eng):
+    """Run migrations on an engine"""
+    with eng.connect() as conn:
         try:
             conn.execute(text("ALTER TABLE entities ADD COLUMN event_date DATETIME"))
             conn.commit()
-            print("✅ Added event_date column to entities table")
         except Exception:
-            pass  # Column already exists
-        
-        # Add event_date to relationships if not exists
+            pass
         try:
             conn.execute(text("ALTER TABLE relationships ADD COLUMN event_date DATETIME"))
             conn.commit()
-            print("✅ Added event_date column to relationships table")
         except Exception:
-            pass  # Column already exists
-        
-        # Add project_id to entities if not exists
+            pass
         try:
             conn.execute(text("ALTER TABLE entities ADD COLUMN project_id VARCHAR(36)"))
             conn.commit()
-            print("✅ Added project_id column to entities table")
         except Exception:
-            pass  # Column already exists
-        
-        # Add project_id to relationships if not exists
+            pass
         try:
             conn.execute(text("ALTER TABLE relationships ADD COLUMN project_id VARCHAR(36)"))
             conn.commit()
-            print("✅ Added project_id column to relationships table")
         except Exception:
-            pass  # Column already exists
+            pass
+
+
+def init_db():
+    """Initialize default database tables"""
+    Base.metadata.create_all(bind=engine)
+    _run_migrations(engine)
+
+
+def create_new_session_id() -> str:
+    """Generate a new session ID"""
+    return str(uuid.uuid4())

app/main.py

@@ -8,7 +8,7 @@ from contextlib import asynccontextmanager
 
 from app.config import settings
 from app.core.database import init_db
-from app.api.routes import entities, relationships, events, search, ingest, analyze, graph, research, chat, investigate, dados_publicos, timeline
+from app.api.routes import entities, relationships, events, search, ingest, analyze, graph, research, chat, investigate, dados_publicos, timeline, session
 
 
 @asynccontextmanager
@@ -62,6 +62,7 @@ app.include_router(chat.router, prefix="/api/v1")
 app.include_router(investigate.router, prefix="/api/v1")
 app.include_router(dados_publicos.router, prefix="/api/v1")
 app.include_router(timeline.router, prefix="/api/v1")
+app.include_router(session.router, prefix="/api/v1")
 
 
 @app.get("/")