@igo2/common 1.14.3 → 1.14.4

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

@@ -1,316 +1,316 @@
-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 {
-    constructor(options = {}) {
-        this.inCommitPhase$ = new BehaviorSubject(false);
-        this.getKey = options.getKey ? options.getKey : getEntityId;
-        this.operations = new EntityStore([], {
-            getKey: (operation) => operation.key
-        });
-    }
-    /**
-     * 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; }
-    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.');
-        }
-    }
-}
+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 {
+    constructor(options = {}) {
+        this.inCommitPhase$ = new BehaviorSubject(false);
+        this.getKey = options.getKey ? options.getKey : getEntityId;
+        this.operations = new EntityStore([], {
+            getKey: (operation) => operation.key
+        });
+    }
+    /**
+     * 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; }
+    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';\nimport { catchError, tap } from 'rxjs/operators';\n\nimport { BehaviorSubject } from 'rxjs';\n\nimport {\n  EntityKey,\n  EntityTransactionOptions,\n  EntityOperation,\n  EntityOperationState\n} from './entity.interfaces';\nimport { EntityStore } from './store';\nimport { EntityOperationType } from './entity.enums';\nimport { getEntityId } from './entity.utils';\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  /**\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> { return this.operations.empty$; }\n\n  /**\n   * Whether there are pending operations\n   */\n  get empty(): boolean { return this.empty$.value; }\n\n  /**\n   * Whether thise store is in commit phase\n   */\n  get inCommitPhase(): boolean { return this.inCommitPhase$.value; }\n  readonly inCommitPhase$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n\n  constructor(options: EntityTransactionOptions = {}) {\n    this.getKey = options.getKey ? options.getKey : getEntityId;\n    this.operations = new EntityStore<EntityOperation, EntityOperationState>([], {\n      getKey: (operation: EntityOperation) => operation.key\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(current: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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(previous: object, current: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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(previous: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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(operations: EntityOperation[], handler: EntityTransactionCommitHandler): Observable<any> {\n    this.inCommitPhase$.next(true);\n\n    return handler(this, operations)\n      .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 = () => 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) { continue; }\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((store: EntityStore<object>) => {\n      const storeOperations = storesOperations.get(store);\n\n      const deletes = storeOperations.get(EntityOperationType.Delete);\n      store.insertMany(deletes.map((_delete: EntityOperation) => _delete.previous));\n\n      const updates = storeOperations.get(EntityOperationType.Update);\n      store.updateMany(updates.map((_update: EntityOperation) => _update.previous));\n\n      const inserts = storeOperations.get(EntityOperationType.Insert);\n      store.deleteMany(inserts.map((_insert: EntityOperation) => _insert.current));\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(current: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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(previous: object, current: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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(previous: object, store?: EntityStore<object>, meta?: {[key: string]: any}) {\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((value: {entity: EntityOperation, state: EntityOperationState}) => {\n        return value.state.added === true;\n      })\n      .map((value: {entity: EntityOperation, state: EntityOperationState}) => value.entity);\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('This transaction is in the commit phase. Cannot complete this operation.');\n    }\n  }\n}\n"]}