@igo2/common 16.3.0 → 17.0.0-next.10

package/esm2022/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,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

package/esm2022/entity/shared/strategies/index.mjs

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

package/esm2022/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,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

package/esm2022/entity/shared/transaction.mjs

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