@igo2/common 1.15.4 → 16.0.0-rc.0

package/esm2022/lib/entity/shared/strategies/filter-custom-function.mjs

@@ -0,0 +1,80 @@
+import { EntityStoreStrategy } from './strategy';
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+export class EntityStoreFilterCustomFuncStrategy extends EntityStoreStrategy {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Store / filter ids map
+     */
+    filters = new Map();
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.filterStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unfilterStore(store);
+        }
+    }
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    doActivate() {
+        this.filterAll();
+    }
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    doDeactivate() {
+        this.unfilterAll();
+    }
+    /**
+     * Filter all stores
+     */
+    filterAll() {
+        this.stores.forEach((store) => this.filterStore(store));
+    }
+    /**
+     * Unfilter all stores
+     */
+    unfilterAll() {
+        this.stores.forEach((store) => this.unfilterStore(store));
+    }
+    /**
+     * Filter a store and add it to the filters map
+     */
+    filterStore(store) {
+        this.filters.set(store, store.stateView.addFilter(this.options.filterClauseFunc));
+    }
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    unfilterStore(store) {
+        const filterId = this.filters.get(store);
+        if (filterId === undefined) {
+            return;
+        }
+        store.stateView.removeFilter(filterId);
+        this.filters.delete(store);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/entity/shared/strategies/filter-selection.mjs

@@ -0,0 +1,81 @@
+import { EntityStoreStrategy } from './strategy';
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+export class EntityStoreFilterSelectionStrategy extends EntityStoreStrategy {
+    /**
+     * Store / filter ids map
+     */
+    filters = new Map();
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.filterStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unfilterStore(store);
+        }
+    }
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    doActivate() {
+        this.filterAll();
+    }
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    doDeactivate() {
+        this.unfilterAll();
+    }
+    /**
+     * Filter all stores
+     */
+    filterAll() {
+        this.stores.forEach((store) => this.filterStore(store));
+    }
+    /**
+     * Unfilter all stores
+     */
+    unfilterAll() {
+        this.stores.forEach((store) => this.unfilterStore(store));
+    }
+    /**
+     * Filter a store and add it to the filters map
+     */
+    filterStore(store) {
+        if (this.filters.has(store)) {
+            return;
+        }
+        const filter = (record) => {
+            return record.state.selected === true;
+        };
+        this.filters.set(store, store.stateView.addFilter(filter));
+    }
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    unfilterStore(store) {
+        const filterId = this.filters.get(store);
+        if (filterId === undefined) {
+            return;
+        }
+        store.stateView.removeFilter(filterId);
+        this.filters.delete(store);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXNlbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9zcmMvbGliL2VudGl0eS9zaGFyZWQvc3RyYXRlZ2llcy9maWx0ZXItc2VsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVqRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sa0NBQW1DLFNBQVEsbUJBQW1CO0lBQ3pFOztPQUVHO0lBQ0ssT0FBTyxHQUE2QixJQUFJLEdBQUcsRUFBRSxDQUFDO0lBRXREOzs7T0FHRztJQUNILFNBQVMsQ0FBQyxLQUFrQjtRQUMxQixLQUFLLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3ZCLElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxJQUFJLEVBQUU7WUFDeEIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztTQUN6QjtJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSCxXQUFXLENBQUMsS0FBa0I7UUFDNUIsS0FBSyxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QixJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssSUFBSSxFQUFFO1lBQ3hCLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDM0I7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ08sVUFBVTtRQUNsQixJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDbkIsQ0FBQztJQUVEOzs7T0FHRztJQUNPLFlBQVk7UUFDcEIsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFFRDs7T0FFRztJQUNLLFNBQVM7UUFDZixJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEtBQWtCLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQ7O09BRUc7SUFDSyxXQUFXO1FBQ2pCLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBa0IsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFFRDs7T0FFRztJQUNLLFdBQVcsQ0FBQyxLQUFrQjtRQUNwQyxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQzNCLE9BQU87U0FDUjtRQUVELE1BQU0sTUFBTSxHQUFHLENBQUMsTUFBNEIsRUFBRSxFQUFFO1lBQzlDLE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxRQUFRLEtBQUssSUFBSSxDQUFDO1FBQ3hDLENBQUMsQ0FBQztRQUNGLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRDs7T0FFRztJQUNLLGFBQWEsQ0FBQyxLQUFrQjtRQUN0QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QyxJQUFJLFFBQVEsS0FBSyxTQUFTLEVBQUU7WUFDMUIsT0FBTztTQUNSO1FBRUQsS0FBSyxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDdkMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRW50aXR5UmVjb3JkIH0gZnJvbSAnLi4vZW50aXR5LmludGVyZmFjZXMnO1xyXG5pbXBvcnQgeyBFbnRpdHlTdG9yZSB9IGZyb20gJy4uL3N0b3JlJztcclxuaW1wb3J0IHsgRW50aXR5U3RvcmVTdHJhdGVneSB9IGZyb20gJy4vc3RyYXRlZ3knO1xyXG5cclxuLyoqXHJcbiAqIFdoZW4gYWN0aXZlLCB0aGlzIHN0cmF0ZWd5IGZpbHRlcnMgYSBzdG9yZSdzIHN0YXRlVmlldyB0byByZXR1cm5cclxuICogc2VsZWN0ZWQgZW50aXRpZXMgb25seS5cclxuICovXHJcbmV4cG9ydCBjbGFzcyBFbnRpdHlTdG9yZUZpbHRlclNlbGVjdGlvblN0cmF0ZWd5IGV4dGVuZHMgRW50aXR5U3RvcmVTdHJhdGVneSB7XHJcbiAgLyoqXHJcbiAgICogU3RvcmUgLyBmaWx0ZXIgaWRzIG1hcFxyXG4gICAqL1xyXG4gIHByaXZhdGUgZmlsdGVyczogTWFwPEVudGl0eVN0b3JlLCBzdHJpbmc+ID0gbmV3IE1hcCgpO1xyXG5cclxuICAvKipcclxuICAgKiBCaW5kIHRoaXMgc3RyYXRlZ3kgdG8gYSBzdG9yZSBhbmQgc3RhcnQgZmlsdGVyaW5nIGl0XHJcbiAgICogQHBhcmFtIHN0b3JlIEVudGl0eSBzdG9yZVxyXG4gICAqL1xyXG4gIGJpbmRTdG9yZShzdG9yZTogRW50aXR5U3RvcmUpIHtcclxuICAgIHN1cGVyLmJpbmRTdG9yZShzdG9yZSk7XHJcbiAgICBpZiAodGhpcy5hY3RpdmUgPT09IHRydWUpIHtcclxuICAgICAgdGhpcy5maWx0ZXJTdG9yZShzdG9yZSk7XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBVbmJpbmQgdGhpcyBzdHJhdGVneSBmcm9tIGEgc3RvcmUgYW5kIHN0b3AgZmlsdGVyaW5nIGl0XHJcbiAgICogQHBhcmFtIHN0b3JlIEVudGl0eSBzdG9yZVxyXG4gICAqL1xyXG4gIHVuYmluZFN0b3JlKHN0b3JlOiBFbnRpdHlTdG9yZSkge1xyXG4gICAgc3VwZXIudW5iaW5kU3RvcmUoc3RvcmUpO1xyXG4gICAgaWYgKHRoaXMuYWN0aXZlID09PSB0cnVlKSB7XHJcbiAgICAgIHRoaXMudW5maWx0ZXJTdG9yZShzdG9yZSk7XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBTdGFydCBmaWx0ZXJpbmcgYWxsIHN0b3Jlc1xyXG4gICAqIEBpbnRlcm5hbFxyXG4gICAqL1xyXG4gIHByb3RlY3RlZCBkb0FjdGl2YXRlKCkge1xyXG4gICAgdGhpcy5maWx0ZXJBbGwoKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFN0b3AgZmlsdGVyaW5nIGFsbCBzdG9yZXNcclxuICAgKiBAaW50ZXJuYWxcclxuICAgKi9cclxuICBwcm90ZWN0ZWQgZG9EZWFjdGl2YXRlKCkge1xyXG4gICAgdGhpcy51bmZpbHRlckFsbCgpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRmlsdGVyIGFsbCBzdG9yZXNcclxuICAgKi9cclxuICBwcml2YXRlIGZpbHRlckFsbCgpIHtcclxuICAgIHRoaXMuc3RvcmVzLmZvckVhY2goKHN0b3JlOiBFbnRpdHlTdG9yZSkgPT4gdGhpcy5maWx0ZXJTdG9yZShzdG9yZSkpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogVW5maWx0ZXIgYWxsIHN0b3Jlc1xyXG4gICAqL1xyXG4gIHByaXZhdGUgdW5maWx0ZXJBbGwoKSB7XHJcbiAgICB0aGlzLnN0b3Jlcy5mb3JFYWNoKChzdG9yZTogRW50aXR5U3RvcmUpID0+IHRoaXMudW5maWx0ZXJTdG9yZShzdG9yZSkpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRmlsdGVyIGEgc3RvcmUgYW5kIGFkZCBpdCB0byB0aGUgZmlsdGVycyBtYXBcclxuICAgKi9cclxuICBwcml2YXRlIGZpbHRlclN0b3JlKHN0b3JlOiBFbnRpdHlTdG9yZSkge1xyXG4gICAgaWYgKHRoaXMuZmlsdGVycy5oYXMoc3RvcmUpKSB7XHJcbiAgICAgIHJldHVybjtcclxuICAgIH1cclxuXHJcbiAgICBjb25zdCBmaWx0ZXIgPSAocmVjb3JkOiBFbnRpdHlSZWNvcmQ8b2JqZWN0PikgPT4ge1xyXG4gICAgICByZXR1cm4gcmVjb3JkLnN0YXRlLnNlbGVjdGVkID09PSB0cnVlO1xyXG4gICAgfTtcclxuICAgIHRoaXMuZmlsdGVycy5zZXQoc3RvcmUsIHN0b3JlLnN0YXRlVmlldy5hZGRGaWx0ZXIoZmlsdGVyKSk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBVbmZpbHRlciBhIHN0b3JlIGFuZCBkZWxldGUgaXQgZnJvbSB0aGUgZmlsdGVycyBtYXBcclxuICAgKi9cclxuICBwcml2YXRlIHVuZmlsdGVyU3RvcmUoc3RvcmU6IEVudGl0eVN0b3JlKSB7XHJcbiAgICBjb25zdCBmaWx0ZXJJZCA9IHRoaXMuZmlsdGVycy5nZXQoc3RvcmUpO1xyXG4gICAgaWYgKGZpbHRlcklkID09PSB1bmRlZmluZWQpIHtcclxuICAgICAgcmV0dXJuO1xyXG4gICAgfVxyXG5cclxuICAgIHN0b3JlLnN0YXRlVmlldy5yZW1vdmVGaWx0ZXIoZmlsdGVySWQpO1xyXG4gICAgdGhpcy5maWx0ZXJzLmRlbGV0ZShzdG9yZSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/{esm2020 → esm2022}/lib/entity/shared/strategies/index.mjs

@@ -1,4 +1,4 @@
-export * from './strategy';
-export * from './filter-custom-function';
-export * from './filter-selection';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2xpYi9lbnRpdHkvc2hhcmVkL3N0cmF0ZWdpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdHJhdGVneSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLWN1c3RvbS1mdW5jdGlvbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLXNlbGVjdGlvbic7XHJcbiJdfQ==
+export * from './strategy';
+export * from './filter-custom-function';
+export * from './filter-selection';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2xpYi9lbnRpdHkvc2hhcmVkL3N0cmF0ZWdpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdHJhdGVneSc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbHRlci1jdXN0b20tZnVuY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXItc2VsZWN0aW9uJztcbiJdfQ==

package/esm2022/lib/entity/shared/strategies/strategy.mjs

@@ -0,0 +1,78 @@
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Entity store strategies. They can do pretty much anything during a store's
+ * lifetime. For example, they may act as triggers when something happens.
+ * Sharing a strategy is a good idea when multiple strategies would have
+ * on cancelling effect on each other.
+ *
+ * At creation, strategy is inactive and needs to be manually activated.
+ */
+export class EntityStoreStrategy {
+    options;
+    /**
+     * Feature store
+     * @internal
+     */
+    stores = [];
+    /**
+     * Whether this strategy is active
+     * @internal
+     */
+    get active() {
+        return this.active$.value;
+    }
+    active$ = new BehaviorSubject(false);
+    constructor(options = {}) {
+        this.options = options;
+        this.options = options;
+    }
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    activate() {
+        if (this.active === true) {
+            this.doDeactivate();
+        }
+        this.active$.next(true);
+        this.doActivate();
+    }
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    deactivate() {
+        this.active$.next(false);
+        this.doDeactivate();
+    }
+    /**
+     * Bind this strategy to a store
+     * @param store Feature store
+     */
+    bindStore(store) {
+        if (this.stores.indexOf(store) < 0) {
+            this.stores.push(store);
+        }
+    }
+    /**
+     * Unbind this strategy from store
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        const index = this.stores.indexOf(store);
+        if (index >= 0) {
+            this.stores.splice(index, 1);
+        }
+    }
+    /**
+     * Do the stataegy activation
+     * @internal
+     */
+    doActivate() { }
+    /**
+     * Do the strategy deactivation
+     * @internal
+     */
+    doDeactivate() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2xpYi9lbnRpdHkvc2hhcmVkL3N0cmF0ZWdpZXMvc3RyYXRlZ3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUt2Qzs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxPQUFPLG1CQUFtQjtJQWdCUjtJQWZ0Qjs7O09BR0c7SUFDTyxNQUFNLEdBQWtCLEVBQUUsQ0FBQztJQUVyQzs7O09BR0c7SUFDSCxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO0lBQzVCLENBQUM7SUFDUSxPQUFPLEdBQTZCLElBQUksZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBRXhFLFlBQXNCLFVBQXNDLEVBQUU7UUFBeEMsWUFBTyxHQUFQLE9BQU8sQ0FBaUM7UUFDNUQsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7SUFDekIsQ0FBQztJQUVEOzs7T0FHRztJQUNILFFBQVE7UUFDTixJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssSUFBSSxFQUFFO1lBQ3hCLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztTQUNyQjtRQUNELElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUNwQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsVUFBVTtRQUNSLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUyxDQUFDLEtBQWtCO1FBQzFCLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFO1lBQ2xDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQ3pCO0lBQ0gsQ0FBQztJQUVEOzs7T0FHRztJQUNILFdBQVcsQ0FBQyxLQUFrQjtRQUM1QixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QyxJQUFJLEtBQUssSUFBSSxDQUFDLEVBQUU7WUFDZCxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7U0FDOUI7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ08sVUFBVSxLQUFJLENBQUM7SUFFekI7OztPQUdHO0lBQ08sWUFBWSxLQUFJLENBQUM7Q0FDNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcclxuXHJcbmltcG9ydCB7IEVudGl0eVN0b3JlU3RyYXRlZ3lPcHRpb25zIH0gZnJvbSAnLi4vZW50aXR5LmludGVyZmFjZXMnO1xyXG5pbXBvcnQgeyBFbnRpdHlTdG9yZSB9IGZyb20gJy4uL3N0b3JlJztcclxuXHJcbi8qKlxyXG4gKiBFbnRpdHkgc3RvcmUgc3RyYXRlZ2llcy4gVGhleSBjYW4gZG8gcHJldHR5IG11Y2ggYW55dGhpbmcgZHVyaW5nIGEgc3RvcmUnc1xyXG4gKiBsaWZldGltZS4gRm9yIGV4YW1wbGUsIHRoZXkgbWF5IGFjdCBhcyB0cmlnZ2VycyB3aGVuIHNvbWV0aGluZyBoYXBwZW5zLlxyXG4gKiBTaGFyaW5nIGEgc3RyYXRlZ3kgaXMgYSBnb29kIGlkZWEgd2hlbiBtdWx0aXBsZSBzdHJhdGVnaWVzIHdvdWxkIGhhdmVcclxuICogb24gY2FuY2VsbGluZyBlZmZlY3Qgb24gZWFjaCBvdGhlci5cclxuICpcclxuICogQXQgY3JlYXRpb24sIHN0cmF0ZWd5IGlzIGluYWN0aXZlIGFuZCBuZWVkcyB0byBiZSBtYW51YWxseSBhY3RpdmF0ZWQuXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgRW50aXR5U3RvcmVTdHJhdGVneSB7XHJcbiAgLyoqXHJcbiAgICogRmVhdHVyZSBzdG9yZVxyXG4gICAqIEBpbnRlcm5hbFxyXG4gICAqL1xyXG4gIHByb3RlY3RlZCBzdG9yZXM6IEVudGl0eVN0b3JlW10gPSBbXTtcclxuXHJcbiAgLyoqXHJcbiAgICogV2hldGhlciB0aGlzIHN0cmF0ZWd5IGlzIGFjdGl2ZVxyXG4gICAqIEBpbnRlcm5hbFxyXG4gICAqL1xyXG4gIGdldCBhY3RpdmUoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy5hY3RpdmUkLnZhbHVlO1xyXG4gIH1cclxuICByZWFkb25seSBhY3RpdmUkOiBCZWhhdmlvclN1YmplY3Q8Ym9vbGVhbj4gPSBuZXcgQmVoYXZpb3JTdWJqZWN0KGZhbHNlKTtcclxuXHJcbiAgY29uc3RydWN0b3IocHJvdGVjdGVkIG9wdGlvbnM6IEVudGl0eVN0b3JlU3RyYXRlZ3lPcHRpb25zID0ge30pIHtcclxuICAgIHRoaXMub3B0aW9ucyA9IG9wdGlvbnM7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBBY3RpdmF0ZSB0aGUgc3RyYXRlZ3kuIElmIGl0J3MgYWxyZWFkeSBhY3RpdmUsIGl0J2xsIGJlIGRlYWN0aXZhdGVkXHJcbiAgICogYW5kIGFjdGl2YXRlZCBhZ2Fpbi5cclxuICAgKi9cclxuICBhY3RpdmF0ZSgpIHtcclxuICAgIGlmICh0aGlzLmFjdGl2ZSA9PT0gdHJ1ZSkge1xyXG4gICAgICB0aGlzLmRvRGVhY3RpdmF0ZSgpO1xyXG4gICAgfVxyXG4gICAgdGhpcy5hY3RpdmUkLm5leHQodHJ1ZSk7XHJcbiAgICB0aGlzLmRvQWN0aXZhdGUoKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEFjdGl2YXRlIHRoZSBzdHJhdGVneS4gSWYgaXQncyBhbHJlYWR5IGFjdGl2ZSwgaXQnbGwgYmUgZGVhY3RpdmF0ZWRcclxuICAgKiBhbmQgYWN0aXZhdGVkIGFnYWluLlxyXG4gICAqL1xyXG4gIGRlYWN0aXZhdGUoKSB7XHJcbiAgICB0aGlzLmFjdGl2ZSQubmV4dChmYWxzZSk7XHJcbiAgICB0aGlzLmRvRGVhY3RpdmF0ZSgpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogQmluZCB0aGlzIHN0cmF0ZWd5IHRvIGEgc3RvcmVcclxuICAgKiBAcGFyYW0gc3RvcmUgRmVhdHVyZSBzdG9yZVxyXG4gICAqL1xyXG4gIGJpbmRTdG9yZShzdG9yZTogRW50aXR5U3RvcmUpIHtcclxuICAgIGlmICh0aGlzLnN0b3Jlcy5pbmRleE9mKHN0b3JlKSA8IDApIHtcclxuICAgICAgdGhpcy5zdG9yZXMucHVzaChzdG9yZSk7XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBVbmJpbmQgdGhpcyBzdHJhdGVneSBmcm9tIHN0b3JlXHJcbiAgICogQHBhcmFtIHN0b3JlIEZlYXR1cmUgc3RvcmVcclxuICAgKi9cclxuICB1bmJpbmRTdG9yZShzdG9yZTogRW50aXR5U3RvcmUpIHtcclxuICAgIGNvbnN0IGluZGV4ID0gdGhpcy5zdG9yZXMuaW5kZXhPZihzdG9yZSk7XHJcbiAgICBpZiAoaW5kZXggPj0gMCkge1xyXG4gICAgICB0aGlzLnN0b3Jlcy5zcGxpY2UoaW5kZXgsIDEpO1xyXG4gICAgfVxyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRG8gdGhlIHN0YXRhZWd5IGFjdGl2YXRpb25cclxuICAgKiBAaW50ZXJuYWxcclxuICAgKi9cclxuICBwcm90ZWN0ZWQgZG9BY3RpdmF0ZSgpIHt9XHJcblxyXG4gIC8qKlxyXG4gICAqIERvIHRoZSBzdHJhdGVneSBkZWFjdGl2YXRpb25cclxuICAgKiBAaW50ZXJuYWxcclxuICAgKi9cclxuICBwcm90ZWN0ZWQgZG9EZWFjdGl2YXRlKCkge31cclxufVxyXG4iXX0=

package/esm2022/lib/entity/shared/transaction.mjs

@@ -0,0 +1,329 @@
+import { of } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
+import { BehaviorSubject } from 'rxjs';
+import { EntityStore } from './store';
+import { EntityOperationType } from './entity.enums';
+import { getEntityId } from './entity.utils';
+/**
+ * This class holds a reference to the insert, update and delete
+ * operations performed on a store. This is useful to commit
+ * these operations in a single pass or to cancel them.
+ */
+export class EntityTransaction {
+    /**
+     * Store holding the operations on another store
+     */
+    operations;
+    /**
+     * Method to get an entity's id
+     */
+    getKey;
+    /**
+     * Whether there are pending operations
+     */
+    get empty$() {
+        return this.operations.empty$;
+    }
+    /**
+     * Whether there are pending operations
+     */
+    get empty() {
+        return this.empty$.value;
+    }
+    /**
+     * Whether thise store is in commit phase
+     */
+    get inCommitPhase() {
+        return this.inCommitPhase$.value;
+    }
+    inCommitPhase$ = new BehaviorSubject(false);
+    constructor(options = {}) {
+        this.getKey = options.getKey ? options.getKey : getEntityId;
+        this.operations = new EntityStore([], {
+            getKey: (operation) => operation.key
+        });
+    }
+    destroy() {
+        this.operations.destroy();
+    }
+    /**
+     * Insert an entity into a store. If no store is specified, an insert
+     * operation is still created but the transaction won't add the new
+     * entity to the store.
+     * @param current The entity to insert
+     * @param store Optional: The store to insert the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    insert(current, store, meta) {
+        const existingOperation = this.getOperationByEntity(current);
+        if (existingOperation !== undefined) {
+            this.removeOperation(existingOperation);
+        }
+        this.doInsert(current, store, meta);
+    }
+    /**
+     * Update an entity in a store. If no store is specified, an update
+     * operation is still created but the transaction won't update the
+     * entity into the store.
+     * @param previous The entity before update
+     * @param current The entity after update
+     * @param store Optional: The store to update the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    update(previous, current, store, meta) {
+        const existingOperation = this.getOperationByEntity(current);
+        if (existingOperation !== undefined) {
+            this.removeOperation(existingOperation);
+            if (existingOperation.type === EntityOperationType.Insert) {
+                this.doInsert(current, store, meta);
+                return;
+            }
+            else if (existingOperation.type === EntityOperationType.Update) {
+                previous = existingOperation.previous;
+            }
+        }
+        this.doUpdate(previous, current, store, meta);
+    }
+    /**
+     * Delete an entity from a store. If no store is specified, a delete
+     * operation is still created but the transaction won't remove the
+     * entity from the store.
+     * @param previous The entity before delete
+     * @param store Optional: The store to delete the entity from
+     * @param meta Optional: Any metadata on the operation
+     */
+    delete(previous, store, meta) {
+        const existingOperation = this.getOperationByEntity(previous);
+        if (existingOperation !== undefined) {
+            this.removeOperation(existingOperation);
+            if (existingOperation.type === EntityOperationType.Insert) {
+                if (store !== undefined) {
+                    store.delete(previous);
+                }
+                return;
+            }
+        }
+        this.doDelete(previous, store, meta);
+    }
+    /**
+     * Commit operations the transaction. This method doesn't do much
+     * in itself. The handler it receives does the hard work and it's
+     * implementation is left to the caller. This method simply wraps
+     * the handler into an error catching mechanism to update
+     * the transaction afterward. The caller needs to subscribe to this
+     * method's output (observable) for the commit to be performed.
+     * @param operations Operations to commit
+     * @param handler Function that handles the commit operation
+     * @returns The handler output (observable)
+     */
+    commit(operations, handler) {
+        this.inCommitPhase$.next(true);
+        return handler(this, operations).pipe(catchError(() => of(new Error())), tap((result) => {
+            if (result instanceof Error) {
+                this.onCommitError(operations);
+            }
+            else {
+                this.onCommitSuccess(operations);
+            }
+        }));
+    }
+    /**
+     * Commit all the operations of the transaction.
+     * @param handler Function that handles the commit operation
+     * @returns The handler output (observable)
+     */
+    commitAll(handler) {
+        const operations = this.getOperationsInCommit();
+        return this.commit(operations, handler);
+    }
+    /**
+     * Rollback this transaction
+     */
+    rollback() {
+        this.rollbackOperations(this.operations.all());
+    }
+    /**
+     * Rollback specific operations
+     */
+    rollbackOperations(operations) {
+        this.checkInCommitPhase();
+        const operationsFactory = () => new Map([
+            [EntityOperationType.Delete, []],
+            [EntityOperationType.Update, []],
+            [EntityOperationType.Insert, []]
+        ]);
+        const storesOperations = new Map();
+        // Group operations by store and by operation type.
+        // Grouping operations allows us to revert them in bacth, thus, triggering
+        // observables only one per operation type.
+        for (const operation of operations) {
+            const store = operation.store;
+            if (operation.store === undefined) {
+                continue;
+            }
+            let storeOperations = storesOperations.get(store);
+            if (storeOperations === undefined) {
+                storeOperations = operationsFactory();
+                storesOperations.set(store, storeOperations);
+            }
+            storeOperations.get(operation.type).push(operation);
+        }
+        Array.from(storesOperations.keys()).forEach((store) => {
+            const storeOperations = storesOperations.get(store);
+            const deletes = storeOperations.get(EntityOperationType.Delete);
+            store.insertMany(deletes.map((_delete) => _delete.previous));
+            const updates = storeOperations.get(EntityOperationType.Update);
+            store.updateMany(updates.map((_update) => _update.previous));
+            const inserts = storeOperations.get(EntityOperationType.Insert);
+            store.deleteMany(inserts.map((_insert) => _insert.current));
+        });
+        this.operations.deleteMany(operations);
+        this.inCommitPhase$.next(false);
+    }
+    /**
+     * Clear this transaction
+     * @todo Raise event and synchronize stores?
+     */
+    clear() {
+        this.operations.clear();
+        this.inCommitPhase$.next(false);
+    }
+    /**
+     * Get any existing operation on an entity
+     * @param entity Entity
+     * @returns Either an insert, update or delete operation
+     */
+    getOperationByEntity(entity) {
+        return this.operations.get(this.getKey(entity));
+    }
+    /**
+     * Merge another transaction in this one
+     * @param transaction Another transaction
+     */
+    mergeTransaction(transaction) {
+        this.checkInCommitPhase();
+        const operations = transaction.operations.all();
+        operations.forEach((operation) => {
+            this.addOperation(operation);
+        });
+    }
+    /**
+     * Create an insert operation and add an entity to the store
+     * @param current The entity to insert
+     * @param store Optional: The store to insert the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    doInsert(current, store, meta) {
+        this.addOperation({
+            key: this.getKey(current),
+            type: EntityOperationType.Insert,
+            previous: undefined,
+            current,
+            store,
+            meta
+        });
+        if (store !== undefined) {
+            store.insert(current);
+        }
+    }
+    /**
+     * Create an update operation and update an entity into the store
+     * @param previous The entity before update
+     * @param current The entity after update
+     * @param store Optional: The store to update the entity into
+     * @param meta Optional: Any metadata on the operation
+     */
+    doUpdate(previous, current, store, meta) {
+        this.addOperation({
+            key: this.getKey(current),
+            type: EntityOperationType.Update,
+            previous,
+            current,
+            store,
+            meta
+        });
+        if (store !== undefined) {
+            store.update(current);
+        }
+    }
+    /**
+     * Create a delete operation and delete an entity from the store
+     * @param previous The entity before delete
+     * @param store Optional: The store to delete the entity from
+     * @param meta Optional: Any metadata on the operation
+     */
+    doDelete(previous, store, meta) {
+        this.addOperation({
+            key: this.getKey(previous),
+            type: EntityOperationType.Delete,
+            previous,
+            current: undefined,
+            store,
+            meta
+        });
+        if (store !== undefined) {
+            store.delete(previous);
+        }
+    }
+    /**
+     * Remove committed operations from store
+     * @param operations Commited operations
+     * @todo Raise event and synchronize stores?
+     */
+    resolveOperations(operations) {
+        this.operations.deleteMany(operations);
+    }
+    /**
+     * On commit success, resolve commited operations and exit commit phase
+     * @param operations Commited operations
+     */
+    onCommitSuccess(operations) {
+        this.resolveOperations(operations);
+        this.inCommitPhase$.next(false);
+    }
+    /**
+     * On commit error, abort transaction
+     * @param operations Commited operations
+     */
+    onCommitError(operations) {
+        this.inCommitPhase$.next(false);
+    }
+    /**
+     * Add an operation to the operations store
+     * @param operation Operation to add
+     */
+    addOperation(operation) {
+        this.checkInCommitPhase();
+        this.operations.insert(operation);
+        this.operations.state.update(operation, { added: true });
+    }
+    /**
+     * Remove an operation from the operations store
+     * @param operation Operation to remove
+     */
+    removeOperation(operation) {
+        this.checkInCommitPhase();
+        this.operations.delete(operation);
+        this.operations.state.update(operation, { added: false });
+    }
+    /**
+     * Get all the operations to commit
+     * @returns Operations to commit
+     */
+    getOperationsInCommit() {
+        return this.operations.stateView
+            .manyBy((value) => {
+            return value.state.added === true;
+        })
+            .map((value) => value.entity);
+    }
+    /**
+     * Check if the transaction is in the commit phase and throw an error if it is
+     */
+    checkInCommitPhase() {
+        if (this.inCommitPhase === true) {
+            throw new Error('This transaction is in the commit phase. Cannot complete this operation.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../../../../packages/common/src/lib/entity/shared/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, of } from 'rxjs';\r\nimport { catchError, tap } from 'rxjs/operators';\r\n\r\nimport { BehaviorSubject } from 'rxjs';\r\n\r\nimport {\r\n  EntityKey,\r\n  EntityTransactionOptions,\r\n  EntityOperationState\r\n} from './entity.interfaces';\r\nimport { EntityStore } from './store';\r\nimport { EntityOperationType } from './entity.enums';\r\nimport { getEntityId } from './entity.utils';\r\n\r\ninterface EntityOperation<E extends object = object> {\r\n  key: EntityKey;\r\n  type: EntityOperationType;\r\n  previous: E | undefined;\r\n  current: E | undefined;\r\n  store?: EntityStore<E>;\r\n  meta?: { [key: string]: any };\r\n}\r\n\r\nexport type EntityTransactionCommitHandler = (\r\n  transaction: EntityTransaction,\r\n  operations: EntityOperation[]\r\n) => Observable<any>;\r\n\r\n/**\r\n * This class holds a reference to the insert, update and delete\r\n * operations performed on a store. This is useful to commit\r\n * these operations in a single pass or to cancel them.\r\n */\r\nexport class EntityTransaction {\r\n  /**\r\n   * Store holding the operations on another store\r\n   */\r\n  readonly operations: EntityStore<EntityOperation, EntityOperationState>;\r\n\r\n  /**\r\n   * Method to get an entity's id\r\n   */\r\n  readonly getKey: (E) => EntityKey;\r\n\r\n  /**\r\n   * Whether there are pending operations\r\n   */\r\n  get empty$(): BehaviorSubject<boolean> {\r\n    return this.operations.empty$;\r\n  }\r\n\r\n  /**\r\n   * Whether there are pending operations\r\n   */\r\n  get empty(): boolean {\r\n    return this.empty$.value;\r\n  }\r\n\r\n  /**\r\n   * Whether thise store is in commit phase\r\n   */\r\n  get inCommitPhase(): boolean {\r\n    return this.inCommitPhase$.value;\r\n  }\r\n  readonly inCommitPhase$: BehaviorSubject<boolean> = new BehaviorSubject(\r\n    false\r\n  );\r\n\r\n  constructor(options: EntityTransactionOptions = {}) {\r\n    this.getKey = options.getKey ? options.getKey : getEntityId;\r\n    this.operations = new EntityStore<EntityOperation, EntityOperationState>(\r\n      [],\r\n      {\r\n        getKey: (operation: EntityOperation) => operation.key\r\n      }\r\n    );\r\n  }\r\n\r\n  destroy() {\r\n    this.operations.destroy();\r\n  }\r\n\r\n  /**\r\n   * Insert an entity into a store. If no store is specified, an insert\r\n   * operation is still created but the transaction won't add the new\r\n   * entity to the store.\r\n   * @param current The entity to insert\r\n   * @param store Optional: The store to insert the entity into\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  insert(\r\n    current: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    const existingOperation = this.getOperationByEntity(current);\r\n    if (existingOperation !== undefined) {\r\n      this.removeOperation(existingOperation);\r\n    }\r\n\r\n    this.doInsert(current, store, meta);\r\n  }\r\n\r\n  /**\r\n   * Update an entity in a store. If no store is specified, an update\r\n   * operation is still created but the transaction won't update the\r\n   * entity into the store.\r\n   * @param previous The entity before update\r\n   * @param current The entity after update\r\n   * @param store Optional: The store to update the entity into\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  update(\r\n    previous: object,\r\n    current: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    const existingOperation = this.getOperationByEntity(current);\r\n    if (existingOperation !== undefined) {\r\n      this.removeOperation(existingOperation);\r\n      if (existingOperation.type === EntityOperationType.Insert) {\r\n        this.doInsert(current, store, meta);\r\n        return;\r\n      } else if (existingOperation.type === EntityOperationType.Update) {\r\n        previous = existingOperation.previous;\r\n      }\r\n    }\r\n\r\n    this.doUpdate(previous, current, store, meta);\r\n  }\r\n\r\n  /**\r\n   * Delete an entity from a store. If no store is specified, a delete\r\n   * operation is still created but the transaction won't remove the\r\n   * entity from the store.\r\n   * @param previous The entity before delete\r\n   * @param store Optional: The store to delete the entity from\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  delete(\r\n    previous: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    const existingOperation = this.getOperationByEntity(previous);\r\n    if (existingOperation !== undefined) {\r\n      this.removeOperation(existingOperation);\r\n      if (existingOperation.type === EntityOperationType.Insert) {\r\n        if (store !== undefined) {\r\n          store.delete(previous);\r\n        }\r\n        return;\r\n      }\r\n    }\r\n\r\n    this.doDelete(previous, store, meta);\r\n  }\r\n\r\n  /**\r\n   * Commit operations the transaction. This method doesn't do much\r\n   * in itself. The handler it receives does the hard work and it's\r\n   * implementation is left to the caller. This method simply wraps\r\n   * the handler into an error catching mechanism to update\r\n   * the transaction afterward. The caller needs to subscribe to this\r\n   * method's output (observable) for the commit to be performed.\r\n   * @param operations Operations to commit\r\n   * @param handler Function that handles the commit operation\r\n   * @returns The handler output (observable)\r\n   */\r\n  commit(\r\n    operations: EntityOperation[],\r\n    handler: EntityTransactionCommitHandler\r\n  ): Observable<any> {\r\n    this.inCommitPhase$.next(true);\r\n\r\n    return handler(this, operations).pipe(\r\n      catchError(() => of(new Error())),\r\n      tap((result: any) => {\r\n        if (result instanceof Error) {\r\n          this.onCommitError(operations);\r\n        } else {\r\n          this.onCommitSuccess(operations);\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Commit all the operations of the transaction.\r\n   * @param handler Function that handles the commit operation\r\n   * @returns The handler output (observable)\r\n   */\r\n  commitAll(handler: EntityTransactionCommitHandler): Observable<any> {\r\n    const operations = this.getOperationsInCommit();\r\n    return this.commit(operations, handler);\r\n  }\r\n\r\n  /**\r\n   * Rollback this transaction\r\n   */\r\n  rollback() {\r\n    this.rollbackOperations(this.operations.all());\r\n  }\r\n\r\n  /**\r\n   * Rollback specific operations\r\n   */\r\n  rollbackOperations(operations: EntityOperation[]) {\r\n    this.checkInCommitPhase();\r\n\r\n    const operationsFactory = () =>\r\n      new Map([\r\n        [EntityOperationType.Delete, []],\r\n        [EntityOperationType.Update, []],\r\n        [EntityOperationType.Insert, []]\r\n      ]);\r\n    const storesOperations = new Map();\r\n\r\n    // Group operations by store and by operation type.\r\n    // Grouping operations allows us to revert them in bacth, thus, triggering\r\n    // observables only one per operation type.\r\n    for (const operation of operations) {\r\n      const store = operation.store;\r\n      if (operation.store === undefined) {\r\n        continue;\r\n      }\r\n\r\n      let storeOperations = storesOperations.get(store);\r\n      if (storeOperations === undefined) {\r\n        storeOperations = operationsFactory();\r\n        storesOperations.set(store, storeOperations);\r\n      }\r\n      storeOperations.get(operation.type).push(operation);\r\n    }\r\n\r\n    Array.from(storesOperations.keys()).forEach(\r\n      (store: EntityStore<object>) => {\r\n        const storeOperations = storesOperations.get(store);\r\n\r\n        const deletes = storeOperations.get(EntityOperationType.Delete);\r\n        store.insertMany(\r\n          deletes.map((_delete: EntityOperation) => _delete.previous)\r\n        );\r\n\r\n        const updates = storeOperations.get(EntityOperationType.Update);\r\n        store.updateMany(\r\n          updates.map((_update: EntityOperation) => _update.previous)\r\n        );\r\n\r\n        const inserts = storeOperations.get(EntityOperationType.Insert);\r\n        store.deleteMany(\r\n          inserts.map((_insert: EntityOperation) => _insert.current)\r\n        );\r\n      }\r\n    );\r\n\r\n    this.operations.deleteMany(operations);\r\n    this.inCommitPhase$.next(false);\r\n  }\r\n\r\n  /**\r\n   * Clear this transaction\r\n   * @todo Raise event and synchronize stores?\r\n   */\r\n  clear() {\r\n    this.operations.clear();\r\n    this.inCommitPhase$.next(false);\r\n  }\r\n\r\n  /**\r\n   * Get any existing operation on an entity\r\n   * @param entity Entity\r\n   * @returns Either an insert, update or delete operation\r\n   */\r\n  getOperationByEntity(entity: object): EntityOperation {\r\n    return this.operations.get(this.getKey(entity));\r\n  }\r\n\r\n  /**\r\n   * Merge another transaction in this one\r\n   * @param transaction Another transaction\r\n   */\r\n  mergeTransaction(transaction: EntityTransaction) {\r\n    this.checkInCommitPhase();\r\n\r\n    const operations = transaction.operations.all();\r\n    operations.forEach((operation: EntityOperation) => {\r\n      this.addOperation(operation);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create an insert operation and add an entity to the store\r\n   * @param current The entity to insert\r\n   * @param store Optional: The store to insert the entity into\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  private doInsert(\r\n    current: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    this.addOperation({\r\n      key: this.getKey(current),\r\n      type: EntityOperationType.Insert,\r\n      previous: undefined,\r\n      current,\r\n      store,\r\n      meta\r\n    });\r\n\r\n    if (store !== undefined) {\r\n      store.insert(current);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create an update operation and update an entity into the store\r\n   * @param previous The entity before update\r\n   * @param current The entity after update\r\n   * @param store Optional: The store to update the entity into\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  private doUpdate(\r\n    previous: object,\r\n    current: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    this.addOperation({\r\n      key: this.getKey(current),\r\n      type: EntityOperationType.Update,\r\n      previous,\r\n      current,\r\n      store,\r\n      meta\r\n    });\r\n\r\n    if (store !== undefined) {\r\n      store.update(current);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a delete operation and delete an entity from the store\r\n   * @param previous The entity before delete\r\n   * @param store Optional: The store to delete the entity from\r\n   * @param meta Optional: Any metadata on the operation\r\n   */\r\n  private doDelete(\r\n    previous: object,\r\n    store?: EntityStore<object>,\r\n    meta?: { [key: string]: any }\r\n  ) {\r\n    this.addOperation({\r\n      key: this.getKey(previous),\r\n      type: EntityOperationType.Delete,\r\n      previous,\r\n      current: undefined,\r\n      store,\r\n      meta\r\n    });\r\n\r\n    if (store !== undefined) {\r\n      store.delete(previous);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove committed operations from store\r\n   * @param operations Commited operations\r\n   * @todo Raise event and synchronize stores?\r\n   */\r\n  private resolveOperations(operations: EntityOperation[]) {\r\n    this.operations.deleteMany(operations);\r\n  }\r\n\r\n  /**\r\n   * On commit success, resolve commited operations and exit commit phase\r\n   * @param operations Commited operations\r\n   */\r\n  private onCommitSuccess(operations: EntityOperation[]) {\r\n    this.resolveOperations(operations);\r\n    this.inCommitPhase$.next(false);\r\n  }\r\n\r\n  /**\r\n   * On commit error, abort transaction\r\n   * @param operations Commited operations\r\n   */\r\n  private onCommitError(operations: EntityOperation[]) {\r\n    this.inCommitPhase$.next(false);\r\n  }\r\n\r\n  /**\r\n   * Add an operation to the operations store\r\n   * @param operation Operation to add\r\n   */\r\n  private addOperation(operation: EntityOperation) {\r\n    this.checkInCommitPhase();\r\n\r\n    this.operations.insert(operation);\r\n    this.operations.state.update(operation, { added: true });\r\n  }\r\n\r\n  /**\r\n   * Remove an operation from the operations store\r\n   * @param operation Operation to remove\r\n   */\r\n  private removeOperation(operation: EntityOperation) {\r\n    this.checkInCommitPhase();\r\n\r\n    this.operations.delete(operation);\r\n    this.operations.state.update(operation, { added: false });\r\n  }\r\n\r\n  /**\r\n   * Get all the operations to commit\r\n   * @returns Operations to commit\r\n   */\r\n  private getOperationsInCommit(): EntityOperation[] {\r\n    return this.operations.stateView\r\n      .manyBy(\r\n        (value: { entity: EntityOperation; state: EntityOperationState }) => {\r\n          return value.state.added === true;\r\n        }\r\n      )\r\n      .map(\r\n        (value: { entity: EntityOperation; state: EntityOperationState }) =>\r\n          value.entity\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Check if the transaction is in the commit phase and throw an error if it is\r\n   */\r\n  private checkInCommitPhase() {\r\n    if (this.inCommitPhase === true) {\r\n      throw new Error(\r\n        'This transaction is in the commit phase. Cannot complete this operation.'\r\n      );\r\n    }\r\n  }\r\n}\r\n"]}