@tramvai/react-query 2.70.0 → 2.72.0

package/lib/infiniteQuery/create.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var identity = require('@tinkoff/utils/function/identity');
+var core = require('@tramvai/core');
+var moduleReactQuery = require('@tramvai/module-react-query');
+var tokensCommon = require('@tramvai/tokens-common');
+var dippy = require('@tinkoff/dippy');
+var types = require('../baseQuery/types.js');
+var normalizeKey = require('../shared/normalizeKey.js');
+var resolveDI = require('../shared/resolveDI.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+
+const convertToRawQuery = (query, di, options) => {
+    const { key = identity__default["default"], fn, getNextPageParam, getPreviousPageParam, deps = {}, conditions, infiniteQueryOptions, } = query[types.QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey.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 = {
+        [types.QUERY_PARAMETERS]: queryParameters,
+        fork: (options) => {
+            return createInfiniteQuery({
+                ...queryParameters,
+                infiniteQueryOptions: {
+                    ...infiniteQueryOptions,
+                    ...options,
+                },
+            });
+        },
+        raw: (diOrContext, options) => {
+            return convertToRawQuery(query, resolveDI.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;
+};
+
+exports.createInfiniteQuery = createInfiniteQuery;

package/lib/infiniteQuery/use.es.js

@@ -0,0 +1,17 @@
+import { useMemo } from 'react';
+import { useInfiniteQuery as useInfiniteQuery$1 } from '@tanstack/react-query';
+import { useDiContainer } from '@tramvai/react';
+import { isQuery } from '../baseQuery/types.es.js';
+
+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);
+}
+
+export { useInfiniteQuery };

package/lib/infiniteQuery/use.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react$1 = require('react');
+var reactQuery = require('@tanstack/react-query');
+var react = require('@tramvai/react');
+var types = require('../baseQuery/types.js');
+
+function useInfiniteQuery(query, options) {
+    const di = react.useDiContainer();
+    const resultQuery = react$1.useMemo(() => {
+        if (types.isQuery(query)) {
+            return query.raw(di, options);
+        }
+        return query;
+    }, [query, di, options]);
+    return reactQuery.useInfiniteQuery(resultQuery);
+}
+
+exports.useInfiniteQuery = useInfiniteQuery;

package/lib/mutation/create.es.js

@@ -0,0 +1,52 @@
+import identity from '@tinkoff/utils/function/identity';
+import { declareAction } from '@tramvai/core';
+import { CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { MUTATION_PARAMETERS } from './types.es.js';
+import { normalizeKey } from '../shared/normalizeKey.es.js';
+import { resolveDI } from '../shared/resolveDI.es.js';
+
+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;
+};
+
+export { createMutation };

package/lib/mutation/create.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var identity = require('@tinkoff/utils/function/identity');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var types = require('./types.js');
+var normalizeKey = require('../shared/normalizeKey.js');
+var resolveDI = require('../shared/resolveDI.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+
+const convertToRawMutation = (mutation, di, options) => {
+    const { key = identity__default["default"], fn, deps = {}, conditions, mutationOptions, } = mutation[types.MUTATION_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawMutationKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const mutationKey = normalizeKey.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 = {
+        [types.MUTATION_PARAMETERS]: mutationParameters,
+        fork: (options) => {
+            return createMutation({
+                ...mutationParameters,
+                mutationOptions: {
+                    ...mutationOptions,
+                    ...options,
+                },
+            });
+        },
+        raw: (diOrContext, options) => {
+            return convertToRawMutation(mutation, resolveDI.resolveDI(diOrContext), options);
+        },
+    };
+    return mutation;
+};
+
+exports.createMutation = createMutation;

package/lib/mutation/types.es.js

@@ -0,0 +1,6 @@
+const MUTATION_PARAMETERS = '__mutations_parameters__';
+const isMutation = (arg) => {
+    return MUTATION_PARAMETERS in arg;
+};
+
+export { MUTATION_PARAMETERS, isMutation };

package/lib/mutation/types.js

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

package/lib/mutation/use.es.js

@@ -0,0 +1,17 @@
+import { useMemo } from 'react';
+import { useMutation as useMutation$1 } from '@tanstack/react-query';
+import { useDiContainer } from '@tramvai/react';
+import { isMutation } from './types.es.js';
+
+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 { useMutation };

package/lib/mutation/use.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react$1 = require('react');
+var reactQuery = require('@tanstack/react-query');
+var react = require('@tramvai/react');
+var types = require('./types.js');
+
+const useMutation = (mutation, options) => {
+    const di = react.useDiContainer();
+    const resultMutation = react$1.useMemo(() => {
+        if (types.isMutation(mutation)) {
+            return mutation.raw(di, options);
+        }
+        return mutation;
+    }, [mutation, di, options]);
+    return reactQuery.useMutation(resultMutation);
+};
+
+exports.useMutation = useMutation;

package/lib/query/create.es.js

@@ -0,0 +1,83 @@
+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 { 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, 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(query, resolveDI(diOrContext), options);
+        },
+        prefetchAction: (options) => {
+            return declareAction({
+                name: 'queryPrefetch',
+                fn() {
+                    return this.deps.queryClient.prefetchQuery(convertToRawQuery(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(query, this.deps.di, options));
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    queryClient: QUERY_CLIENT_TOKEN,
+                },
+                conditions,
+            });
+        },
+    };
+    return query;
+};
+
+export { createQuery };

package/lib/query/create.js

@@ -0,0 +1,91 @@
+'use strict';
+
+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 types = require('../baseQuery/types.js');
+var normalizeKey = require('../shared/normalizeKey.js');
+var resolveDI = require('../shared/resolveDI.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+
+const convertToRawQuery = (query, di, options) => {
+    const { key = identity__default["default"], fn, deps = {}, conditions, queryOptions } = query[types.QUERY_PARAMETERS];
+    const resolvedDeps = di.getOfDeps(deps);
+    const ctx = { deps: resolvedDeps };
+    const rawQueryKey = typeof key === 'function' ? key.call(ctx, options) : key;
+    const queryKey = normalizeKey.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 = {
+        [types.QUERY_PARAMETERS]: queryParameters,
+        fork: (options) => {
+            return createQuery({
+                ...queryParameters,
+                queryOptions: {
+                    ...queryOptions,
+                    ...options,
+                },
+            });
+        },
+        raw: (diOrContext, options) => {
+            return convertToRawQuery(query, resolveDI.resolveDI(diOrContext), options);
+        },
+        prefetchAction: (options) => {
+            return core.declareAction({
+                name: 'queryPrefetch',
+                fn() {
+                    return this.deps.queryClient.prefetchQuery(convertToRawQuery(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(query, this.deps.di, options));
+                },
+                deps: {
+                    di: dippy.DI_TOKEN,
+                    queryClient: moduleReactQuery.QUERY_CLIENT_TOKEN,
+                },
+                conditions,
+            });
+        },
+    };
+    return query;
+};
+
+exports.createQuery = createQuery;

package/lib/query/use.es.js

@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+import { useQuery as useQuery$1, useQueries as useQueries$1 } from '@tanstack/react-query';
+import { useShallowEqual } from '@tinkoff/react-hooks';
+import { useDiContainer } from '@tramvai/react';
+import { isQuery } from '../baseQuery/types.es.js';
+
+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 });
+}
+
+export { useQueries, useQuery };

package/lib/query/use.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react$1 = require('react');
+var reactQuery = require('@tanstack/react-query');
+var reactHooks = require('@tinkoff/react-hooks');
+var react = require('@tramvai/react');
+var types = require('../baseQuery/types.js');
+
+function useQuery(query, options) {
+    const di = react.useDiContainer();
+    const resultQuery = react$1.useMemo(() => {
+        if (types.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 (types.isQuery(query)) {
+                return query.raw(di);
+            }
+            return query;
+        });
+    }, [memoQueries, di]);
+    return reactQuery.useQueries({ queries: resultQueries });
+}
+
+exports.useQueries = useQueries;
+exports.useQuery = useQuery;

package/lib/shared/normalizeKey.es.js

@@ -0,0 +1,10 @@
+import isArray from '@tinkoff/utils/is/array';
+
+const normalizeKey = (key) => {
+    if (isArray(key)) {
+        return key;
+    }
+    return [key];
+};
+
+export { normalizeKey };

package/lib/shared/normalizeKey.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isArray = require('@tinkoff/utils/is/array');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
+
+const normalizeKey = (key) => {
+    if (isArray__default["default"](key)) {
+        return key;
+    }
+    return [key];
+};
+
+exports.normalizeKey = normalizeKey;

package/lib/shared/resolveDI.es.js

@@ -0,0 +1,12 @@
+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;
+};
+
+export { resolveDI };

package/lib/shared/resolveDI.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+};
+
+exports.resolveDI = resolveDI;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/react-query",
-  "version": "2.70.0",
+  "version": "2.72.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -13,19 +13,18 @@
     "url": "git@github.com:Tinkoff/tramvai.git"
   },
   "scripts": {
-    "build": "tramvai-build --for-publish",
-    "watch": "tsc -w",
-    "build-for-publish": "true"
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
   },
   "dependencies": {
-    "@tinkoff/react-hooks": "0.1.4",
-    "@tramvai/core": "2.70.0",
-    "@tramvai/module-react-query": "2.70.0",
-    "@tramvai/react": "2.70.0",
-    "@tramvai/tokens-common": "2.70.0"
+    "@tinkoff/react-hooks": "0.1.5",
+    "@tramvai/core": "2.72.0",
+    "@tramvai/module-react-query": "2.72.0",
+    "@tramvai/react": "2.72.0",
+    "@tramvai/tokens-common": "2.72.0"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.8.12",
+    "@tinkoff/dippy": "0.8.13",
     "@tinkoff/utils": "^2.1.2",
     "react": ">=16.14.0",
     "@tanstack/react-query": "^4.7.1",