FastAPI config

from typing import ClassVar, Sequence

from pydantic import BaseModel


class Spell(BaseModel):
    id: str
    name: str
    description: str
    table_name: ClassVar[str] = "spells"


class SpellCreate(BaseModel):
    id: str
    name: str
    description: str


class SpellUpdate(BaseModel):
    id: str
    name: str
    description: str


class SpellSearchResults(BaseModel):
    results: Sequence[Spell]

from .user import User, UserCreate, UserSearchResults, UserUpdate
from .spell import Spell, SpellCreate, SpellSearchResults, SpellUpdate

from fastapi import HTTPException
from supabase._async.client import AsyncClient

from src.crud.base import CRUDBase
from src.schemas import Spell, SpellCreate, SpellUpdate


class CRUDSpell(CRUDBase[Spell, SpellCreate, SpellUpdate]):
    async def get(self, db: AsyncClient, *, id: str) -> Spell | None:
        try:
            return await super().get(db, id=id)
        except Exception as e:
            raise HTTPException(
                status_code=404,
                detail=f"{e.code}: Spell not found. {e.details}",
            )

    async def get_all(self, db: AsyncClient) -> list[Spell]:
        try:
            return await super().get_all(db)
        except Exception as e:
            raise HTTPException(
                status_code=404,
                detail=f"An error occurred while fetching spells. {e}",
            )

    async def search_all(
        self, db: AsyncClient, *, field: str, search_value: str, max_results: int
    ) -> list[Spell]:
        try:
            return await super().search_all(
                db, field=field, search_value=search_value, max_results=max_results
            )
        except Exception as e:
            raise HTTPException(
                status_code=404,
                detail=f"An error occurred while searching for spells. {e}",
            )


spell = CRUDSpell(Spell)

from .crud_user import user
from .crud_spell import spell

from typing import Literal, Optional, Union

from fastapi import APIRouter, HTTPException

from src.api.deps import SessionDep
from src.crud import spell
from src.schemas import Spell, SpellSearchResults

router = APIRouter()


@router.get("/get/", status_code=200, response_model=Spell)
async def get_spell(session: SessionDep, spell_id: str) -> Spell:
    """Returns a spell from a spell_id.

    **Returns:**
    - spell: spell object.
    """
    return await spell.get(session, id=spell_id)


@router.get("/get-all/", status_code=200, response_model=list[Spell])
async def get_all_spells(session: SessionDep) -> list[Spell]:
    """Returns a list of all spells.

    **Returns:**
    - list[spell]: List of all spells.
    """
    return await spell.get_all(session)


@router.get("/search/", status_code=200, response_model=SpellSearchResults)
async def search_spells(
    session: SessionDep,
    search_on: Literal["spells", "description"] = "spell",
    keyword: Optional[Union[str, int]] = None,
    max_results: Optional[int] = 10,
) -> SpellSearchResults:
    """
    Search for spells based on a keyword and return the top `max_results` spells.

    **Args:**
    - keyword (str, optional): The keyword to search for. Defaults to None.
    - max_results (int, optional): The maximum number of search results to return. Defaults to 10.
    - search_on (str, optional): The field to perform the search on. Defaults to "email".

    **Returns:**
    - SpellSearchResults: Object containing a list of the top `max_results` spells that match the keyword.
    """
    if not keyword:
        results = await spell.get_all(session)
        return SpellSearchResults(results=results)

    results = await spell.search_all(
        session, field=search_on, search_value=keyword, max_results=max_results
    )

    if not results:
        raise HTTPException(
            status_code=404, detail="No spells found matching the search criteria"
        )

    return SpellSearchResults(results=results)

from fastapi import APIRouter
from src.api.api_v1.endpoints import users, spells

api_router = APIRouter()
api_router.include_router(users.router, prefix="/users", tags=["users"], responses={404: {"description": "Not found"}})
api_router.include_router(spells.router, prefix="/spells", tags=["spells"], responses={404: {"description": "Not found"}})