Summary

• Resolves (vue) useQuery loses typing of variables #3733
• Reverts changes from d07602d and 068df71.

Background

This PR addresses issues introduced by the deep unwrapping of the variables field:

1. Type enforcement for variables becomes extremely challenging (if not impossible)
2. Current workarounds use type assertions that completely break the typing of variables (and maybe more)
3. Behavior is undocumented and unintuitive for users

The proposal is to revert to simple unwrapping, along with several improvements detailed below.
Should this proposal be accepted, I'd be happy to update the documentation.

Changes

• Revert MaybeRefObj, UseQueryArgs, and UseSubscriptionArgs definitions from d07602d
• Align with Vue 3.3+ naming:
  • MaybeRef → MaybeRefOrGetter
  • MaybeRefObj → MaybeRefOrGetterObj
  • unwrap → toValue
• Replace deep unwrapping of variables (introduced in 068df71) with a simple toValue
• Revert test changes from 068df71
• Update 'reacts to variables changing' test to use reactive() wrapper since deep unwrapping is no longer performed
• Regenerate pnpm-lock.yaml to use updated dependencies
• Fix createRequest documentation

Implementation Note

In createRequestWithArgs, I had to use a type assertion for _args.variables as TypeScript struggles with type inference in this case. While the typing appears correct, I welcome review of this approach. There is also a related question on the GraphQLRequestParams definition (discussed here). Alternative suggestions for a more elegant solution are appreciated.

Discussion Point: Query Field Reactivity

While this PR doesn't modify it, I question whether the query field should support reactivity. Creating a new query via useQuery or the client handle seems more appropriate. Additionally, TypeScript users wouldn't be able to replace the query value with a different type, which arguably makes this feature useless.

Discussion Point 2: Optional Variables

As noted here, the current implementation of MaybeRefObj also breaks the behavior of GraphQLRequestParams, which makes the variables field optional in certain cases, for example for queries that do not require variables. In the definition of UseQueryArgs, the intersection with this type is wrapped in an outer MaybeRefObj:

& MaybeRefObj<GraphQLRequestParams<Data, MaybeRefObj<Variables>>>;

This causes the variables field to be non-optional even for queries that do not require variables. The reason comes from the definition of MaybeRefObj and the fact that that Exact<{ [key: string]: never; }> extends {}.

Proposed solutions

1. Modify MaybeRefObj definition:

type MaybeRefObj<T extends {}> =
  T extends Record<string, never> ? T : { [K in keyof T]: MaybeRef<T[K]> };

This allows omitting variables when not needed while maintaining type safety, but note that other edge cases may exist.

2. Simplify UseQueryArgs definition:

& GraphQLRequestParams<Data, MaybeRef<Variables>>;

This approach would resolve all the possible edge cases and improve type safety maintainability. It would also make the query field non-reactive, which, as I argued in the previous point, aligns with best practices.