ultra super mega refactoring

Author: aSel1x

app/api/deps.py

@@ -8,19 +8,20 @@
 from fastapi.security import APIKeyHeader
 
 from app.logic import Logic as _Logic
-from app.models.user import User as _User
+from app.models.users.user import User as _User
 
 
 async def get_logic() -> _Logic:
-    return await _Logic.create()
+    async with Logic.create() as logic:
+        yield logic
 
 
 Logic = Annotated[_Logic, Depends(get_logic)]
 
 
 async def get_user(
-    token: Annotated[str, Depends(APIKeyHeader(name='access-token'))],
-    logic: Logic,
+        token: Annotated[str, Depends(APIKeyHeader(name='access-token'))],
+        logic: Logic,
 ) -> _User | None:
     return await logic.users.retrieve_by_token(token)
 

app/api/v1/__init__.py

@@ -6,11 +6,12 @@
 
 from fastapi import APIRouter
 
-from . import users
+from . import auth, users
 
 FOLDER_NAME = f'{Path(__file__).parent.name}'
 
 router = APIRouter(prefix=f'/{FOLDER_NAME}', tags=[FOLDER_NAME])
+router.include_router(auth.router)
 router.include_router(users.router)
 
 __all__ = ['router']

app/api/v1/users/auth/__init__.py renamed to app/api/v1/auth/__init__.py

@@ -1,8 +1,8 @@
 from fastapi import APIRouter
 
 from app.api import deps
-from app.models.token import AccessToken
-from app.models.user import UserCreate
+from app.models.auth import AccessToken
+from app.models.users.user import UserCreate
 
 router = APIRouter(prefix='/token')
 
@@ -12,7 +12,7 @@ async def token(data: UserCreate, logic: deps.Logic):
     """
     Retrieve new access token
     """
-    return await logic.users.auth.generate_token(**data.model_dump())
+    return await logic.auth.generate_token(**data.model_dump())
 
 
 __all__ = ['router']

app/api/v1/users/auth/token.py renamed to app/api/v1/auth/token.py

@@ -4,10 +4,9 @@
 
 from fastapi import APIRouter
 
-from . import auth, create, retrieve
+from . import create, retrieve
 
 router = APIRouter(prefix='/users', tags=['users'])
-router.include_router(auth.router)
 router.include_router(create.router)
 router.include_router(retrieve.router)
 

app/api/v1/users/__init__.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter
 
 from app.api import deps
-from app.models.user import UserCreate, UserRead
+from app.models.users.user import UserCreate, UserRead
 
 router = APIRouter(prefix='/create')
 
@@ -11,7 +11,7 @@ async def create(data: UserCreate, logic: deps.Logic):
     """
     Create user
     """
-    return await logic.users.create(**data.model_dump())
+    return await logic.users.create(data)
 
 
 __all__ = ['router']

app/api/v1/users/create.py

@@ -5,7 +5,7 @@
 from fastapi import APIRouter
 
 from app.api import deps
-from app.models.user import UserRead
+from app.models.users.user import UserRead
 
 router = APIRouter()
 

app/api/v1/users/retrieve.py

@@ -2,7 +2,7 @@
 Database
 """
 
-from typing import NoReturn, Self
+from typing import Self
 
 from sqlalchemy.ext.asyncio import (AsyncEngine, async_sessionmaker,
                                     create_async_engine)
@@ -15,47 +15,49 @@
 class Database:
     _instance = None
 
-    def __new__(cls, *args, **kwargs) -> Self:
+    def __new__(cls, *args, **kwargs) -> 'Database':
         if cls._instance is None:
             cls._instance = super(Database, cls).__new__(cls)
         return cls._instance
 
     def __init__(
-        self,
-        engine: AsyncEngine | None = None,
-        session: AsyncSession | None = None,
+            self,
+            engine: AsyncEngine | None = None,
+            session: AsyncSession | None = None,
     ) -> None:
         if not hasattr(self, 'initialized'):
-            self.engine = engine
-            self.session = session
+            self.__engine = engine
+            self.__session = session
             self.initialized = True
 
-    async def __set_async_engine(self) -> NoReturn:
-        if self.engine is None:
-            self.engine = create_async_engine(
+    async def __set_async_engine(self) -> None:
+        if self.__engine is None:
+            self.__engine = create_async_engine(
                 settings.pg_dsn.unicode_string(), echo=False, future=True
             )
 
-    async def __set_async_session(self) -> NoReturn:
-        if self.session is None:
-            self.session = async_sessionmaker(
+    async def __set_async_session(self) -> None:
+        if self.__session is None:
+            self.__session = async_sessionmaker(
                 autocommit=False,
                 autoflush=False,
-                bind=self.engine,
+                bind=self.__engine,
                 class_=AsyncSession,
                 expire_on_commit=False,
             )()
 
-    async def __set_repositories(self) -> NoReturn:
-        if self.session is not None:
-            self.user = repos.UserRepo(session=self.session)
+    async def __set_repositories(self) -> None:
+        if self.__session is not None:
+            self.user = repos.UserRepo(session=self.__session)
 
     async def __aenter__(self) -> Self:
         await self.__set_async_engine()
         await self.__set_async_session()
         await self.__set_repositories()
         return self
 
-    async def __aexit__(self, exc_type, exc_value, traceback) -> NoReturn:
-        if self.session is not None:
-            await self.session.close()
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+        if self.__session is not None:
+            await self.__session.commit()
+            await self.__session.close()
+            self.__session = None

app/core/db.py

@@ -1,21 +1,3 @@
-from typing import Self
-
-from app.core.db import Database
-
-from .security import Security
-from .users import Users
-
-
-class Logic:
-    def __init__(self, db: Database):
-        self.db = db
-        self.security = Security()
-        self.users = Users(self)
-
-    @classmethod
-    async def create(cls) -> Self:
-        async with Database() as db:
-            return cls(db)
-
+from .logic import Logic
 
 __all__ = ['Logic']