appgenerator-cli 1.0.0__py3-none-any.whl

pyforge/templates/fastapi/Dockerfile

@@ -0,0 +1,27 @@
+# ── Build stage ────────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+# Install dependencies (cached layer)
+COPY pyproject.toml uv.lock* ./
+RUN uv sync --frozen --no-dev
+
+# ── Runtime stage ──────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS runtime
+
+WORKDIR /app
+
+# Copy venv from builder
+COPY --from=builder /app/.venv /app/.venv
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Copy application source
+COPY app ./app
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

pyforge/templates/fastapi/README.md

@@ -0,0 +1,68 @@
+# {{ project_name }}
+
+A production-ready FastAPI backend, scaffolded by [AppGenerator](https://github.com/yourname/appgenerator-cli).
+
+## Tech Stack
+
+- **[FastAPI](https://fastapi.tiangolo.com/)** — high-performance async web framework
+- **[SQLModel](https://sqlmodel.tiangolo.com/)** — type-safe ORM (built on SQLAlchemy + Pydantic)
+- **[Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)** — typed config from env
+- **[Alembic](https://alembic.sqlalchemy.org/)** — database migrations
+- **[uv](https://docs.astral.sh/uv/)** — blazing-fast package management
+{% if postgres %}- **PostgreSQL** — relational database
+{% endif %}{% if redis %}- **Redis** — caching layer
+{% endif %}{% if docker %}- **Docker** — containerisation
+{% endif %}
+
+## Getting Started
+
+```bash
+# 1. Copy and fill in your environment variables
+cp .env.example .env
+
+# 2. Run the development server
+uv run uvicorn app.main:app --reload
+
+# 3. Visit the interactive docs
+open http://localhost:8000/docs
+```
+
+## Project Structure
+
+```
+{{ project_name }}/
+├── app/
+│   ├── main.py          # FastAPI application factory
+│   ├── config.py        # Typed settings (pydantic-settings)
+│   ├── dependencies.py  # Shared FastAPI dependencies
+│   ├── api/
+│   │   ├── __init__.py
+│   │   └── v1/
+│   │       ├── __init__.py
+│   │       └── health.py
+│   ├── models/
+│   │   ├── __init__.py
+│   │   └── base.py      # SQLModel base + common mixins
+│   └── db/
+│       ├── __init__.py
+│       └── session.py   # Async database session
+├── tests/
+│   ├── conftest.py
+│   └── test_health.py
+├── .env.example
+├── .gitignore
+└── pyproject.toml
+```
+
+## Running Tests
+
+```bash
+uv run pytest
+```
+
+## Linting
+
+```bash
+uv run ruff check .
+uv run ruff format .
+```

pyforge/templates/fastapi/app/__init__.py

@@ -0,0 +1 @@
+"""{{ project_name }} application package."""

pyforge/templates/fastapi/app/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

pyforge/templates/fastapi/app/api/v1/__init__.py

@@ -0,0 +1 @@
+"""API v1 package."""

pyforge/templates/fastapi/app/api/v1/health.py

@@ -0,0 +1,25 @@
+"""
+Health-check endpoint — always the first router to wire up.
+GET /api/v1/health  →  200 OK
+"""
+from datetime import datetime, timezone
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: datetime
+    version: str
+
+
+@router.get("/health", response_model=HealthResponse, summary="Service health check")
+async def health_check() -> HealthResponse:
+    return HealthResponse(
+        status="ok",
+        timestamp=datetime.now(timezone.utc),
+        version="0.1.0",
+    )

pyforge/templates/fastapi/app/config.py

@@ -0,0 +1,45 @@
+"""
+Typed application settings loaded from environment variables / .env file.
+"""
+from functools import lru_cache
+from typing import Annotated
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    # App
+    app_name: str = "{{ project_name }}"
+    app_env: str = "development"
+    debug: bool = True
+    secret_key: str = "change-me"
+
+    # Server
+    host: str = "0.0.0.0"
+    port: int = 8000
+    cors_origins: list[str] = ["*"]
+
+    # Database
+    database_url: str = "sqlite+aiosqlite:///./{{ package_name }}.db"
+{% if redis %}
+    # Redis
+    redis_url: str = "redis://localhost:6379/0"
+{% endif %}
+
+    @field_validator("cors_origins", mode="before")
+    @classmethod
+    def parse_cors(cls, v: str | list[str]) -> list[str]:
+        if isinstance(v, str):
+            return [origin.strip() for origin in v.split(",")]
+        return v
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

pyforge/templates/fastapi/app/db/__init__.py

@@ -0,0 +1 @@
+"""Database package."""

pyforge/templates/fastapi/app/db/session.py

@@ -0,0 +1,35 @@
+"""
+Async database session factory using SQLModel + SQLAlchemy.
+"""
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.config import settings
+
+engine = create_async_engine(
+    settings.database_url,
+    echo=settings.debug,
+    future=True,
+)
+
+AsyncSessionLocal = sessionmaker(  # type: ignore[call-overload]
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+async def init_db() -> None:
+    """Create all tables on startup (use Alembic for production migrations)."""
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency that yields an async DB session."""
+    async with AsyncSessionLocal() as session:
+        yield session

pyforge/templates/fastapi/app/dependencies.py

@@ -0,0 +1,12 @@
+"""
+Shared FastAPI dependency functions (DB sessions, auth, pagination, etc.).
+"""
+from typing import Annotated
+
+from fastapi import Depends
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.db.session import get_session
+
+# Re-export as typed dependency alias for cleaner route signatures
+SessionDep = Annotated[AsyncSession, Depends(get_session)]

pyforge/templates/fastapi/app/main.py

@@ -0,0 +1,58 @@
+"""
+{{ project_name }} — FastAPI application entry point.
+"""
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.api.v1 import health
+from app.config import settings
+from app.db.session import init_db
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Run startup/shutdown tasks."""
+    await init_db()
+    yield
+    # teardown (close connections, flush caches, etc.)
+
+
+def create_app() -> FastAPI:
+    application = FastAPI(
+        title=settings.app_name,
+        version="0.1.0",
+        description="Generated by AppGenerator",
+        docs_url="/docs" if settings.debug else None,
+        redoc_url="/redoc" if settings.debug else None,
+        lifespan=lifespan,
+    )
+
+    # CORS
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Routers
+    application.include_router(health.router, prefix="/api/v1", tags=["health"])
+
+    return application
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=settings.debug,
+    )

pyforge/templates/fastapi/app/models/__init__.py

@@ -0,0 +1,4 @@
+"""SQLModel domain models."""
+from app.models.base import BaseModel, TimestampMixin
+
+__all__ = ["BaseModel", "TimestampMixin"]

pyforge/templates/fastapi/app/models/base.py

@@ -0,0 +1,23 @@
+"""
+Base SQLModel classes with common fields (id, created_at, updated_at).
+"""
+from datetime import datetime, timezone
+
+from sqlmodel import Field, SQLModel
+
+
+def utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class TimestampMixin(SQLModel):
+    """Adds created_at and updated_at to any model."""
+
+    created_at: datetime = Field(default_factory=utcnow, nullable=False)
+    updated_at: datetime = Field(default_factory=utcnow, nullable=False)
+
+
+class BaseModel(TimestampMixin, table=False):
+    """Abstract base — inherit from this for all your DB models."""
+
+    id: int | None = Field(default=None, primary_key=True)

pyforge/templates/fastapi/docker-compose.yml

@@ -0,0 +1,39 @@
+version: "3.9"
+
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file: .env
+    depends_on:
+      {% if postgres %}- postgres{% endif %}
+      {% if redis %}- redis{% endif %}
+    restart: unless-stopped
+
+  {% if postgres %}
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: {{ package_name }}_db
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+    restart: unless-stopped
+  {% endif %}
+
+  {% if redis %}
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    restart: unless-stopped
+  {% endif %}
+
+{% if postgres %}
+volumes:
+  pg_data:
+{% endif %}

pyforge/templates/fastapi/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "A FastAPI backend project"
+requires-python = ">=3.10"
+dependencies = []
+
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "app"
+module-root = ""
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "I", "N", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+

pyforge/templates/fastapi/tests/__init__.py

@@ -0,0 +1 @@
+"""Test suite."""

pyforge/templates/fastapi/tests/conftest.py

@@ -0,0 +1,46 @@
+"""
+Pytest configuration and shared fixtures.
+"""
+import pytest_asyncio
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.db.session import get_session
+from app.main import app
+
+# Use an in-memory SQLite DB for tests
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+
+@pytest_asyncio.fixture(scope="session")
+async def test_engine():
+    engine = create_async_engine(TEST_DATABASE_URL, echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+    yield engine
+    await engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def db_session(test_engine):
+    AsyncTestSession = sessionmaker(
+        bind=test_engine, class_=AsyncSession, expire_on_commit=False
+    )
+    async with AsyncTestSession() as session:
+        yield session
+
+
+@pytest_asyncio.fixture
+async def client(db_session):
+    async def override_get_session():
+        yield db_session
+
+    app.dependency_overrides[get_session] = override_get_session
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as ac:
+        yield ac
+    app.dependency_overrides.clear()

pyforge/templates/fastapi/tests/test_health.py

@@ -0,0 +1,13 @@
+"""Tests for the health-check endpoint."""
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.asyncio
+async def test_health_ok(client: AsyncClient) -> None:
+    response = await client.get("/api/v1/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+    assert "timestamp" in data
+    assert "version" in data