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

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

@@ -1,5 +1,65 @@
 {%- if cookiecutter.enable_session_management and cookiecutter.use_jwt %}
-{%- if cookiecutter.use_postgresql %}
+{%- if cookiecutter.use_postgresql and cookiecutter.use_sqlmodel %}
+"""Session database model for tracking user sessions using SQLModel."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, ForeignKey, String, Text
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlmodel import Field, Relationship, SQLModel
+
+
+class Session(SQLModel, table=True):
+    """User session model for tracking active login sessions."""
+
+    __tablename__ = "sessions"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    user_id: uuid.UUID = Field(
+        sa_column=Column(
+            PG_UUID(as_uuid=True),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+    )
+    refresh_token_hash: str = Field(
+        sa_column=Column(String(255), nullable=False, index=True),
+    )
+    device_name: str | None = Field(default=None, max_length=255)
+    device_type: str | None = Field(default=None, max_length=50)
+    ip_address: str | None = Field(default=None, max_length=45)
+    user_agent: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    is_active: bool = Field(default=True)
+    created_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+    last_used_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+    expires_at: datetime = Field(
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+
+    # Relationship
+    user: "User" = Relationship(back_populates="sessions")
+
+    def __repr__(self) -> str:
+        return f"<Session(id={self.id}, user_id={self.user_id}, device={self.device_name})>"
+
+
+# Forward reference for type hints
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from app.db.models.user import User
+
+
+{%- elif cookiecutter.use_postgresql %}
 """Session database model for tracking user sessions."""
 
 import uuid
@@ -44,6 +104,63 @@ class Session(Base):
         return f"<Session(id={self.id}, user_id={self.user_id}, device={self.device_name})>"
 
 
+{%- elif cookiecutter.use_sqlite and cookiecutter.use_sqlmodel %}
+"""Session database model for tracking user sessions using SQLModel."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, ForeignKey, String, Text
+from sqlmodel import Field, Relationship, SQLModel
+
+
+class Session(SQLModel, table=True):
+    """User session model for tracking active login sessions."""
+
+    __tablename__ = "sessions"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    user_id: str = Field(
+        sa_column=Column(
+            String(36),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+    )
+    refresh_token_hash: str = Field(
+        sa_column=Column(String(255), nullable=False, index=True),
+    )
+    device_name: str | None = Field(default=None, max_length=255)
+    device_type: str | None = Field(default=None, max_length=50)
+    ip_address: str | None = Field(default=None, max_length=45)
+    user_agent: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    is_active: bool = Field(default=True)
+    created_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        sa_column=Column(DateTime, nullable=False),
+    )
+    last_used_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        sa_column=Column(DateTime, nullable=False),
+    )
+    expires_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+
+    # Relationship
+    user: "User" = Relationship(back_populates="sessions")
+
+    def __repr__(self) -> str:
+        return f"<Session(id={self.id}, user_id={self.user_id}, device={self.device_name})>"
+
+
+# Forward reference for type hints
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from app.db.models.user import User
+
+
 {%- elif cookiecutter.use_sqlite %}
 """Session database model for tracking user sessions."""
 

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

@@ -1,4 +1,83 @@
-{%- if cookiecutter.use_jwt and cookiecutter.use_postgresql %}
+{%- if cookiecutter.use_jwt and cookiecutter.use_postgresql and cookiecutter.use_sqlmodel %}
+"""User database model using SQLModel."""
+
+import uuid
+from enum import Enum
+{%- if cookiecutter.enable_session_management %}
+from typing import TYPE_CHECKING
+{%- endif %}
+
+from sqlalchemy import Column, String
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import 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(TimestampMixin, SQLModel, table=True):
+    """User model."""
+
+    __tablename__ = "users"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    email: str = Field(
+        sa_column=Column(String(255), unique=True, index=True, nullable=False),
+    )
+    hashed_password: str | None = Field(default=None, max_length=255)
+    full_name: str | None = Field(default=None, max_length=255)
+    is_active: bool = Field(default=True)
+    is_superuser: bool = Field(default=False)
+    role: str = Field(default=UserRole.USER.value, max_length=50)
+{%- if cookiecutter.enable_oauth %}
+    oauth_provider: str | None = Field(default=None, max_length=50)
+    oauth_id: str | None = Field(default=None, max_length=255)
+{%- endif %}
+
+{%- if cookiecutter.enable_session_management %}
+
+    # Relationship to sessions
+    sessions: list["Session"] = Relationship(back_populates="user")
+{%- 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_postgresql %}
 """User database model."""
 
 import uuid
@@ -76,6 +155,84 @@ class User(Base, TimestampMixin):
         return f"<User(id={self.id}, email={self.email}, role={self.role})>"
 
 
+{%- elif cookiecutter.use_jwt and cookiecutter.use_sqlite and cookiecutter.use_sqlmodel %}
+"""User database model using SQLModel."""
+
+import uuid
+from enum import Enum
+{%- if cookiecutter.enable_session_management %}
+from typing import TYPE_CHECKING
+{%- endif %}
+
+from sqlalchemy import Column, String
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import 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(TimestampMixin, SQLModel, table=True):
+    """User model."""
+
+    __tablename__ = "users"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    email: str = Field(
+        sa_column=Column(String(255), unique=True, index=True, nullable=False),
+    )
+    hashed_password: str | None = Field(default=None, max_length=255)
+    full_name: str | None = Field(default=None, max_length=255)
+    is_active: bool = Field(default=True)
+    is_superuser: bool = Field(default=False)
+    role: str = Field(default=UserRole.USER.value, max_length=50)
+{%- if cookiecutter.enable_oauth %}
+    oauth_provider: str | None = Field(default=None, max_length=50)
+    oauth_id: str | None = Field(default=None, max_length=255)
+{%- endif %}
+
+{%- if cookiecutter.enable_session_management %}
+
+    # Relationship to sessions
+    sessions: list["Session"] = Relationship(back_populates="user")
+{%- 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."""
 

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

@@ -1,5 +1,92 @@
 {%- if cookiecutter.enable_webhooks and cookiecutter.use_database %}
-{%- if cookiecutter.use_postgresql %}
+{%- if cookiecutter.use_postgresql and cookiecutter.use_sqlmodel %}
+"""Webhook database models using SQLModel (PostgreSQL async)."""
+
+import uuid
+from datetime import datetime
+from enum import Enum
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.dialects.postgresql import ARRAY, UUID as PG_UUID
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import 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(TimestampMixin, SQLModel, table=True):
+    """Webhook subscription model."""
+
+    __tablename__ = "webhooks"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    name: str = Field(max_length=255)
+    url: str = Field(max_length=2048)
+    secret: str = Field(max_length=255)
+    events: list[str] = Field(sa_column=Column(ARRAY(String), nullable=False))
+    is_active: bool = Field(default=True)
+    description: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+
+{%- if cookiecutter.use_jwt %}
+    user_id: uuid.UUID | None = Field(
+        default=None,
+        sa_column=Column(PG_UUID(as_uuid=True), ForeignKey("users.id"), nullable=True),
+    )
+{%- endif %}
+
+    # Relationship to delivery logs
+    deliveries: list["WebhookDelivery"] = Relationship(
+        back_populates="webhook",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan"},
+    )
+
+
+class WebhookDelivery(SQLModel, table=True):
+    """Webhook delivery log model."""
+
+    __tablename__ = "webhook_deliveries"
+
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        sa_column=Column(PG_UUID(as_uuid=True), primary_key=True),
+    )
+    webhook_id: uuid.UUID = Field(
+        sa_column=Column(PG_UUID(as_uuid=True), ForeignKey("webhooks.id"), nullable=False),
+    )
+    event_type: str = Field(max_length=100)
+    payload: str = Field(sa_column=Column(Text, nullable=False))
+    response_status: int | None = Field(default=None)
+    response_body: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    error_message: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    attempt_count: int = Field(default=1)
+    success: bool = Field(default=False)
+    created_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    delivered_at: datetime | None = Field(
+        default=None,
+        sa_column=Column(DateTime, nullable=True),
+    )
+
+    # Relationship
+    webhook: "Webhook" = Relationship(back_populates="deliveries")
+
+
+{%- elif cookiecutter.use_postgresql %}
 """Webhook database models (PostgreSQL async)."""
 
 import uuid
@@ -82,9 +169,106 @@ class WebhookDelivery(Base):
     webhook: Mapped["Webhook"] = relationship("Webhook", back_populates="deliveries")
 
 
+{%- elif cookiecutter.use_sqlite and cookiecutter.use_sqlmodel %}
+"""Webhook database models using SQLModel (SQLite sync)."""
+
+import json
+import uuid
+from datetime import datetime
+from enum import Enum
+
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlmodel import Field, Relationship, SQLModel
+
+from app.db.base import 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(TimestampMixin, SQLModel, table=True):
+    """Webhook subscription model."""
+
+    __tablename__ = "webhooks"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    name: str = Field(max_length=255)
+    url: str = Field(max_length=2048)
+    secret: str = Field(max_length=255)
+    # Store events as JSON string for SQLite
+    events_json: str = Field(sa_column=Column(Text, nullable=False))
+    is_active: bool = Field(default=True)
+    description: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+
+{%- if cookiecutter.use_jwt %}
+    user_id: str | None = Field(
+        default=None,
+        sa_column=Column(String(36), ForeignKey("users.id"), nullable=True),
+    )
+{%- endif %}
+
+    deliveries: list["WebhookDelivery"] = Relationship(
+        back_populates="webhook",
+        sa_relationship_kwargs={"cascade": "all, delete-orphan"},
+    )
+
+    @property
+    def events(self) -> list[str]:
+        """Parse events from JSON string."""
+        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."""
+        self.events_json = json.dumps(value)
+
+
+class WebhookDelivery(SQLModel, table=True):
+    """Webhook delivery log model."""
+
+    __tablename__ = "webhook_deliveries"
+
+    id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        sa_column=Column(String(36), primary_key=True),
+    )
+    webhook_id: str = Field(
+        sa_column=Column(String(36), ForeignKey("webhooks.id"), nullable=False),
+    )
+    event_type: str = Field(max_length=100)
+    payload: str = Field(sa_column=Column(Text, nullable=False))
+    response_status: int | None = Field(default=None)
+    response_body: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    error_message: str | None = Field(default=None, sa_column=Column(Text, nullable=True))
+    attempt_count: int = Field(default=1)
+    success: bool = Field(default=False)
+    created_at: datetime = Field(sa_column=Column(DateTime, nullable=False))
+    delivered_at: datetime | None = Field(
+        default=None,
+        sa_column=Column(DateTime, nullable=True),
+    )
+
+    webhook: "Webhook" = Relationship(back_populates="deliveries")
+
+
 {%- elif cookiecutter.use_sqlite %}
 """Webhook database models (SQLite sync)."""
 
+import json
 import uuid
 from datetime import datetime
 from enum import Enum
@@ -138,13 +322,11 @@ class Webhook(Base, TimestampMixin):
     @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)
 
 

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/main.py

@@ -17,7 +17,9 @@ from fastapi_pagination import add_pagination
 from app.api.exception_handlers import register_exception_handlers
 from app.api.router import api_router
 from app.core.config import settings
+{%- if cookiecutter.enable_logfire %}
 from app.core.logfire_setup import instrument_app, setup_logfire
+{%- endif %}
 from app.core.middleware import RequestIDMiddleware
 
 {%- if cookiecutter.enable_redis %}
@@ -39,7 +41,9 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[{% if cookiecutter.enable_red
     See: https://asgi.readthedocs.io/en/latest/specs/lifespan.html#lifespan-state
     """
     # === Startup ===
+{%- if cookiecutter.enable_logfire %}
     setup_logfire()
+{%- endif %}
 
 {%- if cookiecutter.use_postgresql and cookiecutter.enable_logfire and cookiecutter.logfire_database %}
     from app.core.logfire_setup import instrument_asyncpg
@@ -71,7 +75,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[{% if cookiecutter.enable_red
     await redis_client.connect()
 {%- endif %}
 
-{%- if cookiecutter.enable_caching %}
+{%- if cookiecutter.enable_caching and cookiecutter.enable_redis %}
     from app.core.cache import setup_cache
     setup_cache(redis_client)
 {%- endif %}
@@ -178,7 +182,7 @@ def create_app() -> FastAPI:
 
     app = FastAPI(
         title=settings.PROJECT_NAME,
-        summary="FastAPI application with Logfire observability",
+        summary="FastAPI application{% if cookiecutter.enable_logfire %} with Logfire observability{% endif %}",
         description="""
 {{ cookiecutter.project_description }}
 
@@ -233,8 +237,10 @@ def create_app() -> FastAPI:
 {%- endif %}
     )
 
+{%- if cookiecutter.enable_logfire %}
     # Logfire instrumentation
     instrument_app(app)
+{%- endif %}
 
     # Request ID middleware (for request correlation/debugging)
     app.add_middleware(RequestIDMiddleware)
@@ -263,6 +269,27 @@ def create_app() -> FastAPI:
         sentry_sdk.init(dsn=settings.SENTRY_DSN, enable_tracing=True)
 {%- endif %}
 
+{%- if cookiecutter.enable_prometheus %}
+
+    # Prometheus metrics
+    from prometheus_fastapi_instrumentator import Instrumentator
+
+    instrumentator = Instrumentator(
+        should_group_status_codes=True,
+        should_ignore_untemplated=True,
+        should_respect_env_var=True,
+        should_instrument_requests_inprogress=True,
+        excluded_handlers=["/health", "/health/ready", "/health/live", settings.PROMETHEUS_METRICS_PATH],
+        inprogress_name="http_requests_inprogress",
+        inprogress_labels=True,
+    )
+    instrumentator.instrument(app).expose(
+        app,
+        endpoint=settings.PROMETHEUS_METRICS_PATH,
+        include_in_schema=settings.PROMETHEUS_INCLUDE_IN_SCHEMA,
+    )
+{%- endif %}
+
 {%- if cookiecutter.enable_rate_limiting %}
 
     # Rate limiting

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

@@ -11,9 +11,15 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 {%- endif %}
 
+{%- if cookiecutter.use_sqlmodel %}
+from sqlmodel import SQLModel
+
+ModelType = TypeVar("ModelType", bound=SQLModel)
+{%- else %}
 from app.db.base import Base
 
 ModelType = TypeVar("ModelType", bound=Base)
+{%- endif %}
 CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
 UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
 

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

@@ -2,7 +2,7 @@
 {%- if cookiecutter.use_postgresql %}
 """Session repository (PostgreSQL async)."""
 
-from datetime import datetime
+from datetime import UTC, datetime
 from uuid import UUID
 
 from sqlalchemy import select, update
@@ -74,7 +74,7 @@ async def update_last_used(db: AsyncSession, session_id: UUID) -> None:
     await db.execute(
         update(Session)
         .where(Session.id == session_id)
-        .values(last_used_at=datetime.utcnow())
+        .values(last_used_at=datetime.now(UTC))
     )
     await db.flush()
 
@@ -113,7 +113,7 @@ async def deactivate_by_refresh_token_hash(db: AsyncSession, token_hash: str) ->
 {%- elif cookiecutter.use_sqlite %}
 """Session repository (SQLite sync)."""
 
-from datetime import datetime
+from datetime import UTC, datetime
 
 from sqlalchemy import select, update
 from sqlalchemy.orm import Session as DBSession
@@ -184,7 +184,7 @@ def update_last_used(db: DBSession, session_id: str) -> None:
     db.execute(
         update(Session)
         .where(Session.id == session_id)
-        .values(last_used_at=datetime.utcnow())
+        .values(last_used_at=datetime.now(UTC))
     )
     db.flush()