@tramvai/react-query 2.150.0 → 2.151.0

package/__migrations__/1-react-query-creating.js

@@ -0,0 +1,152 @@
+'use strict';
+
+var tslib = require('tslib');
+
+var createQueryModuleSpecifier = '@tramvai/react-query';
+var createQueryImportSpecifier = 'createQuery';
+var creatInfiniteQueryImportSpecifier = 'createInfiniteQuery';
+function searchForImports(j, parsed, importSpecifierName) {
+    var result = {
+        isImported: false,
+        isImportedByName: false,
+        importedName: importSpecifierName,
+        importedDefaultName: '',
+    };
+    parsed
+        .find(j.ImportDeclaration, { source: { value: createQueryModuleSpecifier } })
+        .forEach(function (importDeclaration) {
+        result.isImported = true;
+        if (importDeclaration.value.specifiers) {
+            importDeclaration.value.specifiers.forEach(function (specifier) {
+                var _a, _b, _c;
+                // Default imports
+                if (specifier.type === 'ImportDefaultSpecifier') {
+                    result.importedDefaultName = (_b = (_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '';
+                    return;
+                }
+                // Named imports
+                if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported.name === importSpecifierName) {
+                    result.isImportedByName = true;
+                    // Named with overriding local name
+                    if ((_c = specifier.local) === null || _c === void 0 ? void 0 : _c.name) {
+                        result.importedName = specifier.local.name;
+                    }
+                }
+            });
+        }
+    });
+    return result;
+}
+// eslint-disable-next-line import/no-default-export
+var _1ReactQueryCreating = (function (api) { return tslib.__awaiter(void 0, void 0, void 0, function () {
+    return tslib.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, api.transform(function (_a, _b, _c) {
+                    var source = _a.source;
+                    var j = _b.j;
+                    var printOptions = _c.printOptions;
+                    var parsed = j(source);
+                    // ---------------- SEARCHING FOR THE RIGHT IMPORTS ------------------
+                    var createQueryImport = searchForImports(j, parsed, createQueryImportSpecifier);
+                    var createInfiniteQueryImport = searchForImports(j, parsed, creatInfiniteQueryImportSpecifier);
+                    // -----------------------------------------------------------------
+                    // ------- FUNCTION TO VALIDATE AND APPLY CHANGES IN PROPERTIES OF CALL EXPRESSION --------
+                    var hasChanged = false;
+                    var forEachCallExpression = function (callExpression) {
+                        var firstArgument = callExpression.value.arguments[0];
+                        var shouldAddActionNamePostfix = false;
+                        var isObjectAlreadyHasActionNamePostfix = false;
+                        if (!(firstArgument && firstArgument.type === 'ObjectExpression'))
+                            return;
+                        firstArgument.properties.forEach(function (property) {
+                            // for arrow function in property
+                            if (property.type === 'ObjectProperty' &&
+                                property.key.type === 'Identifier' &&
+                                property.key.name === 'key' &&
+                                property.value.type === 'ArrowFunctionExpression') {
+                                shouldAddActionNamePostfix = true;
+                            }
+                            // for method property
+                            if (property.type === 'ObjectMethod' &&
+                                property.key.type === 'Identifier' &&
+                                property.key.name === 'key') {
+                                shouldAddActionNamePostfix = true;
+                            }
+                            if (property.type === 'ObjectProperty' &&
+                                property.key.type === 'Identifier' &&
+                                property.key.name === 'actionNamePostfix') {
+                                isObjectAlreadyHasActionNamePostfix = true;
+                            }
+                            return property;
+                        });
+                        if (shouldAddActionNamePostfix &&
+                            !isObjectAlreadyHasActionNamePostfix &&
+                            callExpression.parent.value.type === 'VariableDeclarator') {
+                            hasChanged = true;
+                            j(callExpression).replaceWith(j.callExpression(callExpression.value.callee, [
+                                j.objectExpression(tslib.__spreadArray(tslib.__spreadArray([], firstArgument.properties, true), [
+                                    j.objectProperty(j.identifier('actionNamePostfix'), j.stringLiteral(callExpression.parent.value.id.name)),
+                                ], false)),
+                            ]));
+                        }
+                    };
+                    // ---------------------------------------------------------------------
+                    // --------- INITIATION OF RECOGNIZING CALL EXPRESSION WITH REQUIRED PROPERTIES ---------
+                    if (createQueryImport.isImported) {
+                        if (createQueryImport.isImportedByName) {
+                            parsed
+                                .find(j.CallExpression, { callee: { name: createQueryImport.importedName } })
+                                .forEach(forEachCallExpression);
+                        }
+                        if (createQueryImport.importedDefaultName) {
+                            parsed
+                                .find(j.CallExpression, {
+                                callee: {
+                                    object: {
+                                        name: createQueryImport.importedDefaultName,
+                                    },
+                                    property: {
+                                        name: createQueryImportSpecifier,
+                                    },
+                                },
+                            })
+                                .forEach(forEachCallExpression);
+                        }
+                    }
+                    if (createInfiniteQueryImport.isImported) {
+                        if (createInfiniteQueryImport.isImportedByName) {
+                            parsed
+                                .find(j.CallExpression, { callee: { name: createInfiniteQueryImport.importedName } })
+                                .forEach(forEachCallExpression);
+                        }
+                        if (createInfiniteQueryImport.importedDefaultName) {
+                            parsed
+                                .find(j.CallExpression, {
+                                callee: {
+                                    object: {
+                                        name: createInfiniteQueryImport.importedDefaultName,
+                                    },
+                                    property: {
+                                        name: creatInfiniteQueryImportSpecifier,
+                                    },
+                                },
+                            })
+                                .forEach(forEachCallExpression);
+                        }
+                    }
+                    // ---------------------------------------------------------------------------
+                    // --------- CHANGING FILES ---------------
+                    if (hasChanged) {
+                        return parsed.toSource(printOptions);
+                    }
+                    // ----------------------------------------
+                })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+
+module.exports = _1ReactQueryCreating;

package/lib/baseQuery/types.d.ts

@@ -9,13 +9,21 @@ export interface ReactQueryContext<Deps extends ProviderDeps> {
 }
 export type ReactQueryKeyOrString = ReactQueryKey | string;
 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>;
+export type CreateQueryOptionsWithSerializableKey<Options, Deps extends ProviderDeps> = {
+    key: ReactQueryKeyOrString;
     actionNamePostfix?: string;
     fn: Function;
     deps?: Deps;
     conditions?: ActionConditionsParameters;
-}
+};
+export type CreateQueryOptionsWithNonSerializableKey<Options, Deps extends ProviderDeps> = {
+    key: (this: ReactQueryContext<Deps>, options: Options) => ReactQueryKeyOrString;
+    actionNamePostfix: string;
+    fn: Function;
+    deps?: Deps;
+    conditions?: ActionConditionsParameters;
+};
+export type BaseCreateQueryOptions<Options, Deps extends ProviderDeps> = CreateQueryOptionsWithSerializableKey<Options, Deps> | CreateQueryOptionsWithNonSerializableKey<Options, Deps>;
 export interface BaseQuery<Options, TCreateQuery, TQuery, TUseQuery> {
     [QUERY_PARAMETERS]: TCreateQuery;
     fork(options: TUseQuery): TQuery;
@@ -28,3 +36,4 @@ export interface BaseQuery<Options, TCreateQuery, TQuery, TUseQuery> {
     actionNamePostfix: string;
 }
 export declare const isQuery: <Options, Result, TCreateQuery, TQuery, TUseQuery>(arg: BaseQuery<Options, TCreateQuery, TQuery, TUseQuery> | QueryOptions<Result, any, any, any>) => arg is BaseQuery<Options, TCreateQuery, TQuery, TUseQuery>;
+//# sourceMappingURL=types.d.ts.map

package/lib/index.d.ts

@@ -5,3 +5,4 @@ export { useInfiniteQuery } from './infiniteQuery/use';
 export { createMutation } from './mutation/create';
 export { useMutation } from './mutation/use';
 export { useQueryClient } from '@tanstack/react-query';
+//# sourceMappingURL=index.d.ts.map

package/lib/infiniteQuery/create.d.ts

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

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=infiniteQuery.test-types.d.ts.map

package/lib/infiniteQuery/types.d.ts

@@ -2,7 +2,7 @@ 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, ReactQueryContext } from '../baseQuery/types';
-export interface CreateInfiniteQueryOptions<Options, PageParam, Result, Deps extends ProviderDeps> extends BaseCreateQueryOptions<Options, Deps> {
+export type CreateInfiniteQueryOptions<Options, PageParam, Result, Deps extends ProviderDeps> = BaseCreateQueryOptions<Options, Deps> & {
     infiniteQueryOptions?: UseInfiniteQueryOptions<Result, Error>;
     fn: (this: ReactQueryContext<Deps>, options: Options, pageParam: PageParam, 
     /**
@@ -11,7 +11,8 @@ export interface CreateInfiniteQueryOptions<Options, PageParam, Result, Deps ext
     deps: ProvideDepsIterator<Deps>) => Promise<Result>;
     getNextPageParam?: (lastPage: Result, allPages: Result[]) => PageParam;
     getPreviousPageParam?: (firstPage: Result, allPages: Result[]) => PageParam;
-}
+};
 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>;
 };
+//# sourceMappingURL=types.d.ts.map

package/lib/infiniteQuery/use.d.ts

@@ -4,3 +4,4 @@ import type { InfiniteQuery } from './types';
 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 };
+//# sourceMappingURL=use.d.ts.map

package/lib/mutation/create.d.ts

@@ -1,3 +1,4 @@
 import type { ProviderDeps } from '@tinkoff/dippy';
 import type { CreateMutationOptions, Mutation, MutationKey } from './types';
 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>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=mutation.test-types.d.ts.map

package/lib/mutation/types.d.ts

@@ -26,3 +26,4 @@ export interface Mutation<Options, Variables, Result, Deps extends ProviderDeps,
     raw(context: ActionContext, options?: Options): UseMutationOptions<Result, Error, Variables>;
 }
 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>;
+//# sourceMappingURL=types.d.ts.map

package/lib/mutation/use.d.ts

@@ -7,3 +7,4 @@ interface UseMutation {
 }
 export declare const useMutation: UseMutation;
 export {};
+//# sourceMappingURL=use.d.ts.map

package/lib/query/create.d.ts

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

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=query.test-types.d.ts.map

package/lib/query/types.d.ts

@@ -2,14 +2,15 @@ import type { ProvideDepsIterator, ProviderDeps } from '@tinkoff/dippy';
 import type { UseQueryOptions } from '@tanstack/react-query';
 import type { TramvaiAction } from '@tramvai/core';
 import type { BaseCreateQueryOptions, BaseQuery, ReactQueryContext } from '../baseQuery/types';
-export interface CreateQueryOptions<Options, Result, Deps extends ProviderDeps> extends BaseCreateQueryOptions<Options, Deps> {
+export type CreateQueryOptions<Options, Result, Deps extends ProviderDeps> = BaseCreateQueryOptions<Options, Deps> & {
     queryOptions?: UseQueryOptions<Result, Error>;
     fn: (this: ReactQueryContext<Deps>, options: Options, 
     /**
      * @deprecated use this.deps instead
      */
     deps: ProvideDepsIterator<Deps>) => Promise<Result>;
-}
+};
 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>;
 };
+//# sourceMappingURL=types.d.ts.map

package/lib/query/use.d.ts

@@ -5,3 +5,4 @@ declare function useQuery<Options extends void, Result, Deps extends ProviderDep
 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 };
+//# sourceMappingURL=use.d.ts.map

package/lib/shared/createUniqueActionKeyForQuery.d.ts

@@ -1,3 +1,4 @@
 import type { ProviderDeps } from '@tinkoff/dippy';
 import type { BaseCreateQueryOptions } from '../baseQuery/types';
 export declare const createUniqueActionKeyForQuery: <Options, Deps extends ProviderDeps>(queryParameters: BaseCreateQueryOptions<Options, Deps>) => string;
+//# sourceMappingURL=createUniqueActionKeyForQuery.d.ts.map

package/lib/shared/createUniqueActionKeyForQuery.es.js

@@ -1,10 +1,13 @@
 import { normalizeKey } from './normalizeKey.es.js';
 
+function isSerializableKey(options) {
+    return !('actionNamePostfix' in options);
+}
 const createUniqueActionKeyForQuery = (queryParameters) => {
     var _a;
-    const rawQueryKey = typeof queryParameters.key === 'function'
-        ? queryParameters.actionNamePostfix
-        : (_a = queryParameters.actionNamePostfix) !== null && _a !== void 0 ? _a : queryParameters.key;
+    const rawQueryKey = isSerializableKey(queryParameters)
+        ? (_a = queryParameters.actionNamePostfix) !== null && _a !== void 0 ? _a : queryParameters.key
+        : queryParameters.actionNamePostfix;
     const queryKeyArray = normalizeKey(rawQueryKey);
     return queryKeyArray.join('_');
 };

package/lib/shared/createUniqueActionKeyForQuery.js

@@ -4,11 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var normalizeKey = require('./normalizeKey.js');
 
+function isSerializableKey(options) {
+    return !('actionNamePostfix' in options);
+}
 const createUniqueActionKeyForQuery = (queryParameters) => {
     var _a;
-    const rawQueryKey = typeof queryParameters.key === 'function'
-        ? queryParameters.actionNamePostfix
-        : (_a = queryParameters.actionNamePostfix) !== null && _a !== void 0 ? _a : queryParameters.key;
+    const rawQueryKey = isSerializableKey(queryParameters)
+        ? (_a = queryParameters.actionNamePostfix) !== null && _a !== void 0 ? _a : queryParameters.key
+        : queryParameters.actionNamePostfix;
     const queryKeyArray = normalizeKey.normalizeKey(rawQueryKey);
     return queryKeyArray.join('_');
 };

package/lib/shared/normalizeKey.d.ts

@@ -1,3 +1,4 @@
 import type { QueryKey } from '@tanstack/react-query';
 import type { ReactQueryKeyOrString } from '../baseQuery/types';
 export declare const normalizeKey: (key: ReactQueryKeyOrString) => QueryKey;
+//# sourceMappingURL=normalizeKey.d.ts.map

package/lib/shared/resolveDI.d.ts

@@ -1,3 +1,4 @@
 import type { Container } from '@tinkoff/dippy';
 import type { ActionContext } from '@tramvai/core';
 export declare const resolveDI: (diOrContext: ActionContext | Container) => Container;
+//# sourceMappingURL=resolveDI.d.ts.map

package/lib/shared/signal.d.ts

@@ -2,3 +2,4 @@ import type { TramvaiActionContext } from '@tramvai/core';
 export declare const mapQuerySignalToxecutionContext: (queryContext: {
     signal?: AbortSignal | undefined;
 } | undefined, actionContext: TramvaiActionContext<any>) => void;
+//# sourceMappingURL=signal.d.ts.map

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@tramvai/react-query",
-  "version": "2.150.0",
+  "version": "2.151.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
-    "lib"
+    "lib",
+    "__migrations__"
   ],
   "sideEffects": false,
   "repository": {
@@ -18,10 +19,10 @@
   },
   "dependencies": {
     "@tinkoff/react-hooks": "0.1.6",
-    "@tramvai/core": "2.150.0",
-    "@tramvai/module-react-query": "2.150.0",
-    "@tramvai/react": "2.150.0",
-    "@tramvai/tokens-common": "2.150.0"
+    "@tramvai/core": "2.151.0",
+    "@tramvai/module-react-query": "2.151.0",
+    "@tramvai/react": "2.151.0",
+    "@tramvai/tokens-common": "2.151.0"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.16",