@tramvai/react-query 2.70.0 → 2.72.0

package/lib/baseQuery/types.es.js

@@ -0,0 +1,6 @@
+const QUERY_PARAMETERS = '__query_parameters__';
+const isQuery = (arg) => {
+    return QUERY_PARAMETERS in arg;
+};
+
+export { QUERY_PARAMETERS, isQuery };

package/lib/baseQuery/types.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const QUERY_PARAMETERS = '__query_parameters__';
+const isQuery = (arg) => {
+    return QUERY_PARAMETERS in arg;
+};
+
+exports.QUERY_PARAMETERS = QUERY_PARAMETERS;
+exports.isQuery = isQuery;

package/lib/index.es.js

@@ -1,279 +1,7 @@
-import identity from '@tinkoff/utils/function/identity';
-import { 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';
-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 { createQuery } from './query/create.es.js';
+export { useQueries, useQuery } from './query/use.es.js';
+export { createInfiniteQuery } from './infiniteQuery/create.es.js';
+export { useInfiniteQuery } from './infiniteQuery/use.es.js';
+export { createMutation } from './mutation/create.es.js';
+export { useMutation } from './mutation/use.es.js';
 export { useQueryClient } from '@tanstack/react-query';
-import { useShallowEqual } from '@tinkoff/react-hooks';
-import { useDiContainer } from '@tramvai/react';
-
-const QUERY_PARAMETERS = '__query_parameters__';
-const isQuery = (arg) => {
-    return QUERY_PARAMETERS in arg;
-};
-
-const normalizeKey = (key) => {
-    if (isArray(key)) {
-        return key;
-    }
-    return [key];
-};
-
-const isActionContext = (diOrContext) => {
-    return 'di' in diOrContext;
-};
-// @TODO: v3: leave only di container in next major
-const resolveDI = (diOrContext) => {
-    if (isActionContext(diOrContext)) {
-        return diOrContext.di;
-    }
-    return diOrContext;
-};
-
-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.call(ctx, options, ctx.deps);
-        },
-        deps,
-        conditions,
-        conditionsFailResult: 'reject',
-    });
-    return {
-        ...queryOptions,
-        queryKey,
-        tramvaiOptions: {
-            conditions,
-        },
-        queryFn: () => {
-            const context = di.get(CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper);
-        },
-    };
-};
-const createQuery = (queryParameters) => {
-    const { queryOptions, conditions } = queryParameters;
-    const query = {
-        [QUERY_PARAMETERS]: queryParameters,
-        fork: (options) => {
-            return createQuery({
-                ...queryParameters,
-                queryOptions: {
-                    ...queryOptions,
-                    ...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.di, options));
-                },
-                deps: {
-                    di: DI_TOKEN,
-                    queryClient: QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-        fetchAction: (options) => {
-            return declareAction({
-                name: 'queryFetch',
-                fn() {
-                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.di, options));
-                },
-                deps: {
-                    di: DI_TOKEN,
-                    queryClient: QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-    };
-    return query;
-};
-
-function useQuery(query, options) {
-    const di = useDiContainer();
-    const resultQuery = useMemo(() => {
-        if (isQuery(query)) {
-            return query.raw(di, options);
-        }
-        return query;
-    }, [query, di, options]);
-    return useQuery$1(resultQuery);
-}
-function useQueries(queries) {
-    const di = useDiContainer();
-    const memoQueries = useShallowEqual(queries);
-    const resultQueries = useMemo(() => {
-        return memoQueries.map((query) => {
-            if (isQuery(query)) {
-                return query.raw(di);
-            }
-            return query;
-        });
-    }, [memoQueries, di]);
-    return useQueries$1({ queries: resultQueries });
-}
-
-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.call(ctx, options, pageParam, ctx.deps);
-        },
-        conditionsFailResult: 'reject',
-        deps,
-        conditions,
-    });
-    return {
-        ...infiniteQueryOptions,
-        getNextPageParam,
-        getPreviousPageParam,
-        queryKey,
-        tramvaiOptions: {
-            conditions,
-        },
-        queryFn: ({ pageParam }) => {
-            const context = di.get(CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper, pageParam);
-        },
-    };
-};
-const createInfiniteQuery = (queryParameters) => {
-    const { infiniteQueryOptions, conditions } = queryParameters;
-    const query = {
-        [QUERY_PARAMETERS]: queryParameters,
-        fork: (options) => {
-            return createInfiniteQuery({
-                ...queryParameters,
-                infiniteQueryOptions: {
-                    ...infiniteQueryOptions,
-                    ...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.di, options));
-                },
-                deps: {
-                    di: DI_TOKEN,
-                    queryClient: QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-        fetchAction: (options) => {
-            return declareAction({
-                name: 'infiniteQueryFetch',
-                fn() {
-                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
-                },
-                deps: {
-                    di: DI_TOKEN,
-                    queryClient: QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-    };
-    return query;
-};
-
-function useInfiniteQuery(query, options) {
-    const di = useDiContainer();
-    const resultQuery = useMemo(() => {
-        if (isQuery(query)) {
-            return query.raw(di, options);
-        }
-        return query;
-    }, [query, di, options]);
-    return useInfiniteQuery$1(resultQuery);
-}
-
-const MUTATION_PARAMETERS = '__mutations_parameters__';
-const isMutation = (arg) => {
-    return MUTATION_PARAMETERS in arg;
-};
-
-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.call(ctx, options, variables, ctx.deps);
-        },
-        deps,
-        conditions,
-        conditionsFailResult: 'reject',
-    });
-    return {
-        ...mutationOptions,
-        mutationKey,
-        mutationFn: (variables) => {
-            const context = di.get(CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper, variables);
-        },
-    };
-};
-const createMutation = (mutationParameters) => {
-    const { mutationOptions } = mutationParameters;
-    const mutation = {
-        [MUTATION_PARAMETERS]: mutationParameters,
-        fork: (options) => {
-            return createMutation({
-                ...mutationParameters,
-                mutationOptions: {
-                    ...mutationOptions,
-                    ...options,
-                },
-            });
-        },
-        raw: (diOrContext, options) => {
-            return convertToRawMutation(mutation, resolveDI(diOrContext), options);
-        },
-    };
-    return mutation;
-};
-
-const useMutation = (mutation, options) => {
-    const di = useDiContainer();
-    const resultMutation = useMemo(() => {
-        if (isMutation(mutation)) {
-            return mutation.raw(di, options);
-        }
-        return mutation;
-    }, [mutation, di, options]);
-    return useMutation$1(resultMutation);
-};
-
-export { createInfiniteQuery, createMutation, createQuery, useInfiniteQuery, useMutation, useQueries, useQuery };

package/lib/index.js

@@ -2,296 +2,24 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var identity = require('@tinkoff/utils/function/identity');
-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$1 = require('react');
+var create = require('./query/create.js');
+var use = require('./query/use.js');
+var create$1 = require('./infiniteQuery/create.js');
+var use$1 = require('./infiniteQuery/use.js');
+var create$2 = require('./mutation/create.js');
+var use$2 = require('./mutation/use.js');
 var reactQuery = require('@tanstack/react-query');
-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 isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
-
-const QUERY_PARAMETERS = '__query_parameters__';
-const isQuery = (arg) => {
-    return QUERY_PARAMETERS in arg;
-};
-
-const normalizeKey = (key) => {
-    if (isArray__default["default"](key)) {
-        return key;
-    }
-    return [key];
-};
-
-const isActionContext = (diOrContext) => {
-    return 'di' in diOrContext;
-};
-// @TODO: v3: leave only di container in next major
-const resolveDI = (diOrContext) => {
-    if (isActionContext(diOrContext)) {
-        return diOrContext.di;
-    }
-    return diOrContext;
-};
-
-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.call(ctx, options, ctx.deps);
-        },
-        deps,
-        conditions,
-        conditionsFailResult: 'reject',
-    });
-    return {
-        ...queryOptions,
-        queryKey,
-        tramvaiOptions: {
-            conditions,
-        },
-        queryFn: () => {
-            const context = di.get(tokensCommon.CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper);
-        },
-    };
-};
-const createQuery = (queryParameters) => {
-    const { queryOptions, conditions } = queryParameters;
-    const query = {
-        [QUERY_PARAMETERS]: queryParameters,
-        fork: (options) => {
-            return createQuery({
-                ...queryParameters,
-                queryOptions: {
-                    ...queryOptions,
-                    ...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.di, options));
-                },
-                deps: {
-                    di: dippy.DI_TOKEN,
-                    queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-        fetchAction: (options) => {
-            return core.declareAction({
-                name: 'queryFetch',
-                fn() {
-                    return this.deps.queryClient.fetchQuery(convertToRawQuery$1(query, this.deps.di, options));
-                },
-                deps: {
-                    di: dippy.DI_TOKEN,
-                    queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-    };
-    return query;
-};
-
-function useQuery(query, options) {
-    const di = react.useDiContainer();
-    const resultQuery = react$1.useMemo(() => {
-        if (isQuery(query)) {
-            return query.raw(di, options);
-        }
-        return query;
-    }, [query, di, options]);
-    return reactQuery.useQuery(resultQuery);
-}
-function useQueries(queries) {
-    const di = react.useDiContainer();
-    const memoQueries = reactHooks.useShallowEqual(queries);
-    const resultQueries = react$1.useMemo(() => {
-        return memoQueries.map((query) => {
-            if (isQuery(query)) {
-                return query.raw(di);
-            }
-            return query;
-        });
-    }, [memoQueries, di]);
-    return reactQuery.useQueries({ queries: resultQueries });
-}
-
-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.call(ctx, options, pageParam, ctx.deps);
-        },
-        conditionsFailResult: 'reject',
-        deps,
-        conditions,
-    });
-    return {
-        ...infiniteQueryOptions,
-        getNextPageParam,
-        getPreviousPageParam,
-        queryKey,
-        tramvaiOptions: {
-            conditions,
-        },
-        queryFn: ({ pageParam }) => {
-            const context = di.get(tokensCommon.CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper, pageParam);
-        },
-    };
-};
-const createInfiniteQuery = (queryParameters) => {
-    const { infiniteQueryOptions, conditions } = queryParameters;
-    const query = {
-        [QUERY_PARAMETERS]: queryParameters,
-        fork: (options) => {
-            return createInfiniteQuery({
-                ...queryParameters,
-                infiniteQueryOptions: {
-                    ...infiniteQueryOptions,
-                    ...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.di, options));
-                },
-                deps: {
-                    di: dippy.DI_TOKEN,
-                    queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-        fetchAction: (options) => {
-            return core.declareAction({
-                name: 'infiniteQueryFetch',
-                fn() {
-                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
-                },
-                deps: {
-                    di: dippy.DI_TOKEN,
-                    queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
-                },
-                conditions,
-            });
-        },
-    };
-    return query;
-};
-
-function useInfiniteQuery(query, options) {
-    const di = react.useDiContainer();
-    const resultQuery = react$1.useMemo(() => {
-        if (isQuery(query)) {
-            return query.raw(di, options);
-        }
-        return query;
-    }, [query, di, options]);
-    return reactQuery.useInfiniteQuery(resultQuery);
-}
-
-const MUTATION_PARAMETERS = '__mutations_parameters__';
-const isMutation = (arg) => {
-    return MUTATION_PARAMETERS in arg;
-};
-
-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.call(ctx, options, variables, ctx.deps);
-        },
-        deps,
-        conditions,
-        conditionsFailResult: 'reject',
-    });
-    return {
-        ...mutationOptions,
-        mutationKey,
-        mutationFn: (variables) => {
-            const context = di.get(tokensCommon.CONTEXT_TOKEN);
-            return context.executeAction(actionWrapper, variables);
-        },
-    };
-};
-const createMutation = (mutationParameters) => {
-    const { mutationOptions } = mutationParameters;
-    const mutation = {
-        [MUTATION_PARAMETERS]: mutationParameters,
-        fork: (options) => {
-            return createMutation({
-                ...mutationParameters,
-                mutationOptions: {
-                    ...mutationOptions,
-                    ...options,
-                },
-            });
-        },
-        raw: (diOrContext, options) => {
-            return convertToRawMutation(mutation, resolveDI(diOrContext), options);
-        },
-    };
-    return mutation;
-};
-
-const useMutation = (mutation, options) => {
-    const di = react.useDiContainer();
-    const resultMutation = react$1.useMemo(() => {
-        if (isMutation(mutation)) {
-            return mutation.raw(di, options);
-        }
-        return mutation;
-    }, [mutation, di, options]);
-    return reactQuery.useMutation(resultMutation);
-};
 
+exports.createQuery = create.createQuery;
+exports.useQueries = use.useQueries;
+exports.useQuery = use.useQuery;
+exports.createInfiniteQuery = create$1.createInfiniteQuery;
+exports.useInfiniteQuery = use$1.useInfiniteQuery;
+exports.createMutation = create$2.createMutation;
+exports.useMutation = use$2.useMutation;
 Object.defineProperty(exports, 'useQueryClient', {
-    enumerable: true,
-    get: function () { return reactQuery.useQueryClient; }
+	enumerable: true,
+	get: function () { return reactQuery.useQueryClient; }
 });
-exports.createInfiniteQuery = createInfiniteQuery;
-exports.createMutation = createMutation;
-exports.createQuery = createQuery;
-exports.useInfiniteQuery = useInfiniteQuery;
-exports.useMutation = useMutation;
-exports.useQueries = useQueries;
-exports.useQuery = useQuery;

package/lib/infiniteQuery/create.es.js

@@ -0,0 +1,85 @@
+import identity from '@tinkoff/utils/function/identity';
+import { declareAction } from '@tramvai/core';
+import { QUERY_CLIENT_TOKEN } from '@tramvai/module-react-query';
+import { CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { DI_TOKEN } from '@tinkoff/dippy';
+import { QUERY_PARAMETERS } from '../baseQuery/types.es.js';
+import { normalizeKey } from '../shared/normalizeKey.es.js';
+import { resolveDI } from '../shared/resolveDI.es.js';
+
+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.call(ctx, options, pageParam, ctx.deps);
+        },
+        conditionsFailResult: 'reject',
+        deps,
+        conditions,
+    });
+    return {
+        ...infiniteQueryOptions,
+        getNextPageParam,
+        getPreviousPageParam,
+        queryKey,
+        tramvaiOptions: {
+            conditions,
+        },
+        queryFn: ({ pageParam }) => {
+            const context = di.get(CONTEXT_TOKEN);
+            return context.executeAction(actionWrapper, pageParam);
+        },
+    };
+};
+const createInfiniteQuery = (queryParameters) => {
+    const { infiniteQueryOptions, conditions } = queryParameters;
+    const query = {
+        [QUERY_PARAMETERS]: queryParameters,
+        fork: (options) => {
+            return createInfiniteQuery({
+                ...queryParameters,
+                infiniteQueryOptions: {
+                    ...infiniteQueryOptions,
+                    ...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.di, options));
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    queryClient: QUERY_CLIENT_TOKEN,
+                },
+                conditions,
+            });
+        },
+        fetchAction: (options) => {
+            return declareAction({
+                name: 'infiniteQueryFetch',
+                fn() {
+                    return this.deps.queryClient.fetchInfiniteQuery(convertToRawQuery(query, this.deps.di, options));
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    queryClient: QUERY_CLIENT_TOKEN,
+                },
+                conditions,
+            });
+        },
+    };
+    return query;
+};
+
+export { createInfiniteQuery };