@astral/mobx-query 1.5.0 → 1.6.1

package/MobxQuery/MobxQuery.d.ts

@@ -3,28 +3,38 @@ import { type InfiniteExecutor, InfiniteQuery, type InfiniteQueryParams } from '
 import { Mutation, type MutationExecutor, type MutationParams } from '../Mutation';
 import type { CacheKey, FetchPolicy } from '../types';
 /**
- * стандартный обработчик ошибки запроса,
+ * Стандартный обработчик ошибки запроса,
  * будет вызван, если при вызове sync не был передан отдельный onError параметр
  */
 type OnError<TError = unknown> = (error: TError) => void;
 type MobxQueryParams = {
+    /**
+     * Политика получения данных по умолчанию.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
     fetchPolicy?: FetchPolicy;
+    /**
+     * обработчик ошибок по умолчанию
+     */
     onError?: OnError;
     /**
-     * флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data по умолчанию.
      * @default false
      */
     enabledAutoFetch?: boolean;
 };
-type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage'> & {
+type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
-     * режим фонового обновления
+     * Режим фонового обновления
+     * @default false
      */
     isBackground?: TIsBackground;
 };
-type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage'> & {
+type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
-     * режим фонового обновления
+     * Режим фонового обновления
+     * @default false
      */
     isBackground?: TIsBackground;
 };
@@ -33,65 +43,66 @@ type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> =
  */
 export declare class MobxQuery<TDefaultError = void> {
     /**
-     * объект соответствия хешей ключей и их значений
+     * Объект соответствия хешей ключей и их значений
      */
     private keys;
     /**
      * Map соответствия хешей ключей к запомненным сторам
      */
-    private cacheableStores;
+    private queriesMap;
     /**
-     * фабрика создания хранилищ данных для обычного Query
+     * Фабрика создания хранилищ данных для обычного Query
      */
     private queryDataStorageFactory;
     /**
-     * фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
+     * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
      */
     private statusStorageFactory;
     /**
-     * фабрика создания хранилищ данных для Infinite Query
-     */
-    private infiniteQueryDataStorageFactory;
-    /**
-     * стандартный обработчик ошибок, будет использован, если не передан другой
+     * Стандартный обработчик ошибок, будет использован, если не передан другой
      */
     private readonly defaultErrorHandler?;
     /**
-     * стандартное поведение политики кеширования
+     * Стандартное поведение политики кеширования
      */
     private readonly defaultFetchPolicy;
     /**
-     * флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      * @default false
      */
     private readonly defaultEnabledAutoFetch;
     private serialize;
     constructor({ onError, fetchPolicy, enabledAutoFetch, }?: MobxQueryParams);
     /**
-     * метод для инвалидации по списку ключей,
+     * Метод для инвалидации по списку ключей,
      * предполагается использование из домена
      */
     invalidate: (keysParts: CacheKey[]) => void;
+    private submitValidity;
     /**
-     * метод инвалидации всех query
+     * Метод инвалидации всех query
      */
     invalidateQueries: () => void;
     /**
-     * метод, который занимается проверкой наличия стора по ключу,
+     * Метод, который занимается проверкой наличия квери по ключу,
      * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
      */
     private getCachedQuery;
+    /**
+     * Метод для создания ключей к внутренним хранилищам
+     */
+    private makeKeys;
     private getBackgroundStatusStorage;
     /**
-     * метод создания стора, кешируется
+     * Метод создания стора, кешируется
      */
     createQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateQueryParams<TResult, TError, TIsBackground> | undefined) => Query<TResult, TError, TIsBackground>;
     /**
-     * метод создания инфинит стора, кешируется
+     * Метод создания инфинит стора, кешируется
      */
     createInfiniteQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError, TIsBackground> | undefined) => InfiniteQuery<TResult, TError, TIsBackground>;
     /**
-     * метод создания мутации, не кешируется
+     * Метод создания мутации, не кешируется
      */
     createMutation: <TResult, TError = TDefaultError, TExecutorParams = void>(executor: MutationExecutor<TResult, TExecutorParams>, params?: MutationParams<TResult, TError> | undefined) => Mutation<TResult, TError, TExecutorParams>;
 }

package/MobxQuery/MobxQuery.js

@@ -3,8 +3,9 @@ import { InfiniteQuery, } from '../InfiniteQuery';
 import { Mutation, } from '../Mutation';
 import { DataStorageFactory } from '../DataStorage';
 import { StatusStorageFactory } from '../StatusStorage';
+import { AdaptableMap } from '../AdaptableMap';
 /**
- * время, спустя которое, запись о query c network-only будет удалена
+ * Время, спустя которое, запись о query c network-only будет удалена
  */
 const DEFAULT_TIME_TO_CLEAN = 100;
 /**
@@ -13,65 +14,87 @@ const DEFAULT_TIME_TO_CLEAN = 100;
 export class MobxQuery {
     constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, } = {}) {
         /**
-         * объект соответствия хешей ключей и их значений
+         * Объект соответствия хешей ключей и их значений
          */
-        this.keys = {};
+        this.keys = new Map();
         /**
          * Map соответствия хешей ключей к запомненным сторам
          */
-        this.cacheableStores = new Map();
+        this.queriesMap = new AdaptableMap();
         /**
-         * фабрика создания хранилищ данных для обычного Query
+         * Фабрика создания хранилищ данных для обычного Query
          */
         this.queryDataStorageFactory = new DataStorageFactory();
         /**
-         * фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
+         * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
          */
         this.statusStorageFactory = new StatusStorageFactory();
-        /**
-         * фабрика создания хранилищ данных для Infinite Query
-         */
-        this.infiniteQueryDataStorageFactory = new DataStorageFactory();
         this.serialize = (data) => JSON.stringify(data);
         /**
-         * метод для инвалидации по списку ключей,
+         * Метод для инвалидации по списку ключей,
          * предполагается использование из домена
          */
         this.invalidate = (keysParts) => {
-            // сет сериализовонных ключей
+            // Сет сериализовонных ключей
             const keysSet = new Set(keysParts.map(this.serialize));
-            Object.keys(this.keys).forEach((key) => {
-                var _a;
-                const value = this.keys[key];
-                // проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
-                const hasTouchedElement = value.some((valuePart) => keysSet.has(this.serialize(valuePart)));
+            [...this.keys.keys()].forEach((keyHash) => {
+                const key = this.keys.get(keyHash);
+                if (!key) {
+                    return;
+                }
+                // Проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
+                const hasTouchedElement = key.some((valuePart) => keysSet.has(this.serialize(valuePart)));
                 if (hasTouchedElement) {
-                    (_a = this.cacheableStores.get(key)) === null || _a === void 0 ? void 0 : _a.invalidate();
+                    const query = this.queriesMap.get(keyHash);
+                    if (query) {
+                        query.invalidate();
+                        // Конвертируем инвалидированный квери в слабый,
+                        // чтобы сборщик мусора мог удалить неиспользуемые квери
+                        this.queriesMap.convertToWeak(keyHash);
+                    }
                 }
             });
         };
+        // Метод для подтверждения того, что квери успешно получил валидные данные
+        this.submitValidity = (keyHash) => {
+            // конвертируем квери в сильный,
+            // чтобы сборщик мусора не удалил наш кеш преждевременно
+            this.queriesMap.convertToStrong(keyHash);
+        };
         /**
-         * метод инвалидации всех query
+         * Метод инвалидации всех query
          */
         this.invalidateQueries = () => {
-            [...this.cacheableStores.entries()].forEach(([, store]) => {
-                store.invalidate();
+            [...this.keys.keys()].forEach((keyHash) => {
+                var _a;
+                (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
+                this.queriesMap.convertToWeak(keyHash);
             });
         };
         /**
-         * метод, который занимается проверкой наличия стора по ключу,
+         * Метод, который занимается проверкой наличия квери по ключу,
          * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
          */
-        this.getCachedQuery = (key, createStore, fetchPolicy) => {
-            // создаем хэш ключа с добавляем к ключу значения fetchPolicy,
-            // чтобы query c одинаковым ключом, но разным fetchPolicy не пересекались бы
-            const keyHash = this.serialize([...key, fetchPolicy]);
-            if (this.cacheableStores.has(keyHash)) {
-                return this.cacheableStores.get(keyHash);
+        this.getCachedQuery = (key, createInstance, type, createParams) => {
+            var _a, _b;
+            const fetchPolicy = (createParams === null || createParams === void 0 ? void 0 : createParams.fetchPolicy) || this.defaultFetchPolicy;
+            const keys = this.makeKeys(key, fetchPolicy, (_a = createParams === null || createParams === void 0 ? void 0 : createParams.isBackground) !== null && _a !== void 0 ? _a : false, type);
+            const cachedQuery = this.queriesMap.get(keys.queryKeyHash);
+            if (cachedQuery) {
+                return cachedQuery;
             }
-            const store = createStore();
-            this.cacheableStores.set(keyHash, store);
-            this.keys[keyHash] = key;
+            const query = createInstance({
+                onError: ((createParams === null || createParams === void 0 ? void 0 : createParams.onError) ||
+                    this.defaultErrorHandler),
+                enabledAutoFetch: (_b = createParams === null || createParams === void 0 ? void 0 : createParams.enabledAutoFetch) !== null && _b !== void 0 ? _b : this.defaultEnabledAutoFetch,
+                fetchPolicy: fetchPolicy,
+                dataStorage: this.queryDataStorageFactory.getStorage(keys.dataKeyHash),
+                statusStorage: this.statusStorageFactory.getStorage(keys.statusKeyHash),
+                backgroundStatusStorage: this.getBackgroundStatusStorage(keys.backgroundStatusKeyHash, Boolean(createParams === null || createParams === void 0 ? void 0 : createParams.isBackground)),
+                submitValidity: () => this.submitValidity(keys.queryKeyHash),
+            });
+            this.queriesMap.set(keys.queryKeyHash, query);
+            this.keys.set(keys.queryKeyHash, keys.queryKey);
             // Ожидается, что network-only квери не должны кешироваться,
             // но, с введением StrictMode в реакт 18, проявилась проблема,
             // что network-only квери, созданные в одном реакт компоненте,
@@ -81,39 +104,45 @@ export class MobxQuery {
             // делают по отдельному запросу к данным единомоментно,
             if (fetchPolicy === 'network-only') {
                 setTimeout(() => {
-                    this.cacheableStores.delete(keyHash);
-                    delete this.keys[keyHash];
+                    this.queriesMap.delete(keys.queryKeyHash);
+                    this.keys.delete(keys.queryKeyHash);
                 }, DEFAULT_TIME_TO_CLEAN);
             }
-            return store;
+            return query;
         };
-        this.getBackgroundStatusStorage = (key, hasBackground) => (hasBackground
-            ? this.statusStorageFactory.getStorage([...key, true])
-            : null);
         /**
-         * метод создания стора, кешируется
+         * Метод для создания ключей к внутренним хранилищам
          */
-        this.createQuery = (key, executor, params) => {
-            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy;
-            return this.getCachedQuery(key, () => {
-                var _a;
-                return new Query(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, fetchPolicy: fetchPolicy, dataStorage: this.queryDataStorageFactory.getStorage(key), statusStorage: this.statusStorageFactory.getStorage(key), backgroundStatusStorage: this.getBackgroundStatusStorage(key, Boolean(params === null || params === void 0 ? void 0 : params.isBackground)) }));
-            }, fetchPolicy);
+        this.makeKeys = (rootKey, fetchPolicy, isBackground, type) => {
+            const queryKey = [...rootKey, { fetchPolicy, isBackground, type }];
+            const queryKeyHash = this.serialize(queryKey);
+            const dataKeyHash = this.serialize([...rootKey, { type }]);
+            const statusKeyHash = this.serialize([...rootKey, { type }]);
+            const backgroundStatusKeyHash = this.serialize([
+                ...rootKey,
+                { type, isBackground },
+            ]);
+            return {
+                queryKey,
+                queryKeyHash,
+                statusKeyHash,
+                backgroundStatusKeyHash,
+                dataKeyHash,
+            };
         };
+        this.getBackgroundStatusStorage = (keyHash, hasBackground) => (hasBackground
+            ? this.statusStorageFactory.getStorage(keyHash)
+            : null);
         /**
-         * метод создания инфинит стора, кешируется
+         * Метод создания стора, кешируется
          */
-        this.createInfiniteQuery = (key, executor, params) => {
-            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy || '';
-            return this.getCachedQuery(key, () => {
-                var _a;
-                return new InfiniteQuery(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, dataStorage: this.infiniteQueryDataStorageFactory.getStorage(key), statusStorage: this.statusStorageFactory.getStorage(key), fetchPolicy: fetchPolicy, backgroundStatusStorage: this.getBackgroundStatusStorage(key, Boolean(params === null || params === void 0 ? void 0 : params.isBackground)) }));
-            }, fetchPolicy);
-        };
+        this.createQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new Query(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), Query.name, params);
+        /**
+         * Метод создания инфинит стора, кешируется
+         */
+        this.createInfiniteQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new InfiniteQuery(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), InfiniteQuery.name, params);
         /**
-         * метод создания мутации, не кешируется
+         * Метод создания мутации, не кешируется
          */
         this.createMutation = (executor, params) => new Mutation(executor, Object.assign(Object.assign({}, params), { onError: (params === null || params === void 0 ? void 0 : params.onError) || this.defaultErrorHandler }));
         this.defaultErrorHandler = onError;

package/Mutation/Mutation.d.ts

@@ -2,32 +2,32 @@ import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import type { QueryBaseActions, Sync, SyncParams } from '../types';
 import { QueryContainer } from '../QueryContainer';
 /**
- * исполнитель запроса
+ * Исполнитель запроса
  */
 export type MutationExecutor<TResult, TParams> = (params: TParams) => Promise<TResult>;
 export type MutationParams<TResult, TError> = {
     /**
-     * обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     onError?: SyncParams<TResult, TError>['onError'];
 };
 /**
- * простой стор для запросов, которые не требуют кэширования,
+ * Простой квери для запросов, которые не требуют кэширования,
  * пример - POST запросы
  */
 export declare class Mutation<TResult, TError = void, TExecutorParams = void> extends QueryContainer<TError, AuxiliaryQuery<TResult, TError>, false> implements QueryBaseActions<TResult, TError, TExecutorParams> {
     private readonly executor;
     /**
-     * обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     private readonly defaultOnError?;
     constructor(executor: MutationExecutor<TResult, TExecutorParams>, { onError }?: MutationParams<TResult, TError>);
     /**
-     * синхронный метод получения/отправки данных
+     * Синхронный метод получения/отправки данных
      */
     sync: Sync<TResult, TError, TExecutorParams>;
     /**
-     * асинхронный метод получения/отправки данных,
+     * Асинхронный метод получения/отправки данных,
      * предполагается, что нужно будет самостоятельно обрабатывать ошибку
      */
     async: (params: TExecutorParams) => Promise<TResult>;

package/Mutation/Mutation.js

@@ -3,7 +3,7 @@ import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import { QueryContainer } from '../QueryContainer';
 import { StatusStorage } from '../StatusStorage';
 /**
- * простой стор для запросов, которые не требуют кэширования,
+ * Простой квери для запросов, которые не требуют кэширования,
  * пример - POST запросы
  */
 export class Mutation extends QueryContainer {
@@ -12,7 +12,7 @@ export class Mutation extends QueryContainer {
         super(statusStorage, null, new AuxiliaryQuery(statusStorage, null));
         this.executor = executor;
         /**
-         * синхронный метод получения/отправки данных
+         * Синхронный метод получения/отправки данных
          */
         this.sync = (options) => {
             const { onSuccess, onError, params } = options || {};
@@ -32,7 +32,7 @@ export class Mutation extends QueryContainer {
             });
         };
         /**
-         * асинхронный метод получения/отправки данных,
+         * Асинхронный метод получения/отправки данных,
          * предполагается, что нужно будет самостоятельно обрабатывать ошибку
          */
         this.async = (params) => {

package/Query/Query.d.ts

@@ -4,84 +4,97 @@ import type { DataStorage } from '../DataStorage';
 import { QueryContainer } from '../QueryContainer';
 import { type StatusStorage } from '../StatusStorage';
 /**
- * исполнитель запроса
+ * Исполнитель запроса
  */
 export type QueryExecutor<TResult> = () => Promise<TResult>;
 export type QueryParams<TResult, TError, TIsBackground extends boolean = false> = {
     /**
-     * обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     onError?: SyncParams<TResult, TError>['onError'];
     /**
-     * флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      */
     enabledAutoFetch?: boolean;
+    /**
+     * Политика получения данных.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
     fetchPolicy?: FetchPolicy;
     /**
-     * инстанс хранилища данных
+     * Инстанс хранилища данных
      */
     dataStorage: DataStorage<TResult>;
     /**
-     * инстанс хранилища основных статусов
+     * Инстанс хранилища основных статусов
      */
     statusStorage: StatusStorage<TError>;
     /**
-     * инстанс хранилища фоновых статусов
+     * Инстанс хранилища фоновых статусов
      */
     backgroundStatusStorage?: TIsBackground extends true ? StatusStorage<TError> : null | undefined;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    submitValidity?: () => void;
 };
 /**
- * стор для работы с запросами,
+ * Стор для работы с запросами,
  * которые должны быть закешированы,
  * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
  */
 export declare class Query<TResult, TError = void, TIsBackground extends boolean = false> extends QueryContainer<TError, AuxiliaryQuery<TResult, TError>, TIsBackground> implements QueryBaseActions<TResult, TError, undefined> {
     private readonly executor;
     /**
-     * хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
+     * Хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
      */
     private storage;
     /**
-     * обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     private defaultOnError?;
     /**
-     * флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      */
     private enabledAutoFetch?;
     /**
-     * стандартное поведение политики кеширования
+     * Стандартное поведение политики кеширования
      */
     private readonly defaultFetchPolicy?;
-    constructor(executor: QueryExecutor<TResult>, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage, }: QueryParams<TResult, TError, TIsBackground>);
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    private readonly submitValidity?;
+    constructor(executor: QueryExecutor<TResult>, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage, submitValidity, }: QueryParams<TResult, TError, TIsBackground>);
     private get isNetworkOnly();
     /**
-     * метод для инвалидации данных
+     * Метод для инвалидации данных
      */
     invalidate: () => void;
     /**
-     * синхронный метод получения данных
+     * Синхронный метод получения данных
      */
     sync: Sync<TResult, TError, undefined>;
     /**
-     * обработчик успешного ответа
+     * Обработчик успешного ответа
      */
     private submitSuccess;
     /**
-     * форс метод для установки данных
+     * Форс метод для установки данных
      */
     forceUpdate: (data: TResult) => void;
     /**
-     * метод для переиспользования синхронной логики запроса
+     * Метод для переиспользования синхронной логики запроса
      */
     protected proceedSync: Sync<TResult, TError>;
     /**
-     * асинхронный метод получения данных,
+     * Асинхронный метод получения данных,
      * предполагается, что нужно будет самостоятельно обрабатывать ошибку
      */
     async: () => Promise<TResult>;
     /**
-     * содержит реактивные данные
+     * Содержит реактивные данные
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся

package/Query/Query.js

@@ -2,22 +2,22 @@ import { action, computed, makeObservable, when } from 'mobx';
 import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import { QueryContainer } from '../QueryContainer';
 /**
- * стор для работы с запросами,
+ * Стор для работы с запросами,
  * которые должны быть закешированы,
  * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
  */
 export class Query extends QueryContainer {
-    constructor(executor, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, }) {
+    constructor(executor, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
         super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery(statusStorage, backgroundStatusStorage));
         this.executor = executor;
         /**
-         * метод для инвалидации данных
+         * Метод для инвалидации данных
          */
         this.invalidate = () => {
             this.auxiliary.invalidate();
         };
         /**
-         * синхронный метод получения данных
+         * Синхронный метод получения данных
          */
         this.sync = (params) => {
             const isInstanceAllow = !(this.isLoading || this.isSuccess);
@@ -26,21 +26,23 @@ export class Query extends QueryContainer {
             }
         };
         /**
-         * обработчик успешного ответа
+         * Обработчик успешного ответа
          */
         this.submitSuccess = (resData) => {
+            var _a;
             this.storage.setData(resData);
+            (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
             return resData;
         };
         /**
-         * форс метод для установки данных
+         * Форс метод для установки данных
          */
         this.forceUpdate = (data) => {
             this.auxiliary.submitSuccess();
             this.submitSuccess(data);
         };
         /**
-         * метод для переиспользования синхронной логики запроса
+         * Метод для переиспользования синхронной логики запроса
          */
         this.proceedSync = (options) => {
             const { onSuccess, onError } = options || {};
@@ -61,7 +63,7 @@ export class Query extends QueryContainer {
             });
         };
         /**
-         * асинхронный метод получения данных,
+         * Асинхронный метод получения данных,
          * предполагается, что нужно будет самостоятельно обрабатывать ошибку
          */
         this.async = () => {
@@ -76,6 +78,7 @@ export class Query extends QueryContainer {
         this.enabledAutoFetch = enabledAutoFetch;
         this.defaultFetchPolicy = fetchPolicy;
         this.storage = dataStorage;
+        this.submitValidity = submitValidity;
         makeObservable(this, {
             async: action,
             sync: action,
@@ -88,7 +91,7 @@ export class Query extends QueryContainer {
         return this.defaultFetchPolicy === 'network-only';
     }
     /**
-     * содержит реактивные данные
+     * Содержит реактивные данные
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся