Pagination REST API: Panduan Lengkap

Dalam dunia pengembangan aplikasi modern, REST API berfungsi sebagai lapisan komunikasi fundamental, memungkinkan sistem yang berbeda untuk bertukar data dengan lancar. Seiring pertumbuhan skala dan kompleksitas aplikasi, volume data yang mereka tangani juga meningkat. Meminta seluruh kumpulan data, yang berpotensi berisi jutaan atau bahkan miliaran catatan, dalam satu panggilan API tidak efisien, tidak dapat diandalkan, dan menjadi hambatan kinerja yang signifikan. Di sinilah teknik krusial dalam desain dan pengembangan API berperan: paginasi REST API. Panduan ini memberikan gambaran mendalam dan komprehensif tentang penerapan paginasi dalam REST API, mencakup segala sesuatu mulai dari konsep fundamental hingga implementasi dunia nyata yang canggih menggunakan berbagai tumpukan teknologi seperti Node.js, Python, dan .NET.

Dasar-dasar Paginasi REST API

Sebelum menyelami contoh kode kompleks dan pola desain, penting untuk memiliki pemahaman yang kuat tentang apa itu paginasi dan mengapa itu merupakan aspek yang tidak dapat dinegosiasikan dalam desain API profesional.

Apa itu Paginasi dalam REST API?

Intinya, paginasi REST API adalah teknik yang digunakan untuk mengambil respons endpoint REST API dan memecahnya menjadi unit-unit yang lebih kecil dan lebih mudah dikelola, sering disebut "halaman". Alih-alih mengirimkan kumpulan data yang berpotensi besar sekaligus, API mengembalikan potongan data yang kecil dan dapat diprediksi. Yang penting, respons API juga menyertakan metadata yang memungkinkan klien untuk mengambil potongan data berikutnya secara bertahap jika mereka membutuhkan lebih banyak data.

Proses ini analog dengan halaman-halaman buku atau hasil pencarian di Google. Anda disajikan dengan halaman pertama hasil, bersama dengan kontrol untuk menavigasi ke halaman kedua, ketiga, dan seterusnya. Seperti yang ditunjukkan oleh komunitas pengembang seperti DEV Community dan platform seperti Merge.dev, ini adalah proses memecah kumpulan data besar menjadi potongan-potongan yang lebih kecil, yang dapat diambil secara bertahap oleh klien jika mereka benar-benar menginginkan semua data itu. Ini adalah konsep dasar untuk membangun aplikasi yang kuat dan terukur.

Mengapa Paginasi Menjadi Persyaratan Inti dalam Desain API Modern?

Motivasi utama untuk paginasi adalah untuk memastikan respons API lebih mudah ditangani baik oleh server maupun klien. Tanpa itu, aplikasi akan menghadapi keterbatasan parah dan pengalaman pengguna yang buruk. Manfaat utamanya meliputi:

• Peningkatan Kinerja dan Pengurangan Latensi: Keuntungan paling signifikan adalah kecepatan. Mentransfer payload JSON kecil berisi 25 catatan jauh lebih cepat daripada mentransfer payload 2,5 juta catatan. Ini menghasilkan pengalaman yang cepat dan responsif bagi pengguna akhir.
• Keandalan API yang Ditingkatkan: Respons HTTP yang besar memiliki probabilitas kegagalan transfer yang lebih tinggi karena batas waktu jaringan, koneksi terputus, atau batas memori sisi klien. Paginasi menciptakan permintaan yang lebih kecil dan lebih tangguh. Jika satu halaman gagal dimuat, klien cukup mencoba kembali permintaan spesifik tersebut tanpa harus memulai kembali seluruh transfer data.
• Pengurangan Beban Server: Menghasilkan respons yang besar dapat memberikan beban signifikan pada sumber daya server. Kueri basis data mungkin lambat, dan serialisasi jutaan catatan ke dalam JSON mengonsumsi CPU dan memori yang cukup besar. Paginasi memungkinkan server untuk melakukan kueri yang lebih kecil dan lebih efisien, meningkatkan kapasitas keseluruhannya dan kemampuannya untuk melayani banyak klien secara bersamaan.
• Pemrosesan Sisi Klien yang Efisien: Untuk aplikasi klien, terutama yang berjalan di perangkat seluler atau di browser web, mengurai objek JSON yang besar dapat membekukan antarmuka pengguna dan menyebabkan pengalaman yang membuat frustrasi. Potongan data yang lebih kecil lebih mudah diurai dan dirender, menghasilkan aplikasi yang lebih lancar.

Strategi dan Teknik Paginasi Umum

Ada beberapa cara untuk menerapkan paginasi, tetapi dua strategi utama telah menjadi standar de facto dalam industri. Pilihan di antara keduanya memiliki implikasi signifikan terhadap kinerja, konsistensi data, dan pengalaman pengguna.

Paginasi Berbasis Offset: Pendekatan Fundamental

Paginasi berbasis offset, sering disebut "paginasi nomor halaman", seringkali merupakan pendekatan pertama yang dipelajari pengembang. Ini secara konseptual sederhana dan terlihat di banyak aplikasi web. Ini bekerja dengan menggunakan dua parameter utama:

• limit (atau page_size): Jumlah maksimum hasil yang akan dikembalikan pada satu halaman.
• offset (atau page): Jumlah catatan yang akan dilewati dari awal kumpulan data. Jika menggunakan parameter page, offset biasanya dihitung sebagai (page - 1) * limit.

Permintaan tipikal terlihat seperti ini: GET /api/products?limit=25&offset=50

Ini akan diterjemahkan menjadi kueri SQL seperti:SQL

SELECT * FROM products ORDER BY created_at DESC LIMIT 25 OFFSET 50;

Kueri ini melewati 50 produk pertama dan mengambil 25 produk berikutnya (yaitu, produk 51-75).

Kelebihan:

• Kesederhanaan: Metode ini mudah diterapkan, seperti yang ditunjukkan dalam banyak tutorial seperti "Node.js REST API: Offset Pagination Made Easy."
• Navigasi Tanpa Status: Klien dapat dengan mudah melompat ke halaman mana pun dalam kumpulan data tanpa memerlukan informasi sebelumnya, menjadikannya ideal untuk UI dengan tautan halaman bernomor.

Kekurangan dan Keterbatasan:

• Kinerja Buruk pada Kumpulan Data Besar: Kelemahan utama adalah klausa OFFSET basis data. Untuk permintaan dengan offset besar (misalnya, OFFSET 1000000), basis data masih harus mengambil semua 1.000.025 catatan dari disk, menghitung melalui satu juta pertama untuk melewatinya, dan baru kemudian mengembalikan 25 catatan terakhir. Ini bisa menjadi sangat lambat seiring bertambahnya nomor halaman.
• Ketidakkonsistenan Data (Page Drift): Jika catatan baru ditulis ke basis data saat pengguna melakukan paginasi, seluruh kumpulan data akan bergeser. Pengguna yang menavigasi dari halaman 2 ke halaman 3 mungkin melihat catatan yang berulang dari akhir halaman 2, atau kehilangan catatan sama sekali. Ini adalah masalah signifikan untuk aplikasi real-time dan merupakan topik umum di forum pengembang seperti Stack Overflow saat membahas cara memastikan konsistensi data.

Paginasi Berbasis Kursor (Keyset): Solusi yang Dapat Diskalakan

Paginasi berbasis kursor, juga dikenal sebagai keyset atau seek pagination, memecahkan masalah kinerja dan konsistensi metode offset. Alih-alih nomor halaman, ia menggunakan "kursor", yang merupakan penunjuk stabil dan buram ke catatan spesifik dalam kumpulan data.

Alurnya adalah sebagai berikut:

1. Klien melakukan permintaan awal untuk satu halaman data.
2. Server mengembalikan halaman data, bersama dengan kursor yang menunjuk ke item terakhir dalam set tersebut.
3. Untuk halaman berikutnya, klien mengirimkan kursor tersebut kembali ke server.
4. Server kemudian mengambil catatan yang datang setelah kursor spesifik tersebut, secara efektif "mencari" ke titik tersebut dalam kumpulan data.

Kursor biasanya merupakan nilai yang dikodekan yang berasal dari kolom yang diurutkan. Misalnya, jika mengurutkan berdasarkan created_at (timestamp), kursor bisa berupa timestamp dari catatan terakhir. Untuk menangani ikatan, kolom kedua yang unik (seperti id catatan) sering disertakan.

Permintaan menggunakan kursor terlihat seperti ini: GET /api/products?limit=25&after_cursor=eyJjcmVhdGVkX2F0IjoiMjAyNS0wNi0wN1QxODowMDowMC4wMDBaIiwiaWQiOjg0N30=

Ini akan diterjemahkan menjadi kueri SQL yang jauh lebih berkinerja:SQL

SELECT * FROM products
WHERE (created_at, id) < ('2025-06-07T18:00:00.000Z', 847)
ORDER BY created_at DESC, id DESC
LIMIT 25;

Kueri ini menggunakan indeks pada (created_at, id) untuk langsung "mencari" ke titik awal yang benar, menghindari pemindaian tabel penuh dan membuatnya konsisten cepat terlepas dari seberapa dalam pengguna melakukan paginasi.

Kelebihan:

• Sangat Berkinerja dan Dapat Diskalakan: Kinerja basis data cepat dan konstan, menjadikannya cocok untuk kumpulan data ukuran berapa pun.
• Konsistensi Data: Karena kursor terikat pada catatan spesifik, bukan posisi absolut, data baru yang ditambahkan atau dihapus tidak akan menyebabkan item terlewat atau berulang di antara halaman.

Kekurangan:

• Kompleksitas Implementasi: Logika untuk menghasilkan dan mengurai kursor lebih kompleks daripada perhitungan offset sederhana.
• Navigasi Terbatas: Klien hanya dapat menavigasi ke halaman "berikutnya" atau "sebelumnya". Tidak mungkin melompat langsung ke nomor halaman spesifik, menjadikannya kurang cocok untuk pola UI tertentu.
• Membutuhkan Kunci Urut yang Stabil: Implementasi sangat terkait dengan urutan pengurutan dan memerlukan setidaknya satu kolom unik dan berurutan.

Perbandingan Dua Jenis Utama Paginasi

Memilih antara paginasi offset dan kursor sepenuhnya bergantung pada kasus penggunaan.

Praktik Terbaik Implementasi untuk Paginasi Sisi Server

Terlepas dari strategi yang dipilih, mengikuti serangkaian praktik terbaik akan menghasilkan API yang bersih, dapat diprediksi, dan mudah digunakan. Ini seringkali merupakan bagian kunci dari jawaban "Apa praktik terbaik paginasi sisi server?".

Merancang Payload Respons Paginasi

Kesalahan umum adalah hanya mengembalikan array hasil. Payload respons paginasi yang dirancang dengan baik harus berupa objek yang "menyelubungi" data dan menyertakan metadata paginasi yang jelas.JSON

{
  "data": [
    { "id": 101, "name": "Product A" },
    { "id": 102, "name": "Product B" }
  ],
  "pagination": {
    "next_cursor": "eJjcmVhdGVkX2F0Ij...",
    "has_next_page": true
  }
}

Untuk paginasi offset, metadatanya akan terlihat berbeda:JSON

{
  "data": [
    // ... hasil ...
  ],
  "metadata": {
    "total_results": 8452,
    "total_pages": 339,
    "current_page": 3,
    "per_page": 25
  }
}

Struktur ini membuatnya mudah bagi klien untuk mengetahui apakah ada lebih banyak data yang harus diambil atau untuk merender kontrol UI.

Menggunakan Tautan Hypermedia untuk Navigasi (HATEOAS)

Prinsip inti REST adalah HATEOAS (Hypermedia as the Engine of Application State). Ini berarti API harus menyediakan tautan kepada klien untuk menavigasi ke sumber daya atau tindakan lain. Untuk paginasi, ini sangat kuat. Seperti yang ditunjukkan dalam GitHub Docs, cara standar untuk melakukan ini adalah dengan header HTTP Link.

Link: <https://api.example.com/items?page=3>; rel="next", <https://api.example.com/items?page=1>; rel="prev"

Sebagai alternatif, tautan ini dapat ditempatkan langsung di badan respons JSON, yang seringkali lebih mudah dikonsumsi oleh klien JavaScript:JSON

"pagination": {
  "links": {
    "next": "https://api.example.com/items?limit=25&offset=75",
    "previous": "https://api.example.com/items?limit=25&offset=25"
  }
}

Ini membebaskan klien dari keharusan membuat URL secara manual.

Memungkinkan Klien Mengontrol Ukuran Halaman

Praktik yang baik adalah mengizinkan klien untuk meminta halaman hasil tambahan untuk respons yang dipaginasi dan juga untuk mengubah jumlah hasil yang dikembalikan di setiap halaman. Ini biasanya dilakukan dengan parameter kueri limit atau per_page. Namun, server harus selalu memberlakukan batas maksimum yang wajar (misalnya, 100) untuk mencegah klien meminta terlalu banyak data sekaligus dan membebani sistem.

Menggabungkan Paginasi dengan Pemfilteran dan Pengurutan

API dunia nyata jarang hanya melakukan paginasi; mereka juga perlu mendukung pemfilteran dan pengurutan. Seperti yang ditunjukkan dalam tutorial yang mencakup teknologi seperti .NET, menambahkan fitur-fitur ini adalah persyaratan umum.

Permintaan kompleks mungkin terlihat seperti: GET /api/products?status=published&sort=-created_at&limit=50&page=2

Saat mengimplementasikan ini, sangat penting bahwa parameter pemfilteran dan pengurutan dianggap sebagai bagian dari logika paginasi. Urutan sort harus stabil dan deterministik agar paginasi berfungsi dengan benar. Jika urutan pengurutan tidak unik, Anda harus menambahkan kolom tie-breaker yang unik (seperti id) untuk memastikan urutan yang konsisten antar halaman.

Contoh Implementasi Dunia Nyata

Mari kita jelajahi cara mengimplementasikan konsep-konsep ini dalam berbagai kerangka kerja populer.

Paginasi REST API di Python dengan Django REST Framework

Salah satu kombinasi paling populer untuk membangun API adalah Python dengan Django REST Framework (DRF). DRF menyediakan dukungan bawaan yang kuat untuk paginasi, membuatnya sangat mudah untuk memulai. Ia menawarkan kelas untuk strategi yang berbeda:

• PageNumberPagination: Untuk paginasi offset standar berbasis nomor halaman.
• LimitOffsetPagination: Untuk implementasi offset yang lebih fleksibel.
• CursorPagination: Untuk paginasi berbasis kursor berperforma tinggi.

Anda dapat mengonfigurasi gaya paginasi default secara global dan kemudian cukup menggunakan ListAPIView generik, dan DRF menangani sisanya. Ini adalah contoh utama Rest api pagination python.Python

# Di settings.py Anda
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.CursorPagination',
    'PAGE_SIZE': 50
}

# Di views.py Anda
class ProductListView(generics.ListAPIView):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    # DRF menangani seluruh logika paginasi secara otomatis!

Membangun REST API yang Dipaginasi dengan Node.js, Express, dan TypeScript

Dalam ekosistem Node.js, Anda sering membangun logika paginasi secara manual, yang memberi Anda kendali penuh. Bagian panduan ini memberikan gambaran konseptual tentang membangun paginasi dengan Node.js, Express, dan TypeScript.

Berikut adalah contoh sederhana penerapan paginasi kursor:TypeScript

// Di controller Express Anda
app.get('/products', async (req: Request, res: Response) => {
  const limit = parseInt(req.query.limit as string) || 25;
  const cursor = req.query.cursor as string;

  let query = db.selectFrom('products').orderBy('createdAt', 'desc').orderBy('id', 'desc').limit(limit);

  if (cursor) {
    const { createdAt, id } = JSON.parse(Buffer.from(cursor, 'base64').toString('ascii'));
    // Tambahkan klausa WHERE untuk kursor
    query = query.where('createdAt', '<=', createdAt).where('id', '<', id);
  }

  const products = await query.execute();

  const nextCursor = products.length > 0
    ? Buffer.from(JSON.stringify({
        createdAt: products[products.length - 1].createdAt,
        id: products[products.length - 1].id
      })).toString('base64')
    : null;

  res.json({
    data: products,
    pagination: { next_cursor: nextCursor }
  });
});

Paginasi dalam Ekosistem Java atau .NET

Kerangka kerja di ekosistem lain juga menyediakan dukungan paginasi yang kuat.

• Java (Spring Boot): Proyek Spring Data membuat paginasi menjadi mudah. Dengan menggunakan PagingAndSortingRepository, Anda dapat mendefinisikan tanda tangan metode seperti Page<Product> findAll(Pageable pageable);. Spring secara otomatis mengimplementasikan metode tersebut, menangani parameter permintaan page, size, dan sort, dan mengembalikan objek Page yang berisi hasil dan semua metadata paginasi yang diperlukan. Ini adalah jawaban praktik terbaik untuk "Bagaimana cara mengimplementasikan paginasi di REST API Java?".
• .NET: Dalam dunia .NET, pengembang sering menggunakan ekstensi IQueryable dengan metode seperti .Skip() dan .Take() untuk mengimplementasikan paginasi offset. Untuk skenario yang lebih canggih, pustaka dapat membantu membangun solusi berbasis kursor yang diterjemahkan menjadi kueri SQL yang efisien.

### Kasus Penggunaan Dunia Nyata: Memaginasi API Katalog Produk

Pertimbangkan situs web e-commerce dengan "API Katalog Produk". Ini adalah kasus penggunaan dunia nyata yang sempurna. Katalognya besar dan dinamis, dengan produk baru sering ditambahkan.

• Masalah: Jika situs menggunakan paginasi offset untuk daftar produknya, dan produk baru ditambahkan saat pelanggan menjelajah dari halaman 1 ke halaman 2, pelanggan mungkin melihat produk terakhir dari halaman 1 berulang di bagian atas halaman 2. Ini adalah pengalaman pengguna yang membingungkan.
• Solusi: Mengimplementasikan paginasi berbasis kursor adalah perbaikan ideal. Tombol "Muat Lebih Banyak" di bagian depan akan meneruskan kursor produk terakhir yang terlihat. API kemudian akan mengembalikan set produk berikutnya setelah produk spesifik tersebut, memastikan daftar hanya bertambah tanpa duplikasi atau item yang terlewatkan bagi pengguna.

Topik Lanjutan dan Masalah Umum

Seperti yang sering ditemukan oleh pengembang di Stack Overflow dan Reddit, membangun sistem paginasi yang benar-benar kuat memerlukan penanganan banyak detail dan kasus ekstrem.

Cara Memastikan Konsistensi Data dalam API yang Dipaginasi

Ini adalah salah satu topik lanjutan yang paling penting. Seperti yang dibahas, satu-satunya cara yang andal untuk menjamin konsistensi data dalam sistem dengan penulisan yang sering adalah dengan menggunakan paginasi keyset/kursor. Desainnya secara inheren mencegah page drift. Jika karena alasan tertentu Anda terjebak dengan paginasi offset, ada beberapa solusi kompleks, seperti membuat snapshot ID yang sementara dan tidak dapat diubah untuk seluruh kumpulan hasil dan melakukan paginasi melalui daftar tersebut, tetapi ini sangat stateful dan umumnya tidak disarankan untuk REST API.

Menangani Kasus Ekstrem yang Aneh

API yang siap produksi harus menangani input yang buruk dengan baik. Pertimbangkan kasus ekstrem umum ini:

• Klien meminta page=0 atau offset=-50. API seharusnya tidak mengeluarkan kesalahan 500. API harus mengembalikan 400 Bad Request dengan pesan kesalahan yang jelas.
• Klien memberikan cursor yang salah format atau tidak valid. API harus kembali mengembalikan 400 Bad Request.
• Klien memberikan kursor yang valid, tetapi item yang ditunjuknya telah dihapus. Strategi yang baik adalah memperlakukan kursor sebagai penunjuk ke "ruang" tempat item itu berada dan mengembalikan halaman hasil berikutnya dari titik itu.

Implementasi Sisi Klien

Sisi klien adalah tempat logika paginasi dikonsumsi. Menggunakan JavaScript untuk mengambil data yang dipaginasi dari REST API seperti seorang profesional melibatkan pembacaan metadata paginasi dan menggunakannya untuk membuat permintaan berikutnya.

Berikut adalah contoh fetch sederhana untuk tombol "Muat Lebih Banyak" menggunakan paginasi kursor:JavaScript

const loadMoreButton = document.getElementById('load-more');
let nextCursor = null; // Simpan kursor secara global atau dalam state komponen

async function fetchProducts(cursor) {
  const url = cursor ? `/api/products?cursor=${cursor}` : '/api/products';
  const response = await fetch(url);
  const data = await response.json();

  // ... render produk baru ...
  nextCursor = data.pagination.next_cursor;

  if (!nextCursor) {
    loadMoreButton.disabled = true; // Tidak ada halaman lagi
  }
}

loadMoreButton.addEventListener('click', () => fetchProducts(nextCursor));

// Muat awal
fetchProducts(null);

Masa Depan Pengambilan Data API dan Standar Paginasi

Meskipun REST telah dominan selama bertahun-tahun, lanskap selalu berkembang.

Standar Paginasi REST API yang Berkembang

Tidak ada satu pun RFC formal yang mendefinisikan standar paginasi REST API. Namun, serangkaian konvensi kuat telah muncul, didorong oleh API publik perusahaan teknologi besar seperti GitHub, Stripe, dan Atlassian. Konvensi ini, seperti menggunakan header Link dan menyediakan metadata yang jelas, telah menjadi standar de facto. Konsistensi adalah kunci; platform API yang dirancang dengan baik akan menggunakan strategi paginasi yang sama di semua endpoint berbasis daftar.

Dampak GraphQL terhadap Paginasi

GraphQL menyajikan paradigma yang berbeda. Alih-alih beberapa endpoint, ia memiliki satu endpoint di mana klien mengirim kueri kompleks yang menentukan data persis yang mereka butuhkan. Namun, kebutuhan untuk memaginasi daftar data yang besar tidak hilang. Komunitas GraphQL juga telah membakukan paginasi berbasis kursor melalui spesifikasi formal yang disebut Relay Cursor Connections Spec. Ini mendefinisikan struktur yang tepat untuk memaginasi data, menggunakan konsep seperti first, after, last, dan before untuk menyediakan paginasi maju dan mundur yang kuat.

Kesimpulan: Ringkasan Praktik Terbaik Paginasi

Menguasai paginasi REST API adalah keterampilan penting bagi pengembang backend mana pun. Ini adalah teknik yang penting untuk membangun aplikasi yang terukur, berkinerja, dan ramah pengguna.

Untuk merangkum praktik terbaik paginasi REST API:

1. Selalu Lakukan Paginasi: Jangan pernah mengembalikan daftar hasil yang tidak terbatas dari endpoint API.
2. Pilih Strategi yang Tepat: Gunakan paginasi offset sederhana untuk kumpulan data kecil, tidak kritis, atau statis. Untuk kumpulan data yang besar, dinamis, atau berhadapan langsung dengan pengguna, sangat disarankan menggunakan paginasi berbasis kursor untuk kinerja yang unggul dan konsistensi data.
3. Sediakan Metadata yang Jelas: Payload respons Anda harus selalu menyertakan informasi yang memberi tahu klien cara mendapatkan halaman data berikutnya, baik itu next_cursor atau nomor halaman dan tautan.
4. Gunakan Hypermedia: Gunakan header Link atau tautan dalam badan JSON Anda untuk membuat API Anda lebih mudah ditemukan dan digunakan.
5. Tangani Kesalahan dengan Baik: Validasi semua parameter paginasi dan kembalikan kesalahan 400 Bad Request yang jelas untuk input yang tidak valid.

Dengan mengikuti panduan ini dan menginternalisasi prinsip-prinsip ini, Anda dapat merancang dan membangun REST API profesional yang siap produksi yang dapat diskalakan secara efektif untuk memenuhi permintaan apa pun.

FAQ Paginasi REST API

1. Apa perbedaan utama antara paginasi offset dan kursor?

Perbedaan utama terletak pada cara mereka menentukan set data mana yang akan diambil. Paginasi offset menggunakan offset numerik (seperti "lewati 50 item pertama") untuk menemukan halaman berikutnya. Ini bisa lambat untuk kumpulan data besar karena basis data masih harus menghitung item yang dilewati. Paginasi kursor menggunakan penunjuk stabil atau "kursor" yang menunjuk ke catatan spesifik (seperti "ambil item setelah ID produk 857"). Ini jauh lebih efisien karena basis data dapat menggunakan indeks untuk melompat langsung ke catatan tersebut.

2. Kapan tepat menggunakan paginasi offset alih-alih paginasi kursor?

Paginasi offset tepat untuk kumpulan data yang kecil, tidak kritis terhadap kinerja, atau tidak sering berubah. Keuntungan utamanya adalah kesederhanaan dan kemampuan bagi pengguna untuk melompat ke nomor halaman spesifik mana pun (misalnya, "Pergi ke Halaman 10"). Ini membuatnya cocok untuk hal-hal seperti dashboard admin atau alat internal di mana pengalaman pengguna melompat antar halaman lebih penting daripada menangani perubahan data real-time.

3. Bagaimana paginasi berbasis kursor mencegah masalah melewatkan atau mengulang item?

Paginasi berbasis kursor mencegah ketidakkonsistenan data karena menambatkan permintaan berikutnya ke item spesifik, bukan posisi numerik. Misalnya, jika Anda meminta halaman setelah item dengan ID=100, tidak peduli jika item baru ditambahkan sebelumnya; kueri akan selalu mulai mengambil dari tempat yang benar. Dengan paginasi offset, jika item baru ditambahkan ke halaman 1 saat Anda melihatnya, ketika Anda meminta halaman 2, item terakhir dari halaman 1 sekarang akan menjadi item pertama di halaman 2, menyebabkan pengulangan.

4. Apakah ada standar resmi untuk respons paginasi REST API?

Tidak ada satu pun RFC resmi atau standar formal yang mendikte bagaimana semua paginasi REST API harus diimplementasikan. Namun, konvensi kuat dan praktik terbaik telah muncul dari industri, sebagian besar ditetapkan oleh API publik besar seperti yang dari GitHub dan Stripe. Konvensi ini mencakup penggunaan header HTTP Link dengan atribut rel="next" dan rel="prev", atau menyematkan objek pagination dengan metadata dan tautan yang jelas langsung di badan respons JSON.

5. Bagaimana saya harus menangani pengurutan dan pemfilteran dengan endpoint yang dipaginasi?

Pengurutan dan pemfilteran harus diterapkan sebelum paginasi. Hasil yang dipaginasi harus menjadi "tampilan" dari kumpulan data yang sudah diurutkan dan difilter. Sangat penting bahwa urutan pengurutan stabil dan deterministik. Jika pengguna mengurutkan berdasarkan bidang yang tidak unik (seperti tanggal), Anda harus menambahkan kunci pengurutan sekunder yang unik (seperti id catatan) untuk bertindak sebagai tie-breaker. Ini memastikan bahwa urutan item selalu sama, yang penting agar paginasi offset dan kursor berfungsi dengan benar.