react-query/docs/framework/vue/reactivity.md

---
id: reactivity
title: Reactivity
---

Vue uses the [the signals paradigm](https://vuejs.org/guide/extras/reactivity-in-depth.html#connection-to-signals) to handle and track reactivity. A key feature of
this system is the reactive system only triggers updates on specifically watched reactive properties. A consequence of this is you also need to ensure that the queries are updated when values they consume are updated.

# Keeping Queries Reactive

When creating a composable for a query your first choice may be to write it like so:

```ts
export function useUserProjects(userId: string) {
  return useQuery(
    queryKey: ['userProjects', userId],
    queryFn: () => api.fetchUserProjects(userId),
  );
}
```

We might consume this composable like so:

```ts
// Reactive user ID ref.
const userId = ref('1')
// Fetches the user 1's projects.
const { data: projects } = useUserProjects(userId.value)

const onChangeUser = (newUserId: string) => {
  // Edits the userId, but the query will not re-fetch.
  userId.value = newUserId
}
```

This code will not work as intended. This is because we are extracting the value from the userId ref directly. Vue-query is not tracking the `userId` `ref` so it has no way of knowing when the value changes.

Luckily, the fix for this is trivial. The value must be made trackable in the query key. We can Just accept the `ref` directly in the composable and place it in the query key:

```ts
export function useUserProjects(userId: Ref<string>) {
  return useQuery(
    queryKey: ['userProjects', userId],
    queryFn: () => api.fetchUserProjects(userId.value),
  );
}
```

Now the query will re-fetch when the `userId` changes.

```ts
const onChangeUser = (newUserId: string) => {
  // Query refetches data with new user ID!
  userId.value = newUserId
}
```

In vue query any reactive properties within a query key are tracked for changes automatically. This allows vue-query to refetch data whenever the
parameters for a given request change.

## Accounting for Non-Reactive Queries

While far less likely, sometimes passing non-reactive variables is intentional. For example, some entities only need to be fetched once and don't need tracking or we invalidate a mutation a query options object after a mutation.
If we use our custom composable defined above the usage in this case feels a bit off:

```ts
const { data: projects } = useUserProjects(ref('1'))
```

We have to create an intermediate `ref` just to make the parameter type-compatible. We can do better here. Let's instead update our composable to accept both plain values and reactive values:

```ts
export function useUserProjects(userId: MaybeRef<string>) {
  return useQuery(
    queryKey: ['userProjects', userId],
    queryFn: () => api.fetchUserProjects(toValue(userId)),
  );
}
```

Now we can use the composable with both plain values and refs:

```ts
// Fetches the user 1's projects, userId is not expected to change.
const { data: projects } = useUserProjects('1')

// Fetches the user 1's projects, queries will react to changes on userId.
const userId = ref('1')

// Make some changes to userId...

// Query re-fetches based on any changes to userId.
const { data: projects } = useUserProjects(userId)
```

## Using Derived State inside Queries

It's quite common to derive some new reactive state from another source of reactive state. Commonly, this problem manifests in situations where you deal with component props. Let's assume our `userId` is a prop passed to a component:

```vue
<script setup lang="ts">
const props = defineProps<{
  userId: string
}>()
</script>
```

You may be tempted to use the prop directly in the query like so:

```ts
// Won't react to changes in props.userId.
const { data: projects } = useUserProjects(props.userId)
```

However, similar to the first example, this is not reactive. Property access on `reactive` variables causes reactivity to be lost. We can fix this by making this derived state reactive via a `computed`:

```ts
const userId = computed(() => props.userId)

// Reacts to changes in props.userId.
const { data: projects } = useUserProjects(userId)
```

This works as expected, however, this solution isn't always the most optimal. Aside from the introduction of an intermediate variable, we also create a memoized value that is somewhat unnecessary. For trivial cases of simple property access `computed` is an optimization with no real benefit. In these cases a more appropriate solution is to use [reactive getters](https://blog.vuejs.org/posts/vue-3-3#better-getter-support-with-toref-and-tovalue). Reactive getters are simply functions that return a value based on some reactive state, similar to how `computed` works. Unlike `computed`, reactive getters do not memoize their values so it makes it a good candidate for simple property access.

Let's once again refactor our composable, but this time we'll have it accept a `ref`, plain value, or a reactive getter:

```ts
export function useUserProjects(userId: MaybeRefOrGetter<string>) {
  ...
}
```

Let's adjust our usage and now use a reactive getter:

```ts
// Reacts to changes in props.userId. No `computed` needed!
const { data: projects } = useUserProjects(() => props.userId)
```

This gives us a terse syntax and the reactivity we need without any unneeded memoization overhead.

## Other tracked Query Options

Above, we only touched one query option that tracks reactive dependencies. However, in addition to `queryKey`, `enabled` also allows
the use of reactive values. This comes in handy in situations where you want to control the fetching of a query based on some derived state:

```ts
export function useUserProjects(userId: MaybeRef<string>) {
  return useQuery(
    queryKey: ['userProjects', userId],
    queryFn: () => api.fetchUserProjects(toValue(userId)),
    enabled: () => userId.value === activeUserId.value,
  );
}
```

More details on this option can be found on the [useQuery reference](../reference/useQuery.md) page.

## Immutability

Results from `useQuery` are always immutable. This is necessary for performance and caching purposes. If you need to mutate a value returned from `useQuery`, you must create a copy of the data.

One implication of this design is that passing values from `useQuery` to a two-way binding such as `v-model` will not work. You must create a mutable copy of the data before attempting to update it in place.

# Key Takeaways

- `enabled` and `queryKey` are the two query options that can accept reactive values.
- Pass query option that accept all three types of values in Vue: refs, plain values, and reactive getters.
- If you expect a query to react to changes based on the values it consumes, ensure that the values are reactive. (i.e. pass in refs directly to the query, or use reactive getters)
- If you don't need a query to be reactive pass in a plain value.
- For trivial derived state such as property access consider using a reactive getter in place of a `computed`.
- Results from `useQuery` are always immutable.