FastAPI Backend Setup for a Code Review Assistant

Welcome to your first lesson in building a Code Review Assistant! In this course, you will learn how to create a backend system that can receive code changes, store them, and process them for review. The backend is the part of your application that runs on a server and handles things like saving data, running logic, and responding to requests from users or other programs.

For this project, we are using FastAPI. FastAPI is a modern Python web framework that makes it easy to build APIs quickly and efficiently. It is known for its speed, simplicity, and automatic documentation features. By the end of this lesson, you will have a working FastAPI backend that can accept code changes and store them in a database, which is the first step toward building your own code review assistant.

Let’s start by creating a simple FastAPI application. This will be the foundation for everything else we build.

First, you need to import FastAPI and create an app instance:

from fastapi import FastAPI

app = FastAPI(title="Code Review Assistant", version="1.0.0")

• FastAPI is the main class you use to create your application.
• The title and version are optional, but they help describe your API.

Now, let’s add a simple endpoint to make sure our app is running. An endpoint is a URL path that your app responds to.

@app.get("/")
def read_root():
    return {"message": "Welcome to the Code Review Assistant!"}

• @app.get("/") tells FastAPI to run this function when someone visits the root URL (/) with a GET request.
• The function returns a dictionary, which FastAPI automatically converts to JSON.

Output Example:

If you run this app and visit the root URL, you will see:

{"message": "Welcome to the Code Review Assistant!"}

On CodeSignal, FastAPI and its dependencies are already installed, so you can focus on writing code. If you want to run this on your own computer, you would need to install FastAPI and a server like uvicorn.

To store code changes, we need a database. In this lesson, we’ll use SQLite because it’s simple and doesn’t require any setup. We’ll use SQLAlchemy to interact with the database from Python.

First, let’s set up the database connection:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

• create_engine creates a connection to the SQLite database file test.db.
• SessionLocal is a factory for creating new database sessions.
• Base is used to define our database models.

Next, we need a way to get a database session for each request:

def get_session():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

• This function creates a new session and ensures it is closed after use.

Now, let’s define the data we want to store. We need to keep track of code changes (called "changesets") and the files that are part of each changeset.

Here’s how we define the models using SQLAlchemy:

from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey
from datetime import datetime

class Changeset(Base):
    __tablename__ = "changesets"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200))
    description = Column(Text, nullable=True)
    author = Column(String(100))
    status = Column(String(20), default="pending")
    created_at = Column(DateTime, default=datetime.utcnow)

class ChangesetFile(Base):
    __tablename__ = "changeset_files"
    id = Column(Integer, primary_key=True, index=True)
    changeset_id = Column(Integer, ForeignKey("changesets.id"))
    file_path = Column(String(255))
    diff_content = Column(Text)

• Changeset represents a group of code changes.
• ChangesetFile represents a single file in a changeset.
• Each model is a Python class that maps to a table in the database.

To create the tables, add:

Base.metadata.create_all(bind=engine)

When building APIs, it’s important to validate the data coming in and out. FastAPI uses Pydantic for this.

from pydantic import BaseModel
from typing import List, Optional

class FileChangeRequest(BaseModel):
    file_path: str
    diff_content: str

class ChangesetRequest(BaseModel):
    title: str
    description: Optional[str] = None
    author: str
    files: List[FileChangeRequest]

• FileChangeRequest describes a single file change.
• ChangesetRequest describes the whole changeset, including a list of files.

Now, let’s build the main feature: an endpoint to submit a new changeset for review.

Here’s how you define the endpoint:

from fastapi import Depends, BackgroundTasks
from sqlalchemy.orm import Session

@app.post("/api/changesets", response_model=dict)
def submit_changeset(
    request: ChangesetRequest,
    background_tasks: BackgroundTasks,
    db: Session = Depends(get_session)
):
    # Create changeset
    changeset = Changeset(
        title=request.title,
        description=request.description,
        author=request.author
    )
    db.add(changeset)
    db.flush()
    
    # Add files
    for file_req in request.files:
        changeset_file = ChangesetFile(
            changeset_id=changeset.id,
            file_path=file_req.file_path,
            diff_content=file_req.diff_content
        )
        db.add(changeset_file)
    
    db.commit()
    
    # Process review in background
    background_tasks.add_task(process_changeset_review, changeset.id)
    
    return {"message": "Changeset submitted", "changeset_id": changeset.id}

Let’s break down what’s happening:

• @app.post("/api/changesets") creates a POST endpoint at /api/changesets.
• The function takes a ChangesetRequest (the data sent by the user), a BackgroundTasks object, and a database session.
• It creates a new Changeset and adds it to the database.
• For each file in the request, it creates a ChangesetFile and adds it to the database.
• It commits the changes to save them.
• It starts a background task to process the review (the review logic is a placeholder for now).
• It returns a message and the ID of the new changeset.

Example Output:

If you send a POST request with a new changeset, you will get a response like:

{"message": "Changeset submitted", "changeset_id": 1}

In this lesson, you learned how to:

• Set up a FastAPI application as the backend for your Code Review Assistant.
• Connect to a SQLite database using SQLAlchemy.
• Define models for changesets and files, and use Pydantic schemas for validation.
• Create an endpoint to submit new changesets and store them in the database.

These are the essential building blocks for your project. In the practice exercises that follow, you will get hands-on experience with each of these steps. This will help you reinforce what you’ve learned and prepare you for adding more features to your Code Review Assistant in future lessons.