@astral/mobx-query 1.15.0 → 1.16.0

package/MobxQuery/MobxQuery.d.ts

@@ -3,6 +3,7 @@ import { Mutation, type MutationExecutor, type MutationParams } from '../Mutatio
 import { Query, type QueryExecutor, type QueryParams } from '../Query';
 import { InfiniteQuerySet, type InfiniteQuerySetConfig, type InfiniteQuerySetConfigurator, MutationSet, QuerySet, type QuerySetConfig, type QuerySetConfigurator } from '../Sets';
 import type { CacheKey, FetchPolicy } from '../types';
+import type { UnknownCachedQuery } from './types';
 /**
  * Стандартный обработчик ошибки запроса,
  * будет вызван, если при вызове sync не был передан отдельный onError параметр
@@ -15,6 +16,12 @@ type WithSynchronization = {
      */
     enabledSynchronization?: boolean;
 };
+type WithPollingTime = {
+    /**
+     * Время в мс, раз в которое необходимо инвалидировать query
+     */
+    pollingTime?: number;
+};
 type MobxQueryParams = {
     /**
      * Политика получения данных по умолчанию.
@@ -43,19 +50,15 @@ export type CreateQueryParams<TResult, TError, TIsBackground extends boolean> =
      * @default false
      */
     isBackground?: TIsBackground;
-} & WithSynchronization;
+} & WithSynchronization & WithPollingTime;
 export type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
      * Режим фонового обновления
      * @default false
      */
     isBackground?: TIsBackground;
-} & WithSynchronization;
+} & WithSynchronization & WithPollingTime;
 export type CreateMutationParams<TResult, TError> = MutationParams<TResult, TError>;
-/**
- * Внутриний тип кешируемого стора
- */
-type CachedQuery<TResult, TError, TIsBackground extends boolean> = Query<TResult, TError, TIsBackground> | InfiniteQuery<TResult, TError, TIsBackground>;
 /**
  * Стратегия инвалидации кэша
  * @property 'partial-match' - Проверяет наличие хотя бы одной части ключа в кэше
@@ -97,11 +100,12 @@ export declare class MobxQuery<TDefaultError = void> {
     private readonly defaultEnabledAutoFetch;
     private readonly defauleEnabledSynchronization;
     private readonly synchronizationService;
+    private readonly pollingService;
     private serialize;
     constructor({ onError, fetchPolicy, enabledAutoFetch, enabledSynchronization, }?: MobxQueryParams, _BroadcastChannel?: {
         new (name: string): BroadcastChannel;
         prototype: BroadcastChannel;
-    });
+    }, _document?: Document);
     /**
      * Проверяет пересечение ключей в зависимости от стратегии
      * @param invalidatedKeys - Ключи для инвалидации
@@ -123,6 +127,7 @@ export declare class MobxQuery<TDefaultError = void> {
      * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
      */
     invalidate: (invalidatedKeys: CacheKey[], strategy?: InvalidateStrategy) => void;
+    private invalidateByKeyHash;
     /**
      * Метод для получения массива хешей ключей на основании ключей и стратегии
      */
@@ -130,7 +135,7 @@ export declare class MobxQuery<TDefaultError = void> {
     /**
      * метод для получения массива существующий квери на основании ключей и стратегии
      */
-    getExistsQueries: <TQuery = CachedQuery<unknown, unknown, false>>(keys: CacheKey[], strategy?: InvalidateStrategy) => TQuery[];
+    getExistsQueries: <TQuery = UnknownCachedQuery>(keys: CacheKey[], strategy?: InvalidateStrategy) => TQuery[];
     private submitValidity;
     /**
      * Метод инвалидации всех query

package/MobxQuery/MobxQuery.js

@@ -2,6 +2,7 @@ import { AdaptableMap } from '../AdaptableMap';
 import { DataStorageFactory } from '../DataStorage';
 import { InfiniteQuery, } from '../InfiniteQuery';
 import { Mutation, } from '../Mutation';
+import { PollingService } from '../PollingService';
 import { Query } from '../Query';
 import { InfiniteQuerySet, MutationSet, QuerySet, } from '../Sets';
 import { StatusStorageFactory } from '../StatusStorage';
@@ -10,7 +11,7 @@ import { SynchronizationService } from '../SynchronizationService';
  * Сервис, позволяющий кэшировать данные.
  */
 export class MobxQuery {
-    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, enabledSynchronization = false, } = {}, _BroadcastChannel = globalThis.BroadcastChannel) {
+    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, enabledSynchronization = false, } = {}, _BroadcastChannel = globalThis.BroadcastChannel, _document = globalThis.document) {
         /**
          * Объект соответствия хешей ключей и их значений
          */
@@ -55,13 +56,15 @@ export class MobxQuery {
          * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
          */
         this.invalidate = (invalidatedKeys, strategy = 'partial-match') => {
-            this.getExistsKeyHashes(invalidatedKeys, strategy).forEach(({ keyHash }) => {
-                var _a;
-                (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
-                // Конвертируем инвалидированный квери в слабый,
-                // чтобы сборщик мусора мог удалить неиспользуемые квери
-                this.queriesMap.convertToWeak(keyHash);
-            });
+            this.getExistsKeyHashes(invalidatedKeys, strategy).forEach(({ keyHash }) => this.invalidateByKeyHash(keyHash));
+        };
+        this.invalidateByKeyHash = (keyHash) => {
+            var _a;
+            (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
+            // Конвертируем инвалидированный квери в слабый,
+            // чтобы сборщик мусора мог удалить неиспользуемые квери
+            this.queriesMap.convertToWeak(keyHash);
+            this.pollingService.clean(keyHash);
         };
         /**
          * Метод для получения массива хешей ключей на основании ключей и стратегии
@@ -78,10 +81,13 @@ export class MobxQuery {
          */
         this.getExistsQueries = (keys, strategy = 'partial-match') => this.getExistsKeyHashes(keys, strategy).map(({ keyHash }) => this.queriesMap.get(keyHash));
         // Метод для подтверждения того, что квери успешно получил валидные данные
-        this.submitValidity = (keys, isNetworkOnly, enabledSynchronization) => {
+        this.submitValidity = (keys, isNetworkOnly, enabledSynchronization, pollingTime) => {
             if (enabledSynchronization) {
                 this.synchronizationService.emit(keys);
             }
+            if (pollingTime) {
+                this.pollingService.setupTimer(keys.queryKeyHash, pollingTime);
+            }
             // 'network-only' квери не будут конвертироваться,
             // следовательно, они всегда будут храниться как "слабые",
             // что позволит сборщику мусора удалять их из памяти при отсутствии ссылок
@@ -95,13 +101,7 @@ export class MobxQuery {
         /**
          * Метод инвалидации всех 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.invalidateQueries = () => [...this.keys.keys()].forEach(this.invalidateByKeyHash);
         /**
          * Метод, который занимается проверкой наличия квери по ключу,
          * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
@@ -124,7 +124,7 @@ export class MobxQuery {
                 backgroundStatusStorage: this.getBackgroundStatusStorage(keys.backgroundStatusKeyHash, Boolean(createParams === null || createParams === void 0 ? void 0 : createParams.isBackground)),
                 submitValidity: () => {
                     var _a;
-                    return this.submitValidity(keys, fetchPolicy !== 'network-only', (_a = createParams === null || createParams === void 0 ? void 0 : createParams.enabledSynchronization) !== null && _a !== void 0 ? _a : this.defauleEnabledSynchronization);
+                    return this.submitValidity(keys, fetchPolicy !== 'network-only', (_a = createParams === null || createParams === void 0 ? void 0 : createParams.enabledSynchronization) !== null && _a !== void 0 ? _a : this.defauleEnabledSynchronization, createParams === null || createParams === void 0 ? void 0 : createParams.pollingTime);
                 },
             });
             this.queriesMap.set(keys.queryKeyHash, query);
@@ -228,6 +228,7 @@ export class MobxQuery {
         this.defaultFetchPolicy = fetchPolicy;
         this.defaultEnabledAutoFetch = enabledAutoFetch;
         this.defauleEnabledSynchronization = enabledSynchronization;
-        this.synchronizationService = new SynchronizationService(this.statusStorageFactory, this.queryDataStorageFactory, _BroadcastChannel);
+        this.pollingService = new PollingService(this.queriesMap, this.invalidateByKeyHash, _document);
+        this.synchronizationService = new SynchronizationService(this.statusStorageFactory, this.queryDataStorageFactory, this.pollingService, _BroadcastChannel);
     }
 }

package/MobxQuery/types.d.ts

@@ -0,0 +1,22 @@
+import { type InfiniteQuery } from '../InfiniteQuery';
+import { type Query } from '../Query';
+import { type CacheKey } from '../types';
+/**
+ * Внутриний тип кешируемого стора
+ */
+export type CachedQuery<TResult, TError, TIsBackground extends boolean> = Query<TResult, TError, TIsBackground> | InfiniteQuery<TResult, TError, TIsBackground>;
+export type UnknownCachedQuery = CachedQuery<unknown, unknown, false>;
+/**
+ * Хэш ключа
+ */
+export type KeyHash = string;
+/**
+ * Набор ключей
+ */
+export type Keys = {
+    queryKey: CacheKey[];
+    dataKeyHash: KeyHash;
+    statusKeyHash: KeyHash;
+    queryKeyHash: KeyHash;
+    backgroundStatusKeyHash: KeyHash;
+};

package/MobxQuery/types.js

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

package/PollingService/PollingService.d.ts

@@ -0,0 +1,34 @@
+import { type AdaptableMap } from '../AdaptableMap';
+import { type KeyHash, type UnknownCachedQuery } from '../MobxQuery/types';
+/**
+ * Сущность для инкапсулирования логики работы с устареванием данных
+ */
+export declare class PollingService {
+    private readonly _queryStorage;
+    private readonly _invalidateByKeyHash;
+    private readonly _document;
+    private timers;
+    private timerDates;
+    private isVisible;
+    constructor(_queryStorage: AdaptableMap<UnknownCachedQuery>, _invalidateByKeyHash: (keyHash: KeyHash) => void, _document?: Document);
+    private updateIsVisible;
+    private init;
+    private handleVisibilityChange;
+    private restartPausedTimers;
+    private pauseTimers;
+    /**
+     * Очистка таймеров,
+     * предполагается использование либо при срабатывании таймера,
+     * либо при досрочном вызове из внешней инвалидации
+     */
+    clean: (key: KeyHash) => void;
+    /**
+     * Перезапуск имеющегося таймера, предполагается использование при срабатывании синхронизации между вкладками
+     */
+    restart: (key: KeyHash) => void;
+    private invalidate;
+    /**
+     * Установка таймера устаревания данных
+     */
+    setupTimer: (key: KeyHash, pollingTime: number) => void;
+}

package/PollingService/PollingService.js

@@ -0,0 +1,95 @@
+/**
+ * Сущность для инкапсулирования логики работы с устареванием данных
+ */
+export class PollingService {
+    constructor(_queryStorage, _invalidateByKeyHash, _document = globalThis.document) {
+        this._queryStorage = _queryStorage;
+        this._invalidateByKeyHash = _invalidateByKeyHash;
+        this._document = _document;
+        this.timers = new Map();
+        this.timerDates = new Map();
+        this.isVisible = true;
+        this.updateIsVisible = () => {
+            var _a;
+            this.isVisible = ((_a = this._document) === null || _a === void 0 ? void 0 : _a.visibilityState) === 'visible';
+        };
+        this.init = () => {
+            var _a;
+            this.updateIsVisible();
+            (_a = this._document) === null || _a === void 0 ? void 0 : _a.addEventListener('visibilitychange', this.handleVisibilityChange);
+        };
+        this.handleVisibilityChange = () => {
+            this.updateIsVisible();
+            if (this.isVisible) {
+                this.restartPausedTimers();
+            }
+            else {
+                this.pauseTimers();
+            }
+        };
+        this.restartPausedTimers = () => {
+            this.timerDates.keys().forEach((key) => {
+                const dateNow = Date.now();
+                const { pollingTime, targetDate } = this.timerDates.get(key);
+                const isAlreadyExpired = targetDate < dateNow;
+                if (isAlreadyExpired) {
+                    this.invalidate(key);
+                }
+                else {
+                    this.setupTimer(key, pollingTime);
+                }
+            });
+        };
+        this.pauseTimers = () => {
+            this.timers.keys().forEach((key) => {
+                globalThis.clearTimeout(this.timers.get(key));
+                this.timers.delete(key);
+            });
+        };
+        /**
+         * Очистка таймеров,
+         * предполагается использование либо при срабатывании таймера,
+         * либо при досрочном вызове из внешней инвалидации
+         */
+        this.clean = (key) => {
+            globalThis.clearTimeout(this.timers.get(key));
+            this.timers.delete(key);
+            this.timerDates.delete(key);
+        };
+        /**
+         * Перезапуск имеющегося таймера, предполагается использование при срабатывании синхронизации между вкладками
+         */
+        this.restart = (key) => {
+            const saved = this.timerDates.get(key);
+            if (saved) {
+                this.setupTimer(key, saved.pollingTime);
+            }
+        };
+        this.invalidate = (key) => {
+            const query = this._queryStorage.get(key);
+            if (query) {
+                this._invalidateByKeyHash(key);
+            }
+            this.clean(key);
+        };
+        /**
+         * Установка таймера устаревания данных
+         */
+        this.setupTimer = (key, pollingTime) => {
+            if (this.timers.has(key)) {
+                globalThis.clearTimeout(this.timers.get(key));
+            }
+            if (!this._queryStorage.get(key)) {
+                return;
+            }
+            this.timerDates.set(key, {
+                pollingTime,
+                targetDate: Date.now() + pollingTime,
+            });
+            if (this.isVisible) {
+                this.timers.set(key, globalThis.setTimeout(() => this.invalidate(key), pollingTime));
+            }
+        };
+        this.init();
+    }
+}

package/PollingService/index.d.ts

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

package/PollingService/index.js

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

package/README.md

@@ -1098,6 +1098,28 @@ export type InfiniteQueryConfig = {
 };
 ```
 
+### Переодическая инвалидация (Поллинг)
+
+Для обеспечения автоматической инвалидации данных по указанному времени используйте настройку `pollingTime` при создании query.
+Значение необходимо указывать в милисекундах.
+
+```ts
+const TEN_MINUTES = 10 * 60 * 1000;
+
+docsfetcher.queries.document.createWithConfig(
+  {
+    pollingTime: TEN_MINUTES,
+  },
+  documenId,
+);
+
+docsfetcher.infiniteQueries.list.createWithConfig(
+  {
+    pollingTime: TEN_MINUTES,
+  },
+);
+```
+
 ### Mutation
 
 `Mutation` предназначен для отправки данных на сервер с целью произведения изменений.

package/SynchronizationService/SynchronizationService.d.ts

@@ -1,16 +1,16 @@
 import { type DataStorageFactory } from '../DataStorage';
+import { type Keys } from '../MobxQuery/types';
+import { type PollingService } from '../PollingService';
 import { type StatusStorageFactory } from '../StatusStorage';
 export declare class SynchronizationService {
     private readonly _statusStorageFactory;
     private readonly _dataStorageFactory;
+    private readonly _pollingService;
     private readonly broadcastChannel?;
-    constructor(_statusStorageFactory: StatusStorageFactory, _dataStorageFactory: DataStorageFactory, _BroadcastChannel?: {
+    constructor(_statusStorageFactory: StatusStorageFactory, _dataStorageFactory: DataStorageFactory, _pollingService: PollingService, _BroadcastChannel?: {
         new (name: string): BroadcastChannel;
         prototype: BroadcastChannel;
     });
     private init;
-    emit: (keys: {
-        dataKeyHash: string;
-        statusKeyHash: string;
-    }) => void;
+    emit: (keys: Keys) => void;
 }

package/SynchronizationService/SynchronizationService.js

@@ -1,7 +1,8 @@
 export class SynchronizationService {
-    constructor(_statusStorageFactory, _dataStorageFactory, _BroadcastChannel = globalThis.BroadcastChannel) {
+    constructor(_statusStorageFactory, _dataStorageFactory, _pollingService, _BroadcastChannel = globalThis.BroadcastChannel) {
         this._statusStorageFactory = _statusStorageFactory;
         this._dataStorageFactory = _dataStorageFactory;
+        this._pollingService = _pollingService;
         this.init = () => {
             var _a;
             (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.addEventListener('message', (event) => {
@@ -10,16 +11,12 @@ export class SynchronizationService {
                     .getStorage(event.data.dataKeyHash)) === null || _a === void 0 ? void 0 : _a.setData(event.data.data);
                 (_b = this._statusStorageFactory
                     .getStorage(event.data.statusKeyHash)) === null || _b === void 0 ? void 0 : _b.setStatues(event.data.statuses);
+                this._pollingService.restart(event.data.queryKeyHash);
             });
         };
         this.emit = (keys) => {
             var _a, _b, _c;
-            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage({
-                dataKeyHash: keys.dataKeyHash,
-                statusKeyHash: keys.statusKeyHash,
-                data: (_b = this._dataStorageFactory.getStorage(keys.dataKeyHash)) === null || _b === void 0 ? void 0 : _b.data,
-                statuses: (_c = this._statusStorageFactory.getStorage(keys.statusKeyHash)) === null || _c === void 0 ? void 0 : _c.statuses,
-            });
+            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage(Object.assign(Object.assign({}, keys), { data: (_b = this._dataStorageFactory.getStorage(keys.dataKeyHash)) === null || _b === void 0 ? void 0 : _b.data, statuses: (_c = this._statusStorageFactory.getStorage(keys.statusKeyHash)) === null || _c === void 0 ? void 0 : _c.statuses }));
         };
         if (_BroadcastChannel) {
             this.broadcastChannel = new _BroadcastChannel('@astral/mobx-query');

package/__test/BroadcastChannel/BroadcastChannel.d.ts

@@ -0,0 +1 @@
+export declare const createBroadcastChannelMock: () => typeof globalThis.BroadcastChannel;

package/__test/BroadcastChannel/BroadcastChannel.js

@@ -0,0 +1,13 @@
+// Мок не предусматривает полного повторения функционала оригинального BroadcastChannelMock
+// поэтому он будет вызывать даже подписчиков вкладки инициатора,
+// но благодаря общему подходу, ожидается, что это не вызовет проблем
+export const createBroadcastChannelMock = () => {
+    const listeners = [];
+    class BroadcastChannelMock {
+        constructor() {
+            this.addEventListener = (_, listener) => listeners.push(listener);
+            this.postMessage = (data) => listeners.forEach((listener) => listener({ data }));
+        }
+    }
+    return BroadcastChannelMock;
+};

package/__test/BroadcastChannel/index.d.ts

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

package/__test/BroadcastChannel/index.js

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