Created Queries and Execute endpoint

app/__init__.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+
+from app.connections import router as connections_router
+from app.operations import router as router
+from app.users import router as user_router
+
+api_router = APIRouter()
+api_router.include_router(router=user_router, prefix="/users", tags=["Users"])
+api_router.include_router(
+    router=connections_router, prefix="/connections", tags=["Connections"]
+)
+api_router.include_router(
+    router=router, prefix='/operations', tags=["Operations"]
+)

app/connections.py

@@ -11,10 +11,10 @@ from data.crud import (
 )
 from core.dependencies import get_db, get_current_user, get_admin_user
 
-connections_router = APIRouter()
+router = APIRouter()
 
 
-@connections_router.post("/", status_code=status.HTTP_201_CREATED)
+@router.post("/", status_code=status.HTTP_201_CREATED)
 async def create_connection_endpoint(
     connection: ConnectionCreate,
     db: AsyncSession = Depends(get_db),
@@ -23,7 +23,7 @@ async def create_connection_endpoint(
     return await create_connection(db=db, connection=connection, user_id=admin.id)
 
 
-@connections_router.get(
+@router.get(
     "/",
     response_model=list[Connection],
     dependencies=[Depends(get_current_user)],
@@ -35,7 +35,7 @@ async def read_connections_endpoint(
     return db_connection
 
 
-@connections_router.get(
+@router.get(
     "/{connection_id}",
     response_model=Connection,
     dependencies=[Depends(get_current_user)],
@@ -47,7 +47,7 @@ async def read_connection_endpoint(connection_id: int, db: AsyncSession = Depend
     return db_connection
 
 
-@connections_router.put(
+@router.put(
     "/{connection_id}",
     response_model=Connection,
     dependencies=[Depends(get_admin_user)],
@@ -63,7 +63,7 @@ async def update_connection_endpoint(
     return db_connection
 
 
-@connections_router.delete(
+@router.delete(
     "/{connection_id}",
     status_code=status.HTTP_204_NO_CONTENT,
     dependencies=[Depends(get_admin_user)],

app/operations.py

@@ -0,0 +1,92 @@
+from fastapi.routing import APIRouter
+from typing_extensions import Annotated
+from pydantic import Field
+from data.schemas import (
+    SelectQueryBase,
+    SelectQueryInDB,
+    SelectQuery,
+    SelectQueryIn,
+    SelectResult,
+    SelectQueryMetaData,
+    SelectQueryInResult,
+)
+from fastapi import Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from data.crud import (
+    read_connection,
+    create_select_query,
+    read_all_select_queries,
+    read_select_query,
+)
+from core.dependencies import get_db, get_current_user, get_admin_user
+from core.exceptions import QueryNotFound, ConnectionNotFound, PoolNotFound
+from utils.sql_creator import build_sql_query_text
+from dbs import mysql
+
+router = APIRouter(prefix="/select")
+
+
+@router.post("/check-query", dependencies=[Depends(get_current_user)])
+async def check_select_query(query: SelectQueryBase) -> SelectQuery:
+    sql, params = build_sql_query_text(query)
+    q = SelectQuery(**query.model_dump(), params=params, sql=sql)
+    return q
+
+
+@router.post("/query")
+async def create_select_query_endpoint(
+    query: SelectQueryBase, db=Depends(get_db), user=Depends(get_current_user)
+) -> SelectQueryInDB:
+    sql, params = build_sql_query_text(query)
+    query_in = SelectQueryIn(
+        **query.model_dump(), owner_id=user.id, params=params, sql=sql
+    )
+    return await create_select_query(db=db, query=query_in)
+
+
+@router.get("/query", dependencies=[Depends(get_current_user)])
+async def get_select_queries_endpoint(db=Depends(get_db)) -> list[SelectQueryInDB]:
+    return await read_all_select_queries(db=db)
+
+
+@router.get("/query/{query_id}", dependencies=[Depends(get_current_user)])
+async def get_select_queries_endpoint(
+    query_id: int, db=Depends(get_db)
+) -> SelectQueryInDB:
+    return await read_select_query(db=db, query_id=query_id)
+
+
+@router.post("/execute", dependencies=[Depends(get_current_user)])
+async def execute_select(
+    query_id: int,
+    connection_id: int,
+    page_size: Annotated[int, Field(ge=1, le=100)] = 50,
+    db=Depends(get_db),
+) -> SelectResult:
+    query = await read_select_query(db=db, query_id=query_id)
+
+    if query is None:
+        raise QueryNotFound
+    connection = await read_connection(db=db, connection_id=connection_id)
+
+    if connection is None:
+        raise ConnectionNotFound
+    pool = mysql.pools.get(connection.id, None)
+    if pool is None:
+        raise PoolNotFound
+
+    raw_result, rowcount = await mysql.execute_select_query(
+        pool=pool, query=query.sql, params=query.params, fetch_num=page_size
+    )
+
+    results = mysql.dict_result_to_list(result=mysql.serializer(raw_result=raw_result))
+
+    meta = SelectQueryMetaData(
+        cursor=None, total_number=rowcount, has_more=len(results.data) != rowcount
+    )
+
+    return SelectResult(
+        meta=meta,
+        query=query,
+        results=results,
+    )

app/users.py

@@ -7,17 +7,17 @@ from data.crud import read_all_users, read_user, create_user, delete_user
 from core.dependencies import get_db, get_current_user, get_admin_user
 from sqlalchemy.exc import IntegrityError
 from core.exceptions import ObjectNotFoundInDB, UserNotFound
-from core.scripts import create_secret
+from utils.scripts import create_secret
 
-users_router = APIRouter()
+router = APIRouter()
 
 
-@users_router.get("/me")
+@router.get("/me")
 async def get_me(user=Depends(get_current_user)) -> UserOut:
     return user
 
 
-@users_router.get(
+@router.get(
     "/",
     dependencies=[Depends(get_current_user)],
 )
@@ -25,7 +25,7 @@ async def get_all_users_endpoint(db=Depends(get_db)) -> list[UserOut]:
     return await read_all_users(db=db)
 
 
-@users_router.post(
+@router.post(
     "/", dependencies=[Depends(get_current_user)], status_code=status.HTTP_201_CREATED
 )
 async def create_user_endpoint(
@@ -42,7 +42,7 @@ async def create_user_endpoint(
             },
         )
 
-@users_router.post('/update-my-api_key/', status_code=status.HTTP_204_NO_CONTENT)
+@router.post('/update-my-api_key/', status_code=status.HTTP_204_NO_CONTENT)
 async def update_user_own_api_key(user=Depends(get_current_user), db=Depends(get_db)):
     if user.role == UserRole.admin:
         raise HTTPException(status_code=400, detail={
@@ -54,7 +54,7 @@ async def update_user_own_api_key(user=Depends(get_current_user), db=Depends(get
     await db.commit()
     await db.refresh(user)
 
-@users_router.post('/update-user-api_key/', status_code=status.HTTP_202_ACCEPTED, dependencies=[Depends(get_admin_user)])
+@router.post('/update-user-api_key/', status_code=status.HTTP_202_ACCEPTED, dependencies=[Depends(get_admin_user)])
 async def update_user_own_api_key(user_id:int, db=Depends(get_db)) -> UserInDBBase:
     user = await read_user(db=db, user_id=user_id)
     if user is None:
@@ -65,7 +65,7 @@ async def update_user_own_api_key(user_id:int, db=Depends(get_db)) -> UserInDBBa
     await db.refresh(user)
     return user
 
-@users_router.delete(
+@router.delete(
     "/", dependencies=[Depends(get_admin_user)], status_code=status.HTTP_204_NO_CONTENT
 )
 async def delete_user_endpoint(user_id: int, db=Depends(get_db)):