Overview - Query

query

7 days30 days

Latest CI Pipeline Executions

Fuzzy

Succeeded
10598
f6b63a04 fix(solid-query): skip reconcile when data reference is unchanged Previously, the reconcile path in useBaseQuery would invoke the user's reconcile callback (or the structural reconcile from solid-js/store) multiple times per logical query update — once for fetching=true transitions where the data reference had not changed, and again when the actual data resolved. With user-provided reconcile functions, this showed up as oldData === newData calls. Short-circuit reconcileFn when store.data === result.data; the rest of the result still flows through setState so isFetching/status updates keep working. Closes #8873
by Ousama Ben...
Succeeded
10580
b8e8cea6 test(vue-query): pin suspense() Promise<TResult> parameterization Adds a regression test asserting that `useQuery(...).suspense()` resolves to `Promise<QueryObserverResult<TData, TError>>` (parameterized by `TResult` on `UseBaseQueryReturnType`) and that awaiting it preserves the discriminated union narrowing on `isSuccess` / `isError`. Closes the verification gap noted on #10580 — the parameterization was previously only validated via tsc build, not by an explicit `expectTypeOf` assertion.
by Ousama Ben...
Succeeded
10593
011141dc refactor(query-core): drop NoInfer re-export, use built-in everywhere Per @TkDodo's review: TypeScript's intrinsic NoInfer (TS ≥ 5.4) is the canonical type, and the package already requires TS ≥ 5.4. Removing the re-export sidesteps the self-shadowing issue entirely and avoids encouraging consumers to import a duplicate.
by Ousama Ben...
Succeeded
10593
24c74b9b test(react-query): document implicit regression guard for generic indexed-access NoInfer Per CodeRabbit nitpick: clarify that the `getLabel(props.dataType, data)` call itself is the regression guard. With the previous hand-rolled NoInfer, this call failed to type-check; with built-in NoInfer (TS 5.4+), it compiles. An explicit `expectTypeOf(data).toEqualTypeOf<...>()` / `toMatchTypeOf<...>()` cannot work here — vitest's type-relation checks reduce to `Extends<NoInfer<T>, T>` which TS leaves unresolved under a generic `TDataType extends DataType` constraint. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
by Ousama Ben...
Succeeded
10593
d942386c test(react-query): move 'generic indexed access TData' describe out of 'initialData' Block was nested inside `describe('initialData', ...)` but is unrelated to initialData behavior. Lift it to sibling level under `describe('useQuery', ...)` so test output groups it correctly. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
by Ousama Ben...
Succeeded
10593
e9172ef8 fix(query-core): use built-in NoInfer to support generic indexed-access types The local `NoInfer<T> = [T][T extends any ? 0 : never]` trick breaks down when `T` is a generic indexed-access type such as `DataTypeToEntity[DT]`, producing errors like "Type '[DataTypeToEntity[DT]]' is not assignable to type 'DataTypeToEntity'". Since the project already requires TypeScript >= 5.4, delegate the public `NoInfer<T>` alias to TypeScript's built-in `NoInfer` (introduced in 5.4). A small `noInfer.ts` helper exposes it as `IntrinsicNoInfer<T>` to avoid the local-shadow recursion problem. Vue's `setQueryData` implementation now forwards the `<TData>` generic to `super.setQueryData<TData>(...)` so its declared `NoInfer<TData> | undefined` return type stays satisfied under the stricter built-in `NoInfer`. Fixes #9937
by Ousama Ben...
Succeeded
10592
fe12586c fix(solid-query): don't trigger Suspense when data is already cached When data was preloaded via `ensureQueryData` (e.g. from a router loader), the proxy `data` getter read `queryResource.latest`, which falls back to a suspending read while the resource is in its initial pending state, even though the fetcher had already synchronously resolved with cached data. If the store already has data and no fetch is in-flight, return `state.data` directly. `state.isFetching` is read via `untrack` so it doesn't widen the data subscriber's reactive deps. Fixes #9955
by Ousama Ben...
Succeeded
10577
e110aff2 Revert "test(solid-query): add runtime test for combine returning arbitrary shape" This reverts commit d1df126685a258f5fc334909df340d3d7bd030e8.
by Ousama Ben...
Succeeded
10584
beb9b81c test(vue-query): strengthen #8199 regression assertion with explicit TData Per CodeRabbit feedback: bare assertType(useBasket('fruit')) only verified the call compiled, which would still pass under the old buggy behavior (TQueryKey collapsing to QueryKey, TData inferred as unknown). Lock the regression by asserting the propagated TData explicitly.
by Ousama Ben...
Succeeded
10584
25f32fb4 fix(vue-query): preserve TQueryKey inference with generic params (#8199) The mapped UseQueryOptions type wrapped queryKey in MaybeRefDeep<DeepUnwrapRef<TQueryKey>>. The recursive DeepUnwrapRef on a generic TQueryKey is opaque to TS's homomorphic mapped type inference, so TQueryKey collapsed to its default (QueryKey) when useQuery was called from a composable that propagates a generic into the queryKey. For the queryKey property only, drop DeepUnwrapRef and use a single- level MaybeRef<TQueryKey> wrap. Inference now binds TQueryKey to the supplied queryKey shape; queryFn still receives DeepUnwrapRef<TQueryKey> via the existing mapping for non-queryKey properties. Co-Authored-By: Ora Studio <noreply@oratelecom.net>
by Ousama Ben...
Failed
10577
d1df1266 test(solid-query): add runtime test for combine returning arbitrary shape Type-only tests (`expectTypeOf(result).toEqualTypeOf<{ data: boolean }>()`) silently pass even when `useQueries` mishandles the combined object at runtime. This adds a render-based test that mounts the hook with a non-array combine return and asserts the resolved shape after queries settle, so a regression in `useQueries.ts` (e.g. proxy/array assumptions) fails the suite instead of slipping through.
by Ousama Ben...
Succeeded
10580
b69f0795 fix(vue-query): parameterize suspense return type by TResult The previous shape pinned `suspense` to `Promise<QueryObserverResult<TData, TError>>` inside the distributive conditional, so awaiting `suspense()` lost type precision when `UseBaseQueryReturnType` was instantiated with `DefinedQueryObserverResult` (data became `TData | undefined` again) or `InfiniteQueryObserverResult` (no `fetchNextPage`/`hasNextPage`/`data.pages`). Lifting `suspense` outside the distributive arm and typing it as `Promise<TResult>` keeps the per-property mapping distributive but lets the suspense result carry the parameterized observer type — matching the runtime already returned by `observer.fetchOptimistic()` / `getOptimisticResult()`.
by Ousama Ben...
Succeeded
10580
7042fa98 fix(vue-query): preserve discriminated union narrowing in UseBaseQueryReturnType (#9244) Make the mapped type explicitly distributive over each variant of QueryObserverResult, and lock in the narrowing patterns that work without reactive() (direct data.value !== undefined check) versus those that require reactive() (narrowing via isSuccess / status). Fixes #9244 Generated by Claude Code Vibe coded by ousamabenyounes Co-Authored-By: Claude <noreply@anthropic.com>
by Ousama Ben...
Succeeded
10578
562030d9 fix(svelte-query): wrap TData in NoInfer on query return types (#7673) The original report (#7673) showed `select`'s `data` parameter typed as `any` when wrapping options in a Svelte 4 `derived` store. Svelte 5 removed that store-based API and the basic case now infers correctly, but `createQuery` / `createInfiniteQuery` still let TypeScript widen `TData` from the result-type annotation, unlike `react-query`, `preact-query`, and `vue-query` which all wrap `TData` in `NoInfer`. Aligning svelte-query with the rest of the ecosystem ensures `TData` comes from the input options only, locking in the inferred `select` result and preventing silent widening when the call site is annotated. Adds three type tests covering: select inference from queryFn return, select inference when spreading queryOptions, and the negative case where a wrong result-type annotation must not widen TData. Generated by Claude Code Vibe coded by ousamabenyounes Co-Authored-By: Claude <noreply@anthropic.com>
by Ousama Ben...
Succeeded
10577
0f01fbd8 fix(solid-query): allow combine to return arbitrary object shape (#7522) Relax `TCombinedResult` from `extends QueriesResults<T>` to `extends object` on `useQueries` / `createQueries`, mirroring the React adapter's flexibility. A `combine` callback can now return any object literal — e.g. `combine: (results) => ({ data: results.every(r => r.data) })` — instead of being forced to match the array of per-query results. The proxy/resource logic that follows still needs an array view of the store, so `state` is aliased to `Array<QueryObserverResult>` for those internal operations only. The reactive Solid store is preserved at runtime; the cast only affects TypeScript. Co-Authored-By: Claude <noreply@anthropic.com>
by Ousama Ben...