@astral/mobx-query 1.18.3 → 1.19.0

package/node/InfiniteQuery/InfiniteQuery.js

@@ -4,28 +4,47 @@ exports.InfiniteQuery = exports.DEFAULT_INFINITE_ITEMS_COUNT = void 0;
 const mobx_1 = require("mobx");
 const AuxiliaryQuery_1 = require("../AuxiliaryQuery");
 const QueryContainer_1 = require("../QueryContainer");
+const StatusStorage_1 = require("../StatusStorage");
 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, }) {
+    constructor(executor, { incrementCount = exports.DEFAULT_INFINITE_ITEMS_COUNT, initialOffset = 0, initialCursor, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
         super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery_1.AuxiliaryQuery(statusStorage, backgroundStatusStorage));
         this.executor = executor;
+        /**
+         * Хранилище статусов для процесса дозапроса данных
+         */
+        this.fetchMoreStatusStorage = new StatusStorage_1.StatusStorage();
+        /**
+         * Стартовый offset для запроса,
+         */
+        this.initialOffset = 0;
+        /**
+         * Стартовое значение курсора, от которого должен произойти первый запрос.
+         * Предполагается, что этот элемент должен содержать только id сущности.
+         */
+        this.initialCursor = undefined;
         /**
          * Обработчик успешного запроса, проверяет что мы достигли предела
          */
-        this.submitSuccess = (result, isEndReached) => {
+        this.submitSuccess = (result, isLimitReached, isBackward) => {
             var _a;
             this.storage.setData((current) => ({
                 offset: current === null || current === void 0 ? void 0 : current.offset,
                 data: result,
-                isEndReached,
+                isEndReached: isBackward
+                    ? Boolean(current === null || current === void 0 ? void 0 : current.isEndReached)
+                    : isLimitReached,
+                isStartReached: isBackward
+                    ? isLimitReached
+                    : Boolean(current === null || current === void 0 ? void 0 : current.isStartReached),
             }));
             (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
         };
-        this.calcIsEndReachedByResult = (result) => {
+        this.calcIsLimitReachedByResult = (result) => {
             // убеждаемся что результат запроса действительно массив,
             // и если количество элементов в ответе меньше,
             // чем запрашивалось, значит у бэка их больше нет,
@@ -50,34 +69,72 @@ class InfiniteQuery extends QueryContainer_1.QueryContainer {
                 this.submitSuccess(param, this.isEndReached);
             }
         };
+        /**
+         * Метод для обогащения параметров текущими значениями для инфинити
+         */
+        this.makeInfiniteExecutor = (offset, cursor, direction) => () => this.executor({
+            offset,
+            count: this.incrementCount,
+            cursor,
+            direction,
+        });
         /**
          * Метод для инвалидации данных
          */
         this.invalidate = () => {
             this.auxiliary.invalidate();
         };
+        this.setOffset = (offset) => {
+            this.storage.setData((current) => ({
+                offset,
+                data: current === null || current === void 0 ? void 0 : current.data,
+                isEndReached: Boolean(current === null || current === void 0 ? void 0 : current.isEndReached),
+                isStartReached: Boolean(current === null || current === void 0 ? void 0 : current.isStartReached),
+            }));
+        };
         /**
          * Метод для запроса следующего набора данных
+         * @param options - параметры дозапроса данных
          */
-        this.fetchMore = () => {
+        this.fetchMore = (options) => {
+            var _a, _b;
+            const { direction = 'forward', onSuccess } = options !== null && options !== void 0 ? options : {};
+            const isBackward = direction === 'backward';
+            const isLimitReached = isBackward ? this.isStartReached : this.isEndReached;
             // если мы еще не достигли предела
-            if (!this.isEndReached && this.storage.data) {
-                // прибавляем к офсету число запрашиваемых элементов
-                this.storage.setData((current) => {
-                    var _a;
-                    return ({
-                        offset: ((_a = current === null || current === void 0 ? void 0 : current.offset) !== null && _a !== void 0 ? _a : 0) + this.incrementCount,
-                        data: current === null || current === void 0 ? void 0 : current.data,
-                        isEndReached: Boolean(current === null || current === void 0 ? void 0 : current.isEndReached),
-                    });
-                });
+            if (!isLimitReached && this.storage.data) {
+                this.fetchMoreStatusStorage.setStartLoading();
+                const offsetBeforeExecute = this.offset;
+                const increment = (isBackward ? -1 : 1) * this.incrementCount;
+                const cursor = isBackward
+                    ? (_a = this.data) === null || _a === void 0 ? void 0 : _a[0]
+                    : (_b = this.data) === null || _b === void 0 ? void 0 : _b[this.data.length - 1];
+                // прибавляем к offset число запрашиваемых элементов
+                const requestedOffset = Math.max(offsetBeforeExecute + increment, 0);
+                this.setOffset(requestedOffset);
                 // запускаем запрос с последними параметрами, и флагом необходимости инкремента
                 this.auxiliary
-                    .getUnifiedPromise(this.infiniteExecutor, (resData) => {
+                    .getUnifiedPromise(this.makeInfiniteExecutor(requestedOffset, cursor, direction), (resData) => {
+                    var _a;
+                    this.fetchMoreStatusStorage.setSuccess();
+                    const currentData = (_a = this.storage.data) === null || _a === void 0 ? void 0 : _a.data;
+                    const result = isBackward
+                        ? [...resData, ...currentData]
+                        : [...currentData, ...resData];
+                    this.submitSuccess(result, this.calcIsLimitReachedByResult(resData), isBackward);
+                    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess({
+                        offset: requestedOffset,
+                        cursor: cursor,
+                    });
+                })
+                    .catch((e) => {
                     var _a;
-                    this.submitSuccess([...(_a = this.storage.data) === null || _a === void 0 ? void 0 : _a.data, ...resData], this.calcIsEndReachedByResult(resData));
+                    this.fetchMoreStatusStorage.setError(e);
+                    // в случае ошибки, откатываем значение offset к состоянию до дозапроса
+                    this.setOffset(offsetBeforeExecute);
+                    return (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
                 })
-                    .catch((e) => { var _a; return (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e); });
+                    .finally(this.fetchMoreStatusStorage.setEndLoading);
             }
         };
         /**
@@ -99,14 +156,15 @@ class InfiniteQuery extends QueryContainer_1.QueryContainer {
          */
         this.proceedSync = ({ onSuccess, onError, } = {}) => {
             this.storage.setData((current) => ({
-                offset: 0,
+                offset: (this.isIdle && this.initialOffset) || 0,
                 data: current === null || current === void 0 ? void 0 : current.data,
                 isEndReached: false,
+                isStartReached: false,
             }));
             this.auxiliary
-                .getUnifiedPromise(this.infiniteExecutor, (resData) => {
+                .getUnifiedPromise(this.makeInfiniteExecutor(this.offset, this.isIdle ? this.initialCursor : undefined), (resData) => {
                 onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(resData);
-                this.submitSuccess(resData, this.calcIsEndReachedByResult(resData));
+                this.submitSuccess(resData, this.calcIsLimitReachedByResult(resData));
             })
                 .catch((e) => {
                 var _a;
@@ -133,12 +191,15 @@ class InfiniteQuery extends QueryContainer_1.QueryContainer {
                 return Promise.resolve((_a = this.storage.data) === null || _a === void 0 ? void 0 : _a.data);
             }
             this.storage.setData((current) => ({
-                offset: 0,
+                offset: (this.isIdle && this.initialOffset) || 0,
                 data: current === null || current === void 0 ? void 0 : current.data,
                 isEndReached: false,
+                isStartReached: false,
             }));
-            return this.auxiliary.getUnifiedPromise(this.infiniteExecutor, (data) => this.submitSuccess(data, this.calcIsEndReachedByResult(data)));
+            return this.auxiliary.getUnifiedPromise(this.makeInfiniteExecutor(this.offset, this.isIdle ? this.initialCursor : undefined), (data) => this.submitSuccess(data, this.calcIsLimitReachedByResult(data)));
         };
+        this.initialOffset = initialOffset;
+        this.initialCursor = initialCursor;
         this.storage = dataStorage;
         this.incrementCount = incrementCount;
         this.defaultOnError = onError;
@@ -146,15 +207,16 @@ class InfiniteQuery extends QueryContainer_1.QueryContainer {
         this.defaultFetchPolicy = fetchPolicy;
         this.submitValidity = submitValidity;
         (0, mobx_1.makeObservable)(this, {
+            fetchMoreStatus: mobx_1.computed,
             data: mobx_1.computed,
             computedData: 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.computed,
+            isStartReached: mobx_1.computed,
         });
     }
     get isNetworkOnly() {
@@ -175,13 +237,14 @@ class InfiniteQuery extends QueryContainer_1.QueryContainer {
         return Boolean((_a = this.storage.data) === null || _a === void 0 ? void 0 : _a.isEndReached);
     }
     /**
-     * Метод для обогащения параметров текущими значениями для инфинити
+     * Флаг того, что мы достигли самого начала запрашиваемых элементов
      */
-    get infiniteExecutor() {
-        return () => this.executor({
-            offset: this.offset,
-            count: this.incrementCount,
-        });
+    get isStartReached() {
+        var _a;
+        return Boolean((_a = this.storage.data) === null || _a === void 0 ? void 0 : _a.isStartReached);
+    }
+    get fetchMoreStatus() {
+        return this.fetchMoreStatusStorage.statuses;
     }
     get computedData() {
         var _a;

package/node/MobxQuery/MobxQuery.js

@@ -111,8 +111,9 @@ class MobxQuery {
          */
         this.getCachedQuery = (key, createInstance, type, createParams) => {
             var _a, _b;
+            const enabledAutoFetch = (_a = createParams === null || createParams === void 0 ? void 0 : createParams.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch;
             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 keys = this.makeKeys(key, fetchPolicy, (_b = createParams === null || createParams === void 0 ? void 0 : createParams.isBackground) !== null && _b !== void 0 ? _b : false, type, enabledAutoFetch);
             const cachedQuery = this.queriesMap.get(keys.queryKeyHash);
             if (cachedQuery) {
                 return cachedQuery;
@@ -120,7 +121,7 @@ class MobxQuery {
             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,
+                enabledAutoFetch,
                 fetchPolicy,
                 dataStorage: this.queryDataStorageFactory.getStorage(keys.dataKeyHash),
                 statusStorage: this.statusStorageFactory.getStorage(keys.statusKeyHash),
@@ -137,7 +138,7 @@ class MobxQuery {
         /**
          * Метод для создания ключей к внутренним хранилищам
          */
-        this.makeKeys = (rootKey, fetchPolicy, isBackground, type) => {
+        this.makeKeys = (rootKey, fetchPolicy, isBackground, type, enabledAutoFetch) => {
             // C введением StrictMode в реакт 18, проявилась проблема,
             // что network-only квери, созданные в одном реакт компоненте,
             // создаются дважды (т.к. все хуки вызываются дважды)
@@ -151,7 +152,10 @@ class MobxQuery {
             // Этот кейс крайне маловероятен, и будет проявляться только в дев режиме с включенным StrictMode,
             // поэтому мы пренебрегаем решением этой проблемы, в угоду упрощения.
             const date = fetchPolicy === 'network-only' ? new Date().setMilliseconds(0) : null;
-            const queryKey = [...rootKey, { fetchPolicy, date, isBackground, type }];
+            const queryKey = [
+                ...rootKey,
+                { fetchPolicy, date, isBackground, type, enabledAutoFetch },
+            ];
             const queryKeyHash = this.serialize(queryKey);
             const dataKeyHash = this.serialize([...rootKey, { type }]);
             const statusKeyHash = this.serialize([...rootKey, { type, date }]);

package/node/Sets/InfiniteQuerySet/InfiniteQuerySet.d.ts

@@ -7,7 +7,7 @@ export type InfiniteQuerySetConfig = {
 };
 export type InfiniteQuerySetConfigurator<TParams extends any[], TResponse> = (...params: TParams) => {
     keys?: CacheKey[];
-    execute: (infiniteParams: InfiniteParams) => Promise<TResponse[]>;
+    execute: (infiniteParams: InfiniteParams<TResponse>) => Promise<TResponse[]>;
 };
 /**
  * Набор infinite queries под одним ключем с целью повышения читаемости кода и удобства инвалидации по общему ключу

package/node/StatusStorage/StatusStorage.d.ts

@@ -24,6 +24,10 @@ export declare class StatusStorage<TError> implements Statuses<TError> {
      */
     isSuccess: boolean;
     setStatues: (data: Statuses<TError>) => void;
+    setStartLoading: () => void;
+    setError: (error: TError) => void;
+    setSuccess: () => void;
+    setEndLoading: () => void;
     get statuses(): Statuses<TError>;
 }
 export declare class StatusStorageFactory extends StorageFactory<StatusStorage<any>> {

package/node/StatusStorage/StatusStorage.js

@@ -27,6 +27,24 @@ class StatusStorage {
             this.error = data.error;
             this.isSuccess = data.isSuccess;
         };
+        this.setStartLoading = () => {
+            this.isLoading = true;
+            this.isError = false;
+            this.isSuccess = false;
+        };
+        this.setError = (error) => {
+            this.isSuccess = false;
+            this.isError = true;
+            this.error = error;
+        };
+        this.setSuccess = () => {
+            this.error = undefined;
+            this.isError = false;
+            this.isSuccess = true;
+        };
+        this.setEndLoading = () => {
+            this.isLoading = false;
+        };
         (0, mobx_1.makeAutoObservable)(this);
     }
     get statuses() {

package/package.json

@@ -10,7 +10,7 @@
   "peerDependencies": {
     "mobx": "^6.0.0"
   },
-  "version": "1.18.3",
+  "version": "1.19.0",
   "author": "Astral.Soft",
   "license": "MIT",
   "repository": {