Drop databases dependency

Signed-off-by: wiseaidev <business@wiseai.dev>

app/auth/crud.py

@@ -2,10 +2,13 @@
 from fastapi.encoders import (
     jsonable_encoder,
 )
-
-from app.auth.model import (
-    AccessTokens,
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+)
+from sqlalchemy.sql import (
+    text,
 )
+
 from app.auth.schemas import (
     UserCreate,
     UserLoginSchema,
@@ -24,12 +27,9 @@
     create_access_token,
     timedelta,
 )
-from app.utils.session import (
-    database,
-)
 
 
-async def create_user(user: UserCreate):
+async def create_user(user: UserCreate, session: AsyncSession):
     query = """
         INSERT INTO users (
           first_name,
@@ -55,22 +55,26 @@ async def create_user(user: UserCreate):
         "password": user.password,
         "creation_date": datetime.datetime.utcnow(),
     }
-    return await database.execute(query, values=values)
+    return await session.execute(text(query), values)
 
 
-async def find_existed_user(email: str):
+async def find_existed_user(email: str, session: AsyncSession):
     query = "SELECT * FROM users WHERE email=:email AND user_status=1"
     values = {"email": email}
-    return await database.fetch_one(query, values=values)
+    result = await session.execute(text(query), values)
+    user = result.fetchone()
+    return user
 
 
-async def find_existed_user_id(id: int):
+async def find_existed_user_id(id: int, session: AsyncSession):
     query = "SELECT * FROM users WHERE id=:id AND user_status=1"
     values = {"id": id}
-    return await database.fetch_one(query, values=values)
+    result = await session.execute(text(query), values)
+    user = result.fetchone()
+    return user
 
 
-async def get_users_with_black_listed_token(token: str):
+async def get_users_with_black_listed_token(token: str, session: AsyncSession):
     query = """
         SELECT
           *
@@ -82,14 +86,15 @@ async def get_users_with_black_listed_token(token: str):
           token_status = 0
     """
     values = {"token": token}
-    return await database.fetch_one(query, values=values)
+    result = await session.execute(text(query), values)
+    token = result.fetchone()
+    return token
 
 
-async def login_user(form_data):
-    user_obj = await find_existed_user(form_data.username)
+async def login_user(form_data, session: AsyncSession):
+    user_obj = await find_existed_user(form_data.username, session)
     if not user_obj:
         return {"status_code": 400, "message": "User not found!"}
-
     user = UserLoginSchema(email=user_obj.email, password=user_obj.password)
     is_valid = verify_password(form_data.password, user.password)
     if not is_valid:
@@ -122,20 +127,21 @@ async def login_user(form_data):
         "token": access_token["access_token"],
         "creation_date": datetime.datetime.utcnow(),
     }
-    await database.execute(query, values=values)
+    await session.execute(text(query), values)
+
     return access_token
 
 
-async def register_user(user):
+async def register_user(user, session: AsyncSession):
 
-    fetched_user = await find_existed_user(user.email)
+    fetched_user = await find_existed_user(user.email, session)
     if fetched_user:
         return {"status_code": 400, "message": "User already signed up!"}
 
     # Create new user
     user.password = get_password_hash(user.password)
-    await create_user(user)
-    user = await find_existed_user(user.email)
+    await create_user(user, session)
+    user = await find_existed_user(user.email, session)
     access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
     access_token = await create_access_token(
         data={"sub": user.email},

app/auth/router.py

@@ -5,6 +5,9 @@
 from fastapi.security import (
     OAuth2PasswordRequestForm,
 )
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+)
 from typing import (
     Union,
 )
@@ -19,6 +22,9 @@
     UserCreate,
     UserSchema,
 )
+from app.utils.dependencies import (
+    get_db_session,
+)
 
 router = APIRouter(prefix="/api/v1")
 
@@ -38,8 +44,11 @@
         401: {"model": ResponseSchema, "description": "Invalid Credentials!"},
     },
 )
-async def login(form_data: OAuth2PasswordRequestForm = Depends()):
-    access_token = await login_user(form_data)
+async def login(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    session: AsyncSession = Depends(get_db_session),
+):
+    access_token = await login_user(form_data, session)
     return access_token
 
 
@@ -58,6 +67,8 @@ async def login(form_data: OAuth2PasswordRequestForm = Depends()):
         },
     },
 )
-async def register(user: UserCreate):
-    results = await register_user(user)
+async def register(
+    user: UserCreate, session: AsyncSession = Depends(get_db_session)
+):
+    results = await register_user(user, session)
     return results

app/chats/crud.py

@@ -1,12 +1,15 @@
 import datetime
 import logging
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+)
+from sqlalchemy.sql import (
+    text,
+)
 
 from app.auth.crud import (
     find_existed_user,
 )
-from app.chats.model import (
-    Messages,
-)
 from app.chats.schemas import (
     MessageCreate,
 )
@@ -17,15 +20,16 @@
 from app.users.schemas import (
     UserObjectSchema,
 )
-from app.utils.session import (
-    database,
-)
 
 logger = logging.getLogger(__name__)
 
 
 async def send_new_message(
-    sender: UserObjectSchema, request: MessageCreate, file, room_id: int
+    sender: UserObjectSchema,
+    request: MessageCreate,
+    file,
+    room_id: int,
+    session: AsyncSession,
 ):
     # Check for empty message
     if isinstance(request, str) and file:
@@ -38,7 +42,9 @@ async def send_new_message(
                     "status_code": 400,
                     "message": "You can't send an empty message!",
                 }
-            receiver = await find_existed_user(email=request.receiver)
+            receiver = await find_existed_user(
+                email=request.receiver, session=session
+            )
             if not receiver:
                 return {
                     "status_code": 400,
@@ -103,7 +109,7 @@ async def send_new_message(
                 "media": request.media,
                 "creation_date": datetime.datetime.utcnow(),
             }
-        await database.execute(query, values=values)
+        await session.execute(text(query), values)
     results = {
         "status_code": 201,
         "message": "A new message has been delivered successfully!",
@@ -112,7 +118,7 @@ async def send_new_message(
 
 
 async def get_sender_receiver_messages(
-    sender: UserObjectSchema, receiver: str
+    sender: UserObjectSchema, receiver: str, session
 ):
     receiver = await find_existed_user(email=receiver)
     if not receiver:
@@ -147,7 +153,8 @@ async def get_sender_receiver_messages(
           creation_date
     """
     values = {"sender_id": sender.id, "receiver_id": receiver.id}
-    messages_sent_received = await database.fetch_all(query, values=values)
+    result = await session.execute(text(query), values)
+    messages_sent_received = result.fetchall()
     results = {
         "status_code": 200,
         "result": messages_sent_received,

app/chats/router.py

@@ -2,6 +2,9 @@
     APIRouter,
     Depends,
 )
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+)
 from typing import (
     Union,
 )
@@ -20,6 +23,9 @@
 from app.users.schemas import (
     UserObjectSchema,
 )
+from app.utils.dependencies import (
+    get_db_session,
+)
 from app.utils.jwt_util import (
     get_current_active_user,
 )
@@ -46,11 +52,12 @@
 async def send_message(
     request: MessageCreate,
     currentUser: UserObjectSchema = Depends(get_current_active_user),
+    session: AsyncSession = Depends(get_db_session),
 ):
     """
     Deliver a new message given an authenticated user.
     """
-    results = await send_new_message(currentUser, request, None, None)
+    results = await send_new_message(currentUser, request, None, None, session)
     return results
 
 

app/config.py

@@ -2,17 +2,62 @@
 from pydantic import (
     BaseSettings,
 )
+from typing import (
+    Any,
+)
 
 
 class Settings(BaseSettings):
+
     SINGLESTORE_HOST: str = os.getenv("SINGLESTORE_HOST")
     SINGLESTORE_PORT: str = os.getenv("SINGLESTORE_PORT")
     SINGLESTORE_USERNAME: str = os.getenv("SINGLESTORE_USERNAME")
     SINGLESTORE_PASSWORD: str = os.getenv("SINGLESTORE_PASSWORD")
     SINGLESTORE_DATABASE: str = os.getenv("SINGLESTORE_DATABASE")
     JWT_SECRET_KEY: str = os.getenv("JWT_SECRET_KEY")
     DEBUG: bool = os.getenv("DEBUG")
+    engine: Any
 
     class Config:
         env_file = ".env"
         env_file_encoding = "utf-8"
+
+    @property
+    def db_url(self) -> str:
+        """
+        Assemble database URL from self.
+
+        :return: database URL.
+        """
+
+        if self.DEBUG:
+            SQLALCHEMY_DATABASE_URL = (
+                "mysql+aiomysql://"
+                + self.SINGLESTORE_USERNAME
+                + ":"
+                + self.SINGLESTORE_PASSWORD
+                + "@"
+                + self.SINGLESTORE_HOST
+                + ":"
+                + self.SINGLESTORE_PORT
+                + "/"
+                + "test"
+            )
+
+        else:
+            SQLALCHEMY_DATABASE_URL = (
+                "mysql+aiomysql://"
+                + self.SINGLESTORE_USERNAME
+                + ":"
+                + self.SINGLESTORE_PASSWORD
+                + "@"
+                + self.SINGLESTORE_HOST
+                + ":"
+                + self.SINGLESTORE_PORT
+                + "/"
+                + self.SINGLESTORE_DATABASE
+            )
+        return SQLALCHEMY_DATABASE_URL
+
+
+settings = Settings()