forgeapi 0.1.0__py3-none-any.whl

fastapi_forge/templates/base/app/api/auth_api.py.jinja

@@ -0,0 +1,72 @@
+"""
+Authentication API
+
+This module provides authentication endpoints for user login/logout.
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, status
+from fastapi.responses import JSONResponse
+from fastapi.security import OAuth2PasswordRequestForm
+{% if use_database %}
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.deps import get_db_session
+{% endif %}
+from app.core.config import get_config
+from app.core.auth import AuthHandler
+from app.schemas.auth_schema import TokenResponse
+from app.utils.log import log
+
+config = get_config()
+authAPI = APIRouter(prefix=f"{config.app.api}/auth")
+
+
+@authAPI.post("/login", response_model=TokenResponse)
+async def login(
+    form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+{% if use_database %}
+    db_session: AsyncSession = Depends(get_db_session),
+{% endif %}
+):
+    """
+    User login endpoint.
+
+    Args:
+        form_data: OAuth2 password request form with username and password
+{% if use_database %}
+        db_session: Database session
+{% endif %}
+
+    Returns:
+        JWT access token on successful authentication
+    """
+    # TODO: Implement actual authentication logic
+    # This is a placeholder - replace with real user validation
+
+    # For demo purposes, accept any credentials
+    log.info(f"Login attempt for user: {form_data.username}")
+
+    # Generate access token
+    access_token = AuthHandler.create_access_token({"sub": form_data.username})
+
+    return TokenResponse(
+        access_token=access_token,
+        token_type="bearer",
+    )
+
+
+@authAPI.post("/logout")
+async def logout():
+    """
+    User logout endpoint.
+
+    Returns:
+        Success message
+    """
+    # TODO: Implement token invalidation if needed
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={"message": "Logged out successfully"},
+    )

fastapi_forge/templates/base/app/api/health_api.py.jinja

@@ -0,0 +1,41 @@
+"""
+Health Check API
+
+This module provides health check endpoints for monitoring.
+"""
+
+from fastapi import APIRouter
+
+from app.core.config import get_config
+from app.schemas.api_schema import HealthResponse
+
+config = get_config()
+healthAPI = APIRouter(prefix=f"{config.app.api}/health")
+
+
+@healthAPI.get("", response_model=HealthResponse)
+async def health_check():
+    """
+    Health check endpoint.
+
+    Returns:
+        Health status response
+    """
+    return HealthResponse(
+        status="healthy",
+        version=config.app.version,
+    )
+
+
+@healthAPI.get("/ready", response_model=HealthResponse)
+async def readiness_check():
+    """
+    Readiness check endpoint.
+
+    Returns:
+        Readiness status response
+    """
+    return HealthResponse(
+        status="ready",
+        version=config.app.version,
+    )

fastapi_forge/templates/base/app/config/__init__.py.jinja

@@ -0,0 +1,31 @@
+"""
+Configuration Module
+"""
+
+from app.config.base import BaseConfig, DevConfig, ProdConfig
+from app.config.env import AppConfig
+{% if use_database %}
+from app.config.env import DatabaseConfig
+{% endif %}
+{% if use_redis %}
+from app.config.env import RedisConfig
+{% endif %}
+{% if use_auth %}
+from app.config.env import JwtConfig
+{% endif %}
+
+__all__ = [
+    "BaseConfig",
+    "DevConfig",
+    "ProdConfig",
+    "AppConfig",
+{% if use_database %}
+    "DatabaseConfig",
+{% endif %}
+{% if use_redis %}
+    "RedisConfig",
+{% endif %}
+{% if use_auth %}
+    "JwtConfig",
+{% endif %}
+]

fastapi_forge/templates/base/app/config/base.py.jinja

@@ -0,0 +1,52 @@
+"""
+Base Configuration Classes
+
+This module defines the base configuration classes for different environments.
+"""
+
+from pydantic_settings import BaseSettings
+
+from app.config.env import AppConfig
+{% if use_database %}
+from app.config.env import DatabaseConfig
+{% endif %}
+{% if use_redis %}
+from app.config.env import RedisConfig
+{% endif %}
+{% if use_auth %}
+from app.config.env import JwtConfig
+{% endif %}
+
+
+class BaseConfig(BaseSettings):
+    """Base configuration for all environments."""
+
+    env: str
+    app: AppConfig
+{% if use_database %}
+    db: DatabaseConfig
+{% endif %}
+{% if use_redis %}
+    redis: RedisConfig
+{% endif %}
+{% if use_auth %}
+    jwt: JwtConfig
+{% endif %}
+
+
+class DevConfig(BaseConfig):
+    """Development environment configuration."""
+
+    pass
+
+
+class StagingConfig(BaseConfig):
+    """Staging environment configuration."""
+
+    pass
+
+
+class ProdConfig(BaseConfig):
+    """Production environment configuration."""
+
+    pass

fastapi_forge/templates/base/app/config/env.py.jinja

@@ -0,0 +1,75 @@
+"""
+Environment Configuration Classes
+
+This module defines Pydantic models for environment-specific configuration.
+"""
+
+from pydantic import BaseModel
+
+
+class AppConfig(BaseModel):
+    """Application configuration."""
+
+    name: str
+    description: str = ""
+    api: str = "/api"
+    host: str = "0.0.0.0"
+    port: int = 8000
+    uvicorn: str = "app.server:app"
+    version: str = "0.1.0"
+    reload: bool = True
+
+{% if use_database %}
+
+class DatabaseConfig(BaseModel):
+    """Database configuration."""
+
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str
+    driver_name: str = "postgresql+asyncpg"
+    echo: bool = False
+    pool_size: int = 5
+    max_overflow: int = 10
+    pool_recycle: int = 3600
+    pool_timeout: int = 30
+
+    @property
+    def database_url(self) -> str:
+        """Get the database URL."""
+{% if use_sqlite %}
+        if "sqlite" in self.driver_name:
+            return f"{self.driver_name}:///{self.database}"
+{% endif %}
+        return f"{self.driver_name}://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}"
+{% endif %}
+
+{% if use_redis %}
+
+class RedisConfig(BaseModel):
+    """Redis configuration."""
+
+    host: str = "localhost"
+    port: int = 6379
+    db: int = 0
+    password: str = ""
+
+    @property
+    def redis_url(self) -> str:
+        """Get the Redis URL."""
+        if self.password:
+            return f"redis://:{self.password}@{self.host}:{self.port}/{self.db}"
+        return f"redis://{self.host}:{self.port}/{self.db}"
+{% endif %}
+
+{% if use_auth %}
+
+class JwtConfig(BaseModel):
+    """JWT configuration."""
+
+    secret_key: str
+    algorithm: str = "HS256"
+    expire_minutes: int = 1440
+{% endif %}

fastapi_forge/templates/base/app/core/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Core Module
+"""

fastapi_forge/templates/base/app/core/auth.py.jinja

@@ -0,0 +1,96 @@
+"""
+Authentication Handler
+
+This module provides JWT token creation and validation utilities.
+"""
+
+from datetime import datetime, timedelta, timezone
+
+import jwt
+from passlib.context import CryptContext
+
+from app.core.config import get_config
+
+config = get_config()
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+class AuthHandler:
+    """Authentication handler for JWT operations."""
+
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """
+        Hash a password using bcrypt.
+
+        Args:
+            password: Plain text password
+
+        Returns:
+            Hashed password
+        """
+        return pwd_context.hash(password)
+
+    @staticmethod
+    def verify_password(plain_password: str, hashed_password: str) -> bool:
+        """
+        Verify a password against its hash.
+
+        Args:
+            plain_password: Plain text password
+            hashed_password: Hashed password
+
+        Returns:
+            True if password matches, False otherwise
+        """
+        return pwd_context.verify(plain_password, hashed_password)
+
+    @staticmethod
+    def create_access_token(data: dict, expires_delta: timedelta | None = None) -> str:
+        """
+        Create a JWT access token.
+
+        Args:
+            data: Data to encode in the token
+            expires_delta: Optional expiration time delta
+
+        Returns:
+            Encoded JWT token
+        """
+        to_encode = data.copy()
+
+        if expires_delta:
+            expire = datetime.now(timezone.utc) + expires_delta
+        else:
+            expire = datetime.now(timezone.utc) + timedelta(
+                minutes=config.jwt.expire_minutes
+            )
+
+        to_encode.update({"exp": expire})
+        encoded_jwt = jwt.encode(
+            to_encode,
+            config.jwt.secret_key,
+            algorithm=config.jwt.algorithm,
+        )
+        return encoded_jwt
+
+    @staticmethod
+    def decode_token(token: str) -> dict | None:
+        """
+        Decode a JWT token.
+
+        Args:
+            token: JWT token to decode
+
+        Returns:
+            Decoded token data or None if invalid
+        """
+        try:
+            payload = jwt.decode(
+                token,
+                config.jwt.secret_key,
+                algorithms=[config.jwt.algorithm],
+            )
+            return payload
+        except jwt.PyJWTError:
+            return None

fastapi_forge/templates/base/app/core/config.py.jinja

@@ -0,0 +1,56 @@
+"""
+Configuration Loader
+
+This module handles loading configuration from YAML files.
+"""
+
+from functools import lru_cache
+from pathlib import Path
+
+import yaml
+
+from app.config.base import BaseConfig, DevConfig, StagingConfig, ProdConfig
+
+
+def get_project_path() -> Path:
+    """Get the project root path."""
+    return Path(__file__).parent.parent.parent
+
+
+@lru_cache()
+def get_config(config_file: str = "config.yaml", env: str | None = None) -> BaseConfig:
+    """
+    Get configuration for the specified environment.
+
+    Args:
+        config_file: Path to the configuration file
+        env: Environment name (dev, staging, prod)
+
+    Returns:
+        Configuration object for the specified environment
+    """
+    project_path = get_project_path()
+    config_path = project_path / config_file
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        yaml_config = yaml.safe_load(f)
+
+    # Get environment from config or parameter
+    if env:
+        yaml_config["env"] = env
+    else:
+        env = yaml_config.get("env", "dev")
+
+    # Get environment-specific config
+    env_config = yaml_config.get(env, {})
+    env_config["env"] = env
+
+    # Select configuration class based on environment
+    config_classes = {
+        "dev": DevConfig,
+        "staging": StagingConfig,
+        "prod": ProdConfig,
+    }
+
+    config_class = config_classes.get(env, DevConfig)
+    return config_class(**env_config)

fastapi_forge/templates/base/app/core/database.py.jinja

@@ -0,0 +1,68 @@
+"""
+Database Utilities
+
+This module provides database connection and session management.
+"""
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from app.config.env import DatabaseConfig
+
+
+class DatabaseUtil:
+    """Database utility class."""
+
+    @classmethod
+    async def init_engine(cls, config: DatabaseConfig) -> AsyncEngine:
+        """
+        Initialize async database engine.
+
+        Args:
+            config: Database configuration
+
+        Returns:
+            Async database engine
+        """
+        engine = create_async_engine(
+            config.database_url,
+            echo=config.echo,
+            pool_size=config.pool_size,
+            max_overflow=config.max_overflow,
+            pool_recycle=config.pool_recycle,
+            pool_timeout=config.pool_timeout,
+        )
+        return engine
+
+    @classmethod
+    async def close_engine(cls, engine: AsyncEngine) -> None:
+        """
+        Close database engine.
+
+        Args:
+            engine: Async database engine to close
+        """
+        await engine.dispose()
+
+    @classmethod
+    async def get_session(cls, engine: AsyncEngine):
+        """
+        Get async database session.
+
+        Args:
+            engine: Async database engine
+
+        Yields:
+            Async database session
+        """
+        async_session = async_sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        async with async_session() as session:
+            yield session

fastapi_forge/templates/base/app/core/deps.py.jinja

@@ -0,0 +1,55 @@
+"""
+FastAPI Dependencies
+
+This module provides dependency injection utilities for FastAPI.
+"""
+
+from fastapi import Request
+{% if use_database %}
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+
+from app.core.database import DatabaseUtil
+{% endif %}
+
+{% if use_database %}
+
+def get_db_engine(request: Request) -> AsyncEngine:
+    """
+    Get database engine from request state.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Async database engine
+    """
+    return request.app.state.db_engine
+
+
+async def get_db_session(request: Request) -> AsyncSession:
+    """
+    Get database session.
+
+    Args:
+        request: FastAPI request object
+
+    Yields:
+        Async database session
+    """
+    engine = get_db_engine(request)
+    async for session in DatabaseUtil.get_session(engine):
+        yield session
+{% endif %}
+
+
+def get_config(request: Request):
+    """
+    Get application configuration from request state.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Application configuration
+    """
+    return request.app.state.config

fastapi_forge/templates/base/app/core/redis.py.jinja

@@ -0,0 +1,41 @@
+"""
+Redis Utilities
+
+This module provides Redis connection management.
+"""
+
+import redis.asyncio as redis
+
+from app.config.env import RedisConfig
+
+
+class RedisUtil:
+    """Redis utility class."""
+
+    @classmethod
+    async def init_redis(cls, config: RedisConfig) -> redis.Redis:
+        """
+        Initialize Redis connection.
+
+        Args:
+            config: Redis configuration
+
+        Returns:
+            Redis client instance
+        """
+        client = redis.from_url(
+            config.redis_url,
+            encoding="utf-8",
+            decode_responses=True,
+        )
+        return client
+
+    @classmethod
+    async def close_redis(cls, client: redis.Redis) -> None:
+        """
+        Close Redis connection.
+
+        Args:
+            client: Redis client to close
+        """
+        await client.aclose()

fastapi_forge/templates/base/app/daos/__init__.py.jinja

@@ -0,0 +1,3 @@
+"""
+Data Access Objects Module
+"""

fastapi_forge/templates/base/app/exceptions/__init__.py.jinja

@@ -0,0 +1,7 @@
+"""
+Exceptions Module
+"""
+
+from app.exceptions.exception import AppException, AuthException
+
+__all__ = ["AppException", "AuthException"]

fastapi_forge/templates/base/app/exceptions/exception.py.jinja

@@ -0,0 +1,34 @@
+"""
+Custom Exceptions
+
+This module defines custom exception classes for the application.
+"""
+
+
+class AppException(Exception):
+    """Base application exception."""
+
+    def __init__(self, message: str = "An error occurred"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class AuthException(AppException):
+    """Authentication exception."""
+
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message)
+
+
+class NotFoundException(AppException):
+    """Resource not found exception."""
+
+    def __init__(self, message: str = "Resource not found"):
+        super().__init__(message)
+
+
+class ValidationException(AppException):
+    """Validation exception."""
+
+    def __init__(self, message: str = "Validation error"):
+        super().__init__(message)

fastapi_forge/templates/base/app/exceptions/handler.py.jinja

@@ -0,0 +1,56 @@
+"""
+Exception Handlers
+
+This module registers global exception handlers for the FastAPI application.
+"""
+
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException
+
+from app.exceptions.exception import AppException, AuthException
+from app.utils.log import log
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    """
+    Register global exception handlers.
+
+    Args:
+        app: FastAPI application instance
+    """
+
+    @app.exception_handler(AuthException)
+    async def auth_exception_handler(request: Request, exc: AuthException):
+        """Handle authentication exceptions."""
+        return JSONResponse(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            content={"message": exc.message},
+        )
+
+    @app.exception_handler(AppException)
+    async def app_exception_handler(request: Request, exc: AppException):
+        """Handle application exceptions."""
+        log.error(f"Application error: {exc.message}")
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={"message": exc.message},
+        )
+
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request: Request, exc: HTTPException):
+        """Handle HTTP exceptions."""
+        log.error(f"HTTP error: {exc.detail}")
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"message": exc.detail},
+        )
+
+    @app.exception_handler(Exception)
+    async def general_exception_handler(request: Request, exc: Exception):
+        """Handle all other exceptions."""
+        log.error(f"Unexpected error: {exc}")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={"message": "Internal server error"},
+        )