@wix/bex-core 1.402.0

package/dist/cjs/state/CollectionOptimisticActions.js

@@ -0,0 +1,725 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.CollectionOptimisticActions = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _mobx = require("mobx");
+var _CollectionOptimisticActionsState = require("./CollectionOptimisticActionsState");
+var _CollectionOptimisticProcessor = require("./CollectionOptimisticProcessor");
+var _CollectionOptimisticPatch = require("./CollectionOptimisticPatch");
+var _CollectionOptimisticExecutor = require("./CollectionOptimisticExecutor");
+var _events = require("events");
+var _QueryResultSimulationDefault = require("./QueryResultSimulationDefault");
+var _CollectionOptimisticSequenceExecutor = require("./CollectionOptimisticSequenceExecutor");
+class CollectionOptimisticActions {
+  get _queryNames() {
+    return [this.collection.queryName, ...this.collections.map(c => c.queryName)];
+  }
+  constructor(params) {
+    (0, _defineProperty2.default)(this, "collection", void 0);
+    (0, _defineProperty2.default)(this, "collections", void 0);
+    (0, _defineProperty2.default)(this, "predicate", void 0);
+    (0, _defineProperty2.default)(this, "orderBy", void 0);
+    (0, _defineProperty2.default)(this, "createdAt", void 0);
+    (0, _defineProperty2.default)(this, "events", new _events.EventEmitter());
+    (0, _defineProperty2.default)(this, "noInvalidate", void 0);
+    (0, _defineProperty2.default)(this, "state", void 0);
+    (0, _defineProperty2.default)(this, "processors", []);
+    (0, _defineProperty2.default)(this, "executor", void 0);
+    (0, _defineProperty2.default)(this, "sequences", new Map());
+    (0, _defineProperty2.default)(this, "resultSimulationDefault", void 0);
+    (0, _defineProperty2.default)(this, "reorderModeCanceledMessage", 'REORDER_MODE_CANCELED');
+    (0, _defineProperty2.default)(this, "_resumeNavigation", null);
+    (0, _defineProperty2.default)(this, "_orderByMode", 'orders');
+    (0, _defineProperty2.default)(this, "_clearPatch", (0, _mobx.action)(patch => {
+      const {
+        state,
+        collection,
+        collections,
+        noInvalidate
+      } = this;
+      if (noInvalidate) {
+        return;
+      }
+      state.patches.remove(patch);
+      collection.invalidate();
+      collections.forEach(p => p.refreshAllPages());
+    }));
+    (0, _defineProperty2.default)(this, "_clearPatchOnNextResultOrUnmount", patch => {
+      const {
+        events
+      } = this;
+      const clearPatch = () => {
+        events.off('unmount', clearPatch);
+        this._clearPatch(patch);
+      };
+      const onRefresh = ({
+        isStale
+      }) => {
+        events.off('refresh', onRefresh);
+
+        // clear only when results are not going to come from cache
+        if (isStale) {
+          events.once('beforeResultUpdated', clearPatch);
+        }
+      };
+
+      // Clear the patch on the next collection result update to eliminate inconsistencies between server state and local patches
+      events.on('refresh', onRefresh);
+      // since not clearing the patch immediately, clear it on unmount if was not cleared yet
+      events.on('unmount', clearPatch);
+      events.emit('updated');
+    });
+    this.collection = params.collection;
+    this.collections = params.collections ?? [];
+    this.state = new _CollectionOptimisticActionsState.CollectionOptimisticActionsState({
+      source: this.collection,
+      patchesCache: params.container.patchesCache,
+      cacheNamespace: params.cacheNamespace
+    });
+    this.resultSimulationDefault = new _QueryResultSimulationDefault.QueryResultSimulationDefault({
+      collection: this.collection
+    });
+    this.predicate = params.predicate ?? this.resultSimulationDefault.predicate;
+    this.orderBy = params.orderBy ?? this.resultSimulationDefault.orderBy;
+    this.createdAt = params.createdAt;
+    this.noInvalidate = params.noInvalidate;
+    this.executor = new _CollectionOptimisticExecutor.CollectionOptimisticExecutor({
+      batchWait: params.batchWait ?? 0,
+      errorMonitor: this.collection.errorMonitor,
+      showToast: this.collection.showToast,
+      translate: this.collection.translate,
+      lodash: this.collection.lodash,
+      container: params.container
+    });
+    this.processors.push(new _CollectionOptimisticProcessor.CollectionOptimisticProcessor({
+      ...params,
+      optimistic: this
+    }));
+    if (params.collections != null) {
+      params.collections.forEach(collection => {
+        this.processors.push(new _CollectionOptimisticProcessor.CollectionOptimisticProcessor({
+          ...params,
+          collection,
+          optimistic: this
+        }));
+      });
+    }
+    this.collection._optimisticActions = this;
+    (0, _mobx.makeObservable)(this, {
+      pushPatchAndReprocess: _mobx.action,
+      replacePatchAndReprocess: _mobx.action,
+      rollback: _mobx.action.bound,
+      clear: _mobx.action,
+      move: _mobx.action,
+      pendingMovePatches: _mobx.computed
+    });
+  }
+  rollback(patch) {
+    const {
+      events,
+      state
+    } = this;
+    const patches = Array.isArray(patch) ? patch : [patch];
+    for (const p of patches) {
+      state.patches.remove(p);
+    }
+    events.emit('reprocess');
+  }
+  get hasRunningSequence() {
+    return Array.from(this.sequences.values()).some(s => s.seq.state.running);
+  }
+  get pendingMovePatches() {
+    return this.state.patches.filter(p => p.move);
+  }
+  pushPatchAndReprocess(patch) {
+    const {
+      state,
+      events
+    } = this;
+    const patches = Array.isArray(patch) ? patch : [patch];
+    state.patches.push(...patches);
+    events.emit('reprocess');
+  }
+  replacePatchAndReprocess(newPatch, oldPatch) {
+    const {
+      state,
+      events
+    } = this;
+    const oldPatchIndex = state.patches.findIndex(patch => patch === oldPatch);
+    state.patches[oldPatchIndex] = newPatch;
+    events.emit('reprocess');
+  }
+
+  /**
+   * @deprecated Use createOne instead
+   */
+  addOne(item, params = {}) {
+    return this.addMany([item], params);
+  }
+
+  /**
+   * @deprecated Use createMany instead
+   */
+  addMany(items, params = {}) {
+    const {
+      collection,
+      executor
+    } = this;
+    const {
+      itemKey,
+      result
+    } = collection;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      queryCache: collection.queryCache,
+      queryNames: this._queryNames,
+      patches: this.state.patches,
+      actionType: 'createMany',
+      patchedItems: new Map(items.map(item => [itemKey(item), item])),
+      originalItems: new Map(),
+      originalTotal: result.total,
+      patch: (item, {
+        patchedItems
+      }) => patchedItems.get(itemKey(item)),
+      selector: (item, {
+        patchedItems
+      }) => patchedItems.has(itemKey(item))
+    });
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    return executor.execute([optimisticPatch], {
+      ...params,
+      submit: (0, _mobx.action)(actions => submit == null ? void 0 : submit(Array.from(actions.filter(({
+        actionType
+      }) => actionType === 'createMany').reduce((map, {
+        patchedItemsEntries
+      }) => {
+        for (const [key, item] of patchedItemsEntries) {
+          map.set(key, item);
+        }
+        return map;
+      }, new Map()).values()))),
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  createOne(item, params) {
+    this.createMany([item], params);
+  }
+  createMany(items, params) {
+    const {
+      collection,
+      executor
+    } = this;
+    const {
+      itemKey,
+      result
+    } = collection;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const optimisticPatchParams = {
+      queryCache: collection.queryCache,
+      queryNames: this._queryNames,
+      patches: this.state.patches,
+      actionType: 'createMany',
+      patchedItems: new Map(items.map(item => [itemKey(item), item])),
+      originalItems: new Map(),
+      originalTotal: result.total,
+      patch: (item, {
+        patchedItems
+      }) => patchedItems.get(itemKey(item)),
+      selector: (item, {
+        patchedItems
+      }) => patchedItems.has(itemKey(item))
+    };
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch(optimisticPatchParams);
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    return executor.execute([optimisticPatch], {
+      ...params,
+      submit: (0, _mobx.action)(async actions => {
+        const submitResult = await submit(Array.from(actions.filter(({
+          actionType
+        }) => actionType === 'createMany').reduce((map, {
+          patchedItemsEntries
+        }) => {
+          for (const [key, item] of patchedItemsEntries) {
+            map.set(key, item);
+          }
+          return map;
+        }, new Map()).values()));
+        const updatedOptimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+          ...optimisticPatchParams,
+          patchedItems: new Map(submitResult.map(item => [itemKey(item), item]))
+        });
+        this.replacePatchAndReprocess(updatedOptimisticPatch, optimisticPatch);
+        return submitResult;
+      }),
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  async updateMany(items, params) {
+    const {
+      executor,
+      collection
+    } = this;
+    const {
+      itemKey,
+      result
+    } = collection;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      keepPosition,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      queryCache: collection.queryCache,
+      queryNames: this._queryNames,
+      patches: this.state.patches,
+      actionType: 'updateMany',
+      keepPosition,
+      patchedItems: new Map(items.map(item => [itemKey(item), item])),
+      originalItems: new Map(items.map(item => {
+        var _result$get;
+        const key = itemKey(item);
+        const originalItem = ((_result$get = result.get(itemKey(item))) == null ? void 0 : _result$get.item) ?? item;
+        return [key, originalItem];
+      })),
+      originalTotal: result.total,
+      patch: (item, {
+        patchedItems
+      }) => patchedItems.get(itemKey(item)),
+      selector: (item, {
+        patchedItems
+      }) => patchedItems.has(itemKey(item))
+    });
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    return executor.execute([optimisticPatch], {
+      ...params,
+      submit: (0, _mobx.action)(actions => submit(Array.from(actions.filter(({
+        actionType
+      }) => actionType === 'updateMany').reduce((map, {
+        patchedItemsEntries
+      }) => {
+        for (const [key, item] of patchedItemsEntries) {
+          map.set(key, item);
+        }
+        return map;
+      }, new Map()).values()))),
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  enqueueMovePatch(optimisticPatch, params) {
+    const {
+      submit,
+      onTryAgain
+    } = params;
+    const {
+      collection,
+      state,
+      events
+    } = this;
+    const {
+      query
+    } = collection;
+    const {
+      patches
+    } = state;
+    const {
+      filtersKeyHash
+    } = query;
+    const event = optimisticPatch.move;
+    if (event == null) {
+      return;
+    }
+    const _initSequence = () => {
+      const {
+        sequences
+      } = this;
+      const seq = sequences.get(filtersKeyHash) ?? new _CollectionOptimisticSequenceExecutor.CollectionOptimisticSequenceExecutor({
+        showToast: collection.showToast,
+        translate: collection.translate,
+        errorMonitor: collection.errorMonitor,
+        onRollback: err => {
+          const pendingPatches = patches.filter(p => {
+            var _p$move;
+            return ((_p$move = p.move) == null ? void 0 : _p$move.filtersKeyHash) === filtersKeyHash;
+          });
+          this.rollback(pendingPatches);
+          if (err instanceof Error && err.message === this.reorderModeCanceledMessage) {
+            executor.seq.clear();
+            return;
+          }
+          events.emit('dragAndDropSequenceError', {
+            patches: pendingPatches
+          });
+          executor.seq.clear();
+          return {
+            message: collection.translate('cairo.dragAndDrop.error.toast'),
+            biName: 'cairo-drag-and-drop-submit-error',
+            action: {
+              onClick: async () => {
+                this.pushPatchAndReprocess(pendingPatches);
+                for (const p of pendingPatches) {
+                  this.enqueueMovePatch(p, params);
+                }
+                events.emit('dragAndDropSequenceRetry', {
+                  patches: pendingPatches
+                });
+                await (onTryAgain == null ? void 0 : onTryAgain());
+              }
+            }
+          };
+        }
+      });
+      if (!sequences.has(filtersKeyHash)) {
+        sequences.set(filtersKeyHash, seq);
+      }
+      return seq;
+    };
+    const executor = _initSequence();
+    executor.sequence({
+      submit: () => submit == null ? void 0 : submit(event),
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated
+    });
+  }
+  async move(event, params) {
+    const {
+      collection,
+      state
+    } = this;
+    const {
+      itemKey,
+      result,
+      query
+    } = collection;
+    const {
+      patches
+    } = state;
+    const {
+      filtersKeyHash
+    } = query;
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      queryCache: collection.queryCache,
+      queryNames: this._queryNames,
+      patches,
+      actionType: 'move',
+      patchedItems: new Map(),
+      originalItems: new Map(),
+      originalTotal: result.total,
+      selector: (item, {
+        patchedItems
+      }) => patchedItems.has(itemKey(item)),
+      move: {
+        ...event,
+        filtersKeyHash
+      },
+      collectionSnapshot: params.collectionSnapshot
+    });
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    this.enqueueMovePatch(optimisticPatch, params);
+  }
+  async updateOne(item, params) {
+    return this.updateMany([item], params);
+  }
+
+  /**
+   * @deprecated `updateAll(fn)` API is not recommended as it's not possible to calculate "optimistic total", prefer updateAll(patchObject) API.
+   */
+
+  async updateAll(patchOrFn, params) {
+    const {
+      executor,
+      collection,
+      predicate,
+      createdAt
+    } = this;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      keepPosition,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const {
+      itemKey,
+      result: {
+        originQuery,
+        items,
+        total
+      }
+    } = collection;
+    const itemPredicate = predicate(originQuery);
+    const updatedAt = new Date();
+    const {
+      patch,
+      actionType
+    } = typeof patchOrFn === 'function' ? {
+      actionType: 'updateAll',
+      patch: patchOrFn
+    } : {
+      actionType: 'updateAllConst',
+      patch: item => ({
+        ...item,
+        ...patchOrFn
+      })
+    };
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      queryCache: collection.queryCache,
+      patches: this.state.patches,
+      actionType,
+      keepPosition,
+      queryNames: this._queryNames,
+      patchedItems: new Map(items.map(item => [itemKey(item), {
+        ...item,
+        ...patch(item)
+      }])),
+      originalItems: new Map(items.map(item => [itemKey(item), item])),
+      originalTotal: total,
+      selector: item => itemPredicate(item) && (createdAt == null || createdAt(item) <= updatedAt),
+      patch
+    });
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    executor.execute([optimisticPatch], {
+      ...params,
+      submit,
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  deleteMany(items, params) {
+    const {
+      executor,
+      collection
+    } = this;
+    const {
+      itemKey,
+      result: {
+        total
+      }
+    } = collection;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const patchedItems = new Map(items.map(item => [itemKey(item), item]));
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      queryCache: collection.queryCache,
+      patches: this.state.patches,
+      actionType: 'deleteMany',
+      patchedItems,
+      queryNames: this._queryNames,
+      originalItems: patchedItems,
+      originalTotal: total,
+      selector: (item, {
+        patchedItems
+      }) => patchedItems.has(itemKey(item))
+    });
+    this.pushPatchAndReprocess(optimisticPatch);
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    executor.execute([optimisticPatch], {
+      ...params,
+      submit: (0, _mobx.action)(actions => submit(Array.from(actions.filter(({
+        actionType
+      }) => actionType === 'deleteMany').reduce((map, {
+        patchedItemsEntries
+      }) => {
+        for (const [key, item] of patchedItemsEntries) {
+          map.set(key, item);
+        }
+        return map;
+      }, new Map()).values()))),
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  deleteOne(item, params) {
+    return this.deleteMany([item], params);
+  }
+  async deleteAll(params) {
+    const {
+      executor,
+      collection,
+      predicate,
+      createdAt
+    } = this;
+    const {
+      submit,
+      serverEventuallyUpdated,
+      onUndo,
+      onTryAgain,
+      onError
+    } = params;
+    const {
+      itemKey,
+      result: {
+        originQuery,
+        items,
+        total
+      }
+    } = collection;
+    const itemPredicate = predicate(originQuery);
+    const updatedAt = new Date();
+    const patchedItems = new Map(items.map(item => [itemKey(item), item]));
+    const optimisticPatch = new _CollectionOptimisticPatch.OptimisticPatch({
+      patches: this.state.patches,
+      queryCache: collection.queryCache,
+      actionType: 'deleteAll',
+      patchedItems,
+      queryNames: this._queryNames,
+      originalItems: patchedItems,
+      originalTotal: total,
+      selector: item => itemPredicate(item) && (createdAt == null || createdAt(item) <= updatedAt)
+    });
+    optimisticPatch.events.on('scheduleRemoval', this._clearPatchOnNextResultOrUnmount);
+    this.pushPatchAndReprocess(optimisticPatch);
+    executor.execute([optimisticPatch], {
+      ...params,
+      submit,
+      onRollback: () => {
+        this.rollback(optimisticPatch);
+      },
+      eventuallyUpdated: serverEventuallyUpdated,
+      onEventuallyUpdated: optimisticPatch.onEventuallyUpdated,
+      onTryAgain: async () => {
+        this.pushPatchAndReprocess(optimisticPatch);
+        await (onTryAgain == null ? void 0 : onTryAgain());
+      },
+      onError,
+      onUndo
+    });
+  }
+  initCollection(collection) {
+    this.collections.push(collection);
+    const processor = new _CollectionOptimisticProcessor.CollectionOptimisticProcessor({
+      collection,
+      optimistic: this,
+      orderBy: this.orderBy,
+      predicate: this.predicate
+    });
+    const dispose = processor.init();
+    return () => {
+      const i = this.collections.indexOf(collection);
+      if (i !== -1) {
+        this.collections.splice(i, 1);
+      }
+      dispose();
+    };
+  }
+  init() {
+    const {
+      collection,
+      processors,
+      events
+    } = this;
+    const emitRefresh = params => {
+      events.emit('refresh', params);
+    };
+    const emitBeforeResultUpdated = () => events.emit('beforeResultUpdated');
+    collection.emitter.on('refresh', emitRefresh);
+    collection.emitter.on('beforeResultUpdated', emitBeforeResultUpdated);
+    const disposers = [(0, _mobx.reaction)(() => {
+      const {
+        result: {
+          isEmpty,
+          _pages
+        }
+      } = collection;
+      const unprocessed = _pages.unprocessed.flatMap(page => page);
+      return isEmpty && unprocessed.length > 0;
+    }, allFilteredOut => {
+      if (allFilteredOut) {
+        collection.fetchNextPageIfNeeded();
+      }
+    }), ...processors.map(p => p.init())];
+    return () => {
+      collection.emitter.off('refresh', emitRefresh);
+      collection.emitter.off('beforeResultUpdated', emitBeforeResultUpdated);
+      disposers.forEach(disposer => disposer());
+      events.emit('unmount');
+    };
+  }
+  clear() {
+    const {
+      patches
+    } = this.state;
+    const remaining = patches.clear();
+    for (const patch of remaining) {
+      if (!patch.isStale) {
+        patches.push(patch);
+      }
+    }
+  }
+}
+exports.CollectionOptimisticActions = CollectionOptimisticActions;
+//# sourceMappingURL=CollectionOptimisticActions.js.map