Belajar FastAPI - Response Model & Status Code

#Pendahuluan

Setelah di episode 6 kita menguasai cara menerima data (body, query, path, form), sekarang kita fokus ke arah sebaliknya: output. Cara API mengirimkan respons menentukan pengalaman klien — bentuk JSON yang tidak konsisten, status code yang salah, atau response yang membocorkan field internal adalah masalah yang paling sering dikeluhkan pengguna API.

Mengapa episode ini penting? Karena output API adalah kontrak publik yang akan dipakai tim lain, SDK, dan mobile app. Di sinilah kita memastikan kontrak itu terjaga — secara otomatis, bukan dengan disiplin manual.

#Response Model: Menjaga Bentuk Output

response_model adalah deklarasi tipe return yang divalidasi FastAPI sebelum dikirim. Manfaatnya ganda: membatasi field yang keluar dan mendokumentasikan response di OpenAPI.

app/schemas.py - model output

from pydantic import BaseModel
 
 
class UserPublic(BaseModel):
    id: int
    username: str
 
 
class UserInternal(UserPublic):
    password_hash: str

Endpoint di bawah memakai response_model=UserPublic — meskipun objek asli punya password_hash, field itu tidak akan pernah keluar:

app/main.py - response_model

from fastapi import FastAPI
from app.schemas import UserInternal, UserPublic
 
app = FastAPI()
 
USERS = {
    1: UserInternal(id=1, username="budi", password_hash="hash_rahasia"),
}
 
 
@app.get("/users/{user_id}", response_model=UserPublic)
def get_user(user_id: int) -> UserInternal:
    return USERS[user_id]

Inilah pola internal vs public schema: simpan objek lengkap (termasuk hash password) di dalam handler, tapi biarkan FastAPI memfilter sesuai response_model. Tidak ada cara yang lebih mudah untuk mencegah kebocoran data.

#Status Code yang Benar

Status code adalah bahasa universal HTTP. FastAPI memakainya lewat parameter status_code pada dekorator:

Status code dengan status module

from fastapi import FastAPI, status
 
app = FastAPI()
 
 
@app.post("/items/", status_code=status.HTTP_201_CREATED)
def create_item(name: str) -> dict:
    return {"name": name}
 
 
@app.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_item(item_id: int) -> None:
    return None

Gunakan status module (bukan angka mentah) — lebih terbaca dan bebas typo. Peta status yang paling sering dipakai:

#Response Headers

Kadang perlu menyisipkan metadata ke header — misalnya X-Process-Time untuk observability atau Location untuk resource baru:

Response headers

from fastapi import FastAPI, Response
 
app = FastAPI()
 
 
@app.post("/items/", status_code=201)
def create_item(item: str, response: Response) -> dict:
    response.headers["Location"] = "/items/1"
    response.headers["X-Created-By"] = "fastapi-lab"
    return {"name": item}

Menyuntikkan parameter bertipe Response ke handler memberi kalian akses langsung ke objek response Starlette — cara idiomatis menambah header tanpa meninggalkan deklarasi normal.

#Custom Response

Tidak semua response adalah JSON. FastAPI menyediakan kelas response khusus:

Contoh streaming generator — pola yang nanti menjadi fondasi LLM streaming:

StreamingResponse dengan generator

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
 
app = FastAPI()
 
 
def angka():
    for i in range(5):
        yield f"{i}\n"
 
 
@app.get("/numbers")
def read_numbers() -> StreamingResponse:
    return StreamingResponse(angka(), media_type="text/plain")

StreamingResponse menerima iterator dan mengirim hasilnya bertahap — klien mulai menerima data sebelum seluruh generator selesai. Ini esensial untuk payload besar dan, di episode 23, untuk streaming token LLM.

#Ringkasan: Deklarasi vs Default

#Common Pitfalls

#Penutup

Inti yang harus dibawa pulang:

• response_model = kontrak output: filter field, validasi, dan dokumentasi dalam satu deklarasi.
• Status code via status.HTTP_*; 201 untuk create, 204 untuk delete.
• Parameter Response memberikan akses header.
• StreamingResponse untuk data bertahap — fondasi streaming LLM di episode 23.

Di episode 8 selanjutnya kita akan membahas dependency injection — cara FastAPI merapikan logika bersama. Kalian akan belajar Depends, sub-dependencies, class dependencies, dan global dependencies, serta pola Annotated yang direkomendasikan FastAPI 0.141. Ini akan mengubah cara kalian menulis endpoint selamanya!