logger added, tier related models and schemas, user model and schemas updated

Author: igorbenav

src/app/api/dependencies.py

@@ -1,10 +1,16 @@
 from typing import Annotated
 
 from app.core.security import SECRET_KEY, ALGORITHM, oauth2_scheme
+from app.core.config import RedisRateLimiterSettings, settings
 
 from sqlalchemy.ext.asyncio import AsyncSession
 from jose import JWTError, jwt
-from fastapi import Depends, HTTPException
+from fastapi import (
+    Depends, 
+    HTTPException, 
+    Request, 
+    status
+)
 
 from app.core.database import async_get_db
 from app.core.models import TokenData

src/app/core/config.py

@@ -85,9 +85,9 @@ class RedisQueueSettings(BaseSettings):
 
 
 class RedisRateLimiterSettings(BaseSettings):
-    REDIS_RATE_LIMITER_HOST: str = config("REDIS_RATE_LIMITER_HOST", default="localhost")
-    REDIS_RATE_LIMITER_PORT: int = config("REDIS_RATE_LIMITER_PORT", default=6379)
-    REDIS_RATE_LIMITER_URL: str = f"redis://{REDIS_RATE_LIMITER_HOST}:{REDIS_RATE_LIMITER_PORT}"
+    REDIS_RATE_LIMIT_HOST: str = config("REDIS_RATE_LIMIT_HOST", default="localhost")
+    REDIS_RATE_LIMIT_PORT: int = config("REDIS_RATE_LIMIT_PORT", default=6379)
+    REDIS_RATE_LIMIT_URL: str = f"redis://{REDIS_RATE_LIMIT_HOST}:{REDIS_RATE_LIMIT_PORT}"
 
 
 class EnvironmentOption(Enum):

src/app/core/logger.py

@@ -0,0 +1,20 @@
+import logging
+from logging.handlers import RotatingFileHandler
+import os
+
+LOG_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'logs')
+if not os.path.exists(LOG_DIR):
+    os.makedirs(LOG_DIR)
+
+LOG_FILE_PATH = os.path.join(LOG_DIR, 'app.log')
+
+LOGGING_LEVEL = logging.INFO
+LOGGING_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+logging.basicConfig(level=LOGGING_LEVEL, format=LOGGING_FORMAT)
+
+file_handler = RotatingFileHandler(LOG_FILE_PATH, maxBytes=10485760, backupCount=5)
+file_handler.setLevel(LOGGING_LEVEL)
+file_handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
+
+logging.getLogger('').addHandler(file_handler)

src/app/core/rate_limit.py

@@ -1,9 +1,15 @@
-import time
+from datetime import datetime
+from typing import Union, Dict
 
 from fastapi import HTTPException, Request, Depends, status
 from redis.asyncio import Redis, ConnectionPool
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.dependencies import get_current_user
+from app.core.logger import logging
+from app.schemas.user import UserRead
+from app.schemas.tier import TierRead
+
+logger = logging.getLogger(__name__)
 
 pool: ConnectionPool | None = None
 client: Redis | None = None

src/app/logs/README.MD

@@ -0,0 +1,54 @@
+from typing import Optional, List
+from datetime import datetime
+
+from sqlalchemy import String, DateTime, ForeignKey, Integer
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.core.database import Base
+
+class RateLimit(Base):
+    __tablename__ = "rate_limit"
+    
+    id: Mapped[int] = mapped_column(
+        "id", autoincrement=True, nullable=False, unique=True, primary_key=True, init=False
+    )
+    name: Mapped[str] = mapped_column(String, nullable=False, unique=True)
+    path: Mapped[str] = mapped_column(String, nullable=False)
+    limit: Mapped[int] = mapped_column(Integer, nullable=False)
+    period: Mapped[int] = mapped_column(Integer, nullable=False)
+
+    tier_rate_limits: Mapped["TierRateLimit"] = relationship(back_populates="rate_limit", cascade="all, delete", lazy="selectin", default_factory=list)
+
+
+class Tier(Base):
+    __tablename__ = "tier"
+
+    id: Mapped[int] = mapped_column(
+        "id", autoincrement=True, nullable=False, unique=True, primary_key=True, init=False
+    )
+    name: Mapped[str] = mapped_column(String, nullable=False, unique=True)
+
+    users: Mapped[List["User"]] = relationship(back_populates="tier", cascade="save-update, merge", lazy="selectin", default_factory=list)
+    tier_rate_limits: Mapped["TierRateLimit"] = relationship(back_populates="tier", cascade="all, delete", lazy="selectin", default_factory=list)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default_factory=datetime.utcnow
+    )
+    updated_at: Mapped[Optional[datetime]] = mapped_column(default=None)
+
+
+class TierRateLimit(Base):
+    __tablename__ = "tier_rate_limit"
+
+    id: Mapped[int] = mapped_column(
+        "id", autoincrement=True, nullable=False, unique=True, primary_key=True, init=False
+    )
+    
+    rate_limit_id: Mapped[int] = mapped_column(ForeignKey("rate_limit.id"), index=True)
+    tier_id: Mapped[int] = mapped_column(ForeignKey("tier.id"), index=True)
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default_factory=datetime.utcnow
+    ) 
+
+    tier: Mapped[Tier] = relationship(back_populates="tier_rate_limits", init=False)
+    rate_limit: Mapped[RateLimit] = relationship(back_populates="tier_rate_limits", init=False)

src/app/models/tier.py

@@ -2,11 +2,12 @@
 import uuid as uuid_pkg
 from datetime import datetime
 
-from sqlalchemy import String, DateTime
+from sqlalchemy import String, DateTime, ForeignKey
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from app.core.database import Base
 from app.models.post import Post
+from app.models.tier import Tier
 
 class User(Base):
     __tablename__ = "user"
@@ -32,4 +33,7 @@ class User(Base):
     is_deleted: Mapped[bool] = mapped_column(default=False, index=True)
     is_superuser: Mapped[bool] = mapped_column(default=False)
 
+    tier_id: Mapped[int | None] = mapped_column(ForeignKey("tier.id"), index=True, default=None)
+
     posts: Mapped[List[Post]] = relationship(back_populates="user", cascade="all, delete", lazy="selectin", default_factory=list)
+    tier: Mapped[Tier | None] = relationship(back_populates="users", lazy="selectin", default=None)

src/app/models/user.py

@@ -0,0 +1,123 @@
+from typing import Annotated
+from datetime import datetime
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from app.core.models import TimestampModel
+
+# -------------- Rate Limit --------------
+class RateLimitBase(BaseModel):
+    path: Annotated[
+        str, 
+        Field(examples=["/users"])
+    ]
+    limit: Annotated[
+        int,
+        Field(examples=[5])
+    ]
+    period: Annotated[
+        int,
+        Field(example=[60])
+    ]
+    name: Annotated[
+        str | None,
+        Field(
+            default=None,
+            examples=["/users:5:60"]
+        )
+    ]
+
+
+class RateLimit(TimestampModel, RateLimitBase):
+    pass
+
+
+class RateLimitRead(RateLimitBase):
+    id: int
+
+
+class RateLimitCreate(RateLimitBase):
+    model_config = ConfigDict(extra='forbid')
+
+
+class RateLimitCreateInternal(RateLimitCreate):
+    pass
+
+
+class RateLimitUpdate(BaseModel):
+    pass
+
+
+class RateLimitDelete(BaseModel):
+    pass
+
+# -------------- Tier --------------
+class TierBase(BaseModel):
+    name: Annotated[
+        str, 
+        Field(examples=["free"])
+    ]
+
+
+class Tier(TimestampModel, TierBase):
+    pass
+
+
+class TierRead(TierBase):
+    id: int
+    created_at: datetime
+
+
+class TierCreate(TierBase):
+    pass
+
+
+class TierCreateInternal(TierCreate):
+    pass
+
+
+class TierUpdate(BaseModel):
+    name: str | None = None
+
+
+class TierUpdateInternal(TierUpdate):
+    updated_at: datetime
+
+
+class TierDelete(BaseModel):
+    pass
+
+
+# -------------- Tier Rate Limit --------------
+class TierRateLimitBase(BaseModel):
+    rate_limit_id: int
+    tier_id: int
+
+
+class TierRateLimit(TimestampModel, TierRateLimitBase):
+    id: int
+    created_at: datetime
+
+
+class TierRateLimitRead(TierRateLimitBase):
+    pass
+
+
+class TierRateLimitCreate(TierRateLimitBase):
+    pass
+
+
+class TierRateLimitCreateInternal(TierRateLimitCreate):
+    pass
+
+
+class TierRateLimitUpdate(BaseModel):
+    pass
+
+
+class TierRateLimitUpdateInternal(TierRateLimitUpdate):
+    pass
+
+
+class TierRateLimitDelete(BaseModel):
+    pass

src/app/schemas/tier.py

@@ -1,7 +1,7 @@
 from typing import Annotated, Optional
 from datetime import datetime
 
-from pydantic import BaseModel, EmailStr, Field, HttpUrl, ConfigDict
+from pydantic import BaseModel, EmailStr, Field, ConfigDict
 
 from app.core.models import UUIDModel, TimestampModel, PersistentDeletion
 
@@ -27,10 +27,13 @@ class User(TimestampModel, UserBase, UUIDModel, PersistentDeletion):
     ]
     hashed_password: str
     is_superuser: bool = False
+    tier_id: int | None = None
 
 
 class UserRead(BaseModel):
     id: int
+    tier_id: int
+    
     name: Annotated[
         str, 
         Field(min_length=2, max_length=30, examples=["User Userson"])
@@ -44,6 +47,7 @@ class UserRead(BaseModel):
         Field(examples=["[email protected]"])
     ]
     profile_image_url: str
+    tier_id: int | None
 
 
 class UserCreate(UserBase):