fastapi-fullstack 0.1.2__py3-none-any.whl

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

@@ -0,0 +1,102 @@
+{%- if cookiecutter.use_jwt %}
+"""Security utilities for JWT authentication."""
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import bcrypt
+import jwt
+
+from app.core.config import settings
+
+
+def create_access_token(
+    subject: str | Any,
+    expires_delta: timedelta | None = None,
+) -> str:
+    """Create a JWT access token."""
+    if expires_delta:
+        expire = datetime.now(UTC) + expires_delta
+    else:
+        expire = datetime.now(UTC) + timedelta(
+            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+        )
+
+    to_encode = {"exp": expire, "sub": str(subject), "type": "access"}
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+
+
+def create_refresh_token(
+    subject: str | Any,
+    expires_delta: timedelta | None = None,
+) -> str:
+    """Create a JWT refresh token."""
+    if expires_delta:
+        expire = datetime.now(UTC) + expires_delta
+    else:
+        expire = datetime.now(UTC) + timedelta(
+            minutes=settings.REFRESH_TOKEN_EXPIRE_MINUTES
+        )
+
+    to_encode = {"exp": expire, "sub": str(subject), "type": "refresh"}
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+
+
+def verify_token(token: str) -> dict[str, Any] | None:
+    """Verify a JWT token and return payload."""
+    try:
+        payload = jwt.decode(
+            token,
+            settings.SECRET_KEY,
+            algorithms=[settings.ALGORITHM],
+        )
+        return payload
+    except jwt.PyJWTError:
+        return None
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against a hash."""
+    return bcrypt.checkpw(
+        plain_password.encode("utf-8"),
+        hashed_password.encode("utf-8"),
+    )
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password."""
+    return bcrypt.hashpw(
+        password.encode("utf-8"),
+        bcrypt.gensalt(),
+    ).decode("utf-8")
+
+
+{%- elif cookiecutter.use_api_key %}
+"""Security utilities for API Key authentication."""
+
+from fastapi import HTTPException, Security, status
+from fastapi.security import APIKeyHeader
+
+from app.core.config import settings
+
+api_key_header = APIKeyHeader(name=settings.API_KEY_HEADER, auto_error=False)
+
+
+async def verify_api_key(api_key: str = Security(api_key_header)) -> str:
+    """Verify API key from header."""
+    if api_key is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="API Key header missing",
+        )
+    if api_key != settings.API_KEY:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid API Key",
+        )
+    return api_key
+
+
+{%- else %}
+"""Security - not configured."""
+{%- endif %}

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

@@ -0,0 +1,7 @@
+"""Database module."""
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+
+from app.db.base import Base
+
+__all__ = ["Base"]
+{%- endif %}

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

@@ -0,0 +1,41 @@
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+"""SQLAlchemy base model."""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, MetaData, func
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+# 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",
+}
+
+
+class Base(DeclarativeBase):
+    """Base class for all SQLAlchemy models."""
+
+    metadata = MetaData(naming_convention=NAMING_CONVENTION)
+
+
+class TimestampMixin:
+    """Mixin for created_at and updated_at timestamps."""
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        onupdate=func.now(),
+        nullable=True,
+    )
+{%- else %}
+"""Database base - not using SQLAlchemy."""
+{%- endif %}

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

@@ -0,0 +1,31 @@
+"""Database models."""
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+# ruff: noqa: I001, RUF022 - Imports structured for Jinja2 template conditionals
+{%- endif %}
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+{%- set models = [] %}
+{%- if cookiecutter.use_jwt %}
+{%- set _ = models.append("User") %}
+from app.db.models.user import User
+{%- endif %}
+{%- if cookiecutter.enable_session_management and cookiecutter.use_jwt %}
+{%- set _ = models.append("Session") %}
+from app.db.models.session import Session
+{%- endif %}
+{%- if cookiecutter.include_example_crud %}
+{%- set _ = models.append("Item") %}
+from app.db.models.item import Item
+{%- endif %}
+{%- if cookiecutter.enable_conversation_persistence %}
+{%- set _ = models.extend(["Conversation", "Message", "ToolCall"]) %}
+from app.db.models.conversation import Conversation, Message, ToolCall
+{%- endif %}
+{%- if cookiecutter.enable_webhooks %}
+{%- set _ = models.extend(["Webhook", "WebhookDelivery"]) %}
+from app.db.models.webhook import Webhook, WebhookDelivery
+{%- endif %}
+{%- if models %}
+
+__all__ = {{ models }}
+{%- endif %}
+{%- endif %}

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

@@ -0,0 +1,319 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_postgresql %}
+"""Conversation and message models for AI chat persistence."""
+
+import uuid
+from datetime import datetime
+from typing import Literal
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.base import Base, TimestampMixin
+
+
+class Conversation(Base, TimestampMixin):
+    """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: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+{%- if cookiecutter.use_jwt %}
+    user_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=True,
+        index=True,
+    )
+{%- endif %}
+    title: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    is_archived: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    # Relationships
+    messages: Mapped[list["Message"]] = relationship(
+        "Message",
+        back_populates="conversation",
+        cascade="all, delete-orphan",
+        order_by="Message.created_at",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Conversation(id={self.id}, title={self.title})>"
+
+
+class Message(Base, TimestampMixin):
+    """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: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    conversation_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("conversations.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    role: Mapped[str] = mapped_column(
+        String(20), nullable=False
+    )  # user, assistant, system
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    model_name: Mapped[str | None] = mapped_column(String(100), nullable=True)
+    tokens_used: Mapped[int | None] = mapped_column(Integer, nullable=True)
+
+    # Relationships
+    conversation: Mapped["Conversation"] = relationship(
+        "Conversation", back_populates="messages"
+    )
+    tool_calls: Mapped[list["ToolCall"]] = relationship(
+        "ToolCall",
+        back_populates="message",
+        cascade="all, delete-orphan",
+        order_by="ToolCall.started_at",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Message(id={self.id}, role={self.role})>"
+
+
+class ToolCall(Base):
+    """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: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    message_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("messages.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    tool_call_id: Mapped[str] = mapped_column(String(100), nullable=False)
+    tool_name: Mapped[str] = mapped_column(String(100), nullable=False)
+    args: Mapped[dict] = mapped_column(JSONB, nullable=False, default=dict)
+    result: Mapped[str | None] = mapped_column(Text, nullable=True)
+    status: Mapped[str] = mapped_column(
+        String(20), nullable=False, default="pending"
+    )  # pending, running, completed, failed
+    started_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False
+    )
+    completed_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
+    duration_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
+
+    # Relationships
+    message: Mapped["Message"] = relationship("Message", 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_sqlite %}
+"""Conversation and message models for AI chat persistence."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.base import Base, TimestampMixin
+
+
+class Conversation(Base, TimestampMixin):
+    """Conversation model - groups messages in a chat session."""
+
+    __tablename__ = "conversations"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+{%- if cookiecutter.use_jwt %}
+    user_id: Mapped[str | None] = mapped_column(
+        String(36),
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=True,
+        index=True,
+    )
+{%- endif %}
+    title: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    is_archived: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    # Relationships
+    messages: Mapped[list["Message"]] = relationship(
+        "Message",
+        back_populates="conversation",
+        cascade="all, delete-orphan",
+        order_by="Message.created_at",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Conversation(id={self.id}, title={self.title})>"
+
+
+class Message(Base, TimestampMixin):
+    """Message model - individual message in a conversation."""
+
+    __tablename__ = "messages"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    conversation_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("conversations.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    role: Mapped[str] = mapped_column(String(20), nullable=False)
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    model_name: Mapped[str | None] = mapped_column(String(100), nullable=True)
+    tokens_used: Mapped[int | None] = mapped_column(Integer, nullable=True)
+
+    # Relationships
+    conversation: Mapped["Conversation"] = relationship(
+        "Conversation", back_populates="messages"
+    )
+    tool_calls: Mapped[list["ToolCall"]] = relationship(
+        "ToolCall",
+        back_populates="message",
+        cascade="all, delete-orphan",
+        order_by="ToolCall.started_at",
+    )
+
+    def __repr__(self) -> str:
+        return f"<Message(id={self.id}, role={self.role})>"
+
+
+class ToolCall(Base):
+    """ToolCall model - record of a tool invocation."""
+
+    __tablename__ = "tool_calls"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    message_id: Mapped[str] = mapped_column(
+        String(36),
+        ForeignKey("messages.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    tool_call_id: Mapped[str] = mapped_column(String(100), nullable=False)
+    tool_name: Mapped[str] = mapped_column(String(100), nullable=False)
+    args: Mapped[str] = mapped_column(Text, nullable=False, default="{}")  # JSON as string
+    result: Mapped[str | None] = mapped_column(Text, nullable=True)
+    status: Mapped[str] = mapped_column(String(20), nullable=False, default="pending")
+    started_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    completed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    duration_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
+
+    # Relationships
+    message: Mapped["Message"] = relationship("Message", 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_mongodb %}
+"""Conversation and message models for AI chat persistence (MongoDB)."""
+
+from datetime import UTC, datetime
+from typing import Literal, Optional
+
+from beanie import Document, Link
+from pydantic import Field
+
+
+class ToolCall(Document):
+    """ToolCall document model - record of a tool invocation."""
+
+    message_id: str
+    tool_call_id: str
+    tool_name: str
+    args: dict = Field(default_factory=dict)
+    result: Optional[str] = None
+    status: Literal["pending", "running", "completed", "failed"] = "pending"
+    started_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    completed_at: Optional[datetime] = None
+    duration_ms: Optional[int] = None
+
+    class Settings:
+        name = "tool_calls"
+        indexes = ["message_id"]
+
+
+class Message(Document):
+    """Message document model - individual message in a conversation."""
+
+    conversation_id: str
+    role: Literal["user", "assistant", "system"]
+    content: str
+    model_name: Optional[str] = None
+    tokens_used: Optional[int] = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+    class Settings:
+        name = "messages"
+        indexes = ["conversation_id"]
+
+
+class Conversation(Document):
+    """Conversation document model - groups messages in a chat session."""
+
+{%- if cookiecutter.use_jwt %}
+    user_id: Optional[str] = None
+{%- endif %}
+    title: Optional[str] = None
+    is_archived: bool = False
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: Optional[datetime] = None
+
+    class Settings:
+        name = "conversations"
+{%- if cookiecutter.use_jwt %}
+        indexes = ["user_id"]
+{%- endif %}
+
+
+{%- else %}
+"""Conversation models - not configured."""
+{%- endif %}

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

@@ -0,0 +1,96 @@
+{%- if cookiecutter.include_example_crud and cookiecutter.use_postgresql %}
+"""Item database model - example CRUD entity."""
+
+import uuid
+
+from sqlalchemy import String, Text
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base, TimestampMixin
+
+
+class Item(Base, TimestampMixin):
+    """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: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    title: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    is_active: Mapped[bool] = mapped_column(default=True, nullable=False)
+
+    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."""
+
+import uuid
+
+from sqlalchemy import Boolean, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base, TimestampMixin
+
+
+class Item(Base, TimestampMixin):
+    """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: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    title: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<Item(id={self.id}, title={self.title})>"
+
+
+{%- elif cookiecutter.include_example_crud and cookiecutter.use_mongodb %}
+"""Item document model for MongoDB - example CRUD entity."""
+
+from datetime import UTC, datetime
+from typing import Optional
+
+from beanie import Document
+from pydantic import Field
+
+
+class Item(Document):
+    """Item document 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.
+    """
+
+    title: str = Field(max_length=255)
+    description: Optional[str] = None
+    is_active: bool = True
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: Optional[datetime] = None
+
+    class Settings:
+        name = "items"
+        indexes = [
+            "title",
+        ]
+
+
+{%- else %}
+"""Item model - not configured."""
+{%- endif %}