BAB 8: API dan Data
Mengambil data dari server dengan TanStack Query: keadaan memuat dan gagal, cache, pemuatan ulang saat aplikasi aktif kembali, mutasi, dan daftar bertahap.
Hampir semua aplikasi mobile mengambil data dari server. Bagian yang sering diremehkan bukan permintaan pertamanya, tapi semua keadaan di sekitarnya: jaringan putus di tengah jalan, pengguna berpindah aplikasi lalu kembali, server membalas dengan error, dan halaman yang sama dibuka berulang kali.
Bab ini membangun lapisan data yang menangani keadaan tersebut, memakai TanStack Query di atas fetch.
Kenapa tidak fetch langsung di useEffect
Pola yang biasa ditulis pemula:
useEffect(() => {
fetch("https://api.contoh.com/catatan")
.then((r) => r.json())
.then(setData);
}, []);
Kode itu berjalan, sampai muncul kebutuhan berikut:
- menampilkan indikator memuat dan pesan gagal
- mencegah permintaan ganda ketika layar dibuka 2 kali
- menyimpan hasil supaya tidak diminta ulang setiap kali layar dibuka
- memperbarui data setelah pengguna menambah item
- membatalkan permintaan ketika layar ditutup
Menulis 5 hal itu sendiri berarti membangun cache, dan cache yang ditulis setengah matang lebih berbahaya daripada tidak ada cache.
Memasang TanStack Query
npm install @tanstack/react-query
Lalu pasang penyedianya di layout akar:
// app/_layout.tsx
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import type { ReactNode } from "react";
const queryClient = new QueryClient({
defaultOptions: {
queries: {
retry: 2,
staleTime: 60_000,
gcTime: 10 * 60_000,
},
},
});
export default function Kerangka({ children }: { children: ReactNode }) {
return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
}
3 pengaturan awal itu perlu dipahami, karena menentukan perilaku seluruh aplikasi.
| Pengaturan | Arti |
|---|---|
retry | jumlah percobaan ulang otomatis saat gagal |
staleTime | berapa lama data dianggap masih segar, selama itu tidak ada permintaan ulang |
gcTime | berapa lama data yang tidak dipakai disimpan sebelum dibuang dari memori |
staleTime dan gcTime sering tertukar. Yang pertama menentukan kapan data perlu diperbarui, yang kedua menentukan kapan data dihapus.
Memberi tahu kapan aplikasi aktif
Di browser, TanStack Query memuat ulang data ketika jendela kembali fokus. Di React Native, informasi itu harus diberikan sendiri lewat AppState:
// lib/fokus.ts
import { focusManager } from "@tanstack/react-query";
import { AppState, Platform } from "react-native";
export function pasangPemantauFokus() {
const langganan = AppState.addEventListener("change", (status) => {
if (Platform.OS !== "web") {
focusManager.setFocused(status === "active");
}
});
return () => langganan.remove();
}
Tanpa ini, pengguna yang meninggalkan aplikasi selama satu jam akan melihat data lama sampai layar dibuka ulang secara manual.
Untuk status jaringan, onlineManager bisa disambungkan ke Expo Network:
// lib/jaringan.ts
import { onlineManager } from "@tanstack/react-query";
import * as Network from "expo-network";
export function pasangPemantauJaringan() {
onlineManager.setEventListener((setOnline) => {
let sudahDapat = false;
const langganan = Network.addNetworkStateListener((state) => {
sudahDapat = true;
setOnline(Boolean(state.isConnected));
});
Network.getNetworkStateAsync()
.then((state) => {
if (!sudahDapat) setOnline(Boolean(state.isConnected));
})
.catch(() => {
// sebagian platform menolak pembacaan awal, abaikan
});
return langganan.remove;
});
}
Dengan itu, permintaan tidak dicoba saat perangkat benar-benar offline, dan otomatis dijalankan ketika koneksi kembali.
Fungsi pengambil data
Pisahkan pengambilan data dari komponen. Satu fungsi, satu tanggung jawab.
// api/catatan.ts
import type { Catatan } from "../types";
const BASE = process.env.EXPO_PUBLIC_API_URL;
export class GalatApi extends Error {
constructor(public status: number, message: string) {
super(message);
}
}
async function minta<T>(jalur: string, init?: RequestInit): Promise<T> {
const respons = await fetch(`${BASE}${jalur}`, {
...init,
headers: { Accept: "application/json", "Content-Type": "application/json", ...init?.headers },
signal: AbortSignal.timeout(10_000),
});
if (!respons.ok) {
throw new GalatApi(respons.status, `Permintaan gagal (${respons.status})`);
}
return (await respons.json()) as T;
}
export const ambilCatatan = (): Promise<Catatan[]> => minta<Catatan[]>("/catatan");
export const ambilCatatanSatu = (id: string): Promise<Catatan> => minta<Catatan>(`/catatan/${id}`);
export const buatCatatan = (isi: { judul: string; isi: string }): Promise<Catatan> =>
minta<Catatan>("/catatan", { method: "POST", body: JSON.stringify(isi) });
export const hapusCatatan = (id: string): Promise<void> =>
minta<void>(`/catatan/${id}`, { method: "DELETE" });
Melempar error saat status bukan 2xx penting. fetch tidak melakukan itu, sehingga respons 500 akan tetap dianggap berhasil kalau tidak diperiksa.
Membaca data di layar
// app/catatan/index.tsx
import { useQuery } from "@tanstack/react-query";
import { ActivityIndicator, FlatList, Pressable, Text, View } from "react-native";
import { ambilCatatan } from "../../api/catatan";
export default function DaftarCatatan() {
const { data, isPending, isError, error, refetch, isRefetching } = useQuery({
queryKey: ["catatan"],
queryFn: ambilCatatan,
});
if (isPending) {
return (
<View style={{ flex: 1, alignItems: "center", justifyContent: "center" }}>
<ActivityIndicator />
</View>
);
}
if (isError) {
return (
<View style={{ padding: 24, gap: 12 }}>
<Text style={{ fontWeight: "700" }}>Data gagal dimuat</Text>
<Text style={{ color: "#64748b" }}>{error.message}</Text>
<Pressable onPress={() => refetch()}>
<Text style={{ color: "#6366f1", fontWeight: "600" }}>Coba lagi</Text>
</Pressable>
</View>
);
}
return (
<FlatList
data={data}
keyExtractor={(item) => item.id}
refreshing={isRefetching}
onRefresh={refetch}
ListEmptyComponent={<Text style={{ padding: 24 }}>Belum ada catatan.</Text>}
renderItem={({ item }) => <Text style={{ padding: 16 }}>{item.judul}</Text>}
/>
);
}
Perhatikan isPending, bukan isLoading. Di TanStack Query versi sekarang, isPending berarti belum ada data sama sekali, sedangkan isFetching berarti sedang ada permintaan termasuk pembaruan latar belakang. Membedakan keduanya mencegah layar berkedip menjadi spinner setiap kali data diperbarui.
Kunci query
queryKey adalah identitas data di dalam cache. Aturannya sederhana: apa pun yang memengaruhi hasil permintaan harus ada di kunci.
useQuery({ queryKey: ["catatan", { status: "selesai" }], queryFn: ... });
useQuery({ queryKey: ["catatan", id], queryFn: () => ambilCatatanSatu(id) });
Kunci juga menjadi dasar pembaruan setelah mutasi. Salah menyusun kunci berarti data lama tetap tampil meski server sudah berubah.
Mutasi
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { Alert } from "react-native";
import { buatCatatan, hapusCatatan } from "../../api/catatan";
export function useAksiCatatan() {
const queryClient = useQueryClient();
const tambah = useMutation({
mutationFn: buatCatatan,
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ["catatan"] });
},
onError: (galat) => {
Alert.alert("Gagal menyimpan", galat.message);
},
});
const hapus = useMutation({
mutationFn: hapusCatatan,
onMutate: async (id: string) => {
await queryClient.cancelQueries({ queryKey: ["catatan"] });
const sebelumnya = queryClient.getQueryData<Catatan[]>(["catatan"]);
queryClient.setQueryData<Catatan[]>(["catatan"], (lama) => lama?.filter((c) => c.id !== id) ?? []);
return { sebelumnya };
},
onError: (_galat, _id, konteks) => {
if (konteks?.sebelumnya) queryClient.setQueryData(["catatan"], konteks.sebelumnya);
},
onSettled: () => {
queryClient.invalidateQueries({ queryKey: ["catatan"] });
},
});
return { tambah, hapus };
}
Pola onMutate di atas disebut pembaruan optimistis: daftar langsung berubah di layar sebelum server menjawab, dan dikembalikan ke keadaan semula kalau permintaan gagal. Untuk aksi yang terasa instan seperti menghapus item, pola ini menghilangkan jeda yang mengganggu.
Daftar bertahap
import { useInfiniteQuery } from "@tanstack/react-query";
import { FlatList } from "react-native";
const { data, fetchNextPage, hasNextPage, isFetchingNextPage } = useInfiniteQuery({
queryKey: ["catatan", "halaman"],
queryFn: ({ pageParam }) => ambilHalaman(pageParam),
initialPageParam: 0,
getNextPageParam: (halamanTerakhir) => halamanTerakhir.cursorBerikutnya ?? undefined,
});
const item = data?.pages.flatMap((halaman) => halaman.item) ?? [];
<FlatList
data={item}
keyExtractor={(i) => i.id}
onEndReached={() => {
if (hasNextPage && !isFetchingNextPage) fetchNextPage();
}}
onEndReachedThreshold={0.5}
renderItem={renderBaris}
/>
3 hal wajib pada useInfiniteQuery: initialPageParam, getNextPageParam, dan penggabungan halaman dengan flatMap. hasNextPage bernilai benar selama getNextPageParam mengembalikan nilai selain null atau undefined.
Menyimpan cache ke disk
Data yang sudah diambil akan hilang saat aplikasi ditutup. Untuk aplikasi yang perlu tetap bisa dibaca offline, cache bisa disimpan:
npm install @tanstack/query-async-storage-persister @tanstack/react-query-persist-client
import AsyncStorage from "@react-native-async-storage/async-storage";
import { createAsyncStoragePersister } from "@tanstack/query-async-storage-persister";
import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
const persister = createAsyncStoragePersister({ storage: AsyncStorage });
<PersistQueryClientProvider client={queryClient} persistOptions={{ persister, maxAge: 24 * 60 * 60 * 1000 }}>
{children}
</PersistQueryClientProvider>
maxAge mencegah data berumur seminggu muncul kembali sebagai keadaan terkini. Tanpa batas, pengguna bisa melihat informasi lama yang terlihat baru.
Batas antara cache dan data sensitif
Cache di penyimpanan biasa tidak terenkripsi. Data seperti token, nomor kartu, atau dokumen pribadi tidak boleh masuk ke sana. Kalau aplikasi harus menyimpan data sensitif untuk dibaca offline, gunakan penyimpanan terenkripsi sistem dan simpan hanya yang benar-benar diperlukan.
Untuk data yang hanya milik satu pengguna, bersihkan cache saat keluar akun:
queryClient.clear();
Kesalahan yang sering terjadi
| Gejala | Penyebab | Perbaikan |
|---|---|---|
| spinner muncul setiap kali layar dibuka | memakai isPending padahal data sudah ada | periksa isFetching untuk pembaruan latar |
| data tidak berubah setelah menambah | kunci tidak diinvalidasi | invalidateQueries pada kunci yang tepat |
| permintaan berulang saat layar dibuka | staleTime nol dan fokus berubah | naikkan staleTime |
| error 500 dianggap berhasil | tidak memeriksa respons.ok | lempar error saat status bukan 2xx |
| aplikasi crash saat respons bukan JSON | JSON.parse pada HTML error | periksa header atau bungkus dengan try |
| daftar bertahap menggandakan item | halaman digabung dengan concat tanpa flatMap | pakai flatMap pada data.pages |
Latihan singkat
- Tambahkan layar detail yang memakai
queryKey: ["catatan", id], lalu pastikan membuka detail 2 catatan berbeda tidak menampilkan data yang tertukar. - Ubah penghapusan menjadi pembaruan optimistis, lalu matikan jaringan dan pastikan item kembali muncul setelah gagal.
- Atur
staleTimemenjadi 5 menit pada daftar, dan bandingkan jumlah permintaan sebelum dan sesudah dengan melihat log server.
Ringkasan
TanStack Query memisahkan data server dari state aplikasi. Kunci query menentukan identitas cache, staleTime menentukan kapan data diperbarui, AppState memberi tahu kapan aplikasi aktif kembali, dan mutasi diikuti invalidasi supaya daftar tidak menampilkan data lama. Untuk aplikasi yang harus tetap terbaca saat offline, cache dapat dipersistenkan, dengan catatan data sensitif tidak boleh ikut.
Bab 9 masuk ke fitur perangkat: kamera, lokasi, penyimpanan aman, dan notifikasi.