packages/tanstack-solid-query/test/skipToken.test.tsx (1)

1-67: 💡 Verification agent

❓ Verification inconclusive

Address commented-out skipToken tests

Almost the entire test file is commented out, which aligns with your PR description mentioning "some issues with the skipToken feature". Consider either:

1. Implementing functioning tests if the feature is ready
2. Adding a TODO comment explaining why tests are disabled
3. Removing the file if the feature isn't planned for this release

This will help maintain a clean codebase and clear expectations about feature status.

---

Clean up disabled skipToken tests

The file packages/tanstack-solid-query/test/skipToken.test.tsx is fully commented out. To keep the codebase clear, please choose one of the following:

• Add a clear TODO at the top of the file explaining why these tests are disabled (e.g. linking an issue or noting planned follow-up).
• Re-enable and implement these tests if the skipToken API is ready for verification.
• Remove the file entirely if testing for this feature isn’t planned in the current release.

packages/tanstack-solid-query/README.md (2)

15-19: Nitpick: Fix blockquote formatting and grammar

Remove the blank line inside the warning blockquote and adjust the verb for better English usage.

Suggested diff:

- > [!WARNING]
- >
- > 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧
- > This package is currently in beta as we stabilize the API. We might do breaking changes without respecting semver.
+ > [!WARNING]
+ > 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧
+ > This package is currently in beta as we stabilize the API. We might make breaking changes without respecting semver.

🧰 Tools

🪛 LanguageTool

[grammar] ~18-~18: Collocation: With the noun “changes”, you should use the verb “make”.
Context: ... beta as we stabilize the API. We might do breaking changes without respecting sem...

(MAKE_A_CHANGE)

---

22-22: Nitpick: Replace bare URL and correct link path

Use a proper Markdown link and update the path to Solid Query documentation to avoid MD034 and align with the new package.

- Full documentation can be found at https://trpc.io/docs/client/tanstack-react-query/setup.
+ Full documentation can be found at [Solid Query docs](https://trpc.io/docs/client/tanstack-solid-query/setup).

🧰 Tools

🪛 markdownlint-cli2 (0.17.2)

22-22: Bare URL used
null

(MD034, no-bare-urls)

packages/tanstack-solid-query/tsconfig.build.json (1)

4-7: Refactor unnecessary type definitions in build config
The build config should focus on production declarations; ambient types like "vite/client" and "@testing-library/jest-dom" aren’t needed here. Consider removing the "types" array or limiting it to only what’s required during build.

packages/tanstack-solid-query/src/internals/Context.tsx (2)

5-5: Convert Component and JSX imports to type imports.

Both Component and JSX are only used as types and should be updated to use import type syntax.

-import { Component, createContext, JSX, useContext } from 'solid-js';
+import { createContext, useContext } from 'solid-js';
+import type { Component, JSX } from 'solid-js';

🧰 Tools

🪛 ESLint

[error] 5-5: Imports "Component" and "JSX" are only used as type.

(@typescript-eslint/consistent-type-imports)

---

21-21: Update documentation link to reference Solid Query.

The JSDoc link currently points to React Query documentation, but this is a Solid Query package.

- * @see https://trpc.io/docs/client/tanstack-react-query/setup#3a-setup-the-trpc-context-provider
+ * @see https://trpc.io/docs/client/tanstack-solid-query/setup#3a-setup-the-trpc-context-provider

If the documentation doesn't exist yet, consider updating the documentation as part of this PR.

packages/tanstack-solid-query/test/mutationOptions.test.tsx (1)

78-84: Prefer onMount over createEffect for one-shot side-effects

createEffect re–runs whenever any reactive value referenced inside the callback changes.
Although the current callback references no reactive sources, future edits (e.g. reading a signal) may turn this into an accidental loop that fires mutation.mutate repeatedly.

Using Solid’s onMount communicates the intent (“run exactly once after mount”) and prevents such hazards.

-import { createEffect } from 'solid-js';
+import { onMount } from 'solid-js';
 ...
-      const mutation = useMutation(() => options);
-
-      createEffect(() => {
-        mutation.mutate({
-          text: 'hello',
-        });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-      });
+      const mutation = useMutation(() => options);
+
+      onMount(() => {
+        mutation.mutate({ text: 'hello' });
+      });

packages/tanstack-solid-query/test/infiniteQueryOptions.test.tsx (1)

226-228: Remove no-op statement

infiniteQueryOptions; is evaluated for its type only and produces no runtime side-effects.
Keeping it reads as leftover debugging code and may confuse readers.

-      infiniteQueryOptions;

packages/tanstack-solid-query/test/polymorphism.factory.tsx (1)

48-53: Global mutable counter can bleed across parallel tests

COUNTER is file-level state and will keep incrementing across multiple invocations of createExportRoute.
When the test runner executes suites in parallel this may lead to surprising IDs. Consider:

• Reseting COUNTER in a beforeEach.
• Moving the counter into the supplied dataProvider.
• Using crypto.randomUUID() for uniqueness.

packages/tanstack-solid-query/test/queryKeyable.test.tsx (2)

9-9: Use import type to satisfy ESLint’s consistent-type-imports.

TRPCQueryKey is only used for compile-time assertions, so it should be imported with import type to avoid the runtime dependency and silence the linter error.

-import { TRPCQueryKey } from '../src';
+import type { TRPCQueryKey } from '../src';

🧰 Tools

🪛 ESLint

[error] 9-9: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

---

11-34: Reduce duplication between testContext variants.

testContext and testContextWithErrorShape differ only by the errorFormatter details yet duplicate ~40 lines. A small factory that receives the errorFormatter (or the whole initTRPC.create options) will keep the tests DRY and easier to maintain.

Example sketch:

function createCtx(errorFormatter?: Parameters<typeof initTRPC.create>[0]['errorFormatter']) {
  const t = initTRPC.create({ errorFormatter });
  const appRouter = t.router({ … });
  return testSolidResource(appRouter);
}

Also applies to: 36-60

packages/tanstack-solid-query/src/internals/queryOptions.ts (2)

141-149: queryClient is unwrapped but never used

const queryClient = unwrapLazyArg(args.queryClient); introduces an unused variable, which
will trigger noUnusedLocals/noUnusedVariables in many TS configs.

If queryClient is only needed when the result is an AsyncIterable, move the unwrap
inside that branch to silence the warning and avoid unnecessary work:

-  const queryClient = unwrapLazyArg(args.queryClient);
...
-    if (isAsyncIterable(result)) {
-      return buildQueryFromAsyncIterable(result, queryClient, queryKey);
+    if (isAsyncIterable(result)) {
+      const qc = unwrapLazyArg(args.queryClient);
+      return buildQueryFromAsyncIterable(result, qc, queryKey);
     }

---

175-182: Generic information lost via double cast

queryFn as unknown as QueryFunction<any, any> erases the rich generics you worked
hard to preserve above, defeating type-safety for consumers. Consider keeping the
QueryFunction<coerceAsyncIterableToArray<…>, TRPCQueryKey, …> signature and use a
// @ts-expect-error annotation only where TS cannot infer correctly.

packages/tanstack-solid-query/src/internals/types.ts (1)

46-57: Name leaks implementation detail (React) in a Solid-specific package

TRPCReactRequestOptions is exported from a package named tanstack-solid-query.
Renaming to something neutral like TRPCQueryRequestOptions (or
TRPCSolidRequestOptions) avoids confusion for downstream users.

Refactor suggestion (public API change; verify before merge):

-export interface TRPCReactRequestOptions
+export interface TRPCQueryRequestOptions

and update all references.

packages/tanstack-solid-query/test/polymorphism.test.tsx (2)

17-17: Import types with import type to silence eslint & reduce bundle size

ESLint hints that this import is type-only. Switching to import type removes the run-time reference and keeps tree-shaking clean.

-import { JSX } from 'solid-js/jsx-runtime';
+import type { JSX } from 'solid-js/jsx-runtime';

🧰 Tools

🪛 ESLint

[error] 17-17: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

---

227-235: Return the promise from onSuccess to keep the mutation’s lifecycle consistent

mutationOptions passes an async onSuccess that invalidates queries, but the promise is swallowed:

await client.invalidateQueries(...)

React/Solid Query waits for the returned promise to settle before firing onSettled.
Add a return so callers can chain off it in tests and UI logic.

-async onSuccess(data) {
-  props.onExportStarted(data.id);
-  await client.invalidateQueries(props.route.pathFilter());
-},
+onSuccess: async (data) => {
+  props.onExportStarted(data.id);
+  return client.invalidateQueries(props.route.pathFilter());
+},

packages/tanstack-solid-query/src/internals/createOptionsProxy.ts (1)

350-365: Minor type/logic mismatch in pathFilter helper

pathFilter accepts one argument (filters) per its declaration, yet the
proxy implementation spreads arg1 and ignores arg2. Accidental two-arg
calls will silently drop the second parameter.

Consider validating arity or forwarding both args for consistency with
queryFilter / infiniteQueryFilter.

packages/tanstack-solid-query/src/internals/subscriptionOptions.ts (1)

155-159: Use const for the tracked-property set

The trackedProps reference is never reassigned; favour const to communicate
intent and satisfy the ESLint prefer-const rule.

-let trackedProps = new Set<keyof $Result>([]);
+const trackedProps = new Set<keyof $Result>();

🧰 Tools

🪛 ESLint

[error] 155-155: 'trackedProps' is never reassigned. Use 'const' instead.

(prefer-const)

packages/tanstack-solid-query/test/__helpers.tsx (1)

10-10: Use import type for the JSX import

Since the JSX import is only used as a type and not as a value, you should use import type to avoid including it in the runtime bundle.

-import { JSX } from 'solid-js/jsx-runtime';
+import type { JSX } from 'solid-js/jsx-runtime';

🧰 Tools

🪛 ESLint

[error] 10-10: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/tanstack-solid-query/src/internals/subscriptionOptions.ts (2)

251-255: Ineffective effect with no side-effects

The createEffect block references reset without calling it and calls getInitialState() without using the result, producing no actual side effects. This will trigger the ESLint error for unused expressions.

-createEffect(() => {
-  reset;
-
-  getInitialState();
-});

🧰 Tools

🪛 ESLint

[error] 252-252: Expected an assignment or function call and instead saw an expression.

(@typescript-eslint/no-unused-expressions)

---

281-290: Duplicate reset logic can cause multiple rapid subscriptions

The reset() function is called both in the initial effect (line 232) and again in this effect (line 285) when opts.enabled is true. This duplication can lead to unnecessary subscription cycles if the dependency tracking causes both effects to run in quick succession.

Consider consolidating the subscription lifecycle management into a single effect:

-createEffect(() => {
-  hashKey(opts.queryKey);
-
-  reset();
-});

// ...

-createEffect(() => {
-  if (!opts.enabled) {
-    return;
-  }
-  reset();
-
-  return () => {
-    currentSubscription?.();
-  };
-});

+createEffect(() => {
+  // Force the effect to track the queryKey
+  hashKey(opts.queryKey);
+  
+  if (!opts.enabled) {
+    // Clean up any existing subscription when disabled
+    currentSubscription?.();
+    updateState(getInitialState);
+    return;
+  }
+  
+  // Initialize or reset the subscription when enabled or dependencies change
+  reset();
+  
+  return () => {
+    currentSubscription?.();
+  };
+});

packages/tanstack-solid-query/src/internals/subscriptionOptions.ts (7)

168-170: Consider adding error handling during unsubscription

The currentSubscription?.() call doesn't handle potential errors that could occur during unsubscription. This might lead to incomplete cleanup if an error occurs.

-  currentSubscription?.();
+  try {
+    currentSubscription?.();
+  } catch (error) {
+    console.error('Error during subscription cleanup:', error);
+  }

---

177-182: Type casting to any can be replaced with more specific typing

The type assertion ...(prev as any) is using any, which bypasses type checking. Consider using a more specific type assertion to maintain type safety.

-        updateState((prev) => ({
-          ...(prev as any),
-          status: 'pending',
-          error: null,
-        }));
+        updateState((prev) => ({
+          ...prev,
+          status: 'pending' as const,
+          error: null,
+        }));

---

185-191: Repeated type casting pattern can be extracted into a utility function

The pattern of spreading (prev as any) and updating specific properties is repeated in several places. Consider extracting this into a utility function to reduce duplication and improve type safety.

+  // Add this helper function
+  const updateStateWithStatus = <S extends TRPCSubscriptionStatus>(
+    status: S,
+    updates: Partial<$Result> = {}
+  ) => {
+    updateState((prev) => ({
+      ...prev,
+      status,
+      ...updates,
+    }));
+  };

   // Then replace the instances with:
-  updateState((prev) => ({
-    ...(prev as any),
-    status: 'pending',
-    data,
-    error: null,
-  }));
+  updateStateWithStatus('pending', { data, error: null });

-  updateState((prev) => ({
-    ...(prev as any),
-    status: 'error',
-    error,
-  }));
+  updateStateWithStatus('error', { error });

Also applies to: 193-199

---

200-221: Missing default case in switch statement

The switch statement for handling connection state changes doesn't have a default case. While the current implementation covers all known states, adding a default case would make the code more robust against future changes.

         switch (result.state) {
           case 'connecting':
             return {
               ...prev,
               status: 'connecting',
               error: result.error,
             };
           case 'pending':
             // handled in onStarted
             return prev;
           case 'idle':
             return {
               ...prev,
               status: 'idle',
               data: undefined,
               error: null,
             };
+          default:
+            console.warn(`Unhandled connection state: ${result.state}`);
+            return prev;
         }

---

258-278: State update logic could be more efficient

The current implementation creates a new tracked result object on every state update, even when only specific properties change. Consider a more granular update approach to improve performance.

A more selective update mechanism could be implemented to only replace the specific properties that have changed, rather than creating an entirely new proxy object. This would be especially beneficial for larger state objects.

-  const updateState = (callback: (prevState: $Result) => $Result) => {
-    const prev = resultRef;
-    const next = (resultRef = callback(prev));
-
-    let shouldUpdate = false;
-    for (const key of trackedProps) {
-      if (prev[key] !== next[key]) {
-        shouldUpdate = true;
-        break;
-      }
-    }
-    if (shouldUpdate) {
-      setState(trackResult(next, addTrackedProp));
-    }
-  };
+  const updateState = (callback: (prevState: $Result) => $Result) => {
+    const prev = resultRef;
+    const next = (resultRef = callback(prev));
+
+    // Only update the specific properties that have changed and are being tracked
+    for (const key of trackedProps) {
+      if (prev[key] !== next[key]) {
+        setState(key, next[key]);
+      }
+    }
+  };

---

12-14: The imported TRPCQueryOptionsResult type doesn't seem to be used directly

The TRPCQueryOptionsResult type is imported but only used indirectly through the TRPCSubscriptionOptionsOut interface. Consider whether this import is necessary or if the types could be restructured for clarity.

---

1-15: Consider organizing imports for better readability

The imports mix external and internal dependencies. Consider organizing them by grouping external dependencies first, followed by internal ones, with a blank line separating the groups.

 import type { SkipToken } from '@tanstack/solid-query';
 import { hashKey, skipToken } from '@tanstack/solid-query';
 import type { TRPCClientErrorLike, TRPCUntypedClient } from '@trpc/client';
 import type { TRPCConnectionState } from '@trpc/client/unstable-internals';
 import type { Unsubscribable } from '@trpc/server/observable';
 import type { inferAsyncIterableYield } from '@trpc/server/unstable-core-do-not-import';
 import { createEffect } from 'solid-js';
 import { createStore } from 'solid-js/store';
+
 import type {
   ResolverDef,
   TRPCQueryKey,
   TRPCQueryOptionsResult,
 } from './types';
 import { createTRPCOptionsResult } from './utils';

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/tanstack-solid-query/test/infiniteQueryOptions.test.tsx (1)

41-43: ⚠️ Potential issue

Off-by-one error in next cursor calculation is still present

The comparison input.cursor + 1 > fixtureData.length allows next
to become fixtureData.length, which triggers an unnecessary extra
request that returns an empty page.
Switch to >= so next is undefined once the end of the dataset
is reached.

-next:
-  input.cursor + 1 > fixtureData.length
-    ? undefined
-    : input.cursor + 1,
+next:
+  input.cursor + 1 >= fixtureData.length
+    ? undefined
+    : input.cursor + 1,

This occurs in both router definitions (lines 41-43 and 334-336).

Also applies to: 334-336

packages/tanstack-solid-query/src/internals/types.ts (1)

25-26: ⚠️ Potential issue

Replace void with undefined in union type

Using void inside a union is confusing because void is intended
for return positions; static analysis (noConfusingVoidType) flags
this. Replace it with undefined to express “value may be absent”.

-type CursorInput = { cursor?: any };
-export type OptionalCursorInput = CursorInput | void;
+type CursorInput = { cursor?: any };
+export type OptionalCursorInput = CursorInput | undefined;

This keeps the intent clear and silences the linter.

🧰 Tools

🪛 Biome (1.9.4)

[error] 26-26: void is confusing inside a union type.

Unsafe fix: Use undefined instead.

(lint/suspicious/noConfusingVoidType)

packages/tanstack-solid-query/test/polymorphism.test.tsx (3)

17-17: Use import type for type-only imports

The JSX import is only used as a type and not as a value. Following TypeScript best practices, it should be imported using import type.

-import { JSX } from 'solid-js/jsx-runtime';
+import type { JSX } from 'solid-js/jsx-runtime';

🧰 Tools

🪛 ESLint

[error] 17-17: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

---

28-28: Consider adding export type for Factory

The Factory import contains types that are used throughout the test file. For clarity and to follow the same pattern, consider using a type import here as well.

-import * as Factory from './polymorphism.factory';
+import type * as Factory from './polymorphism.factory';
+import { createExportRoute } from './polymorphism.factory';

---

276-276: Consider handling the null case more explicitly

Using -1 as a fallback ID when currentExport is null could lead to unexpected behavior if the API doesn't handle negative IDs properly. Consider disabling the query entirely or using a more explicit approach.

-      { id: props.currentExport ?? -1 },
+      { id: props.currentExport! },
       { enabled: props.currentExport !== null },

The non-null assertion operator is safe here because the query is only enabled when currentExport is not null.

packages/tanstack-solid-query/README.md (1)

13-15: Remove blank line inside blockquote for lint compliance
The blank line between the description and the warning block violates MD028 (no blank lines in a blockquote).
Apply this diff to remove it:

@@ lines 13-15
- > 
  > [!WARNING]

🧰 Tools

🪛 markdownlint-cli2 (0.17.2)

14-14: Blank line inside blockquote
null

(MD028, no-blanks-blockquote)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/tanstack-solid-query/src/internals/subscriptionOptions.ts (3)

6-6: Avoid importing from unstable internal tRPC APIs.

The import from @trpc/server/unstable-core-do-not-import suggests you're using unstable APIs that may change in future versions. Consider exploring more stable alternatives.

---

251-255: Effect has no side-effects – likely a leftover.

The createEffect merely reads getInitialState() without doing anything with the result. This produces no runtime effect and may trigger linting warnings.

-createEffect(
-  on(reset, () => {
-    getInitialState();
-  }),
-);

Consider removing this effect as it appears to have no purpose.

---

281-290: Duplicate reset logic can spawn multiple subscriptions.

reset() is executed both in the initial effect (line 232) and in this cleanup effect when opts.enabled is true. If opts.queryKey is stable but some other reactive source triggers both effects, you may end up unsubscribing and resubscribing twice in quick succession.

Consider centralizing the subscription lifecycle in a single effect:

-createEffect(() => {
-  hashKey(opts.queryKey);
-
-  reset();
-});

// ...

-createEffect(() => {
-  if (!opts.enabled) {
-    return;
-  }
-  reset();
-
-  return () => {
-    currentSubscription?.();
-  };
-});
+createEffect(() => {
+  // This effect runs when either the query key changes or enabled changes
+  const key = hashKey(opts.queryKey);
+  const enabled = opts.enabled;
+  
+  if (!enabled) {
+    currentSubscription?.();
+    updateState(getInitialState);
+    return;
+  }
+  
+  reset();
+  
+  return () => {
+    currentSubscription?.();
+  };
+});

packages/tanstack-solid-query/src/internals/subscriptionOptions.ts (4)

16-29: Reduce duplication between subscription option interfaces.

BaseTRPCSubscriptionOptionsIn and UnusedSkipTokenTRPCSubscriptionOptionsIn share identical callback definitions. Consider refactoring to reduce duplication:

+interface SubscriptionCallbacks<TOutput, TError> {
+  onStarted?: () => void;
+  onData?: (data: inferAsyncIterableYield<TOutput>) => void;
+  onError?: (err: TError) => void;
+  onConnectionStateChange?: (state: TRPCConnectionState<TError>) => void;
+}

-interface BaseTRPCSubscriptionOptionsIn<TOutput, TError> {
-  enabled?: boolean;
-  onStarted?: () => void;
-  onData?: (data: inferAsyncIterableYield<TOutput>) => void;
-  onError?: (err: TError) => void;
-  onConnectionStateChange?: (state: TRPCConnectionState<TError>) => void;
+interface BaseTRPCSubscriptionOptionsIn<TOutput, TError> 
+  extends SubscriptionCallbacks<TOutput, TError> {
+  enabled?: boolean;
}

-interface UnusedSkipTokenTRPCSubscriptionOptionsIn<TOutput, TError> {
-  onStarted?: () => void;
-  onData?: (data: inferAsyncIterableYield<TOutput>) => void;
-  onError?: (err: TError) => void;
-  onConnectionStateChange?: (state: TRPCConnectionState<TError>) => void;
+interface UnusedSkipTokenTRPCSubscriptionOptionsIn<TOutput, TError>
+  extends SubscriptionCallbacks<TOutput, TError> {
}

This reduces duplication and makes it easier to maintain these interfaces.

---

166-227: Consider using the discriminated union pattern more consistently in reset function.

The updateState calls in various callbacks use type casting with ...(prev as any) which bypasses TypeScript's type checking. Consider using a more type-safe approach by leveraging the discriminated union pattern already defined in your state types.

const reset = (): void => {
  // unsubscribe from the previous subscription
  currentSubscription?.();

  updateState(getInitialState);
  if (!opts.enabled) {
    return;
  }
  const subscription = opts.subscribe({
    onStarted: () => {
      opts.onStarted?.();
      updateState((prev) => ({
-        ...(prev as any),
+        ...prev,
        status: 'pending',
        error: null,
+        data: prev.data,
+        reset
      }));
    },
    onData: (data) => {
      opts.onData?.(data);
      updateState((prev) => ({
-        ...(prev as any),
+        ...prev,
        status: 'pending',
        data,
        error: null,
+        reset
      }));
    },
    onError: (error) => {
      opts.onError?.(error);
      updateState((prev) => ({
-        ...(prev as any),
+        ...prev,
        status: 'error',
        error,
+        data: prev.data,
+        reset
      }));
    },
    // ...
  });
  // ...
};

This maintains type safety and makes the code more maintainable.

---

229-233: Consider using solid-js's dependency tracking more explicitly.

The current effect doesn't explicitly track the dependency on opts.queryKey. Consider using the on API to make this dependency explicit:

-createEffect(() => {
-  hashKey(opts.queryKey);
-
-  reset();
-});
+createEffect(on(() => hashKey(opts.queryKey), () => {
+  reset();
+}));

This makes it clearer that the effect runs when the query key changes.

---

295-307: Improve type safety in the trackResult function.

The function doesn't handle potential non-existent property access, which could lead to runtime errors if the proxy is accessed with a key that doesn't exist on the target object.

function trackResult<T extends object>(
  result: T,
  onTrackResult: (key: keyof T) => void,
): T {
  const trackedResult = new Proxy(result, {
    get(target, prop) {
-      onTrackResult(prop as keyof T);
-      return target[prop as keyof T];
+      // Ensure prop is a valid key of T
+      if (typeof prop === 'string' || typeof prop === 'symbol') {
+        if (prop in target) {
+          onTrackResult(prop as keyof T);
+        }
+      }
+      return Reflect.get(target, prop);
    },
  });

  return trackedResult;
}

This prevents potential issues with non-existent property access and makes the code more robust.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/tanstack-solid-query/test/client.test.tsx (1)

70-70: 🛠️ Refactor suggestion

Consider replacing Symbol.asyncDispose with makeAsyncResource().

Similar to other test files, using Symbol.asyncDispose directly is discouraged according to the static analysis hint. Consider refactoring to use the recommended makeAsyncResource() pattern.

🧰 Tools

🪛 ESLint

[error] 70-70: Usage of Symbol.asyncDispose is not allowed - use makeAsyncResource()

(no-restricted-syntax)

packages/tanstack-solid-query/test/mutationOptions.test.tsx (1)

101-101: 🛠️ Refactor suggestion

Replace Symbol.asyncDispose with makeAsyncResource().

As in other test files, using Symbol.asyncDispose directly is discouraged. Refactor to use the recommended makeAsyncResource() pattern for resource management.

Also applies to: 166-166

🧰 Tools

🪛 ESLint

[error] 101-101: Usage of Symbol.asyncDispose is not allowed - use makeAsyncResource()

(no-restricted-syntax)

packages/tanstack-solid-query/test/infiniteQueryOptions.test.tsx (1)

38-42: Fix the off-by-one error in cursor calculation

When input.cursor + 1 equals fixtureData.length, the current logic returns a next cursor that's out of bounds, leading to an extra empty page request.

Apply this change to fix the issue:

            next:
              input.cursor + 1 > fixtureData.length
                ? undefined
                : input.cursor + 1,
+            next:
+              input.cursor + 1 >= fixtureData.length
+                ? undefined
+                : input.cursor + 1,

packages/tanstack-solid-query/test/useSubscription.test.tsx (1)

15-31: Avoid exporting helpers from a test file

Helper functions in test files shouldn't be exported as they could leak into the public API.

Either:

1. Remove the export keyword since they're only used within this file, or
2. Move them to a dedicated helper file like test/__helpers/subscription.ts

-export const suppressLogs = () => {
+const suppressLogs = () => {
  // ...
}

-export const suppressLogsUntil = async (fn: () => Promise<void>) => {
+const suppressLogsUntil = async (fn: () => Promise<void>) => {
  // ...
}

Also applies to: 35-43

packages/tanstack-solid-query/test/__helpers.tsx (1)

52-53: Consider adding migration guidance for the deprecated close method.

You've marked the close method as deprecated with a JSDoc comment, but it might be helpful to provide more specific guidance on how to properly use the resource manager instead.

packages/tanstack-solid-query/test/queryKeyable.test.tsx (1)

8-8: Use import type for type-only imports

Since TRPCQueryKey is only used as a type, it should be imported with import type to improve type checking and avoid potential runtime overhead.

-import { TRPCQueryKey } from '../src';
+import type { TRPCQueryKey } from '../src';

🧰 Tools

🪛 ESLint

[error] 8-8: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

packages/tanstack-solid-query/test/polymorphism.test.tsx (1)

16-16: Prefer import type for pure-type imports

JSX is only used as a type, so ESLint rightfully flags this line. Switching to import type keeps the value bundle clean and satisfies the consistent-type-imports rule.

-import { JSX } from 'solid-js/jsx-runtime';
+import type { JSX } from 'solid-js/jsx-runtime';

🧰 Tools

🪛 ESLint

[error] 16-16: All imports in the declaration are only used as types. Use import type.

(@typescript-eslint/consistent-type-imports)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro