Data dan State

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:

React TSXTSX
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

BashBASH
npm install @tanstack/react-query

Lalu pasang penyedianya di layout akar:

React TSXTSX
// 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.

PengaturanArti
retryjumlah percobaan ulang otomatis saat gagal
staleTimeberapa lama data dianggap masih segar, selama itu tidak ada permintaan ulang
gcTimeberapa 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:

React TSXTSX
// 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:

TypeScriptTS
// 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.

TypeScriptTS
// 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

React TSXTSX
// 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.

TypeScriptTS
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

React TSXTSX
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

React TSXTSX
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:

BashBASH
npm install @tanstack/query-async-storage-persister @tanstack/react-query-persist-client
React TSXTSX
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:

TypeScriptTS
queryClient.clear();

Kesalahan yang sering terjadi

GejalaPenyebabPerbaikan
spinner muncul setiap kali layar dibukamemakai isPending padahal data sudah adaperiksa isFetching untuk pembaruan latar
data tidak berubah setelah menambahkunci tidak diinvalidasiinvalidateQueries pada kunci yang tepat
permintaan berulang saat layar dibukastaleTime nol dan fokus berubahnaikkan staleTime
error 500 dianggap berhasiltidak memeriksa respons.oklempar error saat status bukan 2xx
aplikasi crash saat respons bukan JSONJSON.parse pada HTML errorperiksa header atau bungkus dengan try
daftar bertahap menggandakan itemhalaman digabung dengan concat tanpa flatMappakai flatMap pada data.pages

Latihan singkat

  1. Tambahkan layar detail yang memakai queryKey: ["catatan", id], lalu pastikan membuka detail 2 catatan berbeda tidak menampilkan data yang tertukar.
  2. Ubah penghapusan menjadi pembaruan optimistis, lalu matikan jaringan dan pastikan item kembali muncul setelah gagal.
  3. Atur staleTime menjadi 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.