fastapi-fullstack 0.1.7__py3-none-any.whl

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 %}

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

@@ -0,0 +1,126 @@
+{%- if cookiecutter.enable_session_management and cookiecutter.use_jwt %}
+{%- if cookiecutter.use_postgresql %}
+"""Session database model for tracking user sessions."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, String, Text
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.base import Base
+
+
+class Session(Base):
+    """User session model for tracking active login sessions."""
+
+    __tablename__ = "sessions"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    user_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    refresh_token_hash: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    device_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    device_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
+    ip_address: Mapped[str | None] = mapped_column(String(45), nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=datetime.utcnow, nullable=False
+    )
+    last_used_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=datetime.utcnow, nullable=False
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+
+    # Relationship
+    user = relationship("User", back_populates="sessions")
+
+    def __repr__(self) -> str:
+        return f"<Session(id={self.id}, user_id={self.user_id}, device={self.device_name})>"
+
+
+{%- elif cookiecutter.use_sqlite %}
+"""Session database model for tracking user sessions."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.base import Base
+
+
+class Session(Base):
+    """User session model for tracking active login sessions."""
+
+    __tablename__ = "sessions"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    user_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    refresh_token_hash: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    device_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    device_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
+    ip_address: Mapped[str | None] = mapped_column(String(45), nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=datetime.utcnow, nullable=False
+    )
+    last_used_at: Mapped[datetime] = mapped_column(
+        DateTime, default=datetime.utcnow, nullable=False
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    # Relationship
+    user = relationship("User", back_populates="sessions")
+
+    def __repr__(self) -> str:
+        return f"<Session(id={self.id}, user_id={self.user_id}, device={self.device_name})>"
+
+
+{%- elif cookiecutter.use_mongodb %}
+"""Session document model for tracking user sessions."""
+
+from datetime import UTC, datetime
+from typing import Optional
+
+from beanie import Document, Link
+from pydantic import Field
+
+
+class Session(Document):
+    """User session document for tracking active login sessions."""
+
+    user_id: str
+    refresh_token_hash: str
+    device_name: Optional[str] = None
+    device_type: Optional[str] = None
+    ip_address: Optional[str] = None
+    user_agent: Optional[str] = None
+    is_active: bool = True
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    last_used_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    expires_at: datetime
+
+    class Settings:
+        name = "sessions"
+        indexes = [
+            "user_id",
+            "refresh_token_hash",
+        ]
+
+
+{%- endif %}
+{%- else %}
+"""Session model - not configured."""
+{%- endif %}