fastapi-scaffolder 0.1.1__tar.gz

fastapi_scaffolder-0.1.1/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: fastapi-scaffolder
+Version: 0.1.1
+Summary: Scaffold a FastAPI + SQLAlchemy backend boilerplate in seconds
+Project-URL: Homepage, https://github.com/prathamdmehta/fastapi-scaffolder
+Project-URL: Repository, https://github.com/prathamdmehta/fastapi-scaffolder
+Author: Pratham
+License-Expression: MIT
+Keywords: backend,boilerplate,cli,fastapi,scaffold,sqlalchemy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Requires-Dist: jinja2>=3.1
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# fastapi-scaffolder
+
+A CLI that generates a ready-to-code FastAPI + SQLAlchemy + SQLite
+backend project — folders, DB session wiring, an example CRUD
+resource, and tests — so you can skip straight to writing business
+logic instead of rebuilding the same plumbing every time.
+
+## Install & use
+
+```bash
+# one-off, no permanent install (like npx)
+uvx fastapi-scaffolder init "My API"
+
+# or install it properly
+pip install fastapi-scaffolder
+fastapi-scaffold init "My API"
+```
+
+This creates a `my_api/` folder with a working FastAPI app.
+
+## Local development
+
+```bash
+cd fastapi-scaffolder
+pip install -e . --break-system-packages   # editable install
+fastapi-scaffold init "Demo Project"
+```

fastapi_scaffolder-0.1.1/README.md

@@ -0,0 +1,27 @@
+# fastapi-scaffolder
+
+A CLI that generates a ready-to-code FastAPI + SQLAlchemy + SQLite
+backend project — folders, DB session wiring, an example CRUD
+resource, and tests — so you can skip straight to writing business
+logic instead of rebuilding the same plumbing every time.
+
+## Install & use
+
+```bash
+# one-off, no permanent install (like npx)
+uvx fastapi-scaffolder init "My API"
+
+# or install it properly
+pip install fastapi-scaffolder
+fastapi-scaffold init "My API"
+```
+
+This creates a `my_api/` folder with a working FastAPI app.
+
+## Local development
+
+```bash
+cd fastapi-scaffolder
+pip install -e . --break-system-packages   # editable install
+fastapi-scaffold init "Demo Project"
+```

fastapi_scaffolder-0.1.1/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "fastapi-scaffolder"
+version = "0.1.1"
+description = "Scaffold a FastAPI + SQLAlchemy backend boilerplate in seconds"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Pratham" },
+]
+keywords = ["fastapi", "sqlalchemy", "scaffold", "boilerplate", "cli", "backend"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Software Development :: Build Tools",
+    "Framework :: FastAPI",
+]
+dependencies = [
+    "typer>=0.12",
+    "jinja2>=3.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/prathamdmehta/fastapi-scaffolder"
+Repository = "https://github.com/prathamdmehta/fastapi-scaffolder"
+
+[project.scripts]
+fastapi-scaffold = "fastapi_scaffolder.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fastapi_scaffolder"]

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/cli.py

@@ -0,0 +1,87 @@
+import re
+import shutil
+from pathlib import Path
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+
+app = typer.Typer(
+    help="Scaffold a FastAPI + SQLAlchemy backend so you can skip the boilerplate."
+)
+
+TEMPLATES_ROOT = Path(__file__).parent / "templates"
+
+
+def slugify(name: str) -> str:
+    """Turn 'My Cool API' into 'my_cool_api' for use as a folder name."""
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", name.strip()).strip("_").lower()
+    return slug or "backend_project"
+
+
+def render_template(template_dir: Path, target_dir: Path, context: dict) -> None:
+    env = Environment(loader=FileSystemLoader(str(template_dir)), keep_trailing_newline=True)
+
+    for src_path in sorted(template_dir.rglob("*")):
+        if src_path.is_dir():
+            continue
+
+        rel_path = src_path.relative_to(template_dir)
+        rel_str = rel_path.as_posix()
+        is_template = rel_str.endswith(".j2")
+        out_rel = Path(rel_str[:-3]) if is_template else rel_path
+        out_path = target_dir / out_rel
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if is_template:
+            rendered = env.get_template(rel_str).render(**context)
+            out_path.write_text(rendered, encoding="utf-8")
+        else:
+            shutil.copy2(src_path, out_path)
+
+
+@app.command()
+def init(
+    project_name: str = typer.Argument(..., help="Human-readable project name, e.g. 'My API'"),
+    directory: str = typer.Option(
+        None,
+        "--dir",
+        help="Folder to create the project in. Defaults to a slugified version of the project name.",
+    ),
+):
+    """
+    Generate a new FastAPI + SQLAlchemy + SQLite backend project.
+    """
+    project_slug = slugify(directory or project_name)
+    target_dir = Path.cwd() / project_slug
+
+    if target_dir.exists() and any(target_dir.iterdir()):
+        typer.secho(f"'{project_slug}' already exists and is not empty. Aborting.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    template_dir = TEMPLATES_ROOT / "fastapi_sqlite"
+    context = {"project_name": project_name, "project_slug": project_slug}
+
+    render_template(template_dir, target_dir, context)
+
+    typer.secho(f"\n✅ Created '{project_name}' in ./{project_slug}\n", fg=typer.colors.GREEN, bold=True)
+    typer.echo("Next steps:")
+    typer.echo(f"  cd {project_slug}")
+    typer.echo("  pip install -r requirements.txt   # or: uv pip install -r requirements.txt")
+    typer.echo("  cp .env.example .env")
+    typer.echo("  uvicorn app.main:app --reload")
+
+
+@app.command()
+def version():
+    """Print the fastapi-scaffolder version."""
+    from fastapi_scaffolder import __version__
+
+    typer.echo(__version__)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/.env.example.j2

@@ -0,0 +1,3 @@
+PROJECT_NAME="{{ project_name }}"
+DATABASE_URL=sqlite:///./app.db
+DEBUG=True

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/README.md.j2

@@ -0,0 +1,40 @@
+# {{ project_name }}
+
+A FastAPI + SQLAlchemy + SQLite backend, generated by `fastapi-scaffold`.
+
+## Run it
+
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+uvicorn app.main:app --reload
+```
+
+Then open http://127.0.0.1:8000/docs for interactive Swagger docs.
+
+## Run tests
+
+```bash
+pip install pytest httpx
+pytest -v
+```
+
+## What's included
+
+- `app/main.py` — FastAPI app instance, lifespan startup (creates SQLite
+  tables), mounts the API router.
+- `app/core/config.py` — Settings loaded from `.env` via pydantic-settings.
+- `app/db/` — SQLAlchemy engine/session (`session.py`), declarative base
+  (`base_class.py`), model import registry (`base.py`), and a
+  `create_all`-based init helper (`init_db.py`).
+- `app/models/item.py` — Example ORM model. Delete/rename once you add
+  your real models; keep the pattern.
+- `app/schemas/item.py` — Pydantic request/response schemas.
+- `app/crud/item.py` — Data-access layer, kept separate from routes.
+- `app/api/v1/routes_item.py` — Full CRUD route set for the example model.
+- `app/api/v1/api.py` — Aggregates all v1 routers into one.
+- `tests/test_items.py` — Smoke test covering the full create → read →
+  update → delete flow.
+
+Swap `DATABASE_URL` in `.env` for Postgres/MySQL whenever you're ready —
+everything else is written to be database-agnostic.

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/api/deps.py

@@ -0,0 +1,6 @@
+# Shared FastAPI dependencies used across route modules.
+# Re-exported here so routes just do `from app.api.deps import get_db`
+# instead of reaching into app.db.session directly. This is also the
+# natural place to add get_current_user() once auth is introduced.
+
+from app.db.session import get_db  # noqa: F401

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/api/v1/api.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from app.api.v1 import routes_item
+
+api_router = APIRouter()
+api_router.include_router(routes_item.router)
+
+# Add future route modules here, e.g.:
+# from app.api.v1 import routes_user
+# api_router.include_router(routes_user.router)

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/api/v1/routes_item.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.crud import item as crud_item
+from app.schemas.item import ItemCreate, ItemRead, ItemUpdate
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.post("/", response_model=ItemRead, status_code=201)
+def create_item(item_in: ItemCreate, db: Session = Depends(get_db)):
+    return crud_item.create(db, obj_in=item_in)
+
+
+@router.get("/", response_model=list[ItemRead])
+def list_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    return crud_item.get_multi(db, skip=skip, limit=limit)
+
+
+@router.get("/{item_id}", response_model=ItemRead)
+def get_item(item_id: int, db: Session = Depends(get_db)):
+    item = crud_item.get(db, item_id=item_id)
+    if item is None:
+        raise HTTPException(status_code=404, detail="Item not found")
+    return item
+
+
+@router.patch("/{item_id}", response_model=ItemRead)
+def update_item(item_id: int, item_in: ItemUpdate, db: Session = Depends(get_db)):
+    item = crud_item.get(db, item_id=item_id)
+    if item is None:
+        raise HTTPException(status_code=404, detail="Item not found")
+    return crud_item.update(db, db_obj=item, obj_in=item_in)
+
+
+@router.delete("/{item_id}", status_code=204)
+def delete_item(item_id: int, db: Session = Depends(get_db)):
+    item = crud_item.remove(db, item_id=item_id)
+    if item is None:
+        raise HTTPException(status_code=404, detail="Item not found")

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/core/config.py.j2

@@ -0,0 +1,22 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Central app configuration. Values are read from environment
+    variables / a .env file, falling back to the defaults below.
+    """
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    PROJECT_NAME: str = "{{ project_name }}"
+    API_V1_PREFIX: str = "/api/v1"
+
+    # SQLite by default so the project runs with zero external setup.
+    # Swap this for a Postgres/MySQL URL when you're ready.
+    DATABASE_URL: str = "sqlite:///./app.db"
+
+    DEBUG: bool = True
+
+
+settings = Settings()

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/crud/item.py

@@ -0,0 +1,38 @@
+from sqlalchemy.orm import Session
+
+from app.models.item import Item
+from app.schemas.item import ItemCreate, ItemUpdate
+
+
+def get(db: Session, item_id: int) -> Item | None:
+    return db.get(Item, item_id)
+
+
+def get_multi(db: Session, skip: int = 0, limit: int = 100) -> list[Item]:
+    return db.query(Item).offset(skip).limit(limit).all()
+
+
+def create(db: Session, obj_in: ItemCreate) -> Item:
+    db_obj = Item(name=obj_in.name, description=obj_in.description)
+    db.add(db_obj)
+    db.commit()
+    db.refresh(db_obj)
+    return db_obj
+
+
+def update(db: Session, db_obj: Item, obj_in: ItemUpdate) -> Item:
+    update_data = obj_in.model_dump(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(db_obj, field, value)
+    db.add(db_obj)
+    db.commit()
+    db.refresh(db_obj)
+    return db_obj
+
+
+def remove(db: Session, item_id: int) -> Item | None:
+    db_obj = db.get(Item, item_id)
+    if db_obj is not None:
+        db.delete(db_obj)
+        db.commit()
+    return db_obj

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/db/base.py

@@ -0,0 +1,6 @@
+# Import all models here so that Base.metadata is aware of them.
+# This file is imported by init_db.py (and later by Alembic's env.py)
+# purely for its side effects.
+
+from app.db.base_class import Base  # noqa
+from app.models.item import Item  # noqa

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/db/base_class.py

@@ -0,0 +1,10 @@
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    """
+    Shared declarative base for every ORM model in the project.
+    All models should inherit from this class.
+    """
+
+    pass

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/db/init_db.py

@@ -0,0 +1,11 @@
+from app.db.base import Base  # noqa: F401  (pulls in all models)
+from app.db.session import engine
+
+
+def init_db() -> None:
+    """
+    Create all tables that don't exist yet.
+    Fine for SQLite/dev. In a real project you'd swap this for
+    Alembic migrations once the schema stabilizes.
+    """
+    Base.metadata.create_all(bind=engine)

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/db/session.py

@@ -0,0 +1,28 @@
+from collections.abc import Generator
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+
+# check_same_thread is only needed for SQLite; harmless to leave the
+# kwarg conditional so this file works unchanged if you switch DBs.
+connect_args = (
+    {"check_same_thread": False} if settings.DATABASE_URL.startswith("sqlite") else {}
+)
+
+engine = create_engine(settings.DATABASE_URL, connect_args=connect_args)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def get_db() -> Generator:
+    """
+    FastAPI dependency that yields a DB session and guarantees it's
+    closed afterwards, even if the request raises.
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/main.py

@@ -0,0 +1,26 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from app.api.v1.api import api_router
+from app.core.config import settings
+from app.db.init_db import init_db
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Creates SQLite tables on startup. Swap for Alembic migrations
+    # once the schema stabilizes / you move to Postgres.
+    init_db()
+    yield
+
+
+app = FastAPI(title=settings.PROJECT_NAME, lifespan=lifespan)
+
+
+@app.get("/", tags=["health"])
+def health_check():
+    return {"status": "ok", "project": settings.PROJECT_NAME}
+
+
+app.include_router(api_router, prefix=settings.API_V1_PREFIX)

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/models/item.py

@@ -0,0 +1,17 @@
+from sqlalchemy import Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base_class import Base
+
+
+class Item(Base):
+    """
+    Example model showing the pattern every future model should
+    follow. Delete or rename this once you add your real models.
+    """
+
+    __tablename__ = "items"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str | None] = mapped_column(String(1024), nullable=True)

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/app/schemas/item.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class ItemBase(BaseModel):
+    name: str
+    description: str | None = None
+
+
+class ItemCreate(ItemBase):
+    """Fields accepted when creating a new item."""
+
+    pass
+
+
+class ItemUpdate(BaseModel):
+    """Fields accepted when updating an item — all optional."""
+
+    name: str | None = None
+    description: str | None = None
+
+
+class ItemRead(ItemBase):
+    """Fields returned to the client."""
+
+    id: int
+
+    model_config = ConfigDict(from_attributes=True)

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.111
+uvicorn[standard]>=0.30
+sqlalchemy>=2.0
+pydantic-settings>=2.2

fastapi_scaffolder-0.1.1/src/fastapi_scaffolder/templates/fastapi_sqlite/tests/test_items.py

@@ -0,0 +1,48 @@
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+@pytest.fixture()
+def client():
+    # Using a context manager triggers lifespan startup/shutdown,
+    # which is what creates the SQLite tables.
+    with TestClient(app) as c:
+        yield c
+
+
+def test_health_check(client):
+    resp = client.get("/")
+    assert resp.status_code == 200
+
+
+def test_item_crud_flow(client):
+    # create
+    resp = client.post("/api/v1/items/", json={"name": "Widget", "description": "A test widget"})
+    assert resp.status_code == 201
+    item = resp.json()
+    item_id = item["id"]
+    assert item["name"] == "Widget"
+
+    # read one
+    resp = client.get(f"/api/v1/items/{item_id}")
+    assert resp.status_code == 200
+
+    # list
+    resp = client.get("/api/v1/items/")
+    assert resp.status_code == 200
+    assert any(i["id"] == item_id for i in resp.json())
+
+    # update
+    resp = client.patch(f"/api/v1/items/{item_id}", json={"description": "Updated"})
+    assert resp.status_code == 200
+    assert resp.json()["description"] == "Updated"
+
+    # delete
+    resp = client.delete(f"/api/v1/items/{item_id}")
+    assert resp.status_code == 204
+
+    # confirm gone
+    resp = client.get(f"/api/v1/items/{item_id}")
+    assert resp.status_code == 404