@astral/mobx-query 1.7.2 → 1.8.1

package/node/InfiniteQuery/InfiniteQuery.d.ts

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

package/node/InfiniteQuery/InfiniteQuery.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfiniteQuery = exports.DEFAULT_INFINITE_ITEMS_COUNT = void 0;
+const mobx_1 = require("mobx");
+const AuxiliaryQuery_1 = require("../AuxiliaryQuery");
+const QueryContainer_1 = require("../QueryContainer");
+exports.DEFAULT_INFINITE_ITEMS_COUNT = 30;
+/**
+ * Квери для работы с инфинити запросами,
+ * которые должны быть закешированы,
+ */
+class InfiniteQuery extends QueryContainer_1.QueryContainer {
+    constructor(executor, { incrementCount = exports.DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
+        super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery_1.AuxiliaryQuery(statusStorage, backgroundStatusStorage));
+        this.executor = executor;
+        /**
+         * Счетчик отступа для инфинити запроса
+         */
+        this.offset = 0;
+        /**
+         * Флаг того, что мы достигли предела запрашиваемых элементов
+         */
+        this.isEndReached = false;
+        /**
+         * Обработчик успешного запроса, проверяет что мы достигли предела
+         */
+        this.submitSuccess = (result, onSuccess, isIncrement) => {
+            var _a;
+            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
+            if (isIncrement && this.storage.hasData) {
+                this.storage.setData([...this.storage.data, ...result]);
+            }
+            else {
+                this.storage.setData(result);
+                (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
+            }
+            // убеждаемся что результат запроса действительно массив,
+            // и если количество элементов в ответе меньше,
+            // чем запрашивалось, значит у бэка их больше нет,
+            // другими словами мы допускаем что, может произойти лишний запрос,
+            // когда последняя отданная страница содержит ровно то количество,
+            // сколько может содержать страница, а следующая уже просто пустая.
+            if (Array.isArray(result) && result.length < this.incrementCount) {
+                // включаем флаг достижения предела
+                this.isEndReached = true;
+            }
+        };
+        /**
+         * Форс метод для установки данных
+         */
+        this.forceUpdate = (data) => {
+            this.auxiliary.submitSuccess();
+            this.submitSuccess(data);
+        };
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.auxiliary.invalidate();
+        };
+        /**
+         * Метод для запроса следующего набора данных
+         */
+        this.fetchMore = () => {
+            // если мы еще не достигли предела
+            if (!this.isEndReached && this.storage.data) {
+                // прибавляем к офсету число запрашиваемых элементов
+                this.offset += this.incrementCount;
+                // запускаем запрос с последними параметрами, и флагом необходимости инкремента
+                this.auxiliary
+                    .getUnifiedPromise(this.infiniteExecutor, (resData) => {
+                    this.submitSuccess(resData, undefined, true);
+                })
+                    .catch((e) => { var _a; return (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e); });
+            }
+        };
+        /**
+         * Синхронный метод получения данных
+         */
+        this.sync = (params) => {
+            const isInstanceAllow = !(this.isLoading || this.isSuccess);
+            if (this.isNetworkOnly || this.auxiliary.isInvalid || isInstanceAllow) {
+                this.proceedSync(params);
+            }
+        };
+        /**
+         * Метод для переиспользования синхронной логики запроса
+         */
+        this.proceedSync = ({ onSuccess, onError, } = {}) => {
+            this.offset = 0;
+            this.isEndReached = false;
+            this.auxiliary
+                .getUnifiedPromise(this.infiniteExecutor, (resData) => {
+                this.submitSuccess(resData, onSuccess);
+            })
+                .catch((e) => {
+                var _a;
+                if (onError) {
+                    onError(e);
+                }
+                else {
+                    (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
+                }
+            });
+        };
+        /**
+         * Асинхронный метод получения данных,
+         * подходит для изменения параметров запроса(фильтров),
+         * при котором будет сброшен offset,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = () => {
+            if (!this.isNetworkOnly && this.isSuccess && !this.auxiliary.isInvalid) {
+                return Promise.resolve(this.storage.data);
+            }
+            this.offset = 0;
+            this.isEndReached = false;
+            return this.auxiliary.getUnifiedPromise(this.infiniteExecutor, this.submitSuccess);
+        };
+        this.storage = dataStorage;
+        this.incrementCount = incrementCount;
+        this.defaultOnError = onError;
+        this.enabledAutoFetch = enabledAutoFetch;
+        this.defaultFetchPolicy = fetchPolicy;
+        this.submitValidity = submitValidity;
+        (0, mobx_1.makeObservable)(this, {
+            data: mobx_1.computed,
+            infiniteExecutor: mobx_1.computed,
+            forceUpdate: mobx_1.action,
+            async: mobx_1.action,
+            sync: mobx_1.action,
+            fetchMore: mobx_1.action,
+            submitSuccess: mobx_1.action,
+            isEndReached: mobx_1.observable,
+        });
+    }
+    get isNetworkOnly() {
+        return this.defaultFetchPolicy === 'network-only';
+    }
+    /**
+     * Метод для обогащения параметров текущими значениями для инфинити
+     */
+    get infiniteExecutor() {
+        return () => this.executor({
+            offset: this.offset,
+            count: this.incrementCount,
+        });
+    }
+    /**
+     * Вычисляемое свойство, содержащее реактивные данные,
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data() {
+        const shouldSync = this.enabledAutoFetch &&
+            !this.isSuccess &&
+            !this.isLoading &&
+            !this.isError;
+        if (this.auxiliary.isInvalid || shouldSync) {
+            // т.к. при вызове апдейта, изменяются флаги, на которые подписан data,
+            // нужно вызывать этот экшн асинхронно
+            (0, mobx_1.when)(() => true, this.proceedSync);
+        }
+        // возвращаем имеющиеся данные
+        return this.storage.data;
+    }
+}
+exports.InfiniteQuery = InfiniteQuery;

package/node/InfiniteQuery/index.d.ts

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

package/node/InfiniteQuery/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("./InfiniteQuery"), exports);

package/node/MobxQuery/MobxQuery.d.ts

@@ -0,0 +1,132 @@
+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';
+/**
+ * Стандартный обработчик ошибки запроса,
+ * будет вызван, если при вызове 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>;
+}
+export {};

package/node/MobxQuery/MobxQuery.js

@@ -0,0 +1,177 @@
+"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");
+/**
+ * Сервис, позволяющий кэшировать данные.
+ */
+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 }));
+        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);