@astral/mobx-query 1.4.0 → 1.5.0

package/InfiniteQuery/InfiniteQuery.js

@@ -1,30 +1,25 @@
-import { makeAutoObservable, when } from 'mobx';
+import { action, computed, makeObservable, when } from 'mobx';
 import { AuxiliaryQuery } from '../AuxiliaryQuery';
+import { QueryContainer } from '../QueryContainer';
 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();
+export class InfiniteQuery extends QueryContainer {
+    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, }) {
+        super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery(statusStorage, backgroundStatusStorage));
+        this.executor = executor;
         /**
-         * @description счетчик отступа для инфинити запроса
+         * счетчик отступа для инфинити запроса
          */
         this.offset = 0;
         /**
-         * @description флаг того, что мы достигли предела запрашиваемых элементов
+         * флаг того, что мы достигли предела запрашиваемых элементов
          */
         this.isEndReached = false;
         /**
-         * @description флаг необходимости выполнить обновления данных
-         */
-        this.isInvalid = false;
-        /**
-         * @description обработчик успешного запроса, проверяет что мы достигли предела
+         * обработчик успешного запроса, проверяет что мы достигли предела
          */
         this.submitSuccess = (result, onSuccess, isIncrement) => {
             onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
@@ -34,7 +29,6 @@ export class InfiniteQuery {
             else {
                 this.storage.setData(result);
             }
-            this.isInvalid = false;
             // убеждаемся что результат запроса действительно массив,
             // и если количество элементов в ответе меньше,
             // чем запрашивалось, значит у бэка их больше нет,
@@ -47,7 +41,7 @@ export class InfiniteQuery {
             }
         };
         /**
-         * @description форс метод для установки данных
+         * форс метод для установки данных
          */
         this.forceUpdate = (data) => {
             this.offset = 0;
@@ -56,13 +50,13 @@ export class InfiniteQuery {
             this.submitSuccess(data);
         };
         /**
-         * @description метод для инвалидации данных
+         * метод для инвалидации данных
          */
         this.invalidate = () => {
-            this.isInvalid = true;
+            this.auxiliary.invalidate();
         };
         /**
-         * @description метод для запроса следующего набора данных
+         * метод для запроса следующего набора данных
          */
         this.fetchMore = () => {
             // если мы еще не достигли предела
@@ -78,16 +72,16 @@ export class InfiniteQuery {
             }
         };
         /**
-         * @description синхронный метод получения данных
+         * синхронный метод получения данных
          */
         this.sync = (params) => {
             const isInstanceAllow = !(this.isLoading || this.isSuccess);
-            if (this.isNetworkOnly || this.isInvalid || isInstanceAllow) {
+            if (this.isNetworkOnly || this.auxiliary.isInvalid || isInstanceAllow) {
                 this.proceedSync(params);
             }
         };
         /**
-         * @description метод для переиспользования синхронной логики запроса
+         * метод для переиспользования синхронной логики запроса
          */
         this.proceedSync = ({ onSuccess, onError, } = {}) => {
             this.offset = 0;
@@ -108,13 +102,13 @@ export class InfiniteQuery {
             });
         };
         /**
-         * @description aсинхронный метод получения данных,
+         * aсинхронный метод получения данных,
          * подходит для изменения параметров запроса(фильтров),
          * при котором будет сброшен offset,
          * предполагается, что нужно будет самостоятельно обрабатывать ошибку
          */
         this.async = () => {
-            if (!this.isNetworkOnly && this.isSuccess && !this.isInvalid) {
+            if (!this.isNetworkOnly && this.isSuccess && !this.auxiliary.isInvalid) {
                 return Promise.resolve(this.storage.data);
             }
             this.offset = 0;
@@ -132,17 +126,24 @@ export class InfiniteQuery {
         };
         this.storage = dataStorage;
         this.incrementCount = incrementCount;
-        this.executor = executor;
         this.defaultOnError = onError;
         this.enabledAutoFetch = enabledAutoFetch;
         this.defaultFetchPolicy = fetchPolicy;
-        makeAutoObservable(this);
+        makeObservable(this, {
+            data: computed,
+            infiniteExecutor: computed,
+            forceUpdate: action,
+            async: action,
+            sync: action,
+            fetchMore: action,
+            submitSuccess: action,
+        });
     }
     get isNetworkOnly() {
         return this.defaultFetchPolicy === 'network-only';
     }
     /**
-     * @description метод для обогащения параметров текущими значениями для инфинити
+     * метод для обогащения параметров текущими значениями для инфинити
      */
     get infiniteExecutor() {
         return () => this.executor({
@@ -151,7 +152,7 @@ export class InfiniteQuery {
         });
     }
     /**
-     * @description вычисляемое свойство, содержащее реактивные данные,
+     * вычисляемое свойство, содержащее реактивные данные,
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся
@@ -161,7 +162,7 @@ export class InfiniteQuery {
             !this.isSuccess &&
             !this.isLoading &&
             !this.isError;
-        if (this.isInvalid || shouldSync) {
+        if (this.auxiliary.isInvalid || shouldSync) {
             // т.к. при вызове апдейта, изменяются флаги, на которые подписан data,
             // нужно вызывать этот экшн асинхронно
             when(() => true, this.proceedSync);
@@ -169,31 +170,4 @@ export class InfiniteQuery {
         // возвращаем имеющиеся данные
         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;
-    }
-    get isIdle() {
-        return this.auxiliary.isIdle;
-    }
 }

package/MobxQuery/MobxQuery.d.ts

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

package/MobxQuery/MobxQuery.js

@@ -2,34 +2,39 @@ import { Query } from '../Query';
 import { InfiniteQuery, } from '../InfiniteQuery';
 import { Mutation, } from '../Mutation';
 import { DataStorageFactory } from '../DataStorage';
+import { StatusStorageFactory } from '../StatusStorage';
 /**
- * @description время, спустя которое, запись о query c network-only будет удалена
+ * время, спустя которое, запись о query c network-only будет удалена
  */
 const DEFAULT_TIME_TO_CLEAN = 100;
 /**
- * @description Сервис, позволяющий кэшировать данные.
+ * Сервис, позволяющий кэшировать данные.
  */
 export class MobxQuery {
     constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, } = {}) {
         /**
-         * @description объект соответствия хешей ключей и их значений
+         * объект соответствия хешей ключей и их значений
          */
         this.keys = {};
         /**
-         * @description Map соответствия хешей ключей к запомненным сторам
+         * Map соответствия хешей ключей к запомненным сторам
          */
         this.cacheableStores = new Map();
         /**
-         * @description фабрика создания хранилищ данных для обычного Query
+         * фабрика создания хранилищ данных для обычного Query
          */
         this.queryDataStorageFactory = new DataStorageFactory();
         /**
-         * @description фабрика создания хранилищ данных для Infinite Query
+         * фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
+         */
+        this.statusStorageFactory = new StatusStorageFactory();
+        /**
+         * фабрика создания хранилищ данных для Infinite Query
          */
         this.infiniteQueryDataStorageFactory = new DataStorageFactory();
         this.serialize = (data) => JSON.stringify(data);
         /**
-         * @description метод для инвалидации по списку ключей,
+         * метод для инвалидации по списку ключей,
          * предполагается использование из домена
          */
         this.invalidate = (keysParts) => {
@@ -46,7 +51,7 @@ export class MobxQuery {
             });
         };
         /**
-         * @description метод инвалидации всех query
+         * метод инвалидации всех query
          */
         this.invalidateQueries = () => {
             [...this.cacheableStores.entries()].forEach(([, store]) => {
@@ -54,7 +59,7 @@ export class MobxQuery {
             });
         };
         /**
-         * @description метод, который занимается проверкой наличия стора по ключу,
+         * метод, который занимается проверкой наличия стора по ключу,
          * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
          */
         this.getCachedQuery = (key, createStore, fetchPolicy) => {
@@ -82,30 +87,33 @@ export class MobxQuery {
             }
             return store;
         };
+        this.getBackgroundStatusStorage = (key, hasBackground) => (hasBackground
+            ? this.statusStorageFactory.getStorage([...key, true])
+            : null);
         /**
-         * @description метод создания стора, кешируется
+         * метод создания стора, кешируется
          */
         this.createQuery = (key, executor, params) => {
             const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy;
             return this.getCachedQuery(key, () => {
                 var _a;
                 return new Query(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, fetchPolicy: fetchPolicy, dataStorage: this.queryDataStorageFactory.getStorage(key) }));
+                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, fetchPolicy: fetchPolicy, dataStorage: this.queryDataStorageFactory.getStorage(key), statusStorage: this.statusStorageFactory.getStorage(key), backgroundStatusStorage: this.getBackgroundStatusStorage(key, Boolean(params === null || params === void 0 ? void 0 : params.isBackground)) }));
             }, fetchPolicy);
         };
         /**
-         * @description метод создания инфинит стора, кешируется
+         * метод создания инфинит стора, кешируется
          */
         this.createInfiniteQuery = (key, executor, params) => {
             const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy || '';
             return this.getCachedQuery(key, () => {
                 var _a;
                 return new InfiniteQuery(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, dataStorage: this.infiniteQueryDataStorageFactory.getStorage(key), fetchPolicy: fetchPolicy }));
+                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, dataStorage: this.infiniteQueryDataStorageFactory.getStorage(key), statusStorage: this.statusStorageFactory.getStorage(key), fetchPolicy: fetchPolicy, backgroundStatusStorage: this.getBackgroundStatusStorage(key, Boolean(params === null || params === void 0 ? void 0 : params.isBackground)) }));
             }, fetchPolicy);
         };
         /**
-         * @description метод создания мутации, не кешируется
+         * метод создания мутации, не кешируется
          */
         this.createMutation = (executor, params) => new Mutation(executor, Object.assign(Object.assign({}, params), { onError: (params === null || params === void 0 ? void 0 : params.onError) || this.defaultErrorHandler }));
         this.defaultErrorHandler = onError;

package/Mutation/Mutation.d.ts

@@ -1,57 +1,34 @@
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import type { QueryBaseActions, Sync, SyncParams } from '../types';
+import { QueryContainer } from '../QueryContainer';
 /**
- * @description исполнитель запроса
+ * исполнитель запроса
  */
 export type MutationExecutor<TResult, TParams> = (params: TParams) => Promise<TResult>;
 export type MutationParams<TResult, TError> = {
     /**
-     * @description обработчик ошибки, вызываемый по умолчанию
+     * обработчик ошибки, вызываемый по умолчанию
      */
     onError?: SyncParams<TResult, TError>['onError'];
 };
 /**
- * @description простой стор для запросов, которые не требуют кэширования,
+ * простой стор для запросов, которые не требуют кэширования,
  * пример - POST запросы
  */
-export declare class Mutation<TResult, TError = void, TExecutorParams = void> implements QueryBaseActions<TResult, TError, TExecutorParams> {
+export declare class Mutation<TResult, TError = void, TExecutorParams = void> extends QueryContainer<TError, AuxiliaryQuery<TResult, TError>, false> implements QueryBaseActions<TResult, TError, TExecutorParams> {
+    private readonly executor;
     /**
-     * @description инстанс вспомогательного стора
+     * обработчик ошибки, вызываемый по умолчанию
      */
-    private auxiliary;
-    /**
-     * @description исполнитель запроса, ожидается,
-     * что будет использоваться что-то из слоя sources
-     */
-    private executor;
-    /**
-     * @description обработчик ошибки, вызываемый по умолчанию
-     */
-    private defaultOnError?;
+    private readonly defaultOnError?;
     constructor(executor: MutationExecutor<TResult, TExecutorParams>, { onError }?: MutationParams<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;
-    get isIdle(): boolean;
 }

package/Mutation/Mutation.js

@@ -1,17 +1,18 @@
-import { makeAutoObservable } from 'mobx';
+import { action, makeObservable } from 'mobx';
 import { AuxiliaryQuery } from '../AuxiliaryQuery';
+import { QueryContainer } from '../QueryContainer';
+import { StatusStorage } from '../StatusStorage';
 /**
- * @description простой стор для запросов, которые не требуют кэширования,
+ * простой стор для запросов, которые не требуют кэширования,
  * пример - POST запросы
  */
-export class Mutation {
+export class Mutation extends QueryContainer {
     constructor(executor, { onError } = {}) {
+        const statusStorage = new StatusStorage();
+        super(statusStorage, null, new AuxiliaryQuery(statusStorage, null));
+        this.executor = executor;
         /**
-         * @description инстанс вспомогательного стора
-         */
-        this.auxiliary = new AuxiliaryQuery();
-        /**
-         * @description синхронный метод получения/отправки данных
+         * синхронный метод получения/отправки данных
          */
         this.sync = (options) => {
             const { onSuccess, onError, params } = options || {};
@@ -31,41 +32,13 @@ export class Mutation {
             });
         };
         /**
-         * @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;
-    }
-    get isIdle() {
-        return this.auxiliary.isIdle;
+        makeObservable(this, { async: action, sync: action });
     }
 }