fastapi-fullstack 0.1.7__py3-none-any.whl → 0.1.15__py3-none-any.whl

fastapi_gen/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_gen/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_gen/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

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/core/config.py

@@ -1,11 +1,11 @@
 """Application configuration using Pydantic BaseSettings."""
-{% if cookiecutter.use_database -%}
+{% if cookiecutter.use_database or cookiecutter.enable_redis -%}
 # ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
 {% endif %}
 from pathlib import Path
 from typing import Literal
 
-{% if cookiecutter.use_database -%}
+{% if cookiecutter.use_database or cookiecutter.enable_redis -%}
 from pydantic import computed_field, field_validator{% if cookiecutter.use_jwt or cookiecutter.use_api_key or cookiecutter.enable_cors %}, ValidationInfo{% endif %}
 {% else -%}
 from pydantic import field_validator{% if cookiecutter.use_jwt or cookiecutter.use_api_key or cookiecutter.enable_cors %}, ValidationInfo{% endif %}
@@ -109,13 +109,10 @@ class Settings(BaseSettings):
         return f"sqlite:///{self.SQLITE_PATH}"
 {%- endif %}
 
-{%- if cookiecutter.use_jwt %}
+{%- if cookiecutter.use_jwt or (cookiecutter.enable_admin_panel and cookiecutter.admin_require_auth) or cookiecutter.enable_oauth %}
 
-    # === Auth (JWT) ===
+    # === Auth (SECRET_KEY for JWT/Session/Admin) ===
     SECRET_KEY: str = "change-me-in-production-use-openssl-rand-hex-32"
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30  # 30 minutes
-    REFRESH_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 7  # 7 days
-    ALGORITHM: str = "HS256"
 
     @field_validator("SECRET_KEY")
     @classmethod
@@ -133,6 +130,14 @@ class Settings(BaseSettings):
         return v
 {%- endif %}
 
+{%- if cookiecutter.use_jwt %}
+
+    # === JWT Settings ===
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30  # 30 minutes
+    REFRESH_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 7  # 7 days
+    ALGORITHM: str = "HS256"
+{%- endif %}
+
 {%- if cookiecutter.enable_oauth_google %}
 
     # === OAuth2 (Google) ===
@@ -198,12 +203,28 @@ class Settings(BaseSettings):
     TASKIQ_RESULT_BACKEND: str = "redis://localhost:6379/1"
 {%- endif %}
 
+{%- if cookiecutter.use_arq %}
+
+    # === ARQ (Async Redis Queue) ===
+    ARQ_REDIS_HOST: str = "localhost"
+    ARQ_REDIS_PORT: int = 6379
+    ARQ_REDIS_PASSWORD: str | None = None
+    ARQ_REDIS_DB: int = 2
+{%- endif %}
+
 {%- if cookiecutter.enable_sentry %}
 
     # === Sentry ===
     SENTRY_DSN: str | None = None
 {%- endif %}
 
+{%- if cookiecutter.enable_prometheus %}
+
+    # === Prometheus ===
+    PROMETHEUS_METRICS_PATH: str = "/metrics"
+    PROMETHEUS_INCLUDE_IN_SCHEMA: bool = False
+{%- endif %}
+
 {%- if cookiecutter.enable_file_storage %}
 
     # === File Storage (S3/MinIO) ===
@@ -240,6 +261,22 @@ class Settings(BaseSettings):
     LANGCHAIN_PROJECT: str = "{{ cookiecutter.project_slug }}"
     LANGCHAIN_ENDPOINT: str = "https://api.smith.langchain.com"
 {%- endif %}
+{%- if cookiecutter.use_deepagents %}
+
+    # === DeepAgents Configuration ===
+    # Skills paths (comma-separated, relative to backend dir)
+    DEEPAGENTS_SKILLS_PATHS: str | None = None  # e.g. "/skills/user/,/skills/project/"
+    # Enable built-in tools
+    DEEPAGENTS_ENABLE_FILESYSTEM: bool = True  # ls, read_file, write_file, edit_file, glob, grep
+    DEEPAGENTS_ENABLE_EXECUTE: bool = False  # shell execution (disabled by default for security)
+    DEEPAGENTS_ENABLE_TODOS: bool = True  # write_todos tool
+    DEEPAGENTS_ENABLE_SUBAGENTS: bool = True  # task tool for spawning subagents
+    # Human-in-the-loop: tools requiring approval (comma-separated)
+    # e.g. "write_file,edit_file,execute" or "all" for all tools
+    DEEPAGENTS_INTERRUPT_TOOLS: str | None = None
+    # Allowed decisions for interrupted tools: approve,edit,reject
+    DEEPAGENTS_ALLOWED_DECISIONS: str = "approve,edit,reject"
+{%- endif %}
 {%- endif %}
 
 {%- if cookiecutter.enable_cors %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/db/__init__.py

@@ -1,7 +1,14 @@
 """Database module."""
 {%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+{%- if cookiecutter.use_sqlalchemy %}
 
 from app.db.base import Base
 
 __all__ = ["Base"]
+{%- else %}
+# SQLModel uses SQLModel class directly as base, no separate Base class needed
+from app.db.base import TimestampMixin
+
+__all__ = ["TimestampMixin"]
+{%- endif %}
 {%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/db/base.py

@@ -1,4 +1,45 @@
 {%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+{%- if cookiecutter.use_sqlmodel %}
+"""SQLModel base model."""
+
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, MetaData, func
+from sqlmodel import Field, SQLModel
+
+# Naming convention for database constraints and indexes
+# This ensures consistent naming across all migrations
+NAMING_CONVENTION = {
+    "ix": "%(column_0_label)s_idx",
+    "uq": "%(table_name)s_%(column_0_name)s_key",
+    "ck": "%(table_name)s_%(constraint_name)s_check",
+    "fk": "%(table_name)s_%(column_0_name)s_fkey",
+    "pk": "%(table_name)s_pkey",
+}
+
+# Apply naming convention to SQLModel metadata
+SQLModel.metadata.naming_convention = NAMING_CONVENTION
+
+
+class TimestampMixin(SQLModel):
+    """Mixin for created_at and updated_at timestamps."""
+
+    created_at: datetime = Field(
+        sa_column=Column(
+            DateTime(timezone=True),
+            server_default=func.now(),
+            nullable=False,
+        ),
+    )
+    updated_at: datetime | None = Field(
+        default=None,
+        sa_column=Column(
+            DateTime(timezone=True),
+            onupdate=func.now(),
+            nullable=True,
+        ),
+    )
+{%- else %}
 """SQLAlchemy base model."""
 
 from datetime import datetime
@@ -36,6 +77,7 @@ class TimestampMixin:
         onupdate=func.now(),
         nullable=True,
     )
+{%- endif %}
 {%- else %}
 """Database base - not using SQLAlchemy."""
 {%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/db/models/conversation.py

@@ -1,4 +1,151 @@
-{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_postgresql %}
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_postgresql and cookiecutter.use_sqlmodel %}
+"""Conversation and message models for AI chat persistence using SQLModel."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.dialects.postgresql import JSONB, UUID as PG_UUID
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import TimestampMixin
+
+
+class Conversation(TimestampMixin, SQLModel, table=True):
+    """Conversation model - groups messages in a chat session.
+
+    Attributes:
+        id: Unique conversation identifier
+        user_id: Optional user who owns this conversation (if auth enabled)
+        title: Auto-generated or user-defined title
+        is_archived: Whether the conversation is archived
+        messages: List of messages in this conversation
+    """
+
+    __tablename__ = "conversations"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+{%- if cookiecutter.use_jwt %}
+    user_id: uuid.UUID | None = Field(
+        default=None,
+        sa_column=Column(
+            PG_UUID(as_uuid=True),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=True,
+            index=True,
+        ),
+    )
+{%- endif %}
+    title: str | None = Field(default=None, max_length=255)
+    is_archived: bool = Field(default=False)
+
+    # Relationships
+    messages: list["Message"] = Relationship(
+        back_populates="conversation",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan", "order_by": "Message.created_at"},
+    )
+
+    def __repr__(self) -> str:
+        return f"<Conversation(id={self.id}, title={self.title})>"
+
+
+class Message(TimestampMixin, SQLModel, table=True):
+    """Message model - individual message in a conversation.
+
+    Attributes:
+        id: Unique message identifier
+        conversation_id: The conversation this message belongs to
+        role: Message role (user, assistant, system)
+        content: Message text content
+        model_name: AI model used (for assistant messages)
+        tokens_used: Token count for this message
+        tool_calls: List of tool calls made in this message
+    """
+
+    __tablename__ = "messages"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    conversation_id: uuid.UUID = Field(
+        sa_column=Column(
+            PG_UUID(as_uuid=True),
+            ForeignKey("conversations.id", ondelete="CASCADE"),
+            nullable=False,
+            index=True,
+        ),
+    )
+    role: str = Field(max_length=20)  # user, assistant, system
+    content: str = Field(sa_column=Column(Text, nullable=False))
+    model_name: str | None = Field(default=None, max_length=100)
+    tokens_used: int | None = Field(default=None)
+
+    # Relationships
+    conversation: "Conversation" = Relationship(back_populates="messages")
+    tool_calls: list["ToolCall"] = Relationship(
+        back_populates="message",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan", "order_by": "ToolCall.started_at"},
+    )
+
+    def __repr__(self) -> str:
+        return f"<Message(id={self.id}, role={self.role})>"
+
+
+class ToolCall(SQLModel, table=True):
+    """ToolCall model - record of a tool invocation.
+
+    Attributes:
+        id: Unique tool call identifier
+        message_id: The assistant message that triggered this call
+        tool_call_id: External ID from PydanticAI
+        tool_name: Name of the tool that was called
+        args: JSON arguments passed to the tool
+        result: Result returned by the tool
+        status: Current status (pending, running, completed, failed)
+        started_at: When the tool call started
+        completed_at: When the tool call completed
+        duration_ms: Execution time in milliseconds
+    """
+
+    __tablename__ = "tool_calls"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    message_id: uuid.UUID = Field(
+        sa_column=Column(
+            PG_UUID(as_uuid=True),
+            ForeignKey("messages.id", ondelete="CASCADE"),
+            nullable=False,
+            index=True,
+        ),
+    )
+    tool_call_id: str = Field(max_length=100)
+    tool_name: str = Field(max_length=100)
+    args: dict = Field(default_factory=dict, sa_column=Column(JSONB, nullable=False, default=dict))
+    result: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    status: str = Field(default="pending", max_length=20)  # pending, running, completed, failed
+    started_at: datetime = Field(sa_column=Column(DateTime(timezone=True), nullable=False))
+    completed_at: datetime | None = Field(
+        default=None,
+        sa_column=Column(DateTime(timezone=True), nullable=True),
+    )
+    duration_ms: int | None = Field(default=None)
+
+    # Relationships
+    message: "Message" = Relationship(back_populates="tool_calls")
+
+    def __repr__(self) -> str:
+        return f"<ToolCall(id={self.id}, tool_name={self.tool_name}, status={self.status})>"
+
+
+{%- elif cookiecutter.enable_conversation_persistence and cookiecutter.use_postgresql %}
 """Conversation and message models for AI chat persistence."""
 
 import uuid
@@ -146,6 +293,120 @@ class ToolCall(Base):
         return f"<ToolCall(id={self.id}, tool_name={self.tool_name}, status={self.status})>"
 
 
+{%- elif cookiecutter.enable_conversation_persistence and cookiecutter.use_sqlite and cookiecutter.use_sqlmodel %}
+"""Conversation and message models for AI chat persistence using SQLModel."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import TimestampMixin
+
+
+class Conversation(TimestampMixin, SQLModel, table=True):
+    """Conversation model - groups messages in a chat session."""
+
+    __tablename__ = "conversations"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+{%- if cookiecutter.use_jwt %}
+    user_id: str | None = Field(
+        default=None,
+        sa_column=Column(
+            String(36),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=True,
+            index=True,
+        ),
+    )
+{%- endif %}
+    title: str | None = Field(default=None, max_length=255)
+    is_archived: bool = Field(default=False)
+
+    # Relationships
+    messages: list["Message"] = Relationship(
+        back_populates="conversation",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan", "order_by": "Message.created_at"},
+    )
+
+    def __repr__(self) -> str:
+        return f"<Conversation(id={self.id}, title={self.title})>"
+
+
+class Message(TimestampMixin, SQLModel, table=True):
+    """Message model - individual message in a conversation."""
+
+    __tablename__ = "messages"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    conversation_id: str = Field(
+        sa_column=Column(
+            String(36),
+            ForeignKey("conversations.id", ondelete="CASCADE"),
+            nullable=False,
+            index=True,
+        ),
+    )
+    role: str = Field(max_length=20)
+    content: str = Field(sa_column=Column(Text, nullable=False))
+    model_name: str | None = Field(default=None, max_length=100)
+    tokens_used: int | None = Field(default=None)
+
+    # Relationships
+    conversation: "Conversation" = Relationship(back_populates="messages")
+    tool_calls: list["ToolCall"] = Relationship(
+        back_populates="message",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan", "order_by": "ToolCall.started_at"},
+    )
+
+    def __repr__(self) -> str:
+        return f"<Message(id={self.id}, role={self.role})>"
+
+
+class ToolCall(SQLModel, table=True):
+    """ToolCall model - record of a tool invocation."""
+
+    __tablename__ = "tool_calls"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    message_id: str = Field(
+        sa_column=Column(
+            String(36),
+            ForeignKey("messages.id", ondelete="CASCADE"),
+            nullable=False,
+            index=True,
+        ),
+    )
+    tool_call_id: str = Field(max_length=100)
+    tool_name: str = Field(max_length=100)
+    args: str = Field(default="{}", sa_column=Column(Text, nullable=False, default="{}"))  # JSON as string
+    result: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    status: str = Field(default="pending", max_length=20)
+    started_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    completed_at: datetime | None = Field(
+        default=None,
+        sa_column=Column(DateTime, nullable=True),
+    )
+    duration_ms: int | None = Field(default=None)
+
+    # Relationships
+    message: "Message" = Relationship(back_populates="tool_calls")
+
+    def __repr__(self) -> str:
+        return f"<ToolCall(id={self.id}, tool_name={self.tool_name})>"
+
+
 {%- elif cookiecutter.enable_conversation_persistence and cookiecutter.use_sqlite %}
 """Conversation and message models for AI chat persistence."""
 

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/db/models/item.py

@@ -1,4 +1,42 @@
-{%- if cookiecutter.include_example_crud and cookiecutter.use_postgresql %}
+{%- if cookiecutter.include_example_crud and cookiecutter.use_postgresql and cookiecutter.use_sqlmodel %}
+"""Item database model using SQLModel - example CRUD entity."""
+
+import uuid
+
+from sqlalchemy import Column, String, Text
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlmodel import Field, SQLModel
+
+from app.db.base import TimestampMixin
+
+
+class Item(TimestampMixin, SQLModel, table=True):
+    """Item model - example entity for demonstrating CRUD operations.
+
+    This is a simple example model. You can use it as a template
+    for creating your own models or remove it if not needed.
+    """
+
+    __tablename__ = "items"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    title: str = Field(
+        sa_column=Column(String(255), nullable=False, index=True),
+    )
+    description: str | None = Field(
+        default=None,
+        sa_column=Column(Text, nullable=True),
+    )
+    is_active: bool = Field(default=True)
+
+    def __repr__(self) -> str:
+        return f"<Item(id={self.id}, title={self.title})>"
+
+
+{%- elif cookiecutter.include_example_crud and cookiecutter.use_postgresql %}
 """Item database model - example CRUD entity."""
 
 import uuid
@@ -30,6 +68,43 @@ class Item(Base, TimestampMixin):
         return f"<Item(id={self.id}, title={self.title})>"
 
 
+{%- elif cookiecutter.include_example_crud and cookiecutter.use_sqlite and cookiecutter.use_sqlmodel %}
+"""Item database model using SQLModel - example CRUD entity."""
+
+import uuid
+
+from sqlalchemy import Column, String, Text
+from sqlmodel import Field, SQLModel
+
+from app.db.base import TimestampMixin
+
+
+class Item(TimestampMixin, SQLModel, table=True):
+    """Item model - example entity for demonstrating CRUD operations.
+
+    This is a simple example model. You can use it as a template
+    for creating your own models or remove it if not needed.
+    """
+
+    __tablename__ = "items"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    title: str = Field(
+        sa_column=Column(String(255), nullable=False, index=True),
+    )
+    description: str | None = Field(
+        default=None,
+        sa_column=Column(Text, nullable=True),
+    )
+    is_active: bool = Field(default=True)
+
+    def __repr__(self) -> str:
+        return f"<Item(id={self.id}, title={self.title})>"
+
+
 {%- elif cookiecutter.include_example_crud and cookiecutter.use_sqlite %}
 """Item database model - example CRUD entity."""