React Query for data fetching in React Native - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What does this React Query hook render?

Given this React Native component using React Query, what will be displayed when the data is loading?

React Native

import React from 'react';
import {Text, View} from 'react-native';
import {useQuery} from '@tanstack/react-query';

function fetchUser() {
  return new Promise(resolve => setTimeout(() => resolve({name: 'Anna'}), 1000));
}

export default function User() {
  const {data, isLoading} = useQuery(['user'], fetchUser);

  if (isLoading) return <Text>Loading user info...</Text>;

  return <Text>User: {data.name}</Text>;
}

A Text component showing 'User: undefined'

B Text component showing 'User: Anna' immediately

C Text component showing 'Loading user info...'

D Blank screen with no text

💡 Hint

Think about what happens before the data is fetched.

When the query is loading, isLoading is true, so the component returns the loading text first. Only after data is fetched does it show the user name.

❓ lifecycle

intermediate

When does React Query refetch data by default?

Consider a React Native app using React Query. When does React Query automatically refetch the data after the initial fetch?

A Only when the app is restarted

B Every 5 seconds regardless of user interaction

C Never after the first fetch unless manually triggered

D When the component mounts and when the app window regains focus

💡 Hint

Think about how React Query keeps data fresh when users return to the app.

React Query refetches data when the component mounts and when the app window regains focus to keep data fresh.

🔧 Debug

advanced

Why does this React Query hook cause an infinite loop?

Look at this React Native component using React Query. Why does it keep refetching endlessly?

React Native

import React from 'react';
import {Text} from 'react-native';
import {useQuery} from '@tanstack/react-query';

function fetchData() {
  return fetch('https://api.example.com/data').then(res => res.json());
}

export default function DataComponent() {
  const {data} = useQuery(['data'], fetchData);

  React.useEffect(() => {
    console.log('Data changed:', data);
  }, [data]);

  return <Text>{data ? data.title : 'Loading...'}</Text>;
}

A Because useEffect triggers a state update causing rerender

B Because the query key is a new array each render causing refetch

C Because the fetch URL is invalid causing retries

D Because fetchData is redefined inside the component causing query key to change

💡 Hint

Check what is passed as the query key and if it changes every render.

The query key ['data'] is a new array each render, so React Query thinks the key changed and refetches endlessly.

🧠 Conceptual

advanced

What is the purpose of React Query's staleTime option?

In React Query, what does setting the staleTime option do?

A It sets how long data stays fresh before React Query considers it stale and refetches

B It controls how often React Query retries failed requests

C It defines the timeout duration for fetch requests

D It disables caching of query data

💡 Hint

Think about how React Query decides when to refetch data automatically.

staleTime sets the duration data is considered fresh; during this time React Query won't refetch automatically.

📝 Syntax

expert

Which option correctly uses React Query's useMutation hook in React Native?

You want to send data to an API when a button is pressed. Which code snippet correctly uses useMutation?

React Native

import React from 'react';
import {Button, Text} from 'react-native';
import {useMutation} from '@tanstack/react-query';

function postData(newData) {
  return fetch('https://api.example.com/post', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify(newData),
  }).then(res => res.json());
}

export default function PostButton() {
  const mutation = useMutation(postData);

  return (
    <>
      <Button title="Send" onPress={() => mutation.mutate({name: 'John'})} />
      {mutation.isLoading && <Text>Sending...</Text>}
      {mutation.isError && <Text>Error occurred</Text>}
      {mutation.isSuccess && <Text>Sent successfully</Text>}
    </>
  );
}

A Correctly uses useMutation with mutate called on button press and shows status texts

B Calls mutate immediately during render causing infinite loop

C Uses useMutation but calls mutate without arguments causing error

D Uses useMutation but does not handle loading or error states

💡 Hint

Check how mutate is called and how UI updates based on mutation state.

Option A correctly calls mutate inside onPress and shows loading, error, and success states.

Practice

1. What is the main purpose of using useQuery in React Query for React Native apps?

easy

A. To style components dynamically

B. To fetch and manage server data easily with caching and updates

C. To navigate between screens

D. To handle local state only

Solution

1. Step 1: Understand the role of useQuery

   useQuery is designed to fetch data from a server and manage it efficiently in React apps.

2. Step 2: Identify its features

   It automatically handles loading states, errors, caching, and data updates, making server data management easier.

3. Final Answer:

   To fetch and manage server data easily with caching and updates -> Option B

4. Quick Check:

   useQuery purpose = fetch and manage data [OK]

Hint: Remember: useQuery is for fetching and caching data [OK]

Common Mistakes:

• Confusing useQuery with navigation or styling hooks
• Thinking useQuery manages only local state
• Assuming useQuery is for UI rendering only

2. Which of the following is the correct syntax to use useQuery to fetch data with a key 'todos' and a fetch function fetchTodos?

easy

A. const { data } = useQuery('todos', fetchTodos);

B. const data = useQuery(fetchTodos, 'todos');

C. useQuery(fetchTodos, { key: 'todos' });

D. const { data } = useQuery({ key: 'todos', fetch: fetchTodos });

Solution

1. Step 1: Recall the useQuery syntax

   The correct syntax is useQuery(key, fetchFunction), where the first argument is a unique key and the second is the function to fetch data.

2. Step 2: Match the options

   const { data } = useQuery('todos', fetchTodos); matches this syntax exactly: useQuery('todos', fetchTodos).

3. Final Answer:

   const { data } = useQuery('todos', fetchTodos); -> Option A

4. Quick Check:

   useQuery(key, fetchFn) = const { data } = useQuery('todos', fetchTodos); [OK]

Hint: useQuery takes key first, then fetch function [OK]

Common Mistakes:

• Swapping the order of arguments
• Passing an object instead of separate arguments
• Not destructuring the returned data

3. Given this code snippet:

const fetchUser = async () => {
  return { name: 'Alice', age: 30 };
};

const { data, isLoading, error } = useQuery('user', fetchUser);

if (isLoading) return <Text>Loading...</Text>;
if (error) return <Text>Error!</Text>;

return <Text>{data.name} is {data.age} years old.</Text>;

What will be displayed after the data loads successfully?

medium

A. Loading...

B. Error!

C. Alice is 30 years old.

D. undefined is undefined years old.

Solution

1. Step 1: Analyze the fetch function and query

   The fetchUser function returns an object with name 'Alice' and age 30. useQuery fetches this data with key 'user'.

2. Step 2: Understand the rendering logic

   While loading, it shows 'Loading...'. On error, it shows 'Error!'. After successful fetch, it renders the text with data values.

3. Final Answer:

   Alice is 30 years old. -> Option C

4. Quick Check:

   Data loaded = Alice is 30 years old [OK]

Hint: Check loading and error before rendering data [OK]

Common Mistakes:

• Ignoring loading or error states
• Accessing data before it loads
• Assuming data is undefined

4. Identify the error in this React Query usage:

const { data, isLoading } = useQuery(fetchPosts, 'posts');

medium

A. The arguments to useQuery are reversed; key should come first

B. useQuery requires a third argument for options

C. Destructuring data and isLoading is not allowed

D. fetchPosts should be a string, not a function

Solution

1. Step 1: Check the argument order for useQuery

   The correct order is useQuery(key, fetchFunction). Here, the fetch function is passed first, then the key.

2. Step 2: Identify the mistake

   The arguments are reversed, which will cause an error or unexpected behavior.

3. Final Answer:

   The arguments to useQuery are reversed; key should come first -> Option A

4. Quick Check:

   useQuery(key, fetchFn) order matters [OK]

Hint: Key always comes before fetch function in useQuery [OK]

Common Mistakes:

• Swapping key and fetch function arguments
• Forgetting to pass a unique key
• Assuming fetch function can be a string

5. You want to fetch a list of posts and automatically refetch the data every 10 seconds using React Query. Which code snippet correctly implements this behavior?

hard

A. const { data } = useQuery('posts', fetchPosts, { staleTime: 10000 });

B. const { data } = useQuery('posts', fetchPosts, { refetchOnWindowFocus: true });

C. const { data } = useQuery('posts', fetchPosts, { cacheTime: 10000 });

D. const { data } = useQuery('posts', fetchPosts, { refetchInterval: 10000 });

Solution

1. Step 1: Understand refetching options in React Query

   To refetch data automatically at intervals, use the refetchInterval option with the interval time in milliseconds.

2. Step 2: Match the correct option

   const { data } = useQuery('posts', fetchPosts, { refetchInterval: 10000 }); uses refetchInterval: 10000 which means refetch every 10 seconds. Other options control different behaviors.

3. Final Answer:

   const { data } = useQuery('posts', fetchPosts, { refetchInterval: 10000 }); -> Option D

4. Quick Check:

   Auto refetch = refetchInterval option [OK]

Hint: Use refetchInterval to auto-refresh data periodically [OK]

Common Mistakes:

• Confusing refetchOnWindowFocus with interval refetch
• Using cacheTime or staleTime incorrectly
• Not passing options as third argument