feat: add MongoDB database as a part of the CLI

README.md

@@ -72,7 +72,7 @@ scaffoldr --no-banner generate my-project
 When you generate a FastAPI project, you get:
 
 - **Complete FastAPI Application**: Pre-configured with proper structure
-- **Database Integration**: SQLAlchemy with Alembic migrations
+- **Database Integration**: SQLAlchemy with Alembic migrations or MongoDB with Beanie ODM
 - **File Storage**: Built-in file upload/download endpoints
 - **API Documentation**: Auto-generated OpenAPI/Swagger docs
 - **Development Tools**: Pre-configured with ruff, mypy, pytest
@@ -117,7 +117,9 @@ my-project/
 │       ├── core/               # Core components (config, utils, etc.)
 │       ├── features/           # Feature modules (business logic)
 │       ├── services/           # External service integrations
-│       └── database/           # Data access layer
+{% if database %}
+│       └── database/           # Data access layer (SQLAlchemy or MongoDB)
+{% endif %}
 ├── tests/                      # Comprehensive test suite
 ├── scripts/                    # Development scripts
 ├── .github/                    # GitHub workflows and templates

src/scaffoldr/cli/generate.py

@@ -38,6 +38,10 @@ def generate(
 		if use_cloud:
 			cloud_type = Helper.cloud_type()
 
+		database_type = None
+		if use_database:
+			database_type = Helper.database_type()
+
 		project_name = project_name.replace(" ", "-").lower()
 		# Check if directory already exists
 		if destination == ".":
@@ -71,6 +75,7 @@ def generate(
 			"use_docker": docker,
 			"cloud_type": cloud_type,
 			"database": use_database,
+			"database_type": database_type,
 			"framework": framework,
 		}
 

src/scaffoldr/core/constants/__init__.py

@@ -1,8 +1,9 @@
 from .art import ascii_art
-from .const import CloudTypes, Frameworks, console
+from .const import CloudTypes, DatabaseTypes, Frameworks, console
 
 __all__ = [
 	"CloudTypes",
+	"DatabaseTypes",
 	"Frameworks",
 	"ascii_art",
 	"console",

src/scaffoldr/core/constants/const.py

@@ -18,3 +18,8 @@ class CloudTypes(str, Enum):
 	GCP = "gcp"
 	AZURE = "azure"
 	NONE = "none"
+
+
+class DatabaseTypes(str, Enum):
+	SQLALCHEMY = "sqlalchemy"
+	MONGODB = "mongodb"

src/scaffoldr/core/utils/helper.py

@@ -3,7 +3,7 @@
 import typer
 from copier import subprocess
 
-from scaffoldr.core.constants.const import CloudTypes
+from scaffoldr.core.constants.const import CloudTypes, DatabaseTypes, console
 
 if TYPE_CHECKING:
 	from collections.abc import Iterable
@@ -40,6 +40,20 @@ def cloud_type() -> str:
 		cloud_type: str = cast("str", typer.prompt(f"Cloud type: {' | '.join(cloud_types)}"))
 		if cloud_type in cloud_types:
 			return cloud_type
-		raise ValueError(
-			f"Invalid cloud type: {cloud_type}. Must be one of: {' | '.join(cloud_types)}",
+		console.print(f"[red]Error:[/red] Invalid cloud type: {cloud_type}")
+		raise typer.Exit(1)
+
+	@staticmethod
+	def database_type() -> str:
+		"""
+		Prompt for database type selection.
+		"""
+		database_types = list(DatabaseTypes)
+		database_type: str = cast(
+			"str",
+			typer.prompt(f"Database type: {' | '.join(database_types)}"),
 		)
+		if database_type in database_types:
+			return database_type
+		console.print(f"[red]Error:[/red] Invalid database type: {database_type}")
+		raise typer.Exit(1)

templates/fastapi_template/{{ project_name }}/.env.jinja

@@ -13,8 +13,15 @@
 {{ project_slug|upper }}_LOG_GRANIAN_ERROR_LEVEL=40
 
 {% if database %}
+{% if database_ype == 'postgresql' %}
+{{ project_slug|upper }}_DB_URL=postgresql+asyncpg://user:password@localhost:5432/{{ project_slug }}
+{{ project_slug|upper }}_DB_ECHO=false
+{% elif database_type == 'sqlite' %}
 {{ project_slug|upper }}_DB_URL=sqlite+aiosqlite:///./{{ project_name|upper }}.db
 {{ project_slug|upper }}_DB_ECHO=false
+{% elif database_type == 'mongodb' %}
+{{ project_slug|upper }}_DB_URL=mongodb://localhost:27017
+{% endif %}
 {% endif %}
 
 {% if cloud_type %}

templates/fastapi_template/{{ project_name }}/README.md.jinja

@@ -6,8 +6,15 @@
 
 - **FastAPI**: Modern, fast web framework for building APIs
 - **Pydantic**: Data validation and serialization
+{% if database %}
+{% if database_type == 'sqlalchemy' %}
 - **SQLAlchemy**: SQL toolkit and ORM
 - **Alembic**: Database migration tool
+{% elif database_type == 'mongodb' %}
+- **Beanie**: MongoDB ODM for Python
+- **Motor**: Asynchronous MongoDB driver
+{% endif %}
+{% endif %}
 - **Uvicorn**: ASGI web server
 - **Granian**: High-performance web server
   {% if cloud_type == 'aws' %}

templates/fastapi_template/{{ project_name }}/pyproject.toml.jinja

@@ -39,8 +39,14 @@ dependencies = [
 	"azure-identity>=1.25.0",
 	{% endif %}
 	{% if database %}
+	{% if database_type == 'sqlalchemy' %}
 	"aiosqlite>=0.21.0",
 	"sqlalchemy[asyncio]>=2.0.0",
+	{% elif database_type == 'mongodb' %}
+	"beanie>=2.0.0",
+	"motor>=3.7.1",
+	"pymongo>=4.15.1",
+	{% endif %}
 	{% endif %}
 	"fastapi>=0.117.1",
 	"granian[reload]>=2.5.4",

templates/fastapi_template/{{ project_name }}/src/{{ project_slug }}/api/lifespan.py.jinja

@@ -4,18 +4,31 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 
 {% if database %}
+{% if database_type == 'sqlalchemy' %}
 from {{ project_slug }}.connection import Base, database
+{% elif database_type == 'mongodb' %}
+from {{ project_slug }}.connection import mongodb
+{% endif %}
 {% endif %}
 
 {% if framework == 'fastapi' %}
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
 {% if database %}
+{% if database_type == 'sqlalchemy' %}
 	async with database.engine.begin() as conn:
 		# run_sync executes the given function in a sync context using the connection
 		await conn.run_sync(Base.metadata.create_all)
-	{% endif %}
+{% elif database_type == 'mongodb' %}
+	await mongodb.connect()
+{% endif %}
+{% endif %}
 	yield
+{% if database %}
+{% if database_type == 'mongodb' %}
+	await mongodb.close()
+{% endif %}
+{% endif %}
 
 {% endif %}

templates/fastapi_template/{{ project_name }}/src/{{ project_slug }}/connection/__init__.py.jinja

@@ -1,4 +1,7 @@
-{% if database %}
+{% if database_type == 'sqlalchemy' %}
 from .database import database, inject_session, Base
 __all__ = ["Base", "database", "inject_session"]
+{% elif database_type == 'mongodb' %}
+from .database import mongodb
+__all__ = ["mongodb"]
 {% endif %}

templates/fastapi_template/{{ project_name }}/src/{{ project_slug }}/connection/{% if database %}database.py{% endif %}.jinja

@@ -1,3 +1,4 @@
+{% if database_type == 'sqlalchemy' %}
 from collections.abc import AsyncGenerator, Callable
 from functools import wraps
 from typing import Any, cast
@@ -74,3 +75,44 @@ def inject_session(func: Callable[..., Any]) -> Callable[..., Any]:
 		return None  # This should never be reached, but for type safety
 
 	return cast("Callable[..., Any]", wrapper)
+{% elif database_type == 'mongodb' %}
+from beanie import init_beanie
+from motor.motor_asyncio import AsyncIOMotorClient
+from typing import Optional
+
+from {{ project_slug }}.core.config import settings
+
+
+class MongoDB:
+	"""MongoDB connection manager using Beanie ODM."""
+
+	def __init__(self) -> None:
+		"""Initialize the MongoDB connection."""
+		self.client: Optional[AsyncIOMotorClient] = None
+		self.database = None
+
+	async def connect(self) -> None:
+		"""Connect to MongoDB and initialize Beanie."""
+		self.client = AsyncIOMotorClient(settings.database.URL)
+		self.database = self.client[settings.database.DATABASE_NAME]
+
+		# Initialize Beanie with document models
+		# Note: Document models should be imported here when they exist
+		await init_beanie(
+			database=self.database,
+			document_models=[],  # Add your document models here
+		)
+
+	async def close(self) -> None:
+		"""Close the MongoDB connection."""
+		if self.client:
+			self.client.close()
+
+	async def get_database(self):
+		"""Get the database instance."""
+		return self.database
+
+
+# Global MongoDB instance
+mongodb = MongoDB()
+{% endif %}

templates/fastapi_template/{{ project_name }}/src/{{ project_slug }}/core/config/base.py.jinja

@@ -125,11 +125,16 @@ class CloudSettings(BaseSettings):
 
 
 class DatabaseSettings(BaseSettings):
+	{% if database_type == 'sqlalchemy' %}
 	URL: str = "sqlite+aiosqlite:///./{{ project_name|upper }}.db"
 	ECHO: Annotated[
 		bool,
 		AfterValidator(true_bool_validator),
 	] = False
+	{% elif database_type == 'mongodb' %}
+	URL: str = "mongodb://localhost:27017"
+	DATABASE_NAME: str = "{{ project_name|lower }}_db"
+	{% endif %}
 
 	model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
 		extra="ignore",

templates/fastapi_template/{{ project_name }}/tests/conftest.py.jinja

@@ -4,11 +4,16 @@ from typing import Generator
 
 import pytest
 from fastapi.testclient import TestClient
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from {{ project_slug }}.api.application import app
 {% if database %}
+{% if database_type == 'sqlalchemy' %}
+from sqlalchemy.ext.asyncio import AsyncSession
+
 from {{ project_slug }}.connection import database
+{% elif database_type == 'mongodb' %}
+from {{ project_slug }}.connection import mongodb
+{% endif %}
 {% endif %}
 
 
@@ -28,6 +33,7 @@ def client() -> Generator[TestClient, None, None]:
 
 
 {% if database %}
+{% if database_type == 'sqlalchemy' %}
 @pytest.fixture(scope="function")
 async def db_session() -> AsyncGenerator[AsyncSession, None]:
 	"""Create a database session for testing."""
@@ -40,4 +46,14 @@ async def db_session() -> AsyncGenerator[AsyncSession, None]:
 		except Exception:
 			await session.rollback()
 			raise
+{% elif database_type == 'mongodb' %}
+@pytest.fixture(scope="function")
+async def mongodb_client():
+	"""Create a MongoDB client for testing."""
+	await mongodb.connect()
+	try:
+		yield mongodb
+	finally:
+		await mongodb.close()
+{% endif %}
 {% endif %}

templates/fastapi_template/{{ project_name }}/tests/test_health.py.jinja

@@ -3,8 +3,10 @@
 import pytest
 from fastapi.testclient import TestClient
 {% if database %}
+{% if database_type == 'sqlalchemy' %}
 from sqlalchemy.ext.asyncio import AsyncSession
 {% endif %}
+{% endif %}
 
 
 class TestHealth:
@@ -19,6 +21,7 @@ class TestHealth:
 		assert data["status"] == "success"
 
 	{% if database %}
+	{% if database_type == 'sqlalchemy' %}
 	@pytest.mark.asyncio
 	async def test_health_endpoint_with_database(
 		self, client: TestClient, db_session: AsyncSession
@@ -30,4 +33,17 @@ class TestHealth:
 		assert "status" in data
 		assert data["status"] == "success"
 		# Note: Database health check not implemented in basic health endpoint
+	{% elif database_type == 'mongodb' %}
+	@pytest.mark.asyncio
+	async def test_health_endpoint_with_mongodb(
+		self, client: TestClient, mongodb_client: None,
+	) -> None:
+		"""Test health check with MongoDB connectivity."""
+		response = client.get("/")
+		assert response.status_code == 200
+		data = response.json()
+		assert "status" in data
+		assert data["status"] == "success"
+		# Note: Database health check not implemented in basic health endpoint
+	{% endif %}
 	{% endif %}

templates/fastapi_template/{{ project_name }}/tests/unit/test_config.py.jinja

@@ -39,6 +39,7 @@ class TestSettings:
 		assert settings.server.PORT > 0
 
 	{% if database %}
+	{% if database_type == 'sqlalchemy' %}
 	def test_database_settings(self) -> None:
 		"""Test database settings have expected attributes."""
 		settings = get_settings()
@@ -47,4 +48,14 @@ class TestSettings:
 		assert isinstance(settings.database.URL, str)
 		assert isinstance(settings.database.ECHO, bool)
 		assert "sqlite" in settings.database.URL  # Should contain sqlite for basic setup
+	{% elif database_type == 'mongodb' %}
+	def test_database_settings(self) -> None:
+		"""Test MongoDB database settings have expected attributes."""
+		settings = get_settings()
+		assert hasattr(settings.database, 'URL')
+		assert hasattr(settings.database, 'DATABASE_NAME')
+		assert isinstance(settings.database.URL, str)
+		assert isinstance(settings.database.DATABASE_NAME, str)
+		assert "mongodb" in settings.database.URL  # Should contain mongodb for MongoDB setup
+	{% endif %}
 	{% endif %}