@tramvai/react-query 2.49.3 → 2.50.0

package/README.md

@@ -92,15 +92,16 @@ As a parameter `key` you can use:
 
 - a string, such as `key: 'query-name'`
 - an array where any serializable data can be used as elements, for example `key: ['query-name', false, { bar: 'baz }]`
-- a function that takes the parameters with which `query` is called and returns a string - `key: (options) => 'query-name'`
-- a function that accepts parameters, with which `query` is called, and returns an array, where any serializable data can be used as elements - `key: (options) => ['query-name', options, { bar: 'baz' }]`
+- a function that takes the parameters with which `query` is called and returns a string - `key: (this: { deps }, options) => 'query-name'`. Where through `this.deps` you can get resolved deps for the query.
+- a function that accepts parameters, with which `query` is called, and returns an array, where any serializable data can be used as elements - `key: (this: { deps }, options) => ['query-name', options, { bar: 'baz' }]`
 
 ```ts
 import { createQuery, useQuery } from '@tramvai/react-query';
 
 const query = createQuery({
   key: (id: number) => ['user', id],
-  fn: async (id, { apiClient }) => {
+  async fn(id) {
+    const { apiClient } = this.deps;
     const { payload } = await apiClient.get(`api/user/${id}`);
 
     return payload;
@@ -143,10 +144,8 @@ React Hook for working with the list of `Query` objects
 import { useQueries } from '@tramvai/react-query';
 
 export function Component() {
-  const [
-    { data: data1, isLoading: isLoading1 },
-    { data: data2, isLoading: isLoading2 },
-  ] = useQueries([query1, query2]);
+  const [{ data: data1, isLoading: isLoading1 }, { data: data2, isLoading: isLoading2 }] =
+    useQueries([query1, query2]);
 
   return (
     <div>
@@ -166,7 +165,8 @@ import { createInfiniteQuery } from '@tramvai/react-query';
 
 const query = createInfiniteQuery({
   key: 'list',
-  fn: async (_, start = 0, { apiClient }) => {
+  async fn(_, start = 0) {
+    const { apiClient } = this.deps;
     const { payload } = await apiClient.get<Response>('api/list', {
       query: {
         count: 30,
@@ -229,7 +229,8 @@ import { createMutation } from '@tramvai/react-query';
 
 const mutation = createMutation({
   key: 'post',
-  fn: async (_, data: string, { apiClient }) => {
+  async fn(_, data: string) {
+    const { apiClient } = this.deps;
     const { payload } = await apiClient.post('api/post', {
       body: {
         data,

package/lib/baseQuery/types.d.ts

@@ -1,10 +1,14 @@
 import type { ActionConditionsParameters, ActionContext, TramvaiAction } from '@tramvai/core';
 import type { QueryKey as ReactQueryKey, QueryOptions } from '@tanstack/react-query';
+import type { Container, ProvideDepsIterator, ProviderDeps } from '@tinkoff/dippy';
 export declare const QUERY_PARAMETERS = "__query_parameters__";
+export interface ReactQueryContext<Deps extends ProviderDeps> {
+    deps: ProvideDepsIterator<Deps>;
+}
 export type ReactQueryKeyOrString = ReactQueryKey | string;
-export type QueryKey<Options> = ((options: Options) => ReactQueryKeyOrString) | ReactQueryKeyOrString;
-export interface BaseCreateQueryOptions<Options, Deps> {
-    key: QueryKey<Options>;
+export type QueryKey<Options, Deps extends ProviderDeps> = ((this: ReactQueryContext<Deps>, options: Options) => ReactQueryKeyOrString) | ReactQueryKeyOrString;
+export interface BaseCreateQueryOptions<Options, Deps extends ProviderDeps> {
+    key: QueryKey<Options, Deps>;
     fn: Function;
     deps?: Deps;
     conditions?: ActionConditionsParameters;
@@ -12,6 +16,10 @@ export interface BaseCreateQueryOptions<Options, Deps> {
 export interface BaseQuery<Options, TCreateQuery, TQuery, TUseQuery> {
     [QUERY_PARAMETERS]: TCreateQuery;
     fork(options: TUseQuery): TQuery;
+    raw(di: Container, options?: Options): TUseQuery;
+    /**
+     * @deprecated pass di as first parameter instead of context
+     */
     raw(context: ActionContext, options?: Options): TUseQuery;
     prefetchAction(options?: Options): TramvaiAction<[], Promise<void>, any>;
 }

package/lib/index.es.js

@@ -1,5 +1,5 @@
 import identity from '@tinkoff/utils/function/identity';
-import applyOrReturn from '@tinkoff/utils/function/applyOrReturn';
+import { Container, DI_TOKEN } from '@tinkoff/dippy';
 import { declareAction } from '@tramvai/core';
 import { QUERY_CLIENT_TOKEN } from '@tramvai/module-react-query';
 import { CONTEXT_TOKEN } from '@tramvai/tokens-common';
@@ -7,8 +7,8 @@ import isArray from '@tinkoff/utils/is/array';
 import { useMemo } from 'react';
 import { useQuery as useQuery$1, useQueries as useQueries$1, useInfiniteQuery as useInfiniteQuery$1, useMutation as useMutation$1 } from '@tanstack/react-query';
 export { useQueryClient } from '@tanstack/react-query';
-import { useConsumerContext } from '@tramvai/state';
 import { useShallowEqual } from '@tinkoff/react-hooks';
+import { useDiContainer } from '@tramvai/react';
 
 const QUERY_PARAMETERS = '__query_parameters__';
 const isQuery = (arg) => {
@@ -22,13 +22,23 @@ const normalizeKey = (key) => {
     return [key];
 };
 
-const convertToRawQuery$1 = (query, context, options) => {
-    const { key = identity, fn, deps, conditions, queryOptions } = query[QUERY_PARAMETERS];
-    const queryKey = normalizeKey(applyOrReturn([options], key));
+// @TODO: v3: leave only di container in next major
+const resolveDI = (diOrContext) => {
+    return diOrContext instanceof Container
+        ? diOrContext
+        : diOrContext.di;
+};
+
+const convertToRawQuery$1 = (query, di, options) => {
+    const { key = identity, fn, deps = {}, conditions, queryOptions } = query[QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey(rawQueryKey);
     const actionWrapper = declareAction({
         name: 'queryExecution',
         async fn() {
-            return fn(options, this.deps);
+            return fn.call(ctx, options, ctx.deps);
         },
         deps,
         conditions,
@@ -41,6 +51,7 @@ const convertToRawQuery$1 = (query, context, options) => {
             conditions,
         },
         queryFn: () => {
+            const context = di.get(CONTEXT_TOKEN);
             return context.executeAction(actionWrapper);
         },
     };
@@ -58,17 +69,17 @@ const createQuery = (queryParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawQuery$1(query, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawQuery$1(query, resolveDI(diOrContext), options);
         },
         prefetchAction: (options) => {
             return declareAction({
                 name: 'queryPrefetch',
                 fn() {
-                    return this.deps.queryClient.prefetchQuery(convertToRawQuery$1(query, this.deps.context, options));
+                    return this.deps.queryClient.prefetchQuery(convertToRawQuery$1(query, this.deps.di, options));
                 },
                 deps: {
-                    context: CONTEXT_TOKEN,
+                    di: DI_TOKEN,
                     queryClient: QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -78,10 +89,10 @@ const createQuery = (queryParameters) => {
             return declareAction({
                 name: 'queryFetch',
                 fn() {
-                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.context, options));
+                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.di, options));
                 },
                 deps: {
-                    context: CONTEXT_TOKEN,
+                    di: DI_TOKEN,
                     queryClient: QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -92,36 +103,39 @@ const createQuery = (queryParameters) => {
 };
 
 function useQuery(query, options) {
-    const context = useConsumerContext();
+    const di = useDiContainer();
     const resultQuery = useMemo(() => {
         if (isQuery(query)) {
-            return query.raw(context, options);
+            return query.raw(di, options);
         }
         return query;
-    }, [query, context, options]);
+    }, [query, di, options]);
     return useQuery$1(resultQuery);
 }
 function useQueries(queries) {
-    const context = useConsumerContext();
+    const di = useDiContainer();
     const memoQueries = useShallowEqual(queries);
     const resultQueries = useMemo(() => {
         return memoQueries.map((query) => {
             if (isQuery(query)) {
-                return query.raw(context);
+                return query.raw(di);
             }
             return query;
         });
-    }, [memoQueries, context]);
+    }, [memoQueries, di]);
     return useQueries$1({ queries: resultQueries });
 }
 
-const convertToRawQuery = (query, context, options) => {
-    const { key = identity, fn, getNextPageParam, getPreviousPageParam, deps, conditions, infiniteQueryOptions, } = query[QUERY_PARAMETERS];
-    const queryKey = normalizeKey(applyOrReturn([options], key));
+const convertToRawQuery = (query, di, options) => {
+    const { key = identity, fn, getNextPageParam, getPreviousPageParam, deps = {}, conditions, infiniteQueryOptions, } = query[QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey(rawQueryKey);
     const actionWrapper = declareAction({
         name: 'infiniteQueryExecution',
         async fn(pageParam) {
-            return fn(options, pageParam, this.deps);
+            return fn.call(ctx, options, pageParam, ctx.deps);
         },
         conditionsFailResult: 'reject',
         deps,
@@ -136,6 +150,7 @@ const convertToRawQuery = (query, context, options) => {
             conditions,
         },
         queryFn: ({ pageParam }) => {
+            const context = di.get(CONTEXT_TOKEN);
             return context.executeAction(actionWrapper, pageParam);
         },
     };
@@ -153,17 +168,17 @@ const createInfiniteQuery = (queryParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawQuery(query, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawQuery(query, resolveDI(diOrContext), options);
         },
         prefetchAction: (options) => {
             return declareAction({
                 name: 'infiniteQueryPrefetch',
                 fn() {
-                    return this.deps.queryClient.prefetchInfiniteQuery(convertToRawQuery(query, this.deps.context, options));
+                    return this.deps.queryClient.prefetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
                 },
                 deps: {
-                    context: CONTEXT_TOKEN,
+                    di: DI_TOKEN,
                     queryClient: QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -173,10 +188,10 @@ const createInfiniteQuery = (queryParameters) => {
             return declareAction({
                 name: 'infiniteQueryFetch',
                 fn() {
-                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.context, options));
+                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
                 },
                 deps: {
-                    context: CONTEXT_TOKEN,
+                    di: DI_TOKEN,
                     queryClient: QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -187,13 +202,13 @@ const createInfiniteQuery = (queryParameters) => {
 };
 
 function useInfiniteQuery(query, options) {
-    const context = useConsumerContext();
+    const di = useDiContainer();
     const resultQuery = useMemo(() => {
         if (isQuery(query)) {
-            return query.raw(context, options);
+            return query.raw(di, options);
         }
         return query;
-    }, [query, context, options]);
+    }, [query, di, options]);
     return useInfiniteQuery$1(resultQuery);
 }
 
@@ -202,13 +217,16 @@ const isMutation = (arg) => {
     return MUTATION_PARAMETERS in arg;
 };
 
-const convertToRawMutation = (mutation, context, options) => {
-    const { key = identity, fn, deps, conditions, mutationOptions } = mutation[MUTATION_PARAMETERS];
-    const mutationKey = normalizeKey(applyOrReturn([options], key));
+const convertToRawMutation = (mutation, di, options) => {
+    const { key = identity, fn, deps = {}, conditions, mutationOptions, } = mutation[MUTATION_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawMutationKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const mutationKey = normalizeKey(rawMutationKey);
     const actionWrapper = declareAction({
         name: 'mutationExecution',
         async fn(variables) {
-            return fn(options, variables, this.deps);
+            return fn.call(ctx, options, variables, ctx.deps);
         },
         deps,
         conditions,
@@ -218,6 +236,7 @@ const convertToRawMutation = (mutation, context, options) => {
         ...mutationOptions,
         mutationKey,
         mutationFn: (variables) => {
+            const context = di.get(CONTEXT_TOKEN);
             return context.executeAction(actionWrapper, variables);
         },
     };
@@ -235,21 +254,21 @@ const createMutation = (mutationParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawMutation(mutation, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawMutation(mutation, resolveDI(diOrContext), options);
         },
     };
     return mutation;
 };
 
 const useMutation = (mutation, options) => {
-    const context = useConsumerContext();
+    const di = useDiContainer();
     const resultMutation = useMemo(() => {
         if (isMutation(mutation)) {
-            return mutation.raw(context, options);
+            return mutation.raw(di, options);
         }
         return mutation;
-    }, [mutation, context, options]);
+    }, [mutation, di, options]);
     return useMutation$1(resultMutation);
 };
 

package/lib/index.js

@@ -3,20 +3,19 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var identity = require('@tinkoff/utils/function/identity');
-var applyOrReturn = require('@tinkoff/utils/function/applyOrReturn');
+var dippy = require('@tinkoff/dippy');
 var core = require('@tramvai/core');
 var moduleReactQuery = require('@tramvai/module-react-query');
 var tokensCommon = require('@tramvai/tokens-common');
 var isArray = require('@tinkoff/utils/is/array');
-var react = require('react');
+var react$1 = require('react');
 var reactQuery = require('@tanstack/react-query');
-var state = require('@tramvai/state');
 var reactHooks = require('@tinkoff/react-hooks');
+var react = require('@tramvai/react');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
-var applyOrReturn__default = /*#__PURE__*/_interopDefaultLegacy(applyOrReturn);
 var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
 
 const QUERY_PARAMETERS = '__query_parameters__';
@@ -31,13 +30,23 @@ const normalizeKey = (key) => {
     return [key];
 };
 
-const convertToRawQuery$1 = (query, context, options) => {
-    const { key = identity__default["default"], fn, deps, conditions, queryOptions } = query[QUERY_PARAMETERS];
-    const queryKey = normalizeKey(applyOrReturn__default["default"]([options], key));
+// @TODO: v3: leave only di container in next major
+const resolveDI = (diOrContext) => {
+    return diOrContext instanceof dippy.Container
+        ? diOrContext
+        : diOrContext.di;
+};
+
+const convertToRawQuery$1 = (query, di, options) => {
+    const { key = identity__default["default"], fn, deps = {}, conditions, queryOptions } = query[QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey(rawQueryKey);
     const actionWrapper = core.declareAction({
         name: 'queryExecution',
         async fn() {
-            return fn(options, this.deps);
+            return fn.call(ctx, options, ctx.deps);
         },
         deps,
         conditions,
@@ -50,6 +59,7 @@ const convertToRawQuery$1 = (query, context, options) => {
             conditions,
         },
         queryFn: () => {
+            const context = di.get(tokensCommon.CONTEXT_TOKEN);
             return context.executeAction(actionWrapper);
         },
     };
@@ -67,17 +77,17 @@ const createQuery = (queryParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawQuery$1(query, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawQuery$1(query, resolveDI(diOrContext), options);
         },
         prefetchAction: (options) => {
             return core.declareAction({
                 name: 'queryPrefetch',
                 fn() {
-                    return this.deps.queryClient.prefetchQuery(convertToRawQuery$1(query, this.deps.context, options));
+                    return this.deps.queryClient.prefetchQuery(convertToRawQuery$1(query, this.deps.di, options));
                 },
                 deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
+                    di: dippy.DI_TOKEN,
                     queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -87,10 +97,10 @@ const createQuery = (queryParameters) => {
             return core.declareAction({
                 name: 'queryFetch',
                 fn() {
-                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.context, options));
+                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.di, options));
                 },
                 deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
+                    di: dippy.DI_TOKEN,
                     queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -101,36 +111,39 @@ const createQuery = (queryParameters) => {
 };
 
 function useQuery(query, options) {
-    const context = state.useConsumerContext();
-    const resultQuery = react.useMemo(() => {
+    const di = react.useDiContainer();
+    const resultQuery = react$1.useMemo(() => {
         if (isQuery(query)) {
-            return query.raw(context, options);
+            return query.raw(di, options);
         }
         return query;
-    }, [query, context, options]);
+    }, [query, di, options]);
     return reactQuery.useQuery(resultQuery);
 }
 function useQueries(queries) {
-    const context = state.useConsumerContext();
+    const di = react.useDiContainer();
     const memoQueries = reactHooks.useShallowEqual(queries);
-    const resultQueries = react.useMemo(() => {
+    const resultQueries = react$1.useMemo(() => {
         return memoQueries.map((query) => {
             if (isQuery(query)) {
-                return query.raw(context);
+                return query.raw(di);
             }
             return query;
         });
-    }, [memoQueries, context]);
+    }, [memoQueries, di]);
     return reactQuery.useQueries({ queries: resultQueries });
 }
 
-const convertToRawQuery = (query, context, options) => {
-    const { key = identity__default["default"], fn, getNextPageParam, getPreviousPageParam, deps, conditions, infiniteQueryOptions, } = query[QUERY_PARAMETERS];
-    const queryKey = normalizeKey(applyOrReturn__default["default"]([options], key));
+const convertToRawQuery = (query, di, options) => {
+    const { key = identity__default["default"], fn, getNextPageParam, getPreviousPageParam, deps = {}, conditions, infiniteQueryOptions, } = query[QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey(rawQueryKey);
     const actionWrapper = core.declareAction({
         name: 'infiniteQueryExecution',
         async fn(pageParam) {
-            return fn(options, pageParam, this.deps);
+            return fn.call(ctx, options, pageParam, ctx.deps);
         },
         conditionsFailResult: 'reject',
         deps,
@@ -145,6 +158,7 @@ const convertToRawQuery = (query, context, options) => {
             conditions,
         },
         queryFn: ({ pageParam }) => {
+            const context = di.get(tokensCommon.CONTEXT_TOKEN);
             return context.executeAction(actionWrapper, pageParam);
         },
     };
@@ -162,17 +176,17 @@ const createInfiniteQuery = (queryParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawQuery(query, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawQuery(query, resolveDI(diOrContext), options);
         },
         prefetchAction: (options) => {
             return core.declareAction({
                 name: 'infiniteQueryPrefetch',
                 fn() {
-                    return this.deps.queryClient.prefetchInfiniteQuery(convertToRawQuery(query, this.deps.context, options));
+                    return this.deps.queryClient.prefetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
                 },
                 deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
+                    di: dippy.DI_TOKEN,
                     queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -182,10 +196,10 @@ const createInfiniteQuery = (queryParameters) => {
             return core.declareAction({
                 name: 'infiniteQueryFetch',
                 fn() {
-                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.context, options));
+                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
                 },
                 deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
+                    di: dippy.DI_TOKEN,
                     queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
                 },
                 conditions,
@@ -196,13 +210,13 @@ const createInfiniteQuery = (queryParameters) => {
 };
 
 function useInfiniteQuery(query, options) {
-    const context = state.useConsumerContext();
-    const resultQuery = react.useMemo(() => {
+    const di = react.useDiContainer();
+    const resultQuery = react$1.useMemo(() => {
         if (isQuery(query)) {
-            return query.raw(context, options);
+            return query.raw(di, options);
         }
         return query;
-    }, [query, context, options]);
+    }, [query, di, options]);
     return reactQuery.useInfiniteQuery(resultQuery);
 }
 
@@ -211,13 +225,16 @@ const isMutation = (arg) => {
     return MUTATION_PARAMETERS in arg;
 };
 
-const convertToRawMutation = (mutation, context, options) => {
-    const { key = identity__default["default"], fn, deps, conditions, mutationOptions } = mutation[MUTATION_PARAMETERS];
-    const mutationKey = normalizeKey(applyOrReturn__default["default"]([options], key));
+const convertToRawMutation = (mutation, di, options) => {
+    const { key = identity__default["default"], fn, deps = {}, conditions, mutationOptions, } = mutation[MUTATION_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawMutationKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const mutationKey = normalizeKey(rawMutationKey);
     const actionWrapper = core.declareAction({
         name: 'mutationExecution',
         async fn(variables) {
-            return fn(options, variables, this.deps);
+            return fn.call(ctx, options, variables, ctx.deps);
         },
         deps,
         conditions,
@@ -227,6 +244,7 @@ const convertToRawMutation = (mutation, context, options) => {
         ...mutationOptions,
         mutationKey,
         mutationFn: (variables) => {
+            const context = di.get(tokensCommon.CONTEXT_TOKEN);
             return context.executeAction(actionWrapper, variables);
         },
     };
@@ -244,21 +262,21 @@ const createMutation = (mutationParameters) => {
                 },
             });
         },
-        raw: (context, options) => {
-            return convertToRawMutation(mutation, context, options);
+        raw: (diOrContext, options) => {
+            return convertToRawMutation(mutation, resolveDI(diOrContext), options);
         },
     };
     return mutation;
 };
 
 const useMutation = (mutation, options) => {
-    const context = state.useConsumerContext();
-    const resultMutation = react.useMemo(() => {
+    const di = react.useDiContainer();
+    const resultMutation = react$1.useMemo(() => {
         if (isMutation(mutation)) {
-            return mutation.raw(context, options);
+            return mutation.raw(di, options);
         }
         return mutation;
-    }, [mutation, context, options]);
+    }, [mutation, di, options]);
     return reactQuery.useMutation(resultMutation);
 };
 

package/lib/infiniteQuery/create.d.ts

@@ -1,2 +1,3 @@
+import type { ProviderDeps } from '@tinkoff/dippy';
 import type { CreateInfiniteQueryOptions, InfiniteQuery } from './types';
-export declare const createInfiniteQuery: <Options = unknown, PageParam = unknown, Result = unknown, Deps = unknown>(queryParameters: CreateInfiniteQueryOptions<Options, PageParam, Result, Deps>) => InfiniteQuery<Options, PageParam, Result, Deps>;
+export declare const createInfiniteQuery: <Options = unknown, PageParam = unknown, Result = unknown, Deps extends ProviderDeps = {}>(queryParameters: CreateInfiniteQueryOptions<Options, PageParam, Result, Deps>) => InfiniteQuery<Options, PageParam, Result, Deps>;

package/lib/infiniteQuery/types.d.ts

@@ -1,13 +1,17 @@
-import type { ProvideDepsIterator } from '@tinkoff/dippy';
+import type { ProvideDepsIterator, ProviderDeps } from '@tinkoff/dippy';
 import type { UseInfiniteQueryOptions, InfiniteData } from '@tanstack/react-query';
 import type { TramvaiAction } from '@tramvai/core';
-import type { BaseCreateQueryOptions, BaseQuery } from '../baseQuery/types';
-export interface CreateInfiniteQueryOptions<Options, PageParam, Result, Deps> extends BaseCreateQueryOptions<Options, Deps> {
+import type { BaseCreateQueryOptions, BaseQuery, ReactQueryContext } from '../baseQuery/types';
+export interface CreateInfiniteQueryOptions<Options, PageParam, Result, Deps extends ProviderDeps> extends BaseCreateQueryOptions<Options, Deps> {
     infiniteQueryOptions?: UseInfiniteQueryOptions<Result, Error>;
-    fn: (options: Options, pageParam: PageParam, deps: ProvideDepsIterator<Deps>) => Promise<Result>;
+    fn: (this: ReactQueryContext<Deps>, options: Options, pageParam: PageParam, 
+    /**
+     * @deprecated use this.deps instead
+     */
+    deps: ProvideDepsIterator<Deps>) => Promise<Result>;
     getNextPageParam?: (lastPage: Result, allPages: Result[]) => PageParam;
     getPreviousPageParam?: (firstPage: Result, allPages: Result[]) => PageParam;
 }
-export type InfiniteQuery<Options, PageParam, Result, Deps> = BaseQuery<Options, CreateInfiniteQueryOptions<Options, PageParam, Result, Deps>, InfiniteQuery<Options, PageParam, Result, Deps>, UseInfiniteQueryOptions<Result, Error>> & {
+export type InfiniteQuery<Options, PageParam, Result, Deps extends ProviderDeps> = BaseQuery<Options, CreateInfiniteQueryOptions<Options, PageParam, Result, Deps>, InfiniteQuery<Options, PageParam, Result, Deps>, UseInfiniteQueryOptions<Result, Error>> & {
     fetchAction(options?: Options): TramvaiAction<[], Promise<InfiniteData<Result>>, any>;
 };

package/lib/infiniteQuery/use.d.ts

@@ -1,5 +1,6 @@
 import type { InfiniteQueryObserverResult, UseInfiniteQueryOptions } from '@tanstack/react-query';
+import type { ProviderDeps } from '@tinkoff/dippy';
 import type { InfiniteQuery } from './types';
-declare function useInfiniteQuery<Options extends void, PageParam, Result, Deps>(query: UseInfiniteQueryOptions<Result, Error> | InfiniteQuery<Options, PageParam, Result, Deps>): InfiniteQueryObserverResult<Result, Error>;
-declare function useInfiniteQuery<Options, PageParam, Result, Deps>(query: UseInfiniteQueryOptions<Result, Error> | InfiniteQuery<Options, PageParam, Result, Deps>, options: Options): InfiniteQueryObserverResult<Result, Error>;
+declare function useInfiniteQuery<Options extends void, PageParam, Result, Deps extends ProviderDeps>(query: UseInfiniteQueryOptions<Result, Error> | InfiniteQuery<Options, PageParam, Result, Deps>): InfiniteQueryObserverResult<Result, Error>;
+declare function useInfiniteQuery<Options, PageParam, Result, Deps extends ProviderDeps>(query: UseInfiniteQueryOptions<Result, Error> | InfiniteQuery<Options, PageParam, Result, Deps>, options: Options): InfiniteQueryObserverResult<Result, Error>;
 export { useInfiniteQuery };

package/lib/mutation/create.d.ts

@@ -1,2 +1,3 @@
+import type { ProviderDeps } from '@tinkoff/dippy';
 import type { CreateMutationOptions, Mutation, MutationKey } from './types';
-export declare const createMutation: <Options, Variables, Result, Deps, Key extends MutationKey<Options>>(mutationParameters: CreateMutationOptions<Options, Variables, Result, Deps, Key>) => Mutation<Options, Variables, Result, Deps, Key>;
+export declare const createMutation: <Options, Variables, Result, Deps extends ProviderDeps = {}, Key extends MutationKey<Options, Deps> = MutationKey<Options, Deps>>(mutationParameters: CreateMutationOptions<Options, Variables, Result, Deps, Key>) => Mutation<Options, Variables, Result, Deps, Key>;

package/lib/mutation/mutation.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/mutation/types.d.ts

@@ -1,18 +1,28 @@
 import type { ActionConditionsParameters, ActionContext } from '@tramvai/core';
-import type { ProvideDepsIterator } from '@tinkoff/dippy';
+import type { Container, ProvideDepsIterator, ProviderDeps } from '@tinkoff/dippy';
 import type { MutationKey as ReactMutationKey, MutationOptions, UseMutationOptions } from '@tanstack/react-query';
+import type { ReactQueryContext } from '../baseQuery/types';
 export declare const MUTATION_PARAMETERS = "__mutations_parameters__";
-export type MutationKey<Options> = ((options?: Options) => ReactMutationKey) | ReactMutationKey;
-export interface CreateMutationOptions<Options, Variables, Result, Deps, Key extends MutationKey<Options> = (options?: Options) => ReactMutationKey> {
+export type ReactMutationKeyOrString = ReactMutationKey | string;
+export type MutationKey<Options, Deps extends ProviderDeps> = ((this: ReactQueryContext<Deps>, options?: Options) => ReactMutationKeyOrString) | ReactMutationKeyOrString;
+export interface CreateMutationOptions<Options, Variables, Result, Deps extends ProviderDeps, Key extends MutationKey<Options, Deps>> {
     key?: Key;
     mutationOptions?: UseMutationOptions<Result, any, Variables>;
-    fn: (options: Options | undefined, variables: Variables, deps: ProvideDepsIterator<Deps>) => Promise<Result>;
-    deps: Deps;
+    fn: (this: ReactQueryContext<Deps>, options: Options | undefined, variables: Variables, 
+    /**
+     * @deprecated use this.deps instead
+     */
+    deps: ProvideDepsIterator<Deps>) => Promise<Result>;
+    deps?: Deps;
     conditions?: ActionConditionsParameters;
 }
-export interface Mutation<Options, Variables, Result, Deps, Key extends MutationKey<Options>> {
+export interface Mutation<Options, Variables, Result, Deps extends ProviderDeps, Key extends MutationKey<Options, Deps>> {
     [MUTATION_PARAMETERS]: CreateMutationOptions<Options, Variables, Result, Deps, Key>;
     fork(options: MutationOptions<Result, Error, Variables, any>): Mutation<Options, Variables, Result, Deps, Key>;
+    raw(di: Container, options?: Options): UseMutationOptions<Result, Error, Variables>;
+    /**
+     * @deprecated pass di as first parameter instead of context
+     */
     raw(context: ActionContext, options?: Options): UseMutationOptions<Result, Error, Variables>;
 }
-export declare const isMutation: <Options, Variables, Result, Deps, Key extends MutationKey<Options>>(arg: Mutation<Options, Variables, Result, Deps, Key> | MutationOptions<Result, any, Variables, any>) => arg is Mutation<Options, Variables, Result, Deps, Key>;
+export declare const isMutation: <Options, Variables, Result, Deps extends ProviderDeps, Key extends MutationKey<Options, Deps>>(arg: Mutation<Options, Variables, Result, Deps, Key> | MutationOptions<Result, any, Variables, any>) => arg is Mutation<Options, Variables, Result, Deps, Key>;

package/lib/mutation/use.d.ts

@@ -1,8 +1,9 @@
-import type { UseMutationOptions, UseMutationResult, MutationKey as ReactMutationKey } from '@tanstack/react-query';
-import type { Mutation } from './types';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { ProviderDeps } from '@tinkoff/dippy';
+import type { Mutation, MutationKey } from './types';
 interface UseMutation {
-    <Options, Variables, Result, Deps, Key extends (options?: Options) => ReactMutationKey>(Mutation: UseMutationOptions<Result, any, Variables> | Mutation<Options, Variables, Result, Deps, Key>, options: Options): UseMutationResult<Result, any, Variables>;
-    <Options, Variables, Result, Deps, Key extends ReactMutationKey>(Mutation: UseMutationOptions<Result, any, Variables> | Mutation<Options, Variables, Result, Deps, Key>): UseMutationResult<Result, any, Variables>;
+    <Options, Variables, Result, Deps extends ProviderDeps, Key extends MutationKey<Options, Deps>>(Mutation: UseMutationOptions<Result, any, Variables> | Mutation<Options, Variables, Result, Deps, Key>, options: Options): UseMutationResult<Result, any, Variables>;
+    <Options, Variables, Result, Deps extends ProviderDeps, Key extends MutationKey<Options, Deps>>(Mutation: UseMutationOptions<Result, any, Variables> | Mutation<Options, Variables, Result, Deps, Key>): UseMutationResult<Result, any, Variables>;
 }
 export declare const useMutation: UseMutation;
 export {};

package/lib/query/create.d.ts

@@ -1,2 +1,3 @@
+import type { ProviderDeps } from '@tinkoff/dippy';
 import type { CreateQueryOptions, Query } from './types';
-export declare const createQuery: <Options = unknown, Result = unknown, Deps = unknown>(queryParameters: CreateQueryOptions<Options, Result, Deps>) => Query<Options, Result, Deps>;
+export declare const createQuery: <Options = unknown, Result = unknown, Deps extends ProviderDeps = {}>(queryParameters: CreateQueryOptions<Options, Result, Deps>) => Query<Options, Result, Deps>;

package/lib/query/types.d.ts

@@ -1,11 +1,15 @@
-import type { ProvideDepsIterator } from '@tinkoff/dippy';
+import type { ProvideDepsIterator, ProviderDeps } from '@tinkoff/dippy';
 import type { UseQueryOptions } from '@tanstack/react-query';
 import type { TramvaiAction } from '@tramvai/core';
-import type { BaseCreateQueryOptions, BaseQuery } from '../baseQuery/types';
-export interface CreateQueryOptions<Options, Result, Deps> extends BaseCreateQueryOptions<Options, Deps> {
+import type { BaseCreateQueryOptions, BaseQuery, ReactQueryContext } from '../baseQuery/types';
+export interface CreateQueryOptions<Options, Result, Deps extends ProviderDeps> extends BaseCreateQueryOptions<Options, Deps> {
     queryOptions?: UseQueryOptions<Result, Error>;
-    fn: (options: Options, deps: ProvideDepsIterator<Deps>) => Promise<Result>;
+    fn: (this: ReactQueryContext<Deps>, options: Options, 
+    /**
+     * @deprecated use this.deps instead
+     */
+    deps: ProvideDepsIterator<Deps>) => Promise<Result>;
 }
-export type Query<Options, Result, Deps> = BaseQuery<Options, CreateQueryOptions<Options, Result, Deps>, Query<Options, Result, Deps>, UseQueryOptions<Result, Error>> & {
+export type Query<Options, Result, Deps extends ProviderDeps> = BaseQuery<Options, CreateQueryOptions<Options, Result, Deps>, Query<Options, Result, Deps>, UseQueryOptions<Result, Error>> & {
     fetchAction(options?: Options): TramvaiAction<[], Promise<Result>, any>;
 };

package/lib/query/use.d.ts

@@ -1,6 +1,7 @@
 import type { UseQueryOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { ProviderDeps } from '@tinkoff/dippy';
 import type { Query } from './types';
-declare function useQuery<Options extends void, Result, Deps>(query: UseQueryOptions<Result, Error> | Query<Options, Result, Deps>): QueryObserverResult<Result, Error>;
-declare function useQuery<Options, Result, Deps>(query: UseQueryOptions<Result, Error> | Query<Options, Result, Deps>, options: Options): QueryObserverResult<Result, Error>;
-declare function useQueries<Result, Deps>(queries: Array<UseQueryOptions<Result, Error> | Query<any, Result, Deps>>): import("@tanstack/react-query").UseQueryResult<unknown extends Result ? Result : Result, Error>[];
+declare function useQuery<Options extends void, Result, Deps extends ProviderDeps>(query: UseQueryOptions<Result, Error> | Query<Options, Result, Deps>): QueryObserverResult<Result, Error>;
+declare function useQuery<Options, Result, Deps extends ProviderDeps>(query: UseQueryOptions<Result, Error> | Query<Options, Result, Deps>, options: Options): QueryObserverResult<Result, Error>;
+declare function useQueries<Result, Deps extends ProviderDeps>(queries: Array<UseQueryOptions<Result, Error> | Query<any, Result, Deps>>): import("@tanstack/react-query").UseQueryResult<unknown extends Result ? Result : Result, Error>[];
 export { useQuery, useQueries };

package/lib/shared/resolveDI.d.ts

@@ -0,0 +1,3 @@
+import { Container } from '@tinkoff/dippy';
+import type { ActionContext } from '@tramvai/core';
+export declare const resolveDI: (diOrContext: ActionContext | Container) => Container;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/react-query",
-  "version": "2.49.3",
+  "version": "2.50.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -19,10 +19,10 @@
   },
   "dependencies": {
     "@tinkoff/react-hooks": "0.1.4",
-    "@tramvai/core": "2.49.3",
-    "@tramvai/module-react-query": "2.49.3",
-    "@tramvai/state": "2.49.3",
-    "@tramvai/tokens-common": "2.49.3"
+    "@tramvai/core": "2.50.0",
+    "@tramvai/module-react-query": "2.50.0",
+    "@tramvai/react": "2.50.0",
+    "@tramvai/tokens-common": "2.50.0"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.9",