@astral/mobx-query 0.1.0

package/AuxiliaryQuery/AuxiliaryQuery.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @description испольнитель запроса
+ */
+type Executor<TResult> = () => Promise<TResult>;
+/**
+ * @description вспомогательное хранилище данных, для композиции в Query сторах,
+ * содержащее флаги загрузки и ошибки,
+ * колбэки на успешный запрос и на ошибку,
+ * данные последней ошибки,
+ * а так же, управляющее синглтон промисом.
+ */
+export declare class AuxiliaryQuery<TResult, TError = void> {
+    /**
+     * @description флаг обозначающий загрузку данных
+     */
+    isLoading: boolean;
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    isError: boolean;
+    /**
+     * @description данные о последней ошибке
+     */
+    error?: TError;
+    /**
+     * @description флаг, обозначающий успешность завершения последнего запроса
+     */
+    isSuccess: boolean;
+    /**
+     * @description единый промис, для устранения гонки запросов
+     */
+    private unifiedPromise?;
+    constructor();
+    /**
+     * @description метод ответственный за создание единого промиса,
+     * для устранения гонки запросов
+     */
+    getUnifiedPromise: (executor: Executor<TResult>) => Promise<TResult>;
+    /**
+     * @description обработчик успешного ответа
+     */
+    submitSuccess: () => void;
+    /**
+     * @description обработчик ошибки
+     */
+    submitError: (e: TError) => void;
+    /**
+     * @description метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+     */
+    startLoading: () => void;
+}
+export {};

package/AuxiliaryQuery/AuxiliaryQuery.js

@@ -0,0 +1,76 @@
+import { makeAutoObservable, runInAction } from 'mobx';
+/**
+ * @description вспомогательное хранилище данных, для композиции в Query сторах,
+ * содержащее флаги загрузки и ошибки,
+ * колбэки на успешный запрос и на ошибку,
+ * данные последней ошибки,
+ * а так же, управляющее синглтон промисом.
+ */
+export class AuxiliaryQuery {
+    constructor() {
+        /**
+         * @description флаг обозначающий загрузку данных
+         */
+        this.isLoading = false;
+        /**
+         * @description флаг обозначающий, что последний запрос был зафейлен
+         */
+        this.isError = false;
+        /**
+         * @description флаг, обозначающий успешность завершения последнего запроса
+         */
+        this.isSuccess = false;
+        /**
+         * @description метод ответственный за создание единого промиса,
+         * для устранения гонки запросов
+         */
+        this.getUnifiedPromise = (executor) => {
+            // проверяем, если синглтона нет, то надо создать
+            if (!Boolean(this.unifiedPromise)) {
+                this.startLoading();
+                this.unifiedPromise = executor()
+                    .then((resData) => {
+                    runInAction(this.submitSuccess);
+                    return resData;
+                })
+                    .catch((e) => {
+                    runInAction(() => {
+                        this.submitError(e);
+                    });
+                    throw e;
+                })
+                    .finally(() => {
+                    this.unifiedPromise = undefined;
+                    runInAction(() => {
+                        this.isLoading = false;
+                    });
+                });
+            }
+            return this.unifiedPromise;
+        };
+        /**
+         * @description обработчик успешного ответа
+         */
+        this.submitSuccess = () => {
+            this.isError = false;
+            this.isSuccess = true;
+        };
+        /**
+         * @description обработчик ошибки
+         */
+        this.submitError = (e) => {
+            this.isSuccess = false;
+            this.isError = true;
+            this.error = e;
+        };
+        /**
+         * @description метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+         */
+        this.startLoading = () => {
+            this.isLoading = true;
+            this.isError = false;
+            this.isSuccess = false;
+        };
+        makeAutoObservable(this);
+    }
+}

package/AuxiliaryQuery/index.d.ts

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

package/AuxiliaryQuery/index.js

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

package/DataStorage/DataStorage.d.ts

@@ -0,0 +1,36 @@
+import { CacheKey } from '../types';
+/**
+ * @description хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ */
+export declare class DataStorage<TData> {
+    /**
+     * @description поле, отвечающее за непосредственное хранение данных
+     */
+    private internalData?;
+    constructor();
+    /**
+     * @description флаг, отображающий наличие данных
+     */
+    get hasData(): boolean;
+    /**
+     * @description метод для установки данных
+     */
+    setData: (value: TData) => void;
+    /**
+     * @description геттер данных
+     */
+    get data(): TData | undefined;
+}
+/**
+ * @description фабрика ответственная за создание и хранение экземляров хранилищ
+ */
+export declare class DataStorageFactory {
+    /**
+     * @description Map хранящий инстансы хранилищ по хэшу ключа
+     */
+    private storageMap;
+    /**
+     * @description фабричный метод получения/создания инстанса хранилища по ключу
+     */
+    getStorage: <TData>(key: CacheKey[]) => DataStorage<TData>;
+}

package/DataStorage/DataStorage.js

@@ -0,0 +1,48 @@
+import { makeAutoObservable } from 'mobx';
+/**
+ * @description хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ */
+export class DataStorage {
+    constructor() {
+        /**
+         * @description метод для установки данных
+         */
+        this.setData = (value) => {
+            this.internalData = value;
+        };
+        makeAutoObservable(this);
+    }
+    /**
+     * @description флаг, отображающий наличие данных
+     */
+    get hasData() {
+        return Boolean(this.internalData);
+    }
+    /**
+     * @description геттер данных
+     */
+    get data() {
+        return this.internalData;
+    }
+}
+/**
+ * @description фабрика ответственная за создание и хранение экземляров хранилищ
+ */
+export class DataStorageFactory {
+    constructor() {
+        /**
+         * @description Map хранящий инстансы хранилищ по хэшу ключа
+         */
+        this.storageMap = new Map();
+        /**
+         * @description фабричный метод получения/создания инстанса хранилища по ключу
+         */
+        this.getStorage = (key) => {
+            const keyHash = JSON.stringify(key);
+            if (!this.storageMap.has(keyHash)) {
+                this.storageMap.set(keyHash, new DataStorage());
+            }
+            return this.storageMap.get(keyHash);
+        };
+    }
+}

package/DataStorage/index.d.ts

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

package/DataStorage/index.js

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

package/InfiniteQuery/InfiniteQuery.d.ts

@@ -0,0 +1,135 @@
+import { FetchPolicy, QueryBaseActions, Sync, SyncParams } from '../types';
+import { DataStorage } from '../DataStorage';
+export declare const DEFAULT_INFINITE_ITEMS_COUNT = 30;
+export type InfiniteParams = {
+    offset: number;
+    count: number;
+};
+/**
+ * @description исполнитель запроса, ожидается,
+ * что будет использоваться что-то возвращающее массив данных
+ */
+export type InfiniteExecutor<TResult> = (params: InfiniteParams) => Promise<Array<TResult>>;
+export type InfiniteQueryParams<TResult, TError> = {
+    /**
+     * @description количество запрашиваемых элементов
+     * @default 30
+     */
+    incrementCount?: number;
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    onError?: SyncParams<TResult, TError>['onError'];
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    enabledAutoFetch?: boolean;
+    fetchPolicy?: FetchPolicy;
+    /**
+     * @description инстанс хранилища данных
+     */
+    dataStorage: DataStorage<TResult[]>;
+};
+/**
+ * @description стор для работы с инфинити запросами,
+ * которые должны быть закешированы,
+ */
+export declare class InfiniteQuery<TResult, TError = void> implements QueryBaseActions<Array<TResult>, TError> {
+    /**
+     * @description инстанс вспомогательного стора
+     */
+    private auxiliary;
+    /**
+     * @description счетчик отступа для инфинити запроса
+     */
+    private offset;
+    /**
+     * @description количество запрашиваемых элементов
+     */
+    private readonly incrementCount;
+    /**
+     * @description исполнитель запроса, ожидается,
+     * что будет использоваться что-то из слоя sources, возвращающее массив данных
+     */
+    private executor;
+    /**
+     * @description хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
+     */
+    private storage;
+    /**
+     * @description флаг того, что мы достигли предела запрашиваемых элементов
+     */
+    isEndReached: boolean;
+    /**
+     * @description флаг необходимости выполнить обновления данных
+     */
+    private isInvalid;
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    private defaultOnError?;
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    private enabledAutoFetch?;
+    /**
+     * @description стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy?;
+    constructor(executor: InfiniteExecutor<TResult>, { incrementCount, onError, enabledAutoFetch, fetchPolicy, dataStorage, }: InfiniteQueryParams<TResult, TError>);
+    private get isNetworkOnly();
+    /**
+     * @description обработчик успешного запроса, проверяет что мы достигли предела
+     */
+    private submitSuccess;
+    /**
+     * @description метод для обогащения параметров текущими значениями для инфинити
+     */
+    private get infiniteExecutor();
+    /**
+     * @description метод для инвалидации данных
+     */
+    invalidate: () => void;
+    /**
+     * @description метод для запроса следующего набора данных
+     */
+    fetchMore: () => void;
+    /**
+     * @description синхронный метод получения данных
+     */
+    sync: Sync<Array<TResult>, TError>;
+    /**
+     * @description метод для переиспользования синхронной логики запроса
+     */
+    private proceedSync;
+    /**
+     * @description aсинхронный метод получения данных,
+     * подходит для изменения параметров запроса(фильтров),
+     * при котором будет сброшен offset,
+     * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+     */
+    async: () => Promise<TResult[]>;
+    /**
+     * @description вычисляемое свойство, содержащее реактивные данные,
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data(): TResult[] | undefined;
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading(): boolean;
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError(): boolean;
+    /**
+     * @description данные о последней ошибке
+     */
+    get error(): TError | undefined;
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess(): boolean;
+}

package/InfiniteQuery/InfiniteQuery.js

@@ -0,0 +1,183 @@
+import { makeAutoObservable } from 'mobx';
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
+export const DEFAULT_INFINITE_ITEMS_COUNT = 30;
+/**
+ * @description стор для работы с инфинити запросами,
+ * которые должны быть закешированы,
+ */
+export class InfiniteQuery {
+    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, }) {
+        /**
+         * @description инстанс вспомогательного стора
+         */
+        this.auxiliary = new AuxiliaryQuery();
+        /**
+         * @description счетчик отступа для инфинити запроса
+         */
+        this.offset = 0;
+        /**
+         * @description флаг того, что мы достигли предела запрашиваемых элементов
+         */
+        this.isEndReached = false;
+        /**
+         * @description флаг необходимости выполнить обновления данных
+         */
+        this.isInvalid = false;
+        /**
+         * @description обработчик успешного запроса, проверяет что мы достигли предела
+         */
+        this.submitSuccess = (result, onSuccess, isIncrement) => {
+            this.auxiliary.submitSuccess();
+            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);
+            }
+            this.isInvalid = false;
+            // убеждаемся что результат запроса действительно массив,
+            // и если количество элементов в ответе меньше,
+            // чем запрашивалось, значит у бэка их больше нет,
+            // другими словами мы допускаем что, может произойти лишний запрос,
+            // когда последняя отданная страница содержит ровно то количество,
+            // сколько может содержать страница, а следующая уже просто пустая.
+            if (Array.isArray(result) && result.length < this.incrementCount) {
+                // включаем флаг достижения предела
+                this.isEndReached = true;
+            }
+        };
+        /**
+         * @description метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.isInvalid = true;
+        };
+        /**
+         * @description метод для запроса следующего набора данных
+         */
+        this.fetchMore = () => {
+            // если мы еще не достигли предела
+            if (!this.isEndReached && this.storage.data) {
+                // прибавляем к офсету число запрашиваемых элементов
+                this.offset += this.incrementCount;
+                // запускаем запрос с последними параметрами, и флагом необходимости инкремента
+                this.auxiliary
+                    .getUnifiedPromise(this.infiniteExecutor)
+                    .then((resData) => {
+                    this.submitSuccess(resData, undefined, true);
+                });
+            }
+        };
+        /**
+         * @description синхронный метод получения данных
+         */
+        this.sync = (params) => {
+            const isInstanceAllow = !(this.isLoading || this.isSuccess);
+            if (this.isNetworkOnly || this.isInvalid || isInstanceAllow) {
+                this.proceedSync(params);
+            }
+        };
+        /**
+         * @description метод для переиспользования синхронной логики запроса
+         */
+        this.proceedSync = ({ onSuccess, onError, } = {}) => {
+            this.offset = 0;
+            this.isEndReached = false;
+            this.auxiliary
+                .getUnifiedPromise(this.infiniteExecutor)
+                .then((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);
+                }
+            });
+        };
+        /**
+         * @description aсинхронный метод получения данных,
+         * подходит для изменения параметров запроса(фильтров),
+         * при котором будет сброшен offset,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = () => {
+            if (!this.isNetworkOnly && this.isSuccess && !this.isInvalid) {
+                return Promise.resolve(this.storage.data);
+            }
+            this.offset = 0;
+            this.isEndReached = false;
+            return this.auxiliary
+                .getUnifiedPromise(this.infiniteExecutor)
+                .then((resData) => {
+                this.submitSuccess(resData);
+                return resData;
+            })
+                .catch((e) => {
+                this.auxiliary.submitError(e);
+                throw e;
+            });
+        };
+        this.storage = dataStorage;
+        this.incrementCount = incrementCount;
+        this.executor = executor;
+        this.defaultOnError = onError;
+        this.enabledAutoFetch = enabledAutoFetch;
+        this.defaultFetchPolicy = fetchPolicy;
+        makeAutoObservable(this);
+    }
+    get isNetworkOnly() {
+        return this.defaultFetchPolicy === 'network-only';
+    }
+    /**
+     * @description метод для обогащения параметров текущими значениями для инфинити
+     */
+    get infiniteExecutor() {
+        return () => this.executor({
+            offset: this.offset,
+            count: this.incrementCount,
+        });
+    }
+    /**
+     * @description вычисляемое свойство, содержащее реактивные данные,
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data() {
+        const shouldSync = this.enabledAutoFetch && !this.isSuccess && !this.isLoading;
+        if (this.isInvalid || shouldSync) {
+            this.proceedSync();
+        }
+        // возвращаем имеющиеся данные
+        return this.storage.data;
+    }
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading() {
+        return this.auxiliary.isLoading;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError() {
+        return this.auxiliary.isError;
+    }
+    /**
+     * @description данные о последней ошибке
+     */
+    get error() {
+        return this.auxiliary.error;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess() {
+        return this.auxiliary.isSuccess;
+    }
+}

package/InfiniteQuery/index.d.ts

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

package/InfiniteQuery/index.js

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Astral.Soft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MobxQuery/MobxQuery.d.ts

@@ -0,0 +1,79 @@
+import { Query, QueryExecutor, QueryParams } from '../Query';
+import { InfiniteExecutor, InfiniteQuery, InfiniteQueryParams } from '../InfiniteQuery';
+import { MutationExecutor, MutationQuery, MutationQueryParams } from '../MutationQuery';
+import { CacheKey, FetchPolicy } from '../types';
+/**
+ * @description стандартный обработчик ошибки запроса,
+ * будет вызван, если при вызове sync не был передан отдельный onError параметр
+ */
+type OnError<TError = unknown> = (error: TError) => void;
+type MobxQueryParams = {
+    fetchPolicy?: FetchPolicy;
+    onError?: OnError;
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * @default false
+     */
+    enabledAutoFetch?: boolean;
+};
+type CreateCacheableQueryParams<TResult, TError> = Omit<QueryParams<TResult, TError>, 'dataStorage'>;
+type CreateInfiniteQueryParams<TResult, TError> = Omit<InfiniteQueryParams<TResult, TError>, 'dataStorage'>;
+/**
+ * @description Сервис, позволяющий кэшировать данные.
+ */
+export declare class MobxQuery {
+    /**
+     * @description объект соответствия хешей ключей и их значений
+     */
+    private keys;
+    /**
+     * @description Map соответствия хешей ключей к запомненным сторам
+     */
+    private cacheableStores;
+    /**
+     * @description фабрика создания хранилищ данных для обычного Query
+     */
+    private queryDataStorageFactory;
+    /**
+     * @description фабрика создания хранилищ данных для Infinite Query
+     */
+    private infiniteQueryDataStorageFactory;
+    /**
+     * @description стандартный обработчик ошибок, будет использован, если не передан другой
+     */
+    private readonly defaultErrorHandler?;
+    /**
+     * @description стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy;
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * @default false
+     */
+    private readonly defaultEnabledAutoFetch;
+    private serialize;
+    constructor({ onError, fetchPolicy, enabledAutoFetch, }?: MobxQueryParams);
+    /**
+     * @description метод для инвалидации по списку ключей,
+     * предполагается использование из домена
+     */
+    invalidate: (keysParts: CacheKey[]) => void;
+    /**
+     * @description метод, который занимается проверкой наличия стора по ключу,
+     * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
+     */
+    private getCachedQuery;
+    /**
+     * @description метод создания стора, кешируется
+     */
+    createQuery: <TResult, TError>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateCacheableQueryParams<TResult, TError> | undefined) => Query<TResult, TError>;
+    /**
+     * @description метод создания инфинит стора, кешируется
+     */
+    createInfiniteQuery: <TResult, TError>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError> | undefined) => InfiniteQuery<TResult, TError>;
+    /**
+     * @description метод создания мутации, не кешируется
+     */
+    createMutationQuery: <TResult, TError, TExecutorParams>(executor: MutationExecutor<TResult, TExecutorParams>, params?: MutationQueryParams<TResult, TError> | undefined) => MutationQuery<TResult, TError, TExecutorParams>;
+}
+export {};

package/MobxQuery/MobxQuery.js

@@ -0,0 +1,85 @@
+import { Query } from '../Query';
+import { InfiniteQuery, } from '../InfiniteQuery';
+import { MutationQuery, } from '../MutationQuery';
+import { DataStorageFactory } from '../DataStorage';
+/**
+ * @description Сервис, позволяющий кэшировать данные.
+ */
+export class MobxQuery {
+    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, } = {}) {
+        /**
+         * @description объект соответствия хешей ключей и их значений
+         */
+        this.keys = {};
+        /**
+         * @description Map соответствия хешей ключей к запомненным сторам
+         */
+        this.cacheableStores = new Map();
+        /**
+         * @description фабрика создания хранилищ данных для обычного Query
+         */
+        this.queryDataStorageFactory = new DataStorageFactory();
+        /**
+         * @description фабрика создания хранилищ данных для Infinite Query
+         */
+        this.infiniteQueryDataStorageFactory = new DataStorageFactory();
+        this.serialize = (data) => JSON.stringify(data);
+        /**
+         * @description метод для инвалидации по списку ключей,
+         * предполагается использование из домена
+         */
+        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)));
+                if (hasTouchedElement) {
+                    (_a = this.cacheableStores.get(key)) === null || _a === void 0 ? void 0 : _a.invalidate();
+                }
+            });
+        };
+        /**
+         * @description метод, который занимается проверкой наличия стора по ключу,
+         * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
+         */
+        this.getCachedQuery = (key, createStore, fetchPolicy) => {
+            if (fetchPolicy === 'network-only') {
+                return createStore();
+            }
+            const keyHash = this.serialize(key);
+            if (this.cacheableStores.has(keyHash)) {
+                return this.cacheableStores.get(keyHash);
+            }
+            const store = createStore();
+            this.cacheableStores.set(keyHash, store);
+            this.keys[keyHash] = key;
+            return store;
+        };
+        /**
+         * @description метод создания стора, кешируется
+         */
+        this.createQuery = (key, executor, params) => {
+            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy;
+            return this.getCachedQuery(key, () => new Query(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
+                    this.defaultErrorHandler), enabledAutoFetch: (params === null || params === void 0 ? void 0 : params.enabledAutoFetch) || this.defaultEnabledAutoFetch, fetchPolicy: fetchPolicy, dataStorage: this.queryDataStorageFactory.getStorage(key) })), fetchPolicy);
+        };
+        /**
+         * @description метод создания инфинит стора, кешируется
+         */
+        this.createInfiniteQuery = (key, executor, params) => {
+            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy || '';
+            return this.getCachedQuery(key, () => new InfiniteQuery(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
+                    this.defaultErrorHandler), enabledAutoFetch: (params === null || params === void 0 ? void 0 : params.enabledAutoFetch) || this.defaultEnabledAutoFetch, dataStorage: this.infiniteQueryDataStorageFactory.getStorage(key), fetchPolicy: fetchPolicy })), fetchPolicy);
+        };
+        /**
+         * @description метод создания мутации, не кешируется
+         */
+        this.createMutationQuery = (executor, params) => new MutationQuery(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;
+    }
+}

package/MobxQuery/index.d.ts

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

package/MobxQuery/index.js

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

package/MutationQuery/MutationQuery.d.ts

@@ -0,0 +1,56 @@
+import { QueryBaseActions, Sync, SyncParams } from '../types';
+/**
+ * @description исполнитель запроса
+ */
+export type MutationExecutor<TResult, TParams> = (params: TParams) => Promise<TResult>;
+export type MutationQueryParams<TResult, TError> = {
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    onError?: SyncParams<TResult, TError>['onError'];
+};
+/**
+ * @description простой стор для запросов, которые не требуют кэширования,
+ * пример - POST запросы
+ */
+export declare class MutationQuery<TResult, TError = void, TExecutorParams = void> implements QueryBaseActions<TResult, TError, TExecutorParams> {
+    /**
+     * @description инстанс вспомогательного стора
+     */
+    private auxiliary;
+    /**
+     * @description исполнитель запроса, ожидается,
+     * что будет использоваться что-то из слоя sources
+     */
+    private executor;
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    private defaultOnError?;
+    constructor(executor: MutationExecutor<TResult, TExecutorParams>, { onError }?: MutationQueryParams<TResult, TError>);
+    /**
+     * @description синхронный метод получения/отправки данных
+     */
+    sync: Sync<TResult, TError, TExecutorParams>;
+    /**
+     * @description асинхронный метод получения/отправки данных,
+     * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+     */
+    async: (params: TExecutorParams) => Promise<TResult>;
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading(): boolean;
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError(): boolean;
+    /**
+     * @description данные о последней ошибке
+     */
+    get error(): TError | undefined;
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess(): boolean;
+}

package/MutationQuery/MutationQuery.js

@@ -0,0 +1,68 @@
+import { makeAutoObservable } from 'mobx';
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
+/**
+ * @description простой стор для запросов, которые не требуют кэширования,
+ * пример - POST запросы
+ */
+export class MutationQuery {
+    constructor(executor, { onError } = {}) {
+        /**
+         * @description инстанс вспомогательного стора
+         */
+        this.auxiliary = new AuxiliaryQuery();
+        /**
+         * @description синхронный метод получения/отправки данных
+         */
+        this.sync = (options) => {
+            const { onSuccess, onError, params } = options || {};
+            this.auxiliary
+                .getUnifiedPromise(() => this.executor(params))
+                .then((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);
+                }
+            });
+        };
+        /**
+         * @description асинхронный метод получения/отправки данных,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = (params) => {
+            return this.auxiliary.getUnifiedPromise(() => this.executor(params));
+        };
+        this.executor = executor;
+        this.defaultOnError = onError;
+        makeAutoObservable(this);
+    }
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading() {
+        return this.auxiliary.isLoading;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError() {
+        return this.auxiliary.isError;
+    }
+    /**
+     * @description данные о последней ошибке
+     */
+    get error() {
+        return this.auxiliary.error;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess() {
+        return this.auxiliary.isSuccess;
+    }
+}

package/MutationQuery/index.d.ts

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

package/MutationQuery/index.js

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

package/Query/Query.d.ts

@@ -0,0 +1,103 @@
+import { FetchPolicy, QueryBaseActions, Sync, SyncParams } from '../types';
+import { DataStorage } from '../DataStorage';
+/**
+ * @description исполнитель запроса
+ */
+export type QueryExecutor<TResult> = () => Promise<TResult>;
+export type QueryParams<TResult, TError> = {
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    onError?: SyncParams<TResult, TError>['onError'];
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    enabledAutoFetch?: boolean;
+    fetchPolicy?: FetchPolicy;
+    /**
+     * @description инстанс хранилища данных
+     */
+    dataStorage: DataStorage<TResult>;
+};
+/**
+ * @description стор для работы с запросами,
+ * которые должны быть закешированы,
+ * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
+ */
+export declare class Query<TResult, TError = void> implements QueryBaseActions<TResult, TError, undefined> {
+    /**
+     * @description инстанс вспомогательного стора
+     */
+    private auxiliary;
+    /**
+     * @description флаг, по которому реактивно определяется необходимость запуска инвалидации
+     */
+    private isInvalid;
+    /**
+     * @description хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
+     */
+    private storage;
+    /**
+     * @description исполнитель запроса, ожидается,
+     * что будет использоваться что-то из слоя sources
+     */
+    private executor;
+    /**
+     * @description обработчик ошибки, вызываемый по умолчанию
+     */
+    private defaultOnError?;
+    /**
+     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    private enabledAutoFetch?;
+    /**
+     * @description стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy?;
+    constructor(executor: QueryExecutor<TResult>, { onError, enabledAutoFetch, fetchPolicy, dataStorage, }: QueryParams<TResult, TError>);
+    private get isNetworkOnly();
+    /**
+     * @description метод для инвалидации данных
+     */
+    invalidate: () => void;
+    /**
+     * @description синхронный метод получения данных
+     */
+    sync: Sync<TResult, TError, undefined>;
+    /**
+     * @description обработчик успешного ответа
+     */
+    private submitSuccess;
+    /**
+     * @description метод для переиспользования синхронной логики запроса
+     */
+    private proceedSync;
+    /**
+     * @description асинхронный метод получения данных,
+     * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+     */
+    async: () => Promise<TResult>;
+    /**
+     * @description содержит реактивные данные
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data(): TResult | undefined;
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading(): boolean;
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError(): boolean;
+    /**
+     * @description данные о последней ошибке
+     */
+    get error(): TError | undefined;
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess(): boolean;
+}

package/Query/Query.js

@@ -0,0 +1,122 @@
+import { makeAutoObservable } from 'mobx';
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
+/**
+ * @description стор для работы с запросами,
+ * которые должны быть закешированы,
+ * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
+ */
+export class Query {
+    constructor(executor, { onError, enabledAutoFetch, fetchPolicy, dataStorage, }) {
+        /**
+         * @description инстанс вспомогательного стора
+         */
+        this.auxiliary = new AuxiliaryQuery();
+        /**
+         * @description флаг, по которому реактивно определяется необходимость запуска инвалидации
+         */
+        this.isInvalid = false;
+        /**
+         * @description метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.isInvalid = true;
+        };
+        /**
+         * @description синхронный метод получения данных
+         */
+        this.sync = (params) => {
+            const isInstanceAllow = !(this.isLoading || this.isSuccess);
+            if (this.isNetworkOnly || this.isInvalid || isInstanceAllow) {
+                this.proceedSync(params);
+            }
+        };
+        /**
+         * @description обработчик успешного ответа
+         */
+        this.submitSuccess = (resData) => {
+            this.storage.setData(resData);
+            this.isInvalid = false;
+            return resData;
+        };
+        /**
+         * @description метод для переиспользования синхронной логики запроса
+         */
+        this.proceedSync = (options) => {
+            const { onSuccess, onError } = options || {};
+            this.auxiliary
+                .getUnifiedPromise(this.executor)
+                .then((res) => {
+                this.submitSuccess(res);
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(res);
+            })
+                .catch((e) => {
+                var _a;
+                if (onError) {
+                    onError(e);
+                }
+                else {
+                    (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
+                }
+            });
+        };
+        /**
+         * @description асинхронный метод получения данных,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = () => {
+            if (!this.isNetworkOnly && this.isSuccess && !this.isInvalid) {
+                return Promise.resolve(this.storage.data);
+            }
+            return this.auxiliary
+                .getUnifiedPromise(this.executor)
+                .then(this.submitSuccess);
+        };
+        this.executor = executor;
+        this.defaultOnError = onError;
+        this.enabledAutoFetch = enabledAutoFetch;
+        this.defaultFetchPolicy = fetchPolicy;
+        this.storage = dataStorage;
+        makeAutoObservable(this);
+    }
+    get isNetworkOnly() {
+        return this.defaultFetchPolicy === 'network-only';
+    }
+    /**
+     * @description содержит реактивные данные
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data() {
+        const shouldSync = this.enabledAutoFetch && !this.isSuccess && !this.isLoading;
+        if (this.isInvalid || shouldSync) {
+            this.proceedSync();
+        }
+        // возвращаем имеющиеся данные
+        return this.storage.data;
+    }
+    /**
+     * @description флаг загрузки данных
+     */
+    get isLoading() {
+        return this.auxiliary.isLoading;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError() {
+        return this.auxiliary.isError;
+    }
+    /**
+     * @description данные о последней ошибке
+     */
+    get error() {
+        return this.auxiliary.error;
+    }
+    /**
+     * @description флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess() {
+        return this.auxiliary.isSuccess;
+    }
+}

package/Query/index.d.ts

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

package/Query/index.js

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

package/README.md

@@ -0,0 +1 @@
+

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@astral/mobx-query",
+  "version": "0.1.0",
+  "browser": "./index.js",
+  "main": "./index.js",
+  "dependencies": {
+    "mobx": "^6.9.0"
+  },
+  "author": "Astral.Soft",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaluga-astral/mobx-query"
+  },
+  "bugs": {
+    "url": "https://github.com/kaluga-astral/mobx-query/issues"
+  },
+  "keywords": [],
+  "sideEffects": false,
+  "types": "./index.d.ts",
+  "module": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  }
+}

package/types.d.ts

@@ -0,0 +1,51 @@
+export type SyncParams<TResult, TError, TExecutorParams = void> = {
+    onSuccess?: (res: TResult) => void;
+    onError?: (e: TError) => void;
+    params?: TExecutorParams;
+};
+/**
+ * @description синхронный метод получения данных
+ */
+export type Sync<TResult, TError, TExecutorParams = void> = (params?: SyncParams<TResult, TError, TExecutorParams>) => void;
+/**
+ * @description асинхронный метод получения данных
+ */
+export type Async<TResult, TExecutorParams = void> = (params: TExecutorParams) => Promise<TResult>;
+export type QueryBaseActions<TResult, TError, TExecutorParams = void> = {
+    /**
+     * @description синхронный метод получения данных
+     */
+    sync: Sync<TResult, TError, TExecutorParams>;
+    /**
+     * @description асинхронный метод получения данных
+     */
+    async: Async<TResult, TExecutorParams>;
+    /**
+     * @description флаг обозначающий загрузку данных
+     */
+    isLoading: boolean;
+    /**
+     * @description флаг обозначающий, что последний запрос был зафейлен
+     */
+    isError: boolean;
+    /**
+     * @description данные о последней ошибке
+     */
+    error?: TError;
+    /**
+     * @description флаг обзначающий, что последний запрос был успешно выполнен
+     */
+    isSuccess: boolean;
+};
+/**
+ * @description политика получения данных.
+ * @variation 'cache-first' - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+ * @kind 'network-only' - данные всегда беруться из сети, при этом ответ записывается в кэш
+ */
+export type FetchPolicy = 'network-only' | 'cache-first';
+/**
+ * @description ключ для кешированя
+ */
+export type CacheKey = string | string[] | number | {
+    [key: string]: CacheKey;
+};

package/types.js

@@ -0,0 +1 @@
+export {};