Anda bisa mengubah aplikasi Flask sederhana menjadi sebuah REST API yang canggih dan profesional secara “seketika” dengan menggunakan ekstensi Flask-RESTful. Proses “transformasi” ini tidak memerlukan penulisan ulang kode secara besar-besaran. Sebaliknya, ini adalah tentang menerapkan lapisan struktur dan otomatisasi di atas fondasi Flask yang sudah ada, mengubah endpoint-endpoint fungsional Anda menjadi sebuah layanan web yang kokoh.

Flask terkenal karena sifatnya yang minimalis. Ia memberi Anda kebebasan penuh, yang sangat bagus untuk memulai. Namun, ketika aplikasi Anda perlu berkomunikasi dengan aplikasi lain (seperti frontend JavaScript atau aplikasi seluler), Anda membutuhkan lebih dari sekadar endpoint biasa. Anda membutuhkan API yang canggih: terstruktur, andal, dan konsisten. Inilah cara Anda melakukannya dengan cepat menggunakan Flask-RESTful.

baca juga : Cara Mudah Bikin REST API Profesional Pakai Flask-RESTful

Titik Awal: Aplikasi Flask Sederhana

Banyak developer memulai dengan membuat aplikasi Flask yang mengembalikan data JSON secara langsung. Mari kita ambil contoh sebuah aplikasi yang sangat sederhana untuk mengelola data buku.

Kode “Sebelum” Transformasi:

Python

from flask import Flask, jsonify

app = Flask(__name__)

# Data dummy sebagai pengganti database
books = {
    "book1": {"title": "The Hobbit", "author": "J.R.R. Tolkien"}
}

@app.route('/books/book1')
def get_book():
    return jsonify(books['book1'])

if __name__ == '__main__':
    app.run(debug=True)

Kode ini berfungsi. Jika Anda mengakses /books/book1, Anda akan mendapatkan data buku dalam format JSON. Namun, ini belum bisa disebut sebagai API yang “canggih”. Mengapa?

• Tidak Terstruktur: Logika untuk buku tersebar dalam fungsi-fungsi individual.
• Tidak Fleksibel: Bagaimana jika Anda ingin menambahkan metode PUT atau DELETE? Anda harus membuat fungsi dan decorator @app.route baru.
• Tidak Ada Validasi: Ia tidak memiliki cara untuk memvalidasi data yang masuk.
• Tidak Konsisten: Format output dibuat secara manual, yang bisa menjadi tidak konsisten di berbagai endpoint.

Langkah Transformasi #1: Memasang ‘Mesin’ API (Instalasi Flask-RESTful)

Langkah pertama adalah memasang “mesin” yang akan menggerakkan transformasi ini. Flask-RESTful adalah ekstensi resmi yang dirancang khusus untuk tujuan ini.

Instalasi: Buka terminal Anda dan jalankan perintah sederhana ini: pip install Flask-RESTful

Integrasi: Sekarang, ubah file app.py Anda untuk mengintegrasikan mesin ini.

Python

from flask import Flask
from flask_restful import Api  # Impor Api

app = Flask(__name__)
api = Api(app) # Mengubah 'app' menjadi sebuah platform API

# ... sisa kode ...

Dengan menambahkan api = Api(app), Anda telah memberi tahu aplikasi Flask Anda bahwa ia sekarang siap untuk di-upgrade menjadi sebuah platform API yang sesungguhnya.

Langkah Transformasi #2: Dari Fungsi Biasa ke ‘Resource’ Profesional

Ini adalah inti dari transformasi. Kita akan membuang pendekatan berbasis fungsi yang tersebar dan mengadopsi struktur berbasis Resource yang bersih dan profesional. Sebuah Resource adalah sebuah kelas yang mengelompokkan semua logika untuk satu jenis entitas.

Kode “Sesudah” Transformasi (Struktur): Hapus fungsi get_book() Anda dan ganti dengan kelas berikut:

Python

from flask_restful import Resource

# ... data books tetap sama ...

class BookResource(Resource):
    def get(self, book_id):
        # Memastikan buku ada sebelum mengembalikannya
        if book_id not in books:
            return {"message": "Book not found"}, 404
        return books[book_id]

# Daftarkan Resource ini ke URL
api.add_resource(BookResource, '/books/<string:book_id>')

Mengapa Ini Canggih? “Seketika”, kode Anda menjadi jauh lebih profesional.

• Terorganisir: Semua metode yang berhubungan dengan satu buku (nantinya bisa ditambah put, delete) berada di dalam satu kelas.
• Fleksibel: Menambahkan fungsionalitas baru (seperti metode PUT) semudah menambahkan metode baru di dalam kelas yang sama.
• Praktik Terbaik: Ini mengikuti praktik desain REST API di mana URL (/books/<book_id>) merujuk pada sebuah resource, dan kata kerja HTTP (GET, PUT) menentukan aksi yang dilakukan pada resource tersebut.

Langkah Transformasi #3: Menambahkan ‘Kecerdasan’ Validasi (RequestParser)

API yang canggih tidak menerima data mentah begitu saja; ia memvalidasinya. Mari kita tambahkan kemampuan untuk memperbarui data buku (metode PUT) dan memvalidasi inputnya dengan RequestParser.

Kode “Sesudah” Transformasi (Validasi):

Python

from flask_restful import reqparse

# Definisikan parser untuk memvalidasi data yang masuk
parser = reqparse.RequestParser()
parser.add_argument('title', type=str, required=True, help='Title tidak boleh kosong')
parser.add_argument('author', type=str, required=True, help='Author tidak boleh kosong')

class BookResource(Resource):
    def get(self, book_id):
        # ... kode dari langkah sebelumnya ...
        pass

    def put(self, book_id):
        # Validasi data yang masuk dari request body
        args = parser.parse_args()
        
        # Buat buku baru jika belum ada
        book = {'title': args['title'], 'author': args['author']}
        books[book_id] = book
        return book, 201

Mengapa Ini Canggih? API Anda kini memiliki “kecerdasan”. Ia tahu data seperti apa yang diharapkan. Jika klien mengirim data yang tidak valid (misalnya, tidak ada field title), Flask-RESTful akan secara otomatis menolak permintaan tersebut dan mengirim kembali respons error 400 Bad Request dengan pesan yang jelas. Ini membuat API Anda jauh lebih andal dan aman.

baca juga : Pernyataan Sikap Sivitas Akademika Universitas Teknokrat Indonesia Terkait Aksi Massa dan Kondisi Bangsa Indonesia Terkini

Langkah Transformasi #4: Memoles Tampilan dengan ‘Fields’ (Konsistensi Output)

Sentuhan terakhir dari sebuah API profesional adalah konsistensi. Klien harus selalu tahu format JSON seperti apa yang akan mereka terima. Flask-RESTful memudahkan ini dengan modul fields.

Kode “Sesudah” Transformasi (Pemformatan):

Python

from flask_restful import fields, marshal_with

# Definisikan 'cetakan' atau struktur untuk output JSON
book_fields = {
    'title': fields.String,
    'author_name': fields.String(attribute='author'), # Ganti nama 'author' menjadi 'author_name'
    'uri': fields.Url('bookresource', absolute=True)
}

class BookResource(Resource):
    @marshal_with(book_fields) # Terapkan cetakan ini pada output metode get
    def get(self, book_id):
        if book_id not in books:
            return {"message": "Book not found"}, 404
        return books[book_id]

    def put(self, book_id):
        # ... kode dari langkah sebelumnya ...
        pass

Mengapa Ini Canggih? Dengan decorator @marshal_with, Anda menciptakan sebuah kontrak API yang kuat.

• Konsisten: Semua respons dari metode get dijamin akan memiliki format yang sama.
• Fleksibel: Anda bisa mengubah nama field di output (author menjadi author_name) tanpa harus mengubah struktur data internal Anda.
• Profesional: Menambahkan uri secara otomatis menunjukkan praktik HATEOAS, sebuah ciri dari desain REST API yang matang.

penulis : Muhammad Anwar Fuadi