inifastapi 0.1.0__py3-none-any.whl

inifastapi/__init__.py

@@ -0,0 +1,7 @@
+"""inifastapi package."""
+
+from .bootstrap import BootstrapError, bootstrap_project
+from .options import ProjectOptions
+from .scaffold import build_plan, scaffold_project
+
+__all__ = ["BootstrapError", "ProjectOptions", "bootstrap_project", "build_plan", "scaffold_project"]

inifastapi/__main__.py

@@ -0,0 +1,5 @@
+from .cli import app
+
+
+if __name__ == "__main__":
+    app()

inifastapi/bootstrap.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from pathlib import Path
+import shutil
+import subprocess
+
+from .options import ProjectOptions
+
+
+BASE_DEPENDENCIES = [
+    "fastapi[standard]",
+    "pydantic-settings",
+]
+
+AUTH_DEPENDENCIES = [
+    "python-jose[cryptography]",
+    "passlib[bcrypt]",
+    "python-multipart",
+]
+
+DATABASE_DEPENDENCIES = [
+    "sqlalchemy[asyncio]",
+    "alembic",
+    "asyncpg",
+]
+
+CACHE_DEPENDENCIES = [
+    "redis[hiredis]",
+]
+
+TASK_QUEUE_DEPENDENCIES = [
+    "celery",
+]
+
+DEV_DEPENDENCIES = [
+    "coverage>=7.13.5",
+    "prek>=0.3.8",
+    "pytest>=9.0.2",
+    "pytest-alembic>=0.12.1",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.9",
+]
+
+
+class BootstrapError(RuntimeError):
+    """Raised when project environment bootstrap cannot be completed."""
+
+
+def runtime_dependencies(options: ProjectOptions) -> list[str]:
+    dependencies = list(BASE_DEPENDENCIES)
+    if options.auth_enabled:
+        dependencies.extend(AUTH_DEPENDENCIES)
+    if options.database_enabled:
+        dependencies.extend(DATABASE_DEPENDENCIES)
+    if options.cache_enabled:
+        dependencies.extend(CACHE_DEPENDENCIES)
+    if options.task_queue_enabled:
+        dependencies.extend(TASK_QUEUE_DEPENDENCIES)
+    return dependencies
+
+
+def dev_dependencies() -> list[str]:
+    return list(DEV_DEPENDENCIES)
+
+
+def bootstrap_project(options: ProjectOptions) -> None:
+    if shutil.which("uv") is None:
+        raise BootstrapError(
+            "Generated project files, but could not bootstrap the environment because `uv` "
+            "is not installed. Install `uv`, then run `uv sync` in "
+            f"'{options.target_dir}'. For one-off usage, prefer "
+            f"`uvx inifastapi init {options.project_name}`."
+        )
+
+    runtime = runtime_dependencies(options)
+    if runtime:
+        run_uv(["uv", "add", "--no-sync", *runtime], cwd=options.target_dir)
+
+    dev = dev_dependencies()
+    if dev:
+        run_uv(["uv", "add", "--dev", "--no-sync", *dev], cwd=options.target_dir)
+
+    run_uv(["uv", "sync"], cwd=options.target_dir)
+
+
+def run_uv(command: list[str], *, cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        check=True,
+        text=True,
+        capture_output=True,
+    )

inifastapi/cli.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from .bootstrap import BootstrapError
+from .options import ProjectOptions, normalize_package_name
+from .scaffold import build_plan, scaffold_project
+
+
+app = typer.Typer(help="Initialize a production-oriented FastAPI project.", no_args_is_help=True)
+
+
+@app.callback()
+def main() -> None:
+    """CLI entrypoint."""
+
+
+def _prompt_text(value: Optional[str], message: str, default: str) -> str:
+    if value:
+        return value
+    return typer.prompt(message, default=default)
+
+
+def _build_options(
+    project_name: str,
+    package_name: Optional[str],
+    target_dir: Optional[Path],
+    app_name: Optional[str],
+    description: Optional[str],
+    python_version: str,
+    host: str,
+    port: int,
+    api_prefix: str,
+    docs_enabled: Optional[bool],
+    cors_enabled: Optional[bool],
+    tests_enabled: Optional[bool],
+    docker_enabled: Optional[bool],
+    ci_enabled: Optional[bool],
+    auth_enabled: Optional[bool],
+    database_enabled: Optional[bool],
+    cache_enabled: Optional[bool],
+    task_queue_enabled: Optional[bool],
+    layout: Optional[str],
+    ci_provider: Optional[str],
+    force: bool,
+    dry_run: bool,
+    bootstrap_env: bool,
+) -> ProjectOptions:
+    suggested_package = normalize_package_name(package_name or "app")
+    chosen_package = _prompt_text(package_name, "Python package name", suggested_package)
+    chosen_target = target_dir or Path(
+        _prompt_text(None, "Target directory", str(Path.cwd() / project_name))
+    )
+    chosen_layout = layout or typer.prompt("Project layout", default="app")
+    chosen_app_name = _prompt_text(app_name, "Application title", project_name.replace("-", " ").title())
+    chosen_description = _prompt_text(description, "Project description", f"{chosen_app_name} service")
+    chosen_docs_enabled = True if docs_enabled is None else docs_enabled
+    chosen_cors_enabled = True if cors_enabled is None else cors_enabled
+    chosen_tests_enabled = True if tests_enabled is None else tests_enabled
+    chosen_database_enabled = False if database_enabled is None else database_enabled
+    chosen_auth_enabled = False if auth_enabled is None else auth_enabled
+    chosen_cache_enabled = False if cache_enabled is None else cache_enabled
+    chosen_task_queue_enabled = False if task_queue_enabled is None else task_queue_enabled
+    chosen_docker_enabled = False if docker_enabled is None else docker_enabled
+    chosen_ci_enabled = False if ci_enabled is None else ci_enabled
+    chosen_ci_provider = ci_provider or "github"
+    if chosen_ci_enabled and ci_provider is None and not dry_run:
+        chosen_ci_provider = typer.prompt("CI provider", default="github")
+
+    return ProjectOptions(
+        project_name=project_name,
+        package_name=chosen_package,
+        target_dir=chosen_target,
+        app_name=chosen_app_name,
+        description=chosen_description,
+        python_version=python_version,
+        host=host,
+        port=port,
+        api_prefix=api_prefix,
+        docs_enabled=chosen_docs_enabled,
+        cors_enabled=chosen_cors_enabled,
+        tests_enabled=chosen_tests_enabled,
+        docker_enabled=chosen_docker_enabled,
+        ci_enabled=chosen_ci_enabled,
+        auth_enabled=chosen_auth_enabled,
+        database_enabled=chosen_database_enabled,
+        cache_enabled=chosen_cache_enabled,
+        task_queue_enabled=chosen_task_queue_enabled,
+        layout=chosen_layout,
+        ci_provider=chosen_ci_provider,
+        force=force,
+        dry_run=dry_run,
+        bootstrap_env=bootstrap_env,
+    )
+
+
+@app.command()
+def init(
+    project_name: str = typer.Argument(..., help="Distribution name for the generated project."),
+    package_name: Optional[str] = typer.Option(None, "--package-name", help="Python package name."),
+    target_dir: Optional[Path] = typer.Option(None, "--target-dir", help="Directory to generate into."),
+    app_name: Optional[str] = typer.Option(None, "--app-name", help="Human-readable app name."),
+    description: Optional[str] = typer.Option(None, "--description", help="Project description."),
+    python_version: str = typer.Option("3.12.10", "--python-version", help="Python version."),
+    host: str = typer.Option("0.0.0.0", "--host", help="Default host."),
+    port: int = typer.Option(8000, "--port", help="Default port."),
+    api_prefix: str = typer.Option("/api/v1", "--api-prefix", help="Global API prefix."),
+    docs_enabled: Optional[bool] = typer.Option(None, "--with-docs/--no-docs"),
+    cors_enabled: Optional[bool] = typer.Option(None, "--with-cors/--no-cors"),
+    tests_enabled: Optional[bool] = typer.Option(None, "--with-tests/--no-tests"),
+    docker_enabled: Optional[bool] = typer.Option(None, "--with-docker/--no-docker"),
+    ci_enabled: Optional[bool] = typer.Option(None, "--with-ci/--no-ci"),
+    auth_enabled: Optional[bool] = typer.Option(None, "--with-auth/--no-auth"),
+    database_enabled: Optional[bool] = typer.Option(None, "--with-database/--no-database"),
+    cache_enabled: Optional[bool] = typer.Option(None, "--with-cache/--no-cache"),
+    task_queue_enabled: Optional[bool] = typer.Option(None, "--with-task-queue/--no-task-queue"),
+    layout: Optional[str] = typer.Option(None, "--layout", help="app or src"),
+    ci_provider: Optional[str] = typer.Option(None, "--ci-provider", help="github or gitlab"),
+    force: bool = typer.Option(False, "--force", help="Overwrite in non-empty directories."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Only print the files that would be generated."),
+    bootstrap_env: bool = typer.Option(True, "--bootstrap-env/--no-bootstrap-env", help="Create .venv, uv.lock, and install dependencies with uv."),
+) -> None:
+    """Generate a FastAPI project."""
+    options = _build_options(
+        project_name=project_name,
+        package_name=package_name,
+        target_dir=target_dir,
+        app_name=app_name,
+        description=description,
+        python_version=python_version,
+        host=host,
+        port=port,
+        api_prefix=api_prefix,
+        docs_enabled=docs_enabled,
+        cors_enabled=cors_enabled,
+        tests_enabled=tests_enabled,
+        docker_enabled=docker_enabled,
+        ci_enabled=ci_enabled,
+        auth_enabled=auth_enabled,
+        database_enabled=database_enabled,
+        cache_enabled=cache_enabled,
+        task_queue_enabled=task_queue_enabled,
+        layout=layout,
+        ci_provider=ci_provider,
+        force=force,
+        dry_run=dry_run,
+        bootstrap_env=bootstrap_env,
+    )
+
+    try:
+        outputs = scaffold_project(options)
+    except FileExistsError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from exc
+    except BootstrapError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from exc
+
+    if options.dry_run:
+        typer.echo(f"Dry run for {options.project_name}:")
+        for path in build_plan(options):
+            typer.echo(f"  would create {path}")
+        return
+
+    typer.secho(f"Generated FastAPI project at {options.target_dir}", fg=typer.colors.GREEN)
+    if options.bootstrap_env:
+        typer.echo("Environment bootstrapped with uv.")
+    typer.echo("Files created:")
+    for path in outputs:
+        typer.echo(f"  {path.relative_to(options.target_dir)}")

inifastapi/options.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+
+DEFAULT_PYTHON_VERSION = "3.12.10"
+
+
+def slugify_project_name(value: str) -> str:
+    cleaned = re.sub(r"[^a-zA-Z0-9._-]+", "-", value.strip())
+    cleaned = cleaned.strip("-._")
+    return cleaned or "fastapi-app"
+
+
+def normalize_package_name(value: str) -> str:
+    normalized = re.sub(r"[^a-zA-Z0-9_]+", "_", value.strip().lower())
+    normalized = normalized.strip("_")
+    if not normalized:
+        return "app"
+    if normalized[0].isdigit():
+        normalized = f"pkg_{normalized}"
+    return normalized
+
+
+@dataclass(slots=True)
+class ProjectOptions:
+    project_name: str
+    package_name: str
+    target_dir: Path
+    app_name: str
+    description: str
+    python_version: str = DEFAULT_PYTHON_VERSION
+    host: str = "0.0.0.0"
+    port: int = 8000
+    api_prefix: str = "/api/v1"
+    docs_enabled: bool = True
+    cors_enabled: bool = True
+    tests_enabled: bool = True
+    docker_enabled: bool = False
+    ci_enabled: bool = False
+    auth_enabled: bool = False
+    database_enabled: bool = False
+    cache_enabled: bool = False
+    task_queue_enabled: bool = False
+    layout: str = "app"
+    ci_provider: str = "github"
+    force: bool = False
+    dry_run: bool = False
+    bootstrap_env: bool = True
+
+    def __post_init__(self) -> None:
+        self.project_name = slugify_project_name(self.project_name)
+        self.package_name = normalize_package_name(self.package_name)
+        self.target_dir = Path(self.target_dir).expanduser().resolve()
+        self.layout = self.layout if self.layout in {"app", "src"} else "app"
+        self.ci_provider = self.ci_provider if self.ci_provider in {"github", "gitlab"} else "github"
+        if self.port <= 0:
+            self.port = 8000
+        if not self.api_prefix.startswith("/"):
+            self.api_prefix = f"/{self.api_prefix}"
+        self.python_version = self.python_version.strip() or DEFAULT_PYTHON_VERSION
+        self.app_name = self.app_name.strip() or self.project_name
+        self.description = self.description.strip() or f"{self.app_name} service"
+
+    @property
+    def package_root(self) -> str:
+        return f"src/{self.package_name}" if self.layout == "src" else self.package_name
+
+    @property
+    def import_root(self) -> str:
+        return self.package_name
+
+    @property
+    def build_backend_module_root(self) -> str:
+        return "src" if self.layout == "src" else ""
+
+    @property
+    def vscode_extra_path(self) -> str:
+        return "${workspaceFolder}/src" if self.layout == "src" else "${workspaceFolder}"
+
+    @property
+    def pyright_extra_path(self) -> str:
+        return "src" if self.layout == "src" else "."
+
+    @property
+    def needs_rabbitmq(self) -> bool:
+        return self.task_queue_enabled
+
+    @property
+    def docs_url(self) -> str | None:
+        return "/docs" if self.docs_enabled else None
+
+    @property
+    def redoc_url(self) -> str | None:
+        return "/redoc" if self.docs_enabled else None
+
+    @property
+    def openapi_url(self) -> str | None:
+        return "/openapi.json" if self.docs_enabled else None
+
+    def template_context(self) -> dict[str, object]:
+        return {
+            "project_name": self.project_name,
+            "package_name": self.package_name,
+            "package_root": self.package_root,
+            "import_root": self.import_root,
+            "layout": self.layout,
+            "build_backend_module_root": self.build_backend_module_root,
+            "vscode_extra_path": self.vscode_extra_path,
+            "pyright_extra_path": self.pyright_extra_path,
+            "app_name": self.app_name,
+            "description": self.description,
+            "python_version": self.python_version,
+            "host": self.host,
+            "port": self.port,
+            "api_prefix": self.api_prefix,
+            "docs_enabled": self.docs_enabled,
+            "cors_enabled": self.cors_enabled,
+            "tests_enabled": self.tests_enabled,
+            "docker_enabled": self.docker_enabled,
+            "ci_enabled": self.ci_enabled,
+            "auth_enabled": self.auth_enabled,
+            "database_enabled": self.database_enabled,
+            "cache_enabled": self.cache_enabled,
+            "task_queue_enabled": self.task_queue_enabled,
+            "ci_provider": self.ci_provider,
+            "needs_rabbitmq": self.needs_rabbitmq,
+            "docs_url": self.docs_url,
+            "redoc_url": self.redoc_url,
+            "openapi_url": self.openapi_url,
+            "bootstrap_env": self.bootstrap_env,
+        }

inifastapi/scaffold.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import Iterable
+
+from jinja2 import Environment, FileSystemLoader
+
+from .bootstrap import bootstrap_project
+from .options import ProjectOptions
+
+
+@dataclass(frozen=True, slots=True)
+class TemplateEntry:
+    template_name: str
+    output_path: str
+    feature_flag: str | None = None
+
+
+def _template_environment() -> Environment:
+    template_root = files("inifastapi").joinpath("templates")
+    return Environment(
+        loader=FileSystemLoader(str(template_root)),
+        autoescape=False,
+        keep_trailing_newline=True,
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+
+def _template_entries() -> list[TemplateEntry]:
+    base = [
+        TemplateEntry("project/pyproject.toml.j2", "pyproject.toml"),
+        TemplateEntry("project/README.md.j2", "README.md"),
+        TemplateEntry("project/.gitignore.j2", ".gitignore"),
+        TemplateEntry("project/.env.example.j2", ".env.example"),
+        TemplateEntry("project/.python-version.j2", ".python-version"),
+        TemplateEntry("project/vscode_settings.json.j2", ".vscode/settings.json"),
+        TemplateEntry("project/pyrightconfig.json.j2", "pyrightconfig.json"),
+        TemplateEntry("project/main.py.j2", "{package_root}/main.py"),
+        TemplateEntry("project/api_router.py.j2", "{package_root}/api/router.py"),
+        TemplateEntry("project/routes_health.py.j2", "{package_root}/api/routes/health.py"),
+        TemplateEntry("project/config.py.j2", "{package_root}/core/config.py"),
+        TemplateEntry("project/logging.py.j2", "{package_root}/core/logging.py"),
+        TemplateEntry("project/lifespan.py.j2", "{package_root}/core/lifespan.py"),
+        TemplateEntry("project/middleware.py.j2", "{package_root}/core/middleware.py"),
+        TemplateEntry("project/dependencies_init.py.j2", "{package_root}/dependencies/__init__.py"),
+        TemplateEntry("project/models_init.py.j2", "{package_root}/models/__init__.py"),
+        TemplateEntry("project/schemas_init.py.j2", "{package_root}/schemas/__init__.py"),
+        TemplateEntry("project/services_init.py.j2", "{package_root}/services/__init__.py"),
+        TemplateEntry("project/package_init.py.j2", "{package_root}/__init__.py"),
+        TemplateEntry("project/api_init.py.j2", "{package_root}/api/__init__.py"),
+        TemplateEntry("project/api_routes_init.py.j2", "{package_root}/api/routes/__init__.py"),
+        TemplateEntry("project/core_init.py.j2", "{package_root}/core/__init__.py"),
+        TemplateEntry("project/tests_health.py.j2", "tests/test_health.py", "tests_enabled"),
+    ]
+    database = [
+        TemplateEntry("database/db_init.py.j2", "{package_root}/db/__init__.py", "database_enabled"),
+        TemplateEntry("database/base.py.j2", "{package_root}/db/base.py", "database_enabled"),
+        TemplateEntry("database/session.py.j2", "{package_root}/db/session.py", "database_enabled"),
+        TemplateEntry("database/alembic.ini.j2", "alembic.ini", "database_enabled"),
+        TemplateEntry("database/alembic_env.py.j2", "alembic/env.py", "database_enabled"),
+        TemplateEntry("database/alembic_script.py.mako.j2", "alembic/script.py.mako", "database_enabled"),
+        TemplateEntry("database/alembic_readme.py.j2", "alembic/versions/.gitkeep", "database_enabled"),
+    ]
+    auth = [
+        TemplateEntry("auth/routes_auth.py.j2", "{package_root}/api/routes/auth.py", "auth_enabled"),
+        TemplateEntry("auth/dependencies_auth.py.j2", "{package_root}/dependencies/auth.py", "auth_enabled"),
+        TemplateEntry("auth/security.py.j2", "{package_root}/core/security.py", "auth_enabled"),
+        TemplateEntry("auth/schemas_auth.py.j2", "{package_root}/schemas/auth.py", "auth_enabled"),
+    ]
+    cache = [
+        TemplateEntry("cache/cache.py.j2", "{package_root}/core/cache.py", "cache_enabled"),
+    ]
+    task_queue = [
+        TemplateEntry("task_queue/routes_tasks.py.j2", "{package_root}/api/routes/tasks.py", "task_queue_enabled"),
+        TemplateEntry("task_queue/tasks_init.py.j2", "{package_root}/tasks/__init__.py", "task_queue_enabled"),
+        TemplateEntry("task_queue/celery_app.py.j2", "{package_root}/tasks/celery_app.py", "task_queue_enabled"),
+        TemplateEntry("task_queue/sample_task.py.j2", "{package_root}/tasks/sample.py", "task_queue_enabled"),
+    ]
+    docker = [
+        TemplateEntry("docker/Dockerfile.j2", "Dockerfile", "docker_enabled"),
+        TemplateEntry("docker/.dockerignore.j2", ".dockerignore", "docker_enabled"),
+        TemplateEntry("docker/docker-compose.yml.j2", "docker-compose.yml", "docker_enabled"),
+    ]
+    ci = [
+        TemplateEntry("ci/github.yml.j2", ".github/workflows/ci.yml", "ci_enabled"),
+        TemplateEntry("ci/gitlab-ci.yml.j2", ".gitlab-ci.yml", "ci_enabled"),
+    ]
+    return base + database + auth + cache + task_queue + docker + ci
+
+
+def build_plan(options: ProjectOptions) -> list[Path]:
+    outputs: list[Path] = []
+    for entry in _iter_enabled_entries(options):
+        output_path = entry.output_path.format(package_root=options.package_root)
+        outputs.append(options.target_dir / output_path)
+    return outputs
+
+
+def _iter_enabled_entries(options: ProjectOptions) -> Iterable[TemplateEntry]:
+    for entry in _template_entries():
+        if entry.feature_flag is None:
+            yield entry
+            continue
+        if entry.template_name.startswith("ci/"):
+            if options.ci_enabled and (
+                (options.ci_provider == "github" and entry.template_name.endswith("github.yml.j2"))
+                or (options.ci_provider == "gitlab" and entry.template_name.endswith("gitlab-ci.yml.j2"))
+            ):
+                yield entry
+            continue
+        if getattr(options, entry.feature_flag):
+            yield entry
+
+
+def scaffold_project(options: ProjectOptions) -> list[Path]:
+    plan = build_plan(options)
+    _validate_target_dir(options)
+    if options.dry_run:
+        return plan
+
+    env = _template_environment()
+    context = options.template_context()
+
+    options.target_dir.mkdir(parents=True, exist_ok=True)
+    for path in plan:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    for entry in _iter_enabled_entries(options):
+        relative_output = entry.output_path.format(package_root=options.package_root)
+        output_path = options.target_dir / relative_output
+        rendered = env.get_template(entry.template_name).render(**context)
+        output_path.write_text(rendered, encoding="utf-8")
+
+    if options.bootstrap_env:
+        bootstrap_project(options)
+
+    return plan
+
+
+def _validate_target_dir(options: ProjectOptions) -> None:
+    if not options.target_dir.exists():
+        return
+    existing_files = [item for item in options.target_dir.iterdir()]
+    if not existing_files:
+        return
+    if options.force:
+        return
+    raise FileExistsError(
+        f"Target directory '{options.target_dir}' is not empty. Use --force to overwrite generated files."
+    )

inifastapi/templates/auth/dependencies_auth.py.j2

@@ -0,0 +1,19 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+
+from {{ import_root }}.core.security import decode_access_token
+from {{ import_root }}.schemas.auth import User
+
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/login")
+
+
+async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
+    subject = decode_access_token(token)
+    if subject is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return User(username=subject)

inifastapi/templates/auth/routes_auth.py.j2

@@ -0,0 +1,26 @@
+from datetime import timedelta
+
+from fastapi import APIRouter, Depends
+from fastapi.security import OAuth2PasswordRequestForm
+
+from {{ import_root }}.core.config import settings
+from {{ import_root }}.core.security import create_access_token
+from {{ import_root }}.dependencies.auth import get_current_user
+from {{ import_root }}.schemas.auth import Token, User
+
+
+router = APIRouter()
+
+
+@router.post("/login", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()) -> Token:
+    access_token = create_access_token(
+        subject=form_data.username,
+        expires_delta=timedelta(minutes=settings.access_token_expire_minutes),
+    )
+    return Token(access_token=access_token, token_type="bearer")
+
+
+@router.get("/me", response_model=User)
+async def read_current_user(current_user: User = Depends(get_current_user)) -> User:
+    return current_user

inifastapi/templates/auth/schemas_auth.py.j2

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class User(BaseModel):
+    username: str

inifastapi/templates/auth/security.py.j2

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from jose import JWTError, jwt
+
+from {{ import_root }}.core.config import settings
+
+
+def create_access_token(subject: str, expires_delta: timedelta) -> str:
+    expire = datetime.now(timezone.utc) + expires_delta
+    payload = {"sub": subject, "exp": expire}
+    return jwt.encode(payload, settings.secret_key, algorithm=settings.algorithm)
+
+
+def decode_access_token(token: str) -> str | None:
+    try:
+        payload = jwt.decode(token, settings.secret_key, algorithms=[settings.algorithm])
+    except JWTError:
+        return None
+    return payload.get("sub")

inifastapi/templates/cache/cache.py.j2

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from redis.asyncio import Redis
+
+from {{ import_root }}.core.config import settings
+
+
+def get_cache_client() -> Redis:
+    return Redis.from_url(settings.redis_url, encoding="utf-8", decode_responses=True)

inifastapi/templates/ci/github.yml.j2

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "{{ python_version }}"
+      - name: Install uv
+        run: pip install uv
+      - name: Install dependencies
+        run: uv sync
+      - name: Run tests
+        run: uv run pytest