Implementing a Robust Follow System with the Repository Pattern

Introduction

Building social connectivity features requires more than just a database table; it requires a reliable abstraction to handle relationships between users. In the flock-twitter-ai-verified project, we recently implemented a follow system using FastAPI and the Repository pattern to ensure our backend remains clean and testable.

The Architecture Approach

By leveraging the Repository pattern, we decouple our business logic from the data access layer. This allows us to interact with our PostgreSQL database through SQLAlchemy while keeping our FastAPI route handlers thin and focused on request orchestration.

Implementation Strategy

When implementing user follows, we want to ensure that database integrity is maintained. The core logic involves a join table that tracks follower and following IDs.

Defining the Data Access

First, we define a repository method to encapsulate the follow logic:

class FollowRepository:
    def __init__(self, db: Session):
        self.db = db

    def create_follow(self, follower_id: int, following_id: int):
        follow_record = Follow(follower_id=follower_id, following_id=following_id)
        self.db.add(follow_record)
        self.db.commit()
        return follow_record

This method abstracts the SQLAlchemy session operations, making it easy to swap out storage backends or add complex validation rules later without touching the API layer.

Handling the API Request

In our FastAPI route, we inject the repository to perform the action. We use Pydantic models to validate the request schema before hitting the database.

@router.post("/follow/{user_id}")
def follow_user(user_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    repo = FollowRepository(db)
    return repo.create_follow(current_user.id, user_id)

By separating the repository, we make unit testing the follow logic straightforward, as we can mock the FollowRepository instance during our test suite execution.

Results

This modular approach allows us to scale our social features. By centralizing the data access, we can easily add caching layers or audit logging to follow actions without refactoring our primary application code.

Next Steps

Now that the basic follow system is in place, consider implementing background tasks for sending follow notifications and adding database indexes on the follower/following columns to ensure query performance remains high as the user base grows.

Generated with Gitvlg.com