fastapi-fullstack 0.1.12__tar.gz → 0.1.14__tar.gz

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-fullstack
-Version: 0.1.12
+Version: 0.1.14
 Summary: Full-stack FastAPI + Next.js template generator with PydanticAI/LangChain agents, WebSocket streaming, 20+ enterprise integrations, and Logfire/LangSmith observability. Ship AI apps fast. CLI tool to generate production-ready FastAPI + Next.js projects with AI agents, auth, and observability.
 Project-URL: Homepage, https://github.com/vstorm-co/full-stack-fastapi-nextjs-llm-template
 Project-URL: Documentation, https://github.com/vstorm-co/full-stack-fastapi-nextjs-llm-template#readme
@@ -199,8 +199,10 @@ make docker-db
 
 #### 3. Create and apply database migrations
 
+> ⚠️ **Important:** Both commands are required! `db-migrate` creates the migration file, `db-upgrade` applies it to the database.
+
 ```bash
-# Create initial migration (first time only)
+# Create initial migration (REQUIRED first time)
 make db-migrate
 # Enter message: "Initial migration"
 

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/README.md

@@ -163,8 +163,10 @@ make docker-db
 
 #### 3. Create and apply database migrations
 
+> ⚠️ **Important:** Both commands are required! `db-migrate` creates the migration file, `db-upgrade` applies it to the database.
+
 ```bash
-# Create initial migration (first time only)
+# Create initial migration (REQUIRED first time)
 make db-migrate
 # Enter message: "Initial migration"
 

fastapi_fullstack-0.1.14/fastapi_gen/__init__.py

@@ -0,0 +1,8 @@
+"""FastAPI Project Generator with Logfire observability."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("fastapi-fullstack")
+except PackageNotFoundError:
+    __version__ = "0.0.0"  # Development/editable install fallback

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/fastapi_gen/config.py

@@ -283,6 +283,83 @@ class ProjectConfig(BaseModel):
             and not self.enable_redis
         ):
             raise ValueError("Rate limiting with Redis storage requires Redis to be enabled")
+
+        # WebSocket JWT auth requires main JWT auth
+        if self.websocket_auth == WebSocketAuthType.JWT and self.auth not in (
+            AuthType.JWT,
+            AuthType.BOTH,
+        ):
+            raise ValueError("WebSocket JWT authentication requires JWT auth to be enabled")
+
+        # WebSocket API key auth requires main API key auth
+        if self.websocket_auth == WebSocketAuthType.API_KEY and self.auth not in (
+            AuthType.API_KEY,
+            AuthType.BOTH,
+        ):
+            raise ValueError("WebSocket API key authentication requires API key auth to be enabled")
+
+        # Admin panel authentication requires JWT (for User model and security functions)
+        if (
+            self.enable_admin_panel
+            and self.admin_require_auth
+            and self.auth not in (AuthType.JWT, AuthType.BOTH)
+        ):
+            raise ValueError(
+                "Admin panel authentication requires JWT auth to be enabled. "
+                "Either enable JWT auth or set admin_require_auth=False"
+            )
+
+        # Conversation persistence requires AI agent
+        if self.enable_conversation_persistence and not self.enable_ai_agent:
+            raise ValueError("Conversation persistence requires AI agent to be enabled")
+
+        # Admin panel requires SQLAlchemy (SQLAdmin doesn't fully support SQLModel)
+        if self.enable_admin_panel and self.orm_type == OrmType.SQLMODEL:
+            raise ValueError(
+                "Admin panel (SQLAdmin) requires SQLAlchemy ORM. "
+                "SQLModel is not fully supported. Use orm_type=sqlalchemy or disable admin panel."
+            )
+
+        # Session management requires JWT auth
+        if self.enable_session_management and self.auth not in (AuthType.JWT, AuthType.BOTH):
+            raise ValueError("Session management requires JWT auth to be enabled")
+
+        # Webhooks require a database
+        if self.enable_webhooks and self.database == DatabaseType.NONE:
+            raise ValueError(
+                "Webhooks require a database to store subscriptions and delivery history"
+            )
+
+        # Background task queues require Redis
+        if (
+            self.background_tasks
+            in (
+                BackgroundTaskType.CELERY,
+                BackgroundTaskType.TASKIQ,
+                BackgroundTaskType.ARQ,
+            )
+            and not self.enable_redis
+        ):
+            raise ValueError(
+                f"{self.background_tasks.value.title()} requires Redis to be enabled. "
+                "All task queue systems use Redis as broker/backend."
+            )
+
+        # Logfire feature-specific validations (only when logfire is enabled)
+        if self.enable_logfire:
+            if self.logfire_features.database and self.database == DatabaseType.NONE:
+                raise ValueError(
+                    "Logfire database instrumentation requires a database to be enabled"
+                )
+
+            if self.logfire_features.redis and not self.enable_redis:
+                raise ValueError("Logfire Redis instrumentation requires Redis to be enabled")
+
+            if self.logfire_features.celery and self.background_tasks != BackgroundTaskType.CELERY:
+                raise ValueError(
+                    "Logfire Celery instrumentation requires Celery as background task system"
+                )
+
         return self
 
     def to_cookiecutter_context(self) -> dict[str, Any]:

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/fastapi_gen/generator.py

@@ -12,31 +12,31 @@ from .config import DatabaseType, FrontendType, ProjectConfig
 console = Console()
 
 
-def _get_database_setup_commands(database: DatabaseType) -> list[str]:
+def _get_database_setup_commands(database: DatabaseType) -> list[tuple[str, str]]:
     """Get database-specific setup commands for post-generation messages.
 
     Args:
         database: The database type selected by the user
 
     Returns:
-        List of command strings to display
+        List of (command, description) tuples to display
     """
     if database == DatabaseType.SQLITE:
         return [
-            "# SQLite database will be created automatically at first run",
-            "make db-migrate       # Create initial migration",
-            "make db-upgrade       # Apply migrations",
+            ("# SQLite database will be created automatically", ""),
+            ("make db-migrate", "Create initial migration"),
+            ("make db-upgrade", "Apply migrations"),
         ]
     elif database == DatabaseType.MONGODB:
         return [
-            "make docker-mongo     # Start MongoDB container",
-            "# Or configure MongoDB Atlas connection in .env",
+            ("make docker-mongo", "Start MongoDB container"),
+            ("# Or configure MongoDB Atlas connection in .env", ""),
         ]
     else:  # PostgreSQL
         return [
-            "make docker-db        # Start PostgreSQL container",
-            "make db-migrate       # Create initial migration",
-            "make db-upgrade       # Apply migrations",
+            ("make docker-db", "Start PostgreSQL container"),
+            ("make db-migrate", "Create initial migration"),
+            ("make db-upgrade", "Apply migrations"),
         ]
 
 
@@ -153,8 +153,18 @@ def post_generation_tasks(project_path: Path, config: ProjectConfig) -> None:
         if config.database.value != "none":
             console.print()
             console.print(f"[bold]{step}. Database setup:[/]")
-            for cmd in _get_database_setup_commands(config.database):
-                console.print(f"  {cmd}")
+            db_commands = _get_database_setup_commands(config.database)
+            for cmd, desc in db_commands:
+                if desc:
+                    console.print(f"  {cmd:22}# {desc}")
+                else:
+                    console.print(f"  {cmd}")
+            if config.database != DatabaseType.MONGODB:
+                console.print()
+                console.print(
+                    "  [dim]⚠️  Run all commands in order:[/] "
+                    "[dim]db-migrate creates the migration, db-upgrade applies it[/]"
+                )
             step += 1
         console.print()
         console.print(f"[bold]{step}. Run backend:[/]")
@@ -184,8 +194,18 @@ def post_generation_tasks(project_path: Path, config: ProjectConfig) -> None:
         if config.database.value != "none":
             console.print()
             console.print(f"[bold]{step}. Database setup:[/]")
-            for cmd in _get_database_setup_commands(config.database):
-                console.print(f"  {cmd}")
+            db_commands = _get_database_setup_commands(config.database)
+            for cmd, desc in db_commands:
+                if desc:
+                    console.print(f"  {cmd:22}# {desc}")
+                else:
+                    console.print(f"  {cmd}")
+            if config.database != DatabaseType.MONGODB:
+                console.print()
+                console.print(
+                    "  [dim]⚠️  Run all commands in order:[/] "
+                    "[dim]db-migrate creates the migration, db-upgrade applies it[/]"
+                )
             step += 1
         console.print()
         console.print(f"[bold]{step}. Run server:[/]")

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/fastapi_gen/prompts.py

@@ -157,11 +157,11 @@ def prompt_orm_type() -> OrmType:
     """Prompt for ORM library selection."""
     choices = [
         questionary.Choice(
-            "SQLAlchemy (recommended - full control, mature)",
+            "SQLAlchemy — full control, supports admin panel",
             value=OrmType.SQLALCHEMY,
         ),
         questionary.Choice(
-            "SQLModel (simplified - less boilerplate, FastAPI-native)",
+            "SQLModel — less boilerplate, no admin panel support",
             value=OrmType.SQLMODEL,
         ),
     ]
@@ -289,38 +289,120 @@ def prompt_background_tasks() -> BackgroundTaskType:
     )
 
 
-def prompt_integrations() -> dict[str, bool]:
-    """Prompt for optional integrations."""
+def prompt_integrations(
+    database: DatabaseType,
+    orm_type: OrmType,
+) -> dict[str, bool]:
+    """Prompt for optional integrations.
+
+    Args:
+        database: Selected database type (affects which options are shown).
+        orm_type: Selected ORM type (SQLModel doesn't support admin panel).
+    """
     console.print()
     console.print("[bold cyan]Optional Integrations[/]")
     console.print()
 
+    # Build choices dynamically based on context
+    choices: list[questionary.Choice] = [
+        questionary.Choice(
+            "Redis — required for caching, rate limiting (Redis), task queues",
+            value="redis",
+        ),
+        questionary.Choice(
+            "Caching (fastapi-cache2) — requires Redis",
+            value="caching",
+        ),
+        questionary.Choice(
+            "Rate limiting (slowapi) — optional Redis storage",
+            value="rate_limiting",
+        ),
+        questionary.Choice(
+            "Pagination (fastapi-pagination)",
+            value="pagination",
+            checked=True,
+        ),
+        questionary.Choice(
+            "Sentry — error tracking & monitoring",
+            value="sentry",
+        ),
+        questionary.Choice(
+            "Prometheus — metrics endpoint for monitoring",
+            value="prometheus",
+        ),
+    ]
+
+    # Admin Panel only available with SQLAlchemy (not SQLModel) and SQL database
+    if (
+        database in (DatabaseType.POSTGRESQL, DatabaseType.SQLITE)
+        and orm_type == OrmType.SQLALCHEMY
+    ):
+        choices.append(
+            questionary.Choice(
+                "Admin Panel (SQLAdmin) — web UI for database management",
+                value="admin_panel",
+            )
+        )
+
+    choices.extend(
+        [
+            questionary.Choice(
+                "WebSockets — real-time bidirectional communication",
+                value="websockets",
+            ),
+            questionary.Choice(
+                "File Storage (S3/MinIO) — file upload/download support",
+                value="file_storage",
+            ),
+            questionary.Choice(
+                "AI Agent (PydanticAI/LangGraph/CrewAI) — LLM-powered assistant",
+                value="ai_agent",
+                checked=True,
+            ),
+        ]
+    )
+
+    # Webhooks require database
+    if database != DatabaseType.NONE:
+        choices.append(
+            questionary.Choice(
+                "Webhooks — outbound event notifications",
+                value="webhooks",
+            )
+        )
+
+    choices.extend(
+        [
+            questionary.Choice(
+                "Example CRUD (Item model) — sample API endpoints",
+                value="example_crud",
+                checked=True,
+            ),
+            questionary.Choice(
+                "CORS middleware — cross-origin request support",
+                value="cors",
+                checked=True,
+            ),
+            questionary.Choice(
+                "orjson — faster JSON serialization",
+                value="orjson",
+                checked=True,
+            ),
+        ]
+    )
+
     features = _check_cancelled(
         questionary.checkbox(
             "Select additional features:",
-            choices=[
-                questionary.Choice("Redis (caching/sessions)", value="redis"),
-                questionary.Choice("Caching (fastapi-cache2)", value="caching"),
-                questionary.Choice("Rate limiting (slowapi)", value="rate_limiting"),
-                questionary.Choice(
-                    "Pagination (fastapi-pagination)", value="pagination", checked=True
-                ),
-                questionary.Choice("Sentry (error tracking)", value="sentry"),
-                questionary.Choice("Prometheus (metrics)", value="prometheus"),
-                questionary.Choice("Admin Panel (SQLAdmin)", value="admin_panel"),
-                questionary.Choice("WebSockets", value="websockets"),
-                questionary.Choice("File Storage (S3/MinIO)", value="file_storage"),
-                questionary.Choice(
-                    "AI Agent (PydanticAI/LangGraph/CrewAI)", value="ai_agent", checked=True
-                ),
-                questionary.Choice("Webhooks (outbound events)", value="webhooks"),
-                questionary.Choice("Example CRUD (Item model)", value="example_crud", checked=True),
-                questionary.Choice("CORS middleware", value="cors", checked=True),
-                questionary.Choice("orjson (faster JSON)", value="orjson", checked=True),
-            ],
+            choices=choices,
         ).ask()
     )
 
+    # Auto-enable Redis for caching (show info message)
+    if "caching" in features and "redis" not in features:
+        console.print("[yellow]ℹ Caching requires Redis — auto-enabled[/]")
+        features.append("redis")
+
     return {
         "enable_redis": "redis" in features,
         "enable_caching": "caching" in features,
@@ -582,18 +664,31 @@ def prompt_llm_provider(ai_framework: AIFrameworkType) -> LLMProviderType:
     )
 
 
-def prompt_websocket_auth() -> WebSocketAuthType:
-    """Prompt for WebSocket authentication method for AI Agent."""
+def prompt_websocket_auth(auth: AuthType) -> WebSocketAuthType:
+    """Prompt for WebSocket authentication method for AI Agent.
+
+    Args:
+        auth: The main auth type. JWT WebSocket auth is only available
+            if JWT is enabled (JWT or BOTH).
+    """
     console.print()
     console.print("[bold cyan]AI Agent WebSocket Authentication[/]")
     console.print()
 
     choices = [
         questionary.Choice("None (public access)", value=WebSocketAuthType.NONE),
-        questionary.Choice("JWT token required", value=WebSocketAuthType.JWT),
-        questionary.Choice("API Key required (query param)", value=WebSocketAuthType.API_KEY),
     ]
 
+    # JWT WebSocket auth only available if main auth uses JWT
+    if auth in (AuthType.JWT, AuthType.BOTH):
+        choices.append(questionary.Choice("JWT token required", value=WebSocketAuthType.JWT))
+
+    # API Key WebSocket auth available if main auth uses API keys
+    if auth in (AuthType.API_KEY, AuthType.BOTH):
+        choices.append(
+            questionary.Choice("API Key required (query param)", value=WebSocketAuthType.API_KEY)
+        )
+
     return cast(
         WebSocketAuthType,
         _check_cancelled(
@@ -744,8 +839,8 @@ def run_interactive_prompts() -> ProjectConfig:
     # Background tasks
     background_tasks = prompt_background_tasks()
 
-    # Integrations
-    integrations = prompt_integrations()
+    # Integrations (pass context for dynamic option filtering)
+    integrations = prompt_integrations(database=database, orm_type=orm_type)
 
     # Dev tools
     dev_tools = prompt_dev_tools()
@@ -780,7 +875,7 @@ def run_interactive_prompts() -> ProjectConfig:
     if integrations.get("enable_ai_agent"):
         ai_framework = prompt_ai_framework()
         llm_provider = prompt_llm_provider(ai_framework)
-        websocket_auth = prompt_websocket_auth()
+        websocket_auth = prompt_websocket_auth(auth=auth)
         # Only offer persistence if database is enabled
         if database != DatabaseType.NONE:
             enable_conversation_persistence = _check_cancelled(

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-fullstack"
-version = "0.1.12"
+version = "0.1.14"
 description = "Full-stack FastAPI + Next.js template generator with PydanticAI/LangChain agents, WebSocket streaming, 20+ enterprise integrations, and Logfire/LangSmith observability. Ship AI apps fast. CLI tool to generate production-ready FastAPI + Next.js projects with AI agents, auth, and observability."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -165,3 +165,9 @@ exclude_lines = [
     "if TYPE_CHECKING:",
     "raise NotImplementedError",
 ]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pytest-cov>=7.0.0",
+]

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/hooks/post_gen_project.py

@@ -16,10 +16,14 @@ use_database = "{{ cookiecutter.use_database }}" == "True"
 use_postgresql = "{{ cookiecutter.use_postgresql }}" == "True"
 use_sqlite = "{{ cookiecutter.use_sqlite }}" == "True"
 use_mongodb = "{{ cookiecutter.use_mongodb }}" == "True"
+use_sqlalchemy = "{{ cookiecutter.use_sqlalchemy }}" == "True"
+use_sqlmodel = "{{ cookiecutter.use_sqlmodel }}" == "True"
 include_example_crud = "{{ cookiecutter.include_example_crud }}" == "True"
 enable_ai_agent = "{{ cookiecutter.enable_ai_agent }}" == "True"
 use_pydantic_ai = "{{ cookiecutter.use_pydantic_ai }}" == "True"
 use_langchain = "{{ cookiecutter.use_langchain }}" == "True"
+use_langgraph = "{{ cookiecutter.use_langgraph }}" == "True"
+use_crewai = "{{ cookiecutter.use_crewai }}" == "True"
 enable_admin_panel = "{{ cookiecutter.enable_admin_panel }}" == "True"
 enable_websockets = "{{ cookiecutter.enable_websockets }}" == "True"
 enable_redis = "{{ cookiecutter.enable_redis }}" == "True"
@@ -30,6 +34,7 @@ enable_conversation_persistence = "{{ cookiecutter.enable_conversation_persisten
 enable_webhooks = "{{ cookiecutter.enable_webhooks }}" == "True"
 enable_oauth = "{{ cookiecutter.enable_oauth }}" == "True"
 use_jwt = "{{ cookiecutter.use_jwt }}" == "True"
+use_api_key = "{{ cookiecutter.use_api_key }}" == "True"
 use_celery = "{{ cookiecutter.use_celery }}" == "True"
 use_taskiq = "{{ cookiecutter.use_taskiq }}" == "True"
 use_arq = "{{ cookiecutter.use_arq }}" == "True"
@@ -37,6 +42,7 @@ use_github_actions = "{{ cookiecutter.use_github_actions }}" == "True"
 use_gitlab_ci = "{{ cookiecutter.use_gitlab_ci }}" == "True"
 enable_kubernetes = "{{ cookiecutter.enable_kubernetes }}" == "True"
 use_nginx = "{{ cookiecutter.use_nginx }}" == "True"
+enable_logfire = "{{ cookiecutter.enable_logfire }}" == "True"
 
 
 def remove_file(path: str) -> None:
@@ -46,6 +52,23 @@ def remove_file(path: str) -> None:
         print(f"  Removed: {os.path.relpath(path)}")
 
 
+def is_stub_file(filepath: str) -> bool:
+    """Check if file only contains a docstring stub with no real code."""
+    if not os.path.exists(filepath):
+        return False
+    with open(filepath) as f:
+        content = f.read().strip()
+    # Empty file
+    if not content:
+        return True
+    # File only has docstring (triple-quoted string)
+    if content.startswith('"""') and content.endswith('"""'):
+        # Check if there's only one docstring and no code
+        inner = content[3:-3].strip()
+        return '"""' not in inner and "def " not in content and "class " not in content
+    return False
+
+
 def remove_dir(path: str) -> None:
     """Remove a directory if it exists."""
     if os.path.exists(path):
@@ -72,6 +95,10 @@ else:
         remove_file(os.path.join(backend_app, "agents", "assistant.py"))
     if not use_langchain:
         remove_file(os.path.join(backend_app, "agents", "langchain_assistant.py"))
+    if not use_langgraph:
+        remove_file(os.path.join(backend_app, "agents", "langgraph_assistant.py"))
+    if not use_crewai:
+        remove_file(os.path.join(backend_app, "agents", "crewai_assistant.py"))
 
 # --- Example CRUD files ---
 if not include_example_crud or not use_database:
@@ -109,8 +136,8 @@ if not enable_session_management or not use_jwt:
 if not enable_websockets:
     remove_file(os.path.join(backend_app, "api", "routes", "v1", "ws.py"))
 
-# --- Admin panel ---
-if not enable_admin_panel or (not use_postgresql and not use_sqlite):
+# --- Admin panel (requires SQLAlchemy, not SQLModel) ---
+if not enable_admin_panel or (not use_postgresql and not use_sqlite) or not use_sqlalchemy:
     remove_file(os.path.join(backend_app, "admin.py"))
 
 # --- Redis/Cache files ---
@@ -129,6 +156,32 @@ if not enable_oauth:
     remove_file(os.path.join(backend_app, "api", "routes", "v1", "oauth.py"))
     remove_file(os.path.join(backend_app, "core", "oauth.py"))
 
+# --- Security file (only when no auth at all) ---
+if not use_jwt and not use_api_key:
+    remove_file(os.path.join(backend_app, "core", "security.py"))
+
+# --- Auth/User files (when JWT is disabled) ---
+if not use_jwt:
+    remove_file(os.path.join(backend_app, "api", "routes", "v1", "auth.py"))
+    remove_file(os.path.join(backend_app, "api", "routes", "v1", "users.py"))
+    remove_file(os.path.join(backend_app, "db", "models", "user.py"))
+    remove_file(os.path.join(backend_app, "repositories", "user.py"))
+    remove_file(os.path.join(backend_app, "services", "user.py"))
+    remove_file(os.path.join(backend_app, "schemas", "user.py"))
+    remove_file(os.path.join(backend_app, "schemas", "token.py"))
+
+# --- Logfire setup file (when logfire is disabled) ---
+if not enable_logfire:
+    remove_file(os.path.join(backend_app, "core", "logfire_setup.py"))
+
+# --- Cleanup stub files (files with only docstring, no code) ---
+core_dir = os.path.join(backend_app, "core")
+for stub_candidate in ["security.py", "cache.py", "rate_limit.py", "oauth.py", "logfire_setup.py", "csrf.py"]:
+    filepath = os.path.join(core_dir, stub_candidate)
+    if is_stub_file(filepath):
+        remove_file(filepath)
+        print(f"  Removed stub: {os.path.relpath(filepath)}")
+
 # --- Worker/Background tasks ---
 use_any_background_tasks = use_celery or use_taskiq or use_arq
 if not use_any_background_tasks:

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/{{cookiecutter.project_slug}}/backend/app/admin.py

@@ -1,4 +1,4 @@
-{%- if cookiecutter.enable_admin_panel and cookiecutter.use_postgresql %}
+{%- if cookiecutter.enable_admin_panel and (cookiecutter.use_postgresql or cookiecutter.use_sqlite) and cookiecutter.use_sqlalchemy %}
 """SQLAdmin configuration with automatic model discovery."""
 
 from typing import Any, ClassVar

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/{{cookiecutter.project_slug}}/backend/app/agents/langchain_assistant.py

@@ -163,7 +163,7 @@ class LangChainAssistant:
 
         return output, tool_events, agent_context
 
-    def stream(
+    async def stream(
         self,
         user_input: str,
         history: list[dict[str, str]] | None = None,
@@ -186,11 +186,12 @@ class LangChainAssistant:
 
         agent_context: AgentContext = context if context is not None else {}
 
-        yield from self.agent.stream(
+        async for event in self.agent.astream(
             {"messages": messages},
             stream_mode=["messages", "updates"],
             config={"configurable": agent_context} if agent_context else None,
-        )
+        ):
+            yield event
 
 
 def get_agent() -> LangChainAssistant:

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/{{cookiecutter.project_slug}}/backend/app/api/routes/v1/oauth.py

@@ -141,19 +141,15 @@ async def google_callback(request: Request, user_service: UserSvc):
 
 
 @router.get("/google/callback")
-def google_callback(request: Request, user_service: UserSvc):
+async def google_callback(request: Request, user_service: UserSvc):
     """Handle Google OAuth2 callback.
 
     Creates a new user if one doesn't exist with the Google email,
     or returns tokens for existing user. Redirects to frontend with tokens.
     """
-    import asyncio
-
     try:
-        # Run async OAuth in sync context
-        loop = asyncio.new_event_loop()
-        token = loop.run_until_complete(oauth.google.authorize_access_token(request))
-        loop.close()
+        # OAuth token exchange is async
+        token = await oauth.google.authorize_access_token(request)
 
         user_info = token.get("userinfo")
 

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/{{cookiecutter.project_slug}}/backend/app/commands/cleanup.py

@@ -6,7 +6,7 @@ This command is useful for maintenance tasks.
 """
 
 import asyncio
-from datetime import datetime, timedelta
+from datetime import UTC, datetime, timedelta
 
 import click
 
@@ -26,7 +26,7 @@ def cleanup(days: int, dry_run: bool, force: bool) -> None:
         project cmd cleanup --days 30 --dry-run
         project cmd cleanup --days 7 --force
     """
-    cutoff_date = datetime.utcnow() - timedelta(days=days)
+    cutoff_date = datetime.now(UTC) - timedelta(days=days)
 
     if dry_run:
         info(f"[DRY RUN] Would delete records older than {cutoff_date}")

{fastapi_fullstack-0.1.12 → fastapi_fullstack-0.1.14}/template/{{cookiecutter.project_slug}}/backend/app/commands/seed.py

@@ -7,13 +7,16 @@ This command is useful for development and testing.
 Uses random data generation - install faker for better data:
     uv add faker --group dev
 """
-
+{% if cookiecutter.use_postgresql %}
 import asyncio
+{% endif %}
 import random
 import string
 
 import click
+{% if cookiecutter.use_jwt or cookiecutter.include_example_crud %}
 from sqlalchemy import delete, select
+{% endif %}
 
 from app.commands import command, info, success, warning
 
@@ -109,7 +112,9 @@ def seed(
 {%- endif %}
         return
 
-{%- if cookiecutter.use_postgresql %}
+{%- if not cookiecutter.use_jwt and not cookiecutter.include_example_crud %}
+    info("No entities configured to seed. Enable JWT users or example CRUD to use this command.")
+{%- elif cookiecutter.use_postgresql %}
     from app.db.session import async_session_maker
 {%- if cookiecutter.use_jwt %}
     from app.db.models.user import User