@astral/mobx-query 1.8.0 → 1.9.0

package/node/MobxQuery/MobxQuery.d.ts

@@ -0,0 +1,176 @@
+import { Query, type QueryExecutor, type QueryParams } from '../Query';
+import { type InfiniteExecutor, InfiniteQuery, type InfiniteQueryParams } from '../InfiniteQuery';
+import { Mutation, type MutationExecutor, type MutationParams } from '../Mutation';
+import type { CacheKey, FetchPolicy } from '../types';
+import { InfiniteQuerySet, type InfiniteQuerySetConfig, type InfiniteQuerySetConfigurator, MutationSet, QuerySet, type QuerySetConfig, type QuerySetConfigurator } from '../Sets';
+/**
+ * Стандартный обработчик ошибки запроса,
+ * будет вызван, если при вызове sync не был передан отдельный onError параметр
+ */
+type OnError<TError = unknown> = (error: TError) => void;
+type MobxQueryParams = {
+    /**
+     * Политика получения данных по умолчанию.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
+    fetchPolicy?: FetchPolicy;
+    /**
+     * обработчик ошибок по умолчанию
+     */
+    onError?: OnError;
+    /**
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data по умолчанию.
+     * @default false
+     */
+    enabledAutoFetch?: boolean;
+};
+export type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+    /**
+     * Режим фонового обновления
+     * @default false
+     */
+    isBackground?: TIsBackground;
+};
+export type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+    /**
+     * Режим фонового обновления
+     * @default false
+     */
+    isBackground?: TIsBackground;
+};
+export type CreateMutationParams<TResult, TError> = MutationParams<TResult, TError>;
+/**
+ * Стратегия инвалидации кэша
+ * @property 'partial-match' - Проверяет наличие хотя бы одной части ключа в кэше
+ * @property 'chain-match' - Проверяет наличие полной связки ключей в кэше
+ */
+type InvalidateStrategy = 'partial-match' | 'chain-match';
+/**
+ * Сервис, позволяющий кэшировать данные.
+ */
+export declare class MobxQuery<TDefaultError = void> {
+    /**
+     * Объект соответствия хешей ключей и их значений
+     */
+    private keys;
+    /**
+     * Map соответствия хешей ключей к запомненным сторам
+     */
+    private queriesMap;
+    /**
+     * Фабрика создания хранилищ данных для обычного Query
+     */
+    private queryDataStorageFactory;
+    /**
+     * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
+     */
+    private statusStorageFactory;
+    /**
+     * Стандартный обработчик ошибок, будет использован, если не передан другой
+     */
+    private readonly defaultErrorHandler?;
+    /**
+     * Стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy;
+    /**
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * @default false
+     */
+    private readonly defaultEnabledAutoFetch;
+    private serialize;
+    constructor({ onError, fetchPolicy, enabledAutoFetch, }?: MobxQueryParams);
+    /**
+     * Проверяет пересечение ключей в зависимости от стратегии
+     * @param invalidatedKeys - Ключи для инвалидации
+     * @param queryKeys - Ключи запроса
+     * @param strategy - Стратегия проверки:
+     * - 'chain-match' - все ключи из invalidatedKeys должны присутствовать в queryKeys
+     * - 'partial-match' - хотя бы один ключ из invalidatedKeys должен быть в queryKeys
+     */
+    private checkTouchedElement;
+    /**
+     * Метод для инвалидации по списку ключей, предполагается использование из домена
+     * @param invalidatedKeys - Массив ключей для инвалидации
+     * @param strategy - Стратегия инвалидации. 'chain-match' - инвалидировать при совпадении связки ключей в кэше, 'partial-match' - инвалидировать при частичном совпадении ключей. По умолчанию 'partial-match'
+     * @example
+     * // Инвалидация по частичному совпадению ключей
+     * mobxQuery.invalidate(['users', '1']); // Инвалидирует все query, содержащие ключ 'users' или '1'
+     *
+     * // Инвалидация по совпадению связки ключей
+     * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
+     */
+    invalidate: (invalidatedKeys: CacheKey[], strategy?: InvalidateStrategy) => void;
+    private submitValidity;
+    /**
+     * Метод инвалидации всех 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>) => Query<TResult, TError, TIsBackground>;
+    /**
+     * Метод создания инфинит стора, кешируется
+     */
+    createInfiniteQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError, TIsBackground>) => InfiniteQuery<TResult, TError, TIsBackground>;
+    /**
+     * Метод создания мутации, не кешируется
+     */
+    createMutation: <TResult, TError = TDefaultError, TExecutorParams = void>(executor: MutationExecutor<TResult, TExecutorParams>, params?: CreateMutationParams<TResult, TError>) => Mutation<TResult, TError, TExecutorParams>;
+    /**
+     * Создает набор queries под одним ключем
+     * @param configurator - Функция конфигурации набора запросов. Она должна возвращать объект с полями:
+     *   - keys (необязательно): массив ключей для кеширования;
+     *   - execute: функция, которая возвращает промис с результатом выполнения запроса.
+     * @example
+     * const docQuerySet = mobxQuery.createQuerySet((id: string, count?: number) => ({
+     *   execute: () => docEndpoint.getDoc(id),
+     * }));
+     *
+     * const docQuery = docQuerySet.create();
+     *
+     * docQuery.data // { data: [id, count] }
+     */
+    createQuerySet: <TParams extends any[], TResponse>(configurator: QuerySetConfigurator<TParams, TResponse>, config?: QuerySetConfig) => QuerySet<TParams, TResponse, TDefaultError>;
+    /**
+     * Создает набор infinite queries под одним ключем
+     * @param configurator - Функция конфигурации набора запросов. Она должна возвращать объект с полями:
+     *   - keys (необязательно): массив ключей для кеширования;
+     *   - execute: функция, которая возвращает промис с результатом выполнения запроса.
+     * @example
+     * const docListInfiniteQuerySet = mobxQuery.createInfiniteQuerySet((id: string, count?: number) => ({
+     *   execute: ({ offset, count }) => docEndpoint.getDocList(id, offset, count),
+     * }));
+     *
+     * const docListInfiniteQuery = docListInfiniteQuerySet.create();
+     *
+     * docListInfiniteQuery.data
+     */
+    createInfiniteQuerySet: <TParams extends any[], TResponse>(configurator: InfiniteQuerySetConfigurator<TParams, TResponse>, config?: InfiniteQuerySetConfig) => InfiniteQuerySet<TParams, TResponse, TDefaultError>;
+    /**
+     * Создает набор мутаций для единого интерфейса с query sets
+     * @param executor - Функция-исполнитель мутации. Она должна возвращать промис с результатом выполнения мутации.
+     * @example
+     * const editDocMutationSet = mobxQuery.createMutationSet((params: DocsEndpointsDTO.EditDocInput) => {
+     *   return docsEndpoint.editDoc(params);
+     * });
+     *
+     * const editDocMutation = editDocMutationSet.create();
+     *
+     * editDocMutation.sync({ params: { id: 'docId', content: 'Новое содержимое' } });
+     */
+    createMutationSet: <TResponse, TExecutorParams = void>(executor: MutationExecutor<TResponse, TExecutorParams>) => MutationSet<TResponse, TExecutorParams, TDefaultError>;
+}
+export {};

package/node/MobxQuery/MobxQuery.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobxQuery = void 0;
+const Query_1 = require("../Query");
+const InfiniteQuery_1 = require("../InfiniteQuery");
+const Mutation_1 = require("../Mutation");
+const DataStorage_1 = require("../DataStorage");
+const StatusStorage_1 = require("../StatusStorage");
+const AdaptableMap_1 = require("../AdaptableMap");
+const Sets_1 = require("../Sets");
+/**
+ * Сервис, позволяющий кэшировать данные.
+ */
+class MobxQuery {
+    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, } = {}) {
+        /**
+         * Объект соответствия хешей ключей и их значений
+         */
+        this.keys = new Map();
+        /**
+         * Map соответствия хешей ключей к запомненным сторам
+         */
+        this.queriesMap = new AdaptableMap_1.AdaptableMap();
+        /**
+         * Фабрика создания хранилищ данных для обычного Query
+         */
+        this.queryDataStorageFactory = new DataStorage_1.DataStorageFactory();
+        /**
+         * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
+         */
+        this.statusStorageFactory = new StatusStorage_1.StatusStorageFactory();
+        this.serialize = (data) => JSON.stringify(data);
+        /**
+         * Проверяет пересечение ключей в зависимости от стратегии
+         * @param invalidatedKeys - Ключи для инвалидации
+         * @param queryKeys - Ключи запроса
+         * @param strategy - Стратегия проверки:
+         * - 'chain-match' - все ключи из invalidatedKeys должны присутствовать в queryKeys
+         * - 'partial-match' - хотя бы один ключ из invalidatedKeys должен быть в queryKeys
+         */
+        this.checkTouchedElement = (invalidatedKeys, queryKeys, strategy) => {
+            const serializedInvalidatedKeys = invalidatedKeys.map(this.serialize);
+            if (strategy === 'chain-match') {
+                return serializedInvalidatedKeys.every((invalidatedKey) => queryKeys.some((queryKey) => invalidatedKey === this.serialize(queryKey)));
+            }
+            return queryKeys.some((queryKey) => serializedInvalidatedKeys.find((invalidatedKey) => invalidatedKey === this.serialize(queryKey)));
+        };
+        /**
+         * Метод для инвалидации по списку ключей, предполагается использование из домена
+         * @param invalidatedKeys - Массив ключей для инвалидации
+         * @param strategy - Стратегия инвалидации. 'chain-match' - инвалидировать при совпадении связки ключей в кэше, 'partial-match' - инвалидировать при частичном совпадении ключей. По умолчанию 'partial-match'
+         * @example
+         * // Инвалидация по частичному совпадению ключей
+         * mobxQuery.invalidate(['users', '1']); // Инвалидирует все query, содержащие ключ 'users' или '1'
+         *
+         * // Инвалидация по совпадению связки ключей
+         * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
+         */
+        this.invalidate = (invalidatedKeys, strategy = 'partial-match') => {
+            for (const keyHash of this.keys.keys()) {
+                const queryKeys = this.keys.get(keyHash);
+                if (!queryKeys) {
+                    return;
+                }
+                // Проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
+                if (this.checkTouchedElement(invalidatedKeys, queryKeys, strategy)) {
+                    const query = this.queriesMap.get(keyHash);
+                    if (query) {
+                        query.invalidate();
+                        // Конвертируем инвалидированный квери в слабый,
+                        // чтобы сборщик мусора мог удалить неиспользуемые квери
+                        this.queriesMap.convertToWeak(keyHash);
+                    }
+                }
+            }
+        };
+        // Метод для подтверждения того, что квери успешно получил валидные данные
+        this.submitValidity = (keyHash) => {
+            // конвертируем квери в сильный,
+            // чтобы сборщик мусора не удалил наш кеш преждевременно
+            this.queriesMap.convertToStrong(keyHash);
+        };
+        /**
+         * Метод инвалидации всех query
+         */
+        this.invalidateQueries = () => {
+            [...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, 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 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: 
+                // 'network-only' квери не будут подтверждать свою валидность,
+                // следовательно, они всегда будут храниться как "слабые",
+                // что позволит сборщику мусора удалять их из памяти при отсутствии ссылок
+                fetchPolicy !== 'network-only'
+                    ? () => this.submitValidity(keys.queryKeyHash)
+                    : undefined,
+            });
+            this.queriesMap.set(keys.queryKeyHash, query);
+            this.keys.set(keys.queryKeyHash, keys.queryKey);
+            return query;
+        };
+        /**
+         * Метод для создания ключей к внутренним хранилищам
+         */
+        this.makeKeys = (rootKey, fetchPolicy, isBackground, type) => {
+            // C введением StrictMode в реакт 18, проявилась проблема,
+            // что network-only квери, созданные в одном реакт компоненте,
+            // создаются дважды (т.к. все хуки вызываются дважды)
+            // и т.к. мы не ограничиваем момент запроса,
+            // то можем получить эффект, что оба network-only квери
+            // делают по отдельному запросу к данным единомоментно.
+            // Для решения этой проблемы, добавляем уникальный ключ даты, с обнуляемыми милисекундами,
+            // что позволит создавать одинаковые network-only квери в течении одной секунды.
+            // Остается крайне редкий корнер кейс, когда разница между созданиями квери крайне мала,
+            // но все таки первый был создан в одной секунде, а последующее создание уже попало в следующую секунду.
+            // Этот кейс крайне маловероятен, и будет проявляться только в дев режиме с включенным StrictMode,
+            // поэтому мы пренебрегаем решением этой проблемы, в угоду упрощения.
+            const date = fetchPolicy === 'network-only' ? new Date().setMilliseconds(0) : null;
+            const queryKey = [...rootKey, { fetchPolicy, date, 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.createQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new Query_1.Query(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), Query_1.Query.name, params);
+        /**
+         * Метод создания инфинит стора, кешируется
+         */
+        this.createInfiniteQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new InfiniteQuery_1.InfiniteQuery(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), InfiniteQuery_1.InfiniteQuery.name, params);
+        /**
+         * Метод создания мутации, не кешируется
+         */
+        this.createMutation = (executor, params) => new Mutation_1.Mutation(executor, Object.assign(Object.assign({}, params), { onError: (params === null || params === void 0 ? void 0 : params.onError) || this.defaultErrorHandler }));
+        /**
+         * Создает набор queries под одним ключем
+         * @param configurator - Функция конфигурации набора запросов. Она должна возвращать объект с полями:
+         *   - keys (необязательно): массив ключей для кеширования;
+         *   - execute: функция, которая возвращает промис с результатом выполнения запроса.
+         * @example
+         * const docQuerySet = mobxQuery.createQuerySet((id: string, count?: number) => ({
+         *   execute: () => docEndpoint.getDoc(id),
+         * }));
+         *
+         * const docQuery = docQuerySet.create();
+         *
+         * docQuery.data // { data: [id, count] }
+         */
+        // any нужен для вывода типов
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.createQuerySet = (configurator, config) => new Sets_1.QuerySet(this, configurator, config);
+        /**
+         * Создает набор infinite queries под одним ключем
+         * @param configurator - Функция конфигурации набора запросов. Она должна возвращать объект с полями:
+         *   - keys (необязательно): массив ключей для кеширования;
+         *   - execute: функция, которая возвращает промис с результатом выполнения запроса.
+         * @example
+         * const docListInfiniteQuerySet = mobxQuery.createInfiniteQuerySet((id: string, count?: number) => ({
+         *   execute: ({ offset, count }) => docEndpoint.getDocList(id, offset, count),
+         * }));
+         *
+         * const docListInfiniteQuery = docListInfiniteQuerySet.create();
+         *
+         * docListInfiniteQuery.data
+         */
+        // any нужен для вывода типов
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.createInfiniteQuerySet = (configurator, config) => new Sets_1.InfiniteQuerySet(this, configurator, config);
+        /**
+         * Создает набор мутаций для единого интерфейса с query sets
+         * @param executor - Функция-исполнитель мутации. Она должна возвращать промис с результатом выполнения мутации.
+         * @example
+         * const editDocMutationSet = mobxQuery.createMutationSet((params: DocsEndpointsDTO.EditDocInput) => {
+         *   return docsEndpoint.editDoc(params);
+         * });
+         *
+         * const editDocMutation = editDocMutationSet.create();
+         *
+         * editDocMutation.sync({ params: { id: 'docId', content: 'Новое содержимое' } });
+         */
+        this.createMutationSet = (executor) => new Sets_1.MutationSet(this, executor);
+        this.defaultErrorHandler = onError;
+        this.defaultFetchPolicy = fetchPolicy;
+        this.defaultEnabledAutoFetch = enabledAutoFetch;
+    }
+}
+exports.MobxQuery = MobxQuery;

package/node/MobxQuery/index.d.ts

@@ -0,0 +1 @@
+export * from './MobxQuery';

package/node/MobxQuery/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MobxQuery"), exports);

package/node/Mutation/Mutation.d.ts

@@ -0,0 +1,34 @@
+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/node/Mutation/Mutation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mutation = void 0;
+const mobx_1 = require("mobx");
+const AuxiliaryQuery_1 = require("../AuxiliaryQuery");
+const QueryContainer_1 = require("../QueryContainer");
+const StatusStorage_1 = require("../StatusStorage");
+/**
+ * Простой квери для запросов, которые не требуют кэширования,
+ * пример - POST запросы
+ */
+class Mutation extends QueryContainer_1.QueryContainer {
+    constructor(executor, { onError } = {}) {
+        const statusStorage = new StatusStorage_1.StatusStorage();
+        super(statusStorage, null, new AuxiliaryQuery_1.AuxiliaryQuery(statusStorage, null));
+        this.executor = executor;
+        /**
+         * Синхронный метод получения/отправки данных
+         */
+        this.sync = (options) => {
+            const { onSuccess, onError, params } = options || {};
+            this.auxiliary
+                .getUnifiedPromise(() => this.executor(params), (resData) => {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(resData);
+            })
+                .catch((e) => {
+                var _a;
+                if (onError) {
+                    onError(e);
+                }
+                else {
+                    (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
+                }
+            });
+        };
+        /**
+         * Асинхронный метод получения/отправки данных,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = (params) => {
+            return this.auxiliary.getUnifiedPromise(() => this.executor(params));
+        };
+        this.defaultOnError = onError;
+        (0, mobx_1.makeObservable)(this, { async: mobx_1.action, sync: mobx_1.action });
+    }
+}
+exports.Mutation = Mutation;

package/node/Mutation/index.d.ts

@@ -0,0 +1 @@
+export * from './Mutation';

package/node/Mutation/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Mutation"), exports);

package/node/Query/Query.d.ts

@@ -0,0 +1,103 @@
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
+import type { FetchPolicy, QueryBaseActions, Sync, SyncParams } from '../types';
+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
+     */
+    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
+     */
+    private enabledAutoFetch?;
+    /**
+     * Стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy?;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    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, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data(): TResult | undefined;
+}