@astral/mobx-query 1.8.0 → 1.9.0

package/node/AuxiliaryQuery/AuxiliaryQuery.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuxiliaryQuery = void 0;
+const mobx_1 = require("mobx");
+/**
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
+ * содержащее флаги загрузки и ошибки,
+ * колбэки на успешный запрос и на ошибку,
+ * данные последней ошибки,
+ * а так же, управляющее синглтон промисом.
+ */
+class AuxiliaryQuery {
+    constructor(statusStorage, backgroundStatusStorage) {
+        this.statusStorage = statusStorage;
+        this.backgroundStatusStorage = backgroundStatusStorage;
+        /**
+         * Флаг, обозначающий простаивание, т.е. запроса еще не было
+         */
+        this.isIdle = true;
+        /**
+         * Флаг, по которому реактивно определяется необходимость запуска инвалидации
+         */
+        this.isInvalid = false;
+        /**
+         * Метод ответственный за создание единого промиса,
+         * для устранения гонки запросов
+         */
+        this.getUnifiedPromise = (executor, onSuccess) => {
+            // проверяем, если синглтона нет, то надо создать
+            if (!Boolean(this.unifiedPromise)) {
+                this.startLoading();
+                this.unifiedPromise = executor()
+                    .then((resData) => {
+                    (0, mobx_1.runInAction)(this.submitSuccess);
+                    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(resData);
+                    return resData;
+                })
+                    .catch((e) => {
+                    (0, mobx_1.runInAction)(() => {
+                        this.submitError(e);
+                    });
+                    throw e;
+                })
+                    .finally(() => {
+                    this.unifiedPromise = undefined;
+                    (0, mobx_1.runInAction)(() => {
+                        this.statusStorage.isLoading = false;
+                    });
+                });
+            }
+            return this.unifiedPromise;
+        };
+        this.setSuccess = (storage) => {
+            storage.isError = false;
+            storage.isSuccess = true;
+        };
+        this.checkBackgroundAndSet = (setStorage) => {
+            if (this.backgroundStatusStorage && this.statusStorage.isSuccess) {
+                setStorage(this.backgroundStatusStorage);
+            }
+            else {
+                setStorage(this.statusStorage);
+            }
+        };
+        /**
+         * Обработчик успешного ответа
+         */
+        this.submitSuccess = () => {
+            this.checkBackgroundAndSet(this.setSuccess);
+            this.isInvalid = false;
+        };
+        this.setError = (storage, error) => {
+            storage.isSuccess = false;
+            storage.isError = true;
+            storage.error = error;
+        };
+        /**
+         * Обработчик ошибки
+         */
+        this.submitError = (error) => {
+            this.checkBackgroundAndSet((storage) => this.setError(storage, error));
+        };
+        this.setLoading = (storage) => {
+            storage.isLoading = true;
+            storage.isError = false;
+            storage.isSuccess = false;
+        };
+        /**
+         * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+         */
+        this.startLoading = () => {
+            this.isIdle = false;
+            this.checkBackgroundAndSet(this.setLoading);
+        };
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.isInvalid = true;
+        };
+        (0, mobx_1.makeObservable)(this, {
+            getUnifiedPromise: mobx_1.action,
+            isIdle: mobx_1.observable,
+            isInvalid: mobx_1.observable,
+            submitSuccess: mobx_1.action,
+            setSuccess: mobx_1.action,
+            setError: mobx_1.action,
+            setLoading: mobx_1.action,
+            submitError: mobx_1.action,
+            startLoading: mobx_1.action,
+            invalidate: mobx_1.action,
+        });
+    }
+}
+exports.AuxiliaryQuery = AuxiliaryQuery;

package/node/AuxiliaryQuery/index.d.ts

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

package/node/AuxiliaryQuery/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AuxiliaryQuery"), exports);

package/node/DataStorage/DataStorage.d.ts

@@ -0,0 +1,33 @@
+import { StorageFactory } from '../StorageFactory';
+/**
+ * Хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ */
+export declare class DataStorage<TData> {
+    /**
+     * Поле, отвечающее за непосредственное хранение данных
+     */
+    private internalData?;
+    constructor();
+    /**
+     * Флаг, отображающий наличие данных
+     */
+    get hasData(): boolean;
+    /**
+     * Метод для установки данных
+     */
+    setData: (value: TData) => void;
+    /**
+     * Геттер данных
+     */
+    get data(): TData | undefined;
+}
+/**
+ * Фабрика ответственная за создание и хранение экземляров хранилищ
+ */
+export declare class DataStorageFactory extends StorageFactory<DataStorage<unknown>> {
+    constructor();
+    /**
+     * Фабричный метод получения/создания инстанса хранилища по ключу
+     */
+    getStorage: <TData>(keyHash: string) => DataStorage<TData>;
+}

package/node/DataStorage/DataStorage.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorageFactory = exports.DataStorage = void 0;
+const mobx_1 = require("mobx");
+const StorageFactory_1 = require("../StorageFactory");
+/**
+ * Хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ */
+class DataStorage {
+    constructor() {
+        /**
+         * Поле, отвечающее за непосредственное хранение данных
+         */
+        this.internalData = undefined;
+        /**
+         * Метод для установки данных
+         */
+        this.setData = (value) => {
+            this.internalData = value;
+        };
+        (0, mobx_1.makeAutoObservable)(this);
+    }
+    /**
+     * Флаг, отображающий наличие данных
+     */
+    get hasData() {
+        return Boolean(this.internalData);
+    }
+    /**
+     * Геттер данных
+     */
+    get data() {
+        return this.internalData;
+    }
+}
+exports.DataStorage = DataStorage;
+/**
+ * Фабрика ответственная за создание и хранение экземляров хранилищ
+ */
+class DataStorageFactory extends StorageFactory_1.StorageFactory {
+    constructor() {
+        super(() => new DataStorage());
+        /**
+         * Фабричный метод получения/создания инстанса хранилища по ключу
+         */
+        this.getStorage = (keyHash) => {
+            return this.getInternalStorage(keyHash);
+        };
+    }
+}
+exports.DataStorageFactory = DataStorageFactory;

package/node/DataStorage/index.d.ts

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

package/node/DataStorage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DataStorage"), exports);

package/node/InfiniteQuery/InfiniteQuery.d.ts

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

package/node/InfiniteQuery/InfiniteQuery.js

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

package/node/InfiniteQuery/index.d.ts

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

package/node/InfiniteQuery/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./InfiniteQuery"), exports);