fastapi-fullstack 0.1.2__py3-none-any.whl

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

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

@@ -0,0 +1,218 @@
+{%- if cookiecutter.use_jwt and cookiecutter.use_postgresql %}
+"""User database model."""
+
+import uuid
+from enum import Enum
+{%- if cookiecutter.enable_session_management %}
+from typing import TYPE_CHECKING
+{%- endif %}
+
+from sqlalchemy import Boolean, String
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column{% if cookiecutter.enable_session_management %}, relationship{% endif %}
+
+from app.db.base import Base, TimestampMixin
+
+{%- if cookiecutter.enable_session_management %}
+if TYPE_CHECKING:
+    from app.db.models.session import Session
+{%- endif %}
+
+
+class UserRole(str, Enum):
+    """User role enumeration.
+
+    Roles hierarchy (higher includes lower permissions):
+    - ADMIN: Full system access, can manage users and settings
+    - USER: Standard user access
+    """
+
+    ADMIN = "admin"
+    USER = "user"
+
+
+class User(Base, TimestampMixin):
+    """User model."""
+
+    __tablename__ = "users"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True, nullable=False)
+    hashed_password: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    full_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    role: Mapped[str] = mapped_column(String(50), default=UserRole.USER.value, nullable=False)
+{%- if cookiecutter.enable_oauth %}
+    oauth_provider: Mapped[str | None] = mapped_column(String(50), nullable=True, index=True)
+    oauth_id: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+{%- endif %}
+
+{%- if cookiecutter.enable_session_management %}
+
+    # Relationship to sessions
+    sessions: Mapped[list["Session"]] = relationship(
+        "Session", back_populates="user", cascade="all, delete-orphan"
+    )
+{%- endif %}
+
+    @property
+    def user_role(self) -> UserRole:
+        """Get role as enum."""
+        return UserRole(self.role)
+
+    def has_role(self, required_role: UserRole) -> bool:
+        """Check if user has the required role or higher.
+
+        Admin role has access to everything.
+        """
+        if self.role == UserRole.ADMIN.value:
+            return True
+        return self.role == required_role.value
+
+    def __repr__(self) -> str:
+        return f"<User(id={self.id}, email={self.email}, role={self.role})>"
+
+
+{%- elif cookiecutter.use_jwt and cookiecutter.use_sqlite %}
+"""User database model."""
+
+import uuid
+from enum import Enum
+{%- if cookiecutter.enable_session_management %}
+from typing import TYPE_CHECKING
+{%- endif %}
+
+from sqlalchemy import Boolean, String
+from sqlalchemy.orm import Mapped, mapped_column{% if cookiecutter.enable_session_management %}, relationship{% endif %}
+
+from app.db.base import Base, TimestampMixin
+
+{%- if cookiecutter.enable_session_management %}
+if TYPE_CHECKING:
+    from app.db.models.session import Session
+{%- endif %}
+
+
+class UserRole(str, Enum):
+    """User role enumeration.
+
+    Roles hierarchy (higher includes lower permissions):
+    - ADMIN: Full system access, can manage users and settings
+    - USER: Standard user access
+    """
+
+    ADMIN = "admin"
+    USER = "user"
+
+
+class User(Base, TimestampMixin):
+    """User model."""
+
+    __tablename__ = "users"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True, nullable=False)
+    hashed_password: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    full_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    role: Mapped[str] = mapped_column(String(50), default=UserRole.USER.value, nullable=False)
+{%- if cookiecutter.enable_oauth %}
+    oauth_provider: Mapped[str | None] = mapped_column(String(50), nullable=True, index=True)
+    oauth_id: Mapped[str | None] = mapped_column(String(255), nullable=True, index=True)
+{%- endif %}
+
+{%- if cookiecutter.enable_session_management %}
+
+    # Relationship to sessions
+    sessions: Mapped[list["Session"]] = relationship(
+        "Session", back_populates="user", cascade="all, delete-orphan"
+    )
+{%- endif %}
+
+    @property
+    def user_role(self) -> UserRole:
+        """Get role as enum."""
+        return UserRole(self.role)
+
+    def has_role(self, required_role: UserRole) -> bool:
+        """Check if user has the required role or higher.
+
+        Admin role has access to everything.
+        """
+        if self.role == UserRole.ADMIN.value:
+            return True
+        return self.role == required_role.value
+
+    def __repr__(self) -> str:
+        return f"<User(id={self.id}, email={self.email}, role={self.role})>"
+
+
+{%- elif cookiecutter.use_jwt and cookiecutter.use_mongodb %}
+"""User document model for MongoDB."""
+
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Optional
+
+from beanie import Document
+from pydantic import EmailStr, Field
+
+
+class UserRole(str, Enum):
+    """User role enumeration.
+
+    Roles hierarchy (higher includes lower permissions):
+    - ADMIN: Full system access, can manage users and settings
+    - USER: Standard user access
+    """
+
+    ADMIN = "admin"
+    USER = "user"
+
+
+class User(Document):
+    """User document model."""
+
+    email: EmailStr
+    hashed_password: Optional[str] = None
+    full_name: Optional[str] = None
+    is_active: bool = True
+    is_superuser: bool = False
+    role: str = UserRole.USER.value
+{%- if cookiecutter.enable_oauth %}
+    oauth_provider: Optional[str] = None
+    oauth_id: Optional[str] = None
+{%- endif %}
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: Optional[datetime] = None
+
+    @property
+    def user_role(self) -> UserRole:
+        """Get role as enum."""
+        return UserRole(self.role)
+
+    def has_role(self, required_role: UserRole) -> bool:
+        """Check if user has the required role or higher.
+
+        Admin role has access to everything.
+        """
+        if self.role == UserRole.ADMIN.value:
+            return True
+        return self.role == required_role.value
+
+    class Settings:
+        name = "users"
+        indexes = [
+            "email",
+        ]
+
+
+{%- else %}
+"""User model - not configured."""
+{%- endif %}

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

@@ -0,0 +1,244 @@
+{%- if cookiecutter.enable_webhooks and cookiecutter.use_database %}
+{%- if cookiecutter.use_postgresql %}
+"""Webhook database models (PostgreSQL async)."""
+
+import uuid
+from datetime import datetime
+from enum import Enum
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.dialects.postgresql import ARRAY, UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.base import Base, TimestampMixin
+
+
+class WebhookEventType(str, Enum):
+    """Webhook event types."""
+
+    # User events
+    USER_CREATED = "user.created"
+    USER_UPDATED = "user.updated"
+    USER_DELETED = "user.deleted"
+
+    # Custom events (extend as needed)
+    ITEM_CREATED = "item.created"
+    ITEM_UPDATED = "item.updated"
+    ITEM_DELETED = "item.deleted"
+
+
+class Webhook(Base, TimestampMixin):
+    """Webhook subscription model."""
+
+    __tablename__ = "webhooks"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    url: Mapped[str] = mapped_column(String(2048), nullable=False)
+    secret: Mapped[str] = mapped_column(String(255), nullable=False)
+    events: Mapped[list[str]] = mapped_column(ARRAY(String), nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    # Optional: Associate webhook with a user
+{%- if cookiecutter.use_jwt %}
+    user_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("users.id"), nullable=True
+    )
+{%- endif %}
+
+    # Relationship to delivery logs
+    deliveries: Mapped[list["WebhookDelivery"]] = relationship(
+        "WebhookDelivery", back_populates="webhook", cascade="all, delete-orphan"
+    )
+
+
+class WebhookDelivery(Base):
+    """Webhook delivery log model."""
+
+    __tablename__ = "webhook_deliveries"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    webhook_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("webhooks.id"), nullable=False
+    )
+    event_type: Mapped[str] = mapped_column(String(100), nullable=False)
+    payload: Mapped[str] = mapped_column(Text, nullable=False)
+    response_status: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    response_body: Mapped[str | None] = mapped_column(Text, nullable=True)
+    error_message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    attempt_count: Mapped[int] = mapped_column(Integer, default=1, nullable=False)
+    success: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=datetime.utcnow, nullable=False
+    )
+    delivered_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+
+    # Relationship
+    webhook: Mapped["Webhook"] = relationship("Webhook", back_populates="deliveries")
+
+
+{%- elif cookiecutter.use_sqlite %}
+"""Webhook database models (SQLite sync)."""
+
+import uuid
+from datetime import datetime
+from enum import Enum
+
+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 WebhookEventType(str, Enum):
+    """Webhook event types."""
+
+    # User events
+    USER_CREATED = "user.created"
+    USER_UPDATED = "user.updated"
+    USER_DELETED = "user.deleted"
+
+    # Custom events (extend as needed)
+    ITEM_CREATED = "item.created"
+    ITEM_UPDATED = "item.updated"
+    ITEM_DELETED = "item.deleted"
+
+
+class Webhook(Base, TimestampMixin):
+    """Webhook subscription model."""
+
+    __tablename__ = "webhooks"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    url: Mapped[str] = mapped_column(String(2048), nullable=False)
+    secret: Mapped[str] = mapped_column(String(255), nullable=False)
+    # Store events as comma-separated string for SQLite
+    events_json: Mapped[str] = mapped_column(Text, nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+{%- if cookiecutter.use_jwt %}
+    user_id: Mapped[str | None] = mapped_column(
+        String(36), ForeignKey("users.id"), nullable=True
+    )
+{%- endif %}
+
+    deliveries: Mapped[list["WebhookDelivery"]] = relationship(
+        "WebhookDelivery", back_populates="webhook", cascade="all, delete-orphan"
+    )
+
+    @property
+    def events(self) -> list[str]:
+        """Parse events from JSON string."""
+        import json
+        return json.loads(self.events_json) if self.events_json else []
+
+    @events.setter
+    def events(self, value: list[str]) -> None:
+        """Store events as JSON string."""
+        import json
+        self.events_json = json.dumps(value)
+
+
+class WebhookDelivery(Base):
+    """Webhook delivery log model."""
+
+    __tablename__ = "webhook_deliveries"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    webhook_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("webhooks.id"), nullable=False
+    )
+    event_type: Mapped[str] = mapped_column(String(100), nullable=False)
+    payload: Mapped[str] = mapped_column(Text, nullable=False)
+    response_status: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    response_body: Mapped[str | None] = mapped_column(Text, nullable=True)
+    error_message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    attempt_count: Mapped[int] = mapped_column(Integer, default=1, nullable=False)
+    success: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=datetime.utcnow, nullable=False
+    )
+    delivered_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+
+    webhook: Mapped["Webhook"] = relationship("Webhook", back_populates="deliveries")
+
+
+{%- elif cookiecutter.use_mongodb %}
+"""Webhook document models (MongoDB)."""
+
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Optional
+
+from beanie import Document
+from pydantic import Field
+
+
+class WebhookEventType(str, Enum):
+    """Webhook event types."""
+
+    # User events
+    USER_CREATED = "user.created"
+    USER_UPDATED = "user.updated"
+    USER_DELETED = "user.deleted"
+
+    # Custom events
+    ITEM_CREATED = "item.created"
+    ITEM_UPDATED = "item.updated"
+    ITEM_DELETED = "item.deleted"
+
+
+class WebhookDelivery(Document):
+    """Webhook delivery log document."""
+
+    webhook_id: str
+    event_type: str
+    payload: str
+    response_status: Optional[int] = None
+    response_body: Optional[str] = None
+    error_message: Optional[str] = None
+    attempt_count: int = 1
+    success: bool = False
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    delivered_at: Optional[datetime] = None
+
+    class Settings:
+        name = "webhook_deliveries"
+        indexes = ["webhook_id", "event_type", "created_at"]
+
+
+class Webhook(Document):
+    """Webhook subscription document."""
+
+    name: str
+    url: str
+    secret: str
+    events: list[str]
+    is_active: bool = True
+    description: Optional[str] = None
+{%- if cookiecutter.use_jwt %}
+    user_id: Optional[str] = None
+{%- endif %}
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: Optional[datetime] = None
+
+    class Settings:
+        name = "webhooks"
+        indexes = ["events", "is_active"]
+
+
+{%- endif %}
+{%- else %}
+"""Webhook models - not configured."""
+{%- endif %}

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

@@ -0,0 +1,113 @@
+{%- if cookiecutter.use_postgresql %}
+"""Async PostgreSQL database session."""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.core.config import settings
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=settings.DEBUG,
+    pool_size=settings.DB_POOL_SIZE,
+    max_overflow=settings.DB_MAX_OVERFLOW,
+    pool_timeout=settings.DB_POOL_TIMEOUT,
+)
+
+async_session_maker = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+@asynccontextmanager
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """Get async database session.
+
+    Can be used both as a FastAPI dependency and as an async context manager.
+    """
+    async with async_session_maker() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+
+async def close_db() -> None:
+    """Close database connections."""
+    await engine.dispose()
+
+
+{%- elif cookiecutter.use_mongodb %}
+"""Async MongoDB database session."""
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+
+from app.core.config import settings
+
+client: AsyncIOMotorClient | None = None
+
+
+async def get_db_session() -> AsyncIOMotorDatabase:
+    """Get MongoDB database instance."""
+    global client
+    if client is None:
+        client = AsyncIOMotorClient(settings.MONGO_URL)
+    return client[settings.MONGO_DB]
+
+
+async def close_db() -> None:
+    """Close MongoDB connection."""
+    global client
+    if client is not None:
+        client.close()
+        client = None
+
+
+{%- elif cookiecutter.use_sqlite %}
+"""Sync SQLite database session."""
+
+from collections.abc import Generator
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from app.core.config import settings
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False},
+    echo=settings.DEBUG,
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def get_db_session() -> Generator[Session, None, None]:
+    """Get sync database session."""
+    db = SessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+{%- else %}
+"""No database configured."""
+
+
+async def get_db_session():
+    """No-op when database is disabled."""
+    yield None
+{%- endif %}