Refactor settings to use DB_URL exclusively and added comments to database module

Author: Pythonian

.env.example

@@ -1,10 +1,5 @@
-# DB_TYPE Options: sqlite, mysql
+# DB_TYPE Options: sqlite, mysql, postgresql
 DB_TYPE=postgresql
-DB_NAME=fastapidb
-DB_USER=fastapiusr
-DB_PASSWORD=fastapipwd
-DB_HOST=localhost
-DB_PORT=5432
 # Uncomment the line below if DB_TYPE=postgresql
 DB_URL=postgresql://fastapiusr:fastapipwd@localhost:5432/fastapidb
 # Uncomment the line below if DB_TYPE=sqlite

api/db/database.py

@@ -6,48 +6,59 @@
 
 from api.utils.settings import BASE_DIR, settings
 
-DB_HOST = settings.DB_HOST
-DB_PORT = settings.DB_PORT
-DB_USER = settings.DB_USER
-DB_PASSWORD = settings.DB_PASSWORD
-DB_NAME = settings.DB_NAME
-DB_TYPE = settings.DB_TYPE
-
 
 def get_db_engine(test_mode: bool = False):  # type: ignore
-    if DB_TYPE == "sqlite" or test_mode:
+    """Create a SQLAlchemy engine instance.
+
+    Args:
+        test_mode (bool): If True, use a SQLite database for testing purposes.
+
+    Returns:
+        Engine: SQLAlchemy engine instance.
+    """
+    if settings.DB_TYPE == "sqlite" or test_mode:
+        # If the database type is SQLite or we are in test mode, use a SQLite database
         BASE_PATH = f"sqlite:///{BASE_DIR}"
         DATABASE_URL = BASE_PATH + ("/test.db" if test_mode else "/db.sqlite3")
-
-        return create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
-    elif DB_TYPE == "mysql":
-        DATABASE_URL = (
-            f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
-        )
-    elif DB_TYPE == "postgresql":
-        DATABASE_URL = (
-            f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
-        )
     else:
-        raise ValueError(f"Unsupported DB_TYPE: {DB_TYPE}")
+        # For other database types, use the provided DATABASE_URL
+        DATABASE_URL = settings.DB_URL
 
-    return create_engine(DATABASE_URL)
+    return create_engine(
+        DATABASE_URL,
+        connect_args={"check_same_thread": False}
+        if settings.DB_TYPE == "sqlite"
+        else {},
+    )
 
 
+# Create an engine instance
 engine = get_db_engine()
 
+# Create a configured "Session" class
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
+# Create a configured "scoped_session" factory
 db_session = scoped_session(SessionLocal)
 
+# Create a base class for declarative class definitions
 Base = declarative_base()
 
 
 def create_database():
+    """Create all tables in the database."""
     return Base.metadata.create_all(bind=engine)
 
 
 def get_db():
+    """Yield a database session.
+
+    This function provides a context manager for database sessions, ensuring that
+    each session is properly closed after use.
+
+    Yields:
+        Session: SQLAlchemy session instance.
+    """
     db = db_session()
     try:
         yield db

api/utils/settings.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 
-from decouple import config
-from pydantic_settings import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Use this to build paths inside the project
 BASE_DIR = Path(__file__).resolve().parent
@@ -10,13 +9,11 @@
 class Settings(BaseSettings):
     """Class to hold application's config values."""
 
-    # Database configurations
-    DB_HOST: str = config("DB_HOST")
-    DB_PORT: int = config("DB_PORT", cast=int)
-    DB_USER: str = config("DB_USER")
-    DB_PASSWORD: str = config("DB_PASSWORD")
-    DB_NAME: str = config("DB_NAME")
-    DB_TYPE: str = config("DB_TYPE")
+    DB_TYPE: str
+    DB_URL: str
 
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
 
+
+# Load settings from the .env file
 settings = Settings()