@effector-tanstack-query/core 0.2.0 → 0.4.0

package/dist/types.d.cts

@@ -11,8 +11,32 @@ type StoreOrValue<T> = Store<T> | T;
  * queryKey: ['user', $userId, 'details']
  */
 type EffectorQueryKey = ReadonlyArray<StoreOrValue<string | number | bigint | boolean | null | undefined | object>>;
-interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey' | 'enabled' | 'refetchInterval'> {
-    queryKey: EffectorQueryKey;
+/**
+ * Resolves a single `EffectorQueryKey` element to its runtime value type:
+ * `Store<T>` → `T`, everything else is left as-is. Used by `ResolvedQueryKey`
+ * so `queryFn`'s context can present `queryKey` with stores already unwrapped.
+ */
+type ResolveQueryKeyElement<T> = T extends Store<infer U> ? U : T;
+/**
+ * Tuple-aware mapping that walks an `EffectorQueryKey` and replaces each
+ * `Store<T>` with `T`, preserving tuple shape (length, readonly-ness, element
+ * positions). Drives the `TQueryKey` generic of `CreateQueryOptions` so the
+ * `queryFn({ queryKey })` parameter is typed with the resolved values:
+ *
+ * ```ts
+ * const $name = createStore<string>('pikachu')
+ * createQuery({
+ *   queryKey: ['pokemon', $name],
+ *   queryFn: ({ queryKey }) => fetchByName(queryKey[1]),
+ *   //                                     ^ string — no cast needed
+ * })
+ * ```
+ */
+type ResolvedQueryKey<T extends ReadonlyArray<unknown>> = {
+    readonly [K in keyof T]: ResolveQueryKeyElement<T[K]>;
+};
+interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends EffectorQueryKey = EffectorQueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, ResolvedQueryKey<TQueryKey>>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: TQueryKey;
     enabled?: StoreOrValue<boolean>;
     /**
      * Polling interval in milliseconds, `false` to disable, or a Store for
@@ -21,7 +45,7 @@ interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQu
      * `setOptions` on every store change. The function form (`(query) => …`)
      * from TanStack Query is also still supported.
      */
-    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchInterval'] | Store<number | false | undefined>;
+    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, ResolvedQueryKey<TQueryKey>>['refetchInterval'] | Store<number | false | undefined>;
     /**
      * Stable name used to derive SIDs for the internal effector stores so that
      * `serialize(scope)` / `fork({ values })` round-trip works for SSR. Without
@@ -95,11 +119,11 @@ interface QueryResult<TData, TError = Error> {
      */
     $queryClient: Store<QueryClient | null>;
 }
-interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
-    queryKey: EffectorQueryKey;
+interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>, TQueryKey extends EffectorQueryKey = EffectorQueryKey> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ResolvedQueryKey<TQueryKey>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: TQueryKey;
     enabled?: StoreOrValue<boolean>;
     /** See {@link CreateQueryOptions.refetchInterval}. */
-    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
+    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ResolvedQueryKey<TQueryKey>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
     /** See {@link CreateQueryOptions.name}. */
     name?: string;
 }
@@ -205,5 +229,115 @@ interface MutationResult<TData = unknown, TError = Error, TVariables = void> {
         }>;
     };
 }
+/**
+ * Per-item snapshot inside a `createQueries` family. Parallel to the
+ * factory's `source` array — one entry per item, in source order.
+ */
+interface QueryItemState<TItem, TData, TError = Error> {
+    /** The source item this entry was derived from. */
+    source: TItem;
+    data: TData | undefined;
+    error: TError | null;
+    status: QueryStatus;
+    isPending: boolean;
+    isFetching: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isPlaceholderData: boolean;
+    fetchStatus: FetchStatus;
+}
+/**
+ * Per-item query options produced by `createQueries({ query })`. A pure
+ * function of one source item — no effector stores, no closures over
+ * mutable state. Reactivity comes from the source store; whenever it
+ * updates, this callback re-runs to compute fresh options.
+ *
+ * `enabled` is a plain boolean (not a `Store`) for the same reason —
+ * it's derived from the item, so reactivity is already covered.
+ */
+interface CreateQueriesItemOptions<TQueryFnData, TError, TData, TQueryKey extends ReadonlyArray<unknown>> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey' | 'enabled'> {
+    queryKey: TQueryKey;
+    enabled?: boolean;
+}
+interface CreateQueriesOptions<TItem, TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends ReadonlyArray<unknown> = ReadonlyArray<unknown>> {
+    /**
+     * Stable name used to derive the SID of the result `$items` store so
+     * `serialize(scope)` round-trips it for SSR. Without a name, the
+     * QueryClient cache still hydrates via `dehydrate`/`hydrate`, but the
+     * `$items` snapshot is silently dropped from `serialize(scope)`.
+     */
+    name?: string;
+    /**
+     * Reactive list of items. Each item becomes one parallel query in the
+     * family. Adding / removing items updates the family (spawn / dispose
+     * observer). Order is preserved in `$items`.
+     *
+     * Duplicates in `source` deduplicate observers (same `queryKey` hash)
+     * but produce separate `$items` entries — one per occurrence.
+     */
+    source: Store<ReadonlyArray<TItem>>;
+    /**
+     * Per-item options builder. MUST be pure — same item in, same options
+     * out. Reactivity is driven by the source store; this callback fires
+     * synchronously when source updates.
+     */
+    query: (item: TItem) => CreateQueriesItemOptions<TQueryFnData, TError, TData, TQueryKey>;
+    /** Shared QueryObserver defaults applied on top of `query(item)`. */
+    staleTime?: number;
+    gcTime?: number;
+    retry?: QueryObserverOptions<TQueryFnData, TError, TData>['retry'];
+    retryDelay?: QueryObserverOptions<TQueryFnData, TError, TData>['retryDelay'];
+    refetchOnMount?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnMount'];
+    refetchOnReconnect?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnReconnect'];
+    refetchOnWindowFocus?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnWindowFocus'];
+    networkMode?: QueryObserverOptions<TQueryFnData, TError, TData>['networkMode'];
+}
+/**
+ * Result of `createQueries(...)`. A reactive "family" of parallel
+ * queries indexed by a source store. Composes naturally with
+ * `useUnit($items)` for non-Suspense usage and with
+ * `useQueries(family)` / `useSuspenseQueries(family)` for React-style
+ * consumption.
+ */
+interface QueriesResult<TItem, TData = unknown, TError = Error> {
+    /** Per-item snapshots, parallel to `source`. */
+    $items: Store<ReadonlyArray<QueryItemState<TItem, TData, TError>>>;
+    /** Just the `data` field of `$items` — shortcut for common UIs. */
+    $data: Store<ReadonlyArray<TData | undefined>>;
+    /** `true` while **any** query in the family is pending. */
+    $isPending: Store<boolean>;
+    /** `true` only when **every** query in the family has succeeded. */
+    $isSuccess: Store<boolean>;
+    /** `true` if **any** query in the family is currently fetching. */
+    $isFetching: Store<boolean>;
+    /** `true` if **any** query in the family errored. */
+    $isError: Store<boolean>;
+    /**
+     * Triggers a parallel `fetchQuery` for every current source item.
+     * SSR-friendly — `await allSettled(family.prefetch, { scope })`
+     * returns after every queryFn has resolved (or failed).
+     */
+    prefetch: EventCallable<void>;
+    /**
+     * Increment the per-scope refcount and ensure every observer is
+     * subscribed to the QueryClient. Call from `useEffect` (or its
+     * effector equivalent). The matching `unmounted()` decrements; when
+     * the count hits zero, observers unsubscribe.
+     */
+    mounted: EventCallable<void>;
+    unmounted: EventCallable<void>;
+    /** Invalidates every query in the family — re-fetches in background. */
+    refresh: EventCallable<void>;
+    /** Invalidates one specific item's query. */
+    refreshOne: EventCallable<TItem>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+    /**
+     * Discriminator that lets `useQueries` / `useSuspenseQueries` and
+     * other helpers distinguish a family from a tuple of factories at
+     * runtime. Not part of the public API.
+     */
+    readonly __family: true;
+}
 
-export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueryResult, StoreOrValue };
+export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueriesItemOptions, CreateQueriesOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueriesResult, QueryItemState, QueryResult, ResolveQueryKeyElement, ResolvedQueryKey, StoreOrValue };

package/dist/types.d.ts

@@ -11,8 +11,32 @@ type StoreOrValue<T> = Store<T> | T;
  * queryKey: ['user', $userId, 'details']
  */
 type EffectorQueryKey = ReadonlyArray<StoreOrValue<string | number | bigint | boolean | null | undefined | object>>;
-interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey' | 'enabled' | 'refetchInterval'> {
-    queryKey: EffectorQueryKey;
+/**
+ * Resolves a single `EffectorQueryKey` element to its runtime value type:
+ * `Store<T>` → `T`, everything else is left as-is. Used by `ResolvedQueryKey`
+ * so `queryFn`'s context can present `queryKey` with stores already unwrapped.
+ */
+type ResolveQueryKeyElement<T> = T extends Store<infer U> ? U : T;
+/**
+ * Tuple-aware mapping that walks an `EffectorQueryKey` and replaces each
+ * `Store<T>` with `T`, preserving tuple shape (length, readonly-ness, element
+ * positions). Drives the `TQueryKey` generic of `CreateQueryOptions` so the
+ * `queryFn({ queryKey })` parameter is typed with the resolved values:
+ *
+ * ```ts
+ * const $name = createStore<string>('pikachu')
+ * createQuery({
+ *   queryKey: ['pokemon', $name],
+ *   queryFn: ({ queryKey }) => fetchByName(queryKey[1]),
+ *   //                                     ^ string — no cast needed
+ * })
+ * ```
+ */
+type ResolvedQueryKey<T extends ReadonlyArray<unknown>> = {
+    readonly [K in keyof T]: ResolveQueryKeyElement<T[K]>;
+};
+interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends EffectorQueryKey = EffectorQueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, ResolvedQueryKey<TQueryKey>>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: TQueryKey;
     enabled?: StoreOrValue<boolean>;
     /**
      * Polling interval in milliseconds, `false` to disable, or a Store for
@@ -21,7 +45,7 @@ interface CreateQueryOptions<TQueryFnData = unknown, TError = Error, TData = TQu
      * `setOptions` on every store change. The function form (`(query) => …`)
      * from TanStack Query is also still supported.
      */
-    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchInterval'] | Store<number | false | undefined>;
+    refetchInterval?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, ResolvedQueryKey<TQueryKey>>['refetchInterval'] | Store<number | false | undefined>;
     /**
      * Stable name used to derive SIDs for the internal effector stores so that
      * `serialize(scope)` / `fork({ values })` round-trip works for SSR. Without
@@ -95,11 +119,11 @@ interface QueryResult<TData, TError = Error> {
      */
     $queryClient: Store<QueryClient | null>;
 }
-interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
-    queryKey: EffectorQueryKey;
+interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = Error, TPageParam = unknown, TData = InfiniteData<TQueryFnData, TPageParam>, TQueryKey extends EffectorQueryKey = EffectorQueryKey> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ResolvedQueryKey<TQueryKey>, TPageParam>, 'queryKey' | 'enabled' | 'refetchInterval'> {
+    queryKey: TQueryKey;
     enabled?: StoreOrValue<boolean>;
     /** See {@link CreateQueryOptions.refetchInterval}. */
-    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ReadonlyArray<unknown>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
+    refetchInterval?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, ResolvedQueryKey<TQueryKey>, TPageParam>['refetchInterval'] | Store<number | false | undefined>;
     /** See {@link CreateQueryOptions.name}. */
     name?: string;
 }
@@ -205,5 +229,115 @@ interface MutationResult<TData = unknown, TError = Error, TVariables = void> {
         }>;
     };
 }
+/**
+ * Per-item snapshot inside a `createQueries` family. Parallel to the
+ * factory's `source` array — one entry per item, in source order.
+ */
+interface QueryItemState<TItem, TData, TError = Error> {
+    /** The source item this entry was derived from. */
+    source: TItem;
+    data: TData | undefined;
+    error: TError | null;
+    status: QueryStatus;
+    isPending: boolean;
+    isFetching: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isPlaceholderData: boolean;
+    fetchStatus: FetchStatus;
+}
+/**
+ * Per-item query options produced by `createQueries({ query })`. A pure
+ * function of one source item — no effector stores, no closures over
+ * mutable state. Reactivity comes from the source store; whenever it
+ * updates, this callback re-runs to compute fresh options.
+ *
+ * `enabled` is a plain boolean (not a `Store`) for the same reason —
+ * it's derived from the item, so reactivity is already covered.
+ */
+interface CreateQueriesItemOptions<TQueryFnData, TError, TData, TQueryKey extends ReadonlyArray<unknown>> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey' | 'enabled'> {
+    queryKey: TQueryKey;
+    enabled?: boolean;
+}
+interface CreateQueriesOptions<TItem, TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends ReadonlyArray<unknown> = ReadonlyArray<unknown>> {
+    /**
+     * Stable name used to derive the SID of the result `$items` store so
+     * `serialize(scope)` round-trips it for SSR. Without a name, the
+     * QueryClient cache still hydrates via `dehydrate`/`hydrate`, but the
+     * `$items` snapshot is silently dropped from `serialize(scope)`.
+     */
+    name?: string;
+    /**
+     * Reactive list of items. Each item becomes one parallel query in the
+     * family. Adding / removing items updates the family (spawn / dispose
+     * observer). Order is preserved in `$items`.
+     *
+     * Duplicates in `source` deduplicate observers (same `queryKey` hash)
+     * but produce separate `$items` entries — one per occurrence.
+     */
+    source: Store<ReadonlyArray<TItem>>;
+    /**
+     * Per-item options builder. MUST be pure — same item in, same options
+     * out. Reactivity is driven by the source store; this callback fires
+     * synchronously when source updates.
+     */
+    query: (item: TItem) => CreateQueriesItemOptions<TQueryFnData, TError, TData, TQueryKey>;
+    /** Shared QueryObserver defaults applied on top of `query(item)`. */
+    staleTime?: number;
+    gcTime?: number;
+    retry?: QueryObserverOptions<TQueryFnData, TError, TData>['retry'];
+    retryDelay?: QueryObserverOptions<TQueryFnData, TError, TData>['retryDelay'];
+    refetchOnMount?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnMount'];
+    refetchOnReconnect?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnReconnect'];
+    refetchOnWindowFocus?: QueryObserverOptions<TQueryFnData, TError, TData>['refetchOnWindowFocus'];
+    networkMode?: QueryObserverOptions<TQueryFnData, TError, TData>['networkMode'];
+}
+/**
+ * Result of `createQueries(...)`. A reactive "family" of parallel
+ * queries indexed by a source store. Composes naturally with
+ * `useUnit($items)` for non-Suspense usage and with
+ * `useQueries(family)` / `useSuspenseQueries(family)` for React-style
+ * consumption.
+ */
+interface QueriesResult<TItem, TData = unknown, TError = Error> {
+    /** Per-item snapshots, parallel to `source`. */
+    $items: Store<ReadonlyArray<QueryItemState<TItem, TData, TError>>>;
+    /** Just the `data` field of `$items` — shortcut for common UIs. */
+    $data: Store<ReadonlyArray<TData | undefined>>;
+    /** `true` while **any** query in the family is pending. */
+    $isPending: Store<boolean>;
+    /** `true` only when **every** query in the family has succeeded. */
+    $isSuccess: Store<boolean>;
+    /** `true` if **any** query in the family is currently fetching. */
+    $isFetching: Store<boolean>;
+    /** `true` if **any** query in the family errored. */
+    $isError: Store<boolean>;
+    /**
+     * Triggers a parallel `fetchQuery` for every current source item.
+     * SSR-friendly — `await allSettled(family.prefetch, { scope })`
+     * returns after every queryFn has resolved (or failed).
+     */
+    prefetch: EventCallable<void>;
+    /**
+     * Increment the per-scope refcount and ensure every observer is
+     * subscribed to the QueryClient. Call from `useEffect` (or its
+     * effector equivalent). The matching `unmounted()` decrements; when
+     * the count hits zero, observers unsubscribe.
+     */
+    mounted: EventCallable<void>;
+    unmounted: EventCallable<void>;
+    /** Invalidates every query in the family — re-fetches in background. */
+    refresh: EventCallable<void>;
+    /** Invalidates one specific item's query. */
+    refreshOne: EventCallable<TItem>;
+    /** See {@link QueryResult.$queryClient}. */
+    $queryClient: Store<QueryClient | null>;
+    /**
+     * Discriminator that lets `useQueries` / `useSuspenseQueries` and
+     * other helpers distinguish a family from a tuple of factories at
+     * runtime. Not part of the public API.
+     */
+    readonly __family: true;
+}
 
-export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueryResult, StoreOrValue };
+export type { CreateInfiniteQueryOptions, CreateMutationOptions, CreateQueriesItemOptions, CreateQueriesOptions, CreateQueryOptions, EffectorQueryKey, InfiniteQueryResult, MutationResult, MutationStatus, QueriesResult, QueryItemState, QueryResult, ResolveQueryKeyElement, ResolvedQueryKey, StoreOrValue };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effector-tanstack-query/core",
-  "version": "0.2.0",
-  "description": "Effector bindings for TanStack Query — core factories (createQuery, createMutation, createInfiniteQuery)",
+  "version": "0.4.0",
+  "description": "Effector bindings for TanStack Query — core factories (createQuery, createMutation, createInfiniteQuery, createQueries)",
   "license": "MIT",
   "author": "Ilya Agarkov <ilya.al.ag@gmail.com>",
   "repository": {
@@ -44,7 +44,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@tanstack/query-core": "^5.0.0"
+    "@tanstack/query-core": "^5.100.10"
   },
   "peerDependencies": {
     "effector": ">=23.0.0"

package/src/createInfiniteQuery.ts

@@ -9,6 +9,7 @@ import { createBaseQuery, sidConfig, warnMissingName } from './createBaseQuery'
 import { resolveReactiveRefetchInterval } from './resolve'
 import type {
   CreateInfiniteQueryOptions,
+  EffectorQueryKey,
   InfiniteQueryResult,
 } from './types'
 
@@ -29,34 +30,62 @@ export function createInfiniteQuery<
   TError = Error,
   TPageParam = unknown,
   TData = InfiniteData<TQueryFnData, TPageParam>,
+  const TQueryKey extends EffectorQueryKey = EffectorQueryKey,
 >(
-  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  options: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData,
+    TQueryKey
+  >,
 ): InfiniteQueryResult<TData, TError, TPageParam>
 export function createInfiniteQuery<
   TQueryFnData = unknown,
   TError = Error,
   TPageParam = unknown,
   TData = InfiniteData<TQueryFnData, TPageParam>,
+  const TQueryKey extends EffectorQueryKey = EffectorQueryKey,
 >(
   queryClient: QueryClient,
-  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  options: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData,
+    TQueryKey
+  >,
 ): InfiniteQueryResult<TData, TError, TPageParam>
 export function createInfiniteQuery<
   TQueryFnData = unknown,
   TError = Error,
   TPageParam = unknown,
   TData = InfiniteData<TQueryFnData, TPageParam>,
+  const TQueryKey extends EffectorQueryKey = EffectorQueryKey,
 >(
   arg1:
     | QueryClient
-    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
-  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+    | CreateInfiniteQueryOptions<
+        TQueryFnData,
+        TError,
+        TPageParam,
+        TData,
+        TQueryKey
+      >,
+  arg2?: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData,
+    TQueryKey
+  >,
 ): InfiniteQueryResult<TData, TError, TPageParam> {
   const [explicitClient, options] = parseInfiniteArgs<
     TQueryFnData,
     TError,
     TPageParam,
-    TData
+    TData,
+    TQueryKey
   >(arg1, arg2)
   const { queryKey, enabled, name, ...restOptions } = options
 
@@ -272,20 +301,50 @@ export function createInfiniteQuery<
   return result
 }
 
-function parseInfiniteArgs<TQueryFnData, TError, TPageParam, TData>(
+function parseInfiniteArgs<
+  TQueryFnData,
+  TError,
+  TPageParam,
+  TData,
+  TQueryKey extends EffectorQueryKey,
+>(
   arg1:
     | QueryClient
-    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
-  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+    | CreateInfiniteQueryOptions<
+        TQueryFnData,
+        TError,
+        TPageParam,
+        TData,
+        TQueryKey
+      >,
+  arg2?: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData,
+    TQueryKey
+  >,
 ): [
   QueryClient | null,
-  CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData,
+    TQueryKey
+  >,
 ] {
   if (arg2 !== undefined) {
     return [arg1 as QueryClient, arg2]
   }
   return [
     null,
-    arg1 as CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+    arg1 as CreateInfiniteQueryOptions<
+      TQueryFnData,
+      TError,
+      TPageParam,
+      TData,
+      TQueryKey
+    >,
   ]
 }