mocksql 0.1.0__py3-none-any.whl

app/api/endpoints/messages.py

@@ -0,0 +1,114 @@
+import logging
+from typing import List, Any, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from storage.config import is_initialized
+from storage.test_repository import get_test, update_test
+from utils.saver import common_history_retriever
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class MessageRequest(BaseModel):
+    modelId: str
+
+
+class PatchTestsRequest(BaseModel):
+    sessionId: str
+    tests: List[Any]
+
+
+class PatchSqlRequest(BaseModel):
+    sessionId: str
+    sql: str
+    optimized_sql: str = ""
+    tests: Optional[List[Any]] = None
+    test_results: Optional[List[Any]] = None
+    restored_message_id: Optional[str] = None
+    last_error: Optional[str] = None
+
+
+@router.post("/getMessages")
+async def get_messages(body: MessageRequest):
+    if not is_initialized():
+        raise HTTPException(
+            status_code=400,
+            detail="Projet non initialisé. Lancez 'mocksql init' dans votre répertoire de travail pour commencer.",
+        )
+    try:
+        history = await common_history_retriever(body.modelId, filtered_types=[])
+        if history is None:
+            raise HTTPException(status_code=404, detail="Session not found")
+
+        test = get_test(body.modelId)
+        sql = test.get("sql") if test else None
+        optimized_sql = test.get("optimized_sql") if test else None
+        last_error = test.get("last_error") if test else ""
+        test_results = test.get("test_cases", []) if test else []
+        restored_message_id = test.get("restored_message_id") if test else None
+
+        # Fallback: extract from last results message in history
+        if not test_results:
+            import json
+
+            for msg in reversed(history):
+                if msg.additional_kwargs.get("type") == "results":
+                    try:
+                        test_results = json.loads(msg.content)
+                    except Exception:
+                        pass
+                    break
+
+        return {
+            "messages": history,
+            "sql": sql,
+            "optimized_sql": optimized_sql,
+            "test_results": test_results,
+            "restored_message_id": restored_message_id,
+            "last_error": last_error or "",
+            "sql_history": [],
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception(
+            "Erreur lors du chargement des messages pour la session %s", body.modelId
+        )
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/models/sql")
+async def patch_model_sql(body: PatchSqlRequest):
+    try:
+        updates: dict = {
+            "sql": body.sql,
+            "optimized_sql": body.optimized_sql,
+        }
+        if body.tests is not None:
+            updates["test_cases"] = body.tests
+        if body.test_results is not None:
+            updates["test_cases"] = body.test_results
+        if body.restored_message_id is not None:
+            updates["restored_message_id"] = body.restored_message_id or None
+        if body.last_error is not None:
+            updates["last_error"] = body.last_error
+
+        update_test(body.sessionId, updates)
+        return {"ok": True}
+    except Exception as e:
+        print(e)
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+
+@router.patch("/models/tests")
+async def patch_model_tests(body: PatchTestsRequest):
+    try:
+        update_test(body.sessionId, {"test_cases": body.tests})
+        return {"ok": True}
+    except Exception as e:
+        print(e)
+        raise HTTPException(status_code=500, detail="Internal Server Error")

app/api/endpoints/models.py

@@ -0,0 +1,117 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from storage.test_repository import (
+    list_models,
+    list_all_tests,
+    list_tests,
+    get_test,
+    create_test,
+    delete_test,
+    _test_path,
+    _read_json,
+)
+
+router = APIRouter()
+
+
+# ---------------------------------------------------------------------------
+# SQL Models (fichiers physiques dans models_path)
+# ---------------------------------------------------------------------------
+
+
+@router.get("/models")
+async def get_models():
+    """Liste les fichiers .sql disponibles dans models_path.
+
+    Each entry includes session_id / updated_at / test_name when a test already
+    exists for that model, so the frontend can redirect instead of regenerating.
+    Tested models are returned first (sorted by updated_at desc), then untested.
+    """
+    try:
+        sql_files = list_models()
+        tested = []
+        untested = []
+        for f in sql_files:
+            p = _test_path(f["name"])
+            if p.exists():
+                data = _read_json(p)
+                if data:
+                    tested.append(
+                        {
+                            **f,
+                            "session_id": data.get("test_id"),
+                            "updated_at": data.get("updated_at"),
+                            "test_name": data.get("test_name"),
+                        }
+                    )
+                    continue
+            untested.append(f)
+        tested.sort(key=lambda x: x.get("updated_at") or "", reverse=True)
+        return tested + untested
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/tests/all")
+async def get_all_tests():
+    """Liste toutes les sessions de test (tous models confondus), triées par date décroissante."""
+    try:
+        return list_all_tests()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ---------------------------------------------------------------------------
+# Tests (fichiers dans .mocksql/tests/)
+# ---------------------------------------------------------------------------
+
+
+class CreateTestRequest(BaseModel):
+    model_name: str
+
+
+@router.get("/tests")
+async def get_tests(model_name: str):
+    """Liste tous les tests pour un model donné."""
+    try:
+        return list_tests(model_name)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/test/{session_id}")
+async def get_test_route(session_id: str, model_name: str = None):
+    try:
+        test = get_test(session_id, model_name)
+        if test is None:
+            raise HTTPException(status_code=404, detail="Test not found")
+        return test
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/tests")
+async def create_test_route(body: CreateTestRequest):
+    """Crée un nouveau test pour un model. Retourne le test_id (= session_id)."""
+    try:
+        test = create_test(body.model_name)
+        return JSONResponse(content=test, status_code=201)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/tests/{session_id}")
+async def delete_test_route(session_id: str, model_name: str):
+    try:
+        ok = delete_test(session_id, model_name)
+        if not ok:
+            raise HTTPException(status_code=404, detail="Test not found")
+        return JSONResponse(status_code=204, content={"message": "Test deleted"})
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/api/endpoints/projects.py

@@ -0,0 +1,141 @@
+import json
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from common_vars import PROJECTS_TABLE_NAME, USERS_TABLE_NAME
+from models.database import execute, query
+from models.permissions import grant_role
+
+router = APIRouter()
+
+
+class ProjectRequest(BaseModel):
+    project_id: Optional[str] = None
+    name: str
+    dialect: str
+    description: Optional[str] = None
+    service_account_key: Optional[str] = None
+    auto_import: Optional[bool] = False
+    user_sub: Optional[str] = ""
+
+
+class ShareProjectRequest(BaseModel):
+    project: str
+    target: str
+
+
+def _row_to_project(row: dict) -> dict:
+    return {
+        "project_id": row["project_id"],
+        "name": row["name"],
+        "dialect": row["dialect"],
+        "description": row.get("description") or "",
+        "service_account_key": row.get("service_account_key"),
+        "auto_import": row.get("auto_import") or False,
+        "schema": json.loads(row["json_schema"]) if row.get("json_schema") else [],
+    }
+
+
+@router.get("/projects")
+async def get_projects():
+    rows = await query(f"SELECT * FROM {PROJECTS_TABLE_NAME}")
+    return [_row_to_project(r) for r in (rows or [])]
+
+
+@router.get("/project/{project_id}")
+async def get_project(project_id: str):
+    rows = await query(
+        f"SELECT * FROM {PROJECTS_TABLE_NAME} WHERE project_id = $1",
+        (project_id,),
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Project not found")
+    return _row_to_project(rows[0])
+
+
+@router.post("/projects")
+async def create_project(body: ProjectRequest):
+    project_id = body.project_id or str(uuid.uuid4())
+    now = datetime.now().isoformat()
+    await execute(
+        f"""
+        INSERT INTO {PROJECTS_TABLE_NAME}
+            (project_id, name, dialect, description, service_account_key, auto_import, user_sub, created_at, updated_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        ON CONFLICT (project_id) DO UPDATE SET
+            name = EXCLUDED.name,
+            dialect = EXCLUDED.dialect,
+            description = EXCLUDED.description,
+            service_account_key = EXCLUDED.service_account_key,
+            auto_import = EXCLUDED.auto_import,
+            updated_at = EXCLUDED.updated_at
+        """,
+        project_id,
+        body.name,
+        body.dialect,
+        body.description or "",
+        body.service_account_key,
+        body.auto_import or False,
+        body.user_sub or "",
+        now,
+        now,
+    )
+    rows = await query(
+        f"SELECT * FROM {PROJECTS_TABLE_NAME} WHERE project_id = $1",
+        (project_id,),
+    )
+    return JSONResponse(content=_row_to_project(rows[0]), status_code=201)
+
+
+@router.delete("/projects/{project_id}")
+async def delete_project(project_id: str):
+    rows = await query(
+        f"SELECT project_id FROM {PROJECTS_TABLE_NAME} WHERE project_id = $1",
+        (project_id,),
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Project not found")
+    await execute(
+        f"DELETE FROM {PROJECTS_TABLE_NAME} WHERE project_id = $1",
+        project_id,
+    )
+    return JSONResponse(status_code=204, content={"message": "Project deleted"})
+
+
+@router.delete("/projects/{project_id}/table/{table_name}")
+async def delete_project_table(project_id: str, table_name: str):
+    rows = await query(
+        f"SELECT json_schema FROM {PROJECTS_TABLE_NAME} WHERE project_id = $1",
+        (project_id,),
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    schema = json.loads(rows[0].get("json_schema") or "[]")
+    updated = [t for t in schema if t.get("table_name") != table_name]
+
+    await execute(
+        f"UPDATE {PROJECTS_TABLE_NAME} SET json_schema = $1, updated_at = $2 WHERE project_id = $3",
+        json.dumps(updated, ensure_ascii=False),
+        datetime.now().isoformat(),
+        project_id,
+    )
+    return {"removed": table_name, "remaining": len(updated)}
+
+
+@router.post("/projects/share")
+async def share_project(body: ShareProjectRequest):
+    target_rows = await query(
+        f"SELECT user_id FROM {USERS_TABLE_NAME} WHERE email = $1 OR user_id = $1",
+        (body.target,),
+    )
+    if not target_rows:
+        raise HTTPException(status_code=404, detail=f"User not found: {body.target}")
+    target_user_id = target_rows[0]["user_id"]
+    await grant_role(target_user_id, body.project, role="user")
+    return {"shared": True, "user_id": target_user_id}