Pydantic Book Request Validation

🔄 Replace Body() With Pydantic Validation (POST)

Earlier, we used Body() to read request data.

But it did not provide validation or type safety.

👉 Using Pydantic ensures incoming data is:

• ✅ Properly formatted

• ✅ Strongly typed

• ✅ Automatically validated

📦 Step 1 — Importing Pydantic

FastAPI includes Pydantic by default — no extra installation is required.

from fastapi import FastAPI, Body # we have removed Body
from pydantic import BaseModel # 👉 FastAPI includes Pydantic by default

📘 Step 2 — Existing Book Class (Internal Object)

class Book:
    id: int
    title: str
    author: str
    description: str
    rating: int

    def __init__(self, id, title, author, description, rating):
        self.id = id
        self.title = title
        self.author = author
        self.description = description
        self.rating = rating

👉 This is a plain Python class used inside the app.

• ✅ Represents a trusted object

• ❌ No validation

• ❌ No automatic type checking

🧱 Step 3 — Create Pydantic Request Model

class BookRequest(BaseModel):
    id: int
    title: str
    author: str
    description: str
    rating: int

👉 This defines the structure of incoming JSON data.

FastAPI will automatically:

• Validate data types

• Reject invalid/missing fields

• Return HTTP 422 on errors

• Show schema in Swagger UI

💡 Think of it as an API boundary guard.

🔁 Step 4 — Updating the POST Endpoint

Previously, we used Body().

Now, we replace it with a typed parameter:

❌ # Old version using Body()
@app.post("/create-book")
async def create_book(book_request=Body()): 
		BOOKS.append(book_request)

✅ # New version using Pydantic
@app.post("/create_book")
async def create_book(book_request: BookRequest): 
    BOOKS.append(book_request)

🌐 Testing in the Browser

POST request with Pydantic in Swagger UI

🔍 What Just Happened?

When a request is sent:

👉 FastAPI will:

1. Parse the JSON body

2. Convert it into a BookRequest object

3. Validate it

4. Reject it if invalid

⚠️ Problem: book_request is a BookRequest object, not a Book.

Mixing types in BOOKS leads to inconsistent data.

🧪 Verifying the Request Type

Let’s confirm what FastAPI is actually passing into our function.

@app.post("/create_book")
async def create_book(book_request: BookRequest):
    print(type(book_request)) # 👉 confirms type of book_request. 
    BOOKS.append(book_request)

🌐 Testing in the Browser

Printing and verifying BookRequest type

When you send a request, the terminal will display:

<class 'books2.BookRequest'> # 👉 this means its of type BookRequest.

This confirms:

• ✅ Request body was parsed

• ✅ Data was validated

• ✅ We received a Pydantic model instance

Not a dictionary.

🔄 Step 5 — Convert to Book Object

@app.post("/create_book")
async def create_book(book_request: BookRequest):
    new_book = Book(**book_request.model_dump())
    BOOKS.append(new_book)

📘 What’s Happening?

👉 model_dump()

Converts the Pydantic model into a dictionary.

book_request.model_dump()

(In Pydantic v2, this replaces .dict())

👉 * (Dictionary Unpacking)

Book(**data)

Is equivalent to:

Book(id=data["id"],
    title=data["title"],
    author=data["author"],
    description=data["description"],
    rating=data["rating"]
)

🧪 Verifying the Conversion

Let’s confirm we are now storing a Book object.

@app.post("/create_book")
async def create_book(book_request: BookRequest):
    new_book = Book(**book_request.model_dump())
    print(type(new_book))
    BOOKS.append(new_book)

🌐 Testing in the Browser

Verifying Book object type after conversion

When you send a request, the terminal will display:

<class 'books2.Book'>

This confirms:

• ✅ Validation occurred

• ✅ Data was converted

• ✅ Only Book objects are stored

🧠 Why This Architecture Matters

You now have a clear separation between:

This improves:

• 🔒 Data integrity

• 📈 Scalability

• 🧩 Maintainability

• 🏗 Professional architecture

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Book:
    id: int
    title: str
    author: str
    description: str
    rating: int
    
    def __init__(self, id, title, author, description, rating):
        self.id = id
        self.title = title
        self.author = author
        self.description = description
        self.rating = rating 
        
class BookRequest(BaseModel):
    id: int
    title: str
    author: str
    description: str
    rating: int

BOOKS = [
    Book(1, 'Computer Science Pro', 'codingwithrobby', 'A very nice book', 3),
    Book(2, 'Be Fast with FastAPI', 'codingwithrobby', 'A great book', 5),
    Book(3, 'Master Endpoints', 'codingwithrobby', 'An awesome book', 5),
    Book(4, 'HP1', 'Author 1', 'Book Description', 2),
    Book(5, 'HP2', 'Author 2', 'Book Description', 3),
    Book(6, 'HP3', 'Author 3', 'Book Description', 1)
]

@app.get("/books")
async def read_all_books():
    return BOOKS
    
@app.post("/create_book")
async def create_book(book_request: BookRequest):
    new_book = Book(**book_request.model_dump())
    BOOKS.append(new_book)