@ngrx/data 13.0.0-beta.0 → 13.0.0-rc.0

package/esm2020/src/reducers/entity-change-tracker-base.mjs

@@ -0,0 +1,587 @@
+import { ChangeType } from './entity-collection';
+import { defaultSelectId } from '../utils/utilities';
+import { MergeStrategy } from '../actions/merge-strategy';
+/**
+ * The default implementation of EntityChangeTracker with
+ * methods for tracking, committing, and reverting/undoing unsaved entity changes.
+ * Used by EntityCollectionReducerMethods which should call tracker methods BEFORE modifying the collection.
+ * See EntityChangeTracker docs.
+ */
+export class EntityChangeTrackerBase {
+    constructor(adapter, selectId) {
+        this.adapter = adapter;
+        this.selectId = selectId;
+        /** Extract the primary key (id); default to `id` */
+        this.selectId = selectId || defaultSelectId;
+    }
+    // #region commit methods
+    /**
+     * Commit all changes as when the collection has been completely reloaded from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param collection The entity collection
+     */
+    commitAll(collection) {
+        return Object.keys(collection.changeState).length === 0
+            ? collection
+            : { ...collection, changeState: {} };
+    }
+    /**
+     * Commit changes for the given entities as when they have been refreshed from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param entityOrIdList The entities to clear tracking or their ids.
+     * @param collection The entity collection
+     */
+    commitMany(entityOrIdList, collection) {
+        if (entityOrIdList == null || entityOrIdList.length === 0) {
+            return collection; // nothing to commit
+        }
+        let didMutate = false;
+        const changeState = entityOrIdList.reduce((chgState, entityOrId) => {
+            const id = typeof entityOrId === 'object'
+                ? this.selectId(entityOrId)
+                : entityOrId;
+            if (chgState[id]) {
+                if (!didMutate) {
+                    chgState = { ...chgState };
+                    didMutate = true;
+                }
+                delete chgState[id];
+            }
+            return chgState;
+        }, collection.changeState);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Commit changes for the given entity as when it have been refreshed from the server.
+     * Harmless when no entity changes to commit.
+     * @param entityOrId The entity to clear tracking or its id.
+     * @param collection The entity collection
+     */
+    commitOne(entityOrId, collection) {
+        return entityOrId == null
+            ? collection
+            : this.commitMany([entityOrId], collection);
+    }
+    // #endregion commit methods
+    // #region merge query
+    /**
+     * Merge query results into the collection, adjusting the ChangeState per the mergeStrategy.
+     * @param entities Entities returned from querying the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a queried entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.PreserveChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeQueryResults(entities, collection, mergeStrategy) {
+        return this.mergeServerUpserts(entities, collection, MergeStrategy.PreserveChanges, mergeStrategy);
+    }
+    // #endregion merge query results
+    // #region merge save results
+    /**
+     * Merge result of saving new entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving new entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveAdds(entities, collection, mergeStrategy) {
+        return this.mergeServerUpserts(entities, collection, MergeStrategy.OverwriteChanges, mergeStrategy);
+    }
+    /**
+     * Merge successful result of deleting entities on the server that have the given primary keys
+     * Clears the entity changeState for those keys unless the MergeStrategy is ignoreChanges.
+     * @param entities keys primary keys of the entities to remove/delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to adjust change tracking when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveDeletes(keys, collection, mergeStrategy) {
+        mergeStrategy =
+            mergeStrategy == null ? MergeStrategy.OverwriteChanges : mergeStrategy;
+        // same logic for all non-ignore merge strategies: always clear (commit) the changes
+        const deleteIds = keys; // make TypeScript happy
+        collection =
+            mergeStrategy === MergeStrategy.IgnoreChanges
+                ? collection
+                : this.commitMany(deleteIds, collection);
+        return this.adapter.removeMany(deleteIds, collection);
+    }
+    /**
+     * Merge result of saving updated entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param updateResponseData Entity response data returned from saving updated entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @param [skipUnchanged] True means skip update if server didn't change it. False by default.
+     * If the update was optimistic and the server didn't make more changes of its own
+     * then the updates are already in the collection and shouldn't make them again.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpdates(updateResponseData, collection, mergeStrategy, skipUnchanged = false) {
+        if (updateResponseData == null || updateResponseData.length === 0) {
+            return collection; // nothing to merge.
+        }
+        let didMutate = false;
+        let changeState = collection.changeState;
+        mergeStrategy =
+            mergeStrategy == null ? MergeStrategy.OverwriteChanges : mergeStrategy;
+        let updates;
+        switch (mergeStrategy) {
+            case MergeStrategy.IgnoreChanges:
+                updates = filterChanged(updateResponseData);
+                return this.adapter.updateMany(updates, collection);
+            case MergeStrategy.OverwriteChanges:
+                changeState = updateResponseData.reduce((chgState, update) => {
+                    const oldId = update.id;
+                    const change = chgState[oldId];
+                    if (change) {
+                        if (!didMutate) {
+                            chgState = { ...chgState };
+                            didMutate = true;
+                        }
+                        delete chgState[oldId];
+                    }
+                    return chgState;
+                }, collection.changeState);
+                collection = didMutate ? { ...collection, changeState } : collection;
+                updates = filterChanged(updateResponseData);
+                return this.adapter.updateMany(updates, collection);
+            case MergeStrategy.PreserveChanges: {
+                const updateableEntities = [];
+                changeState = updateResponseData.reduce((chgState, update) => {
+                    const oldId = update.id;
+                    const change = chgState[oldId];
+                    if (change) {
+                        // Tracking a change so update original value but not the current value
+                        if (!didMutate) {
+                            chgState = { ...chgState };
+                            didMutate = true;
+                        }
+                        const newId = this.selectId(update.changes);
+                        const oldChangeState = change;
+                        // If the server changed the id, register the new "originalValue" under the new id
+                        // and remove the change tracked under the old id.
+                        if (newId !== oldId) {
+                            delete chgState[oldId];
+                        }
+                        const newOrigValue = {
+                            ...oldChangeState.originalValue,
+                            ...update.changes,
+                        };
+                        chgState[newId] = {
+                            ...oldChangeState,
+                            originalValue: newOrigValue,
+                        };
+                    }
+                    else {
+                        updateableEntities.push(update);
+                    }
+                    return chgState;
+                }, collection.changeState);
+                collection = didMutate ? { ...collection, changeState } : collection;
+                updates = filterChanged(updateableEntities);
+                return this.adapter.updateMany(updates, collection);
+            }
+        }
+        /**
+         * Conditionally keep only those updates that have additional server changes.
+         * (e.g., for optimistic saves because they updates are already in the current collection)
+         * Strip off the `changed` property.
+         * @responseData Entity response data from server.
+         * May be an UpdateResponseData<T>, a subclass of Update<T> with a 'changed' flag.
+         * @returns Update<T> (without the changed flag)
+         */
+        function filterChanged(responseData) {
+            if (skipUnchanged === true) {
+                // keep only those updates that the server changed (knowable if is UpdateResponseData<T>)
+                responseData = responseData.filter((r) => r.changed === true);
+            }
+            // Strip unchanged property from responseData, leaving just the pure Update<T>
+            // TODO: Remove? probably not necessary as the Update isn't stored and adapter will ignore `changed`.
+            return responseData.map((r) => ({ id: r.id, changes: r.changes }));
+        }
+    }
+    /**
+     * Merge result of saving upserted entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving upserts to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpserts(entities, collection, mergeStrategy) {
+        return this.mergeServerUpserts(entities, collection, MergeStrategy.OverwriteChanges, mergeStrategy);
+    }
+    // #endregion merge save results
+    // #region query & save helpers
+    /**
+     *
+     * @param entities Entities to merge
+     * @param collection Collection into which entities are merged
+     * @param defaultMergeStrategy How to merge when action's MergeStrategy is unspecified
+     * @param [mergeStrategy] The action's MergeStrategy
+     */
+    mergeServerUpserts(entities, collection, defaultMergeStrategy, mergeStrategy) {
+        if (entities == null || entities.length === 0) {
+            return collection; // nothing to merge.
+        }
+        let didMutate = false;
+        let changeState = collection.changeState;
+        mergeStrategy =
+            mergeStrategy == null ? defaultMergeStrategy : mergeStrategy;
+        switch (mergeStrategy) {
+            case MergeStrategy.IgnoreChanges:
+                return this.adapter.upsertMany(entities, collection);
+            case MergeStrategy.OverwriteChanges:
+                collection = this.adapter.upsertMany(entities, collection);
+                changeState = entities.reduce((chgState, entity) => {
+                    const id = this.selectId(entity);
+                    const change = chgState[id];
+                    if (change) {
+                        if (!didMutate) {
+                            chgState = { ...chgState };
+                            didMutate = true;
+                        }
+                        delete chgState[id];
+                    }
+                    return chgState;
+                }, collection.changeState);
+                return didMutate ? { ...collection, changeState } : collection;
+            case MergeStrategy.PreserveChanges: {
+                const upsertEntities = [];
+                changeState = entities.reduce((chgState, entity) => {
+                    const id = this.selectId(entity);
+                    const change = chgState[id];
+                    if (change) {
+                        if (!didMutate) {
+                            chgState = {
+                                ...chgState,
+                                [id]: {
+                                    ...chgState[id],
+                                    originalValue: entity,
+                                },
+                            };
+                            didMutate = true;
+                        }
+                    }
+                    else {
+                        upsertEntities.push(entity);
+                    }
+                    return chgState;
+                }, collection.changeState);
+                collection = this.adapter.upsertMany(upsertEntities, collection);
+                return didMutate ? { ...collection, changeState } : collection;
+            }
+        }
+    }
+    // #endregion query & save helpers
+    // #region track methods
+    /**
+     * Track multiple entities before adding them to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entities The entities to add. They must all have their ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackAddMany(entities, collection, mergeStrategy) {
+        if (mergeStrategy === MergeStrategy.IgnoreChanges ||
+            entities == null ||
+            entities.length === 0) {
+            return collection; // nothing to track
+        }
+        let didMutate = false;
+        const changeState = entities.reduce((chgState, entity) => {
+            const id = this.selectId(entity);
+            if (id == null || id === '') {
+                throw new Error(`${collection.entityName} entity add requires a key to be tracked`);
+            }
+            const trackedChange = chgState[id];
+            if (!trackedChange) {
+                if (!didMutate) {
+                    didMutate = true;
+                    chgState = { ...chgState };
+                }
+                chgState[id] = { changeType: ChangeType.Added };
+            }
+            return chgState;
+        }, collection.changeState);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Track an entity before adding it to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entity The entity to add. It must have an id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     * If not specified, implementation supplies a default strategy.
+     */
+    trackAddOne(entity, collection, mergeStrategy) {
+        return entity == null
+            ? collection
+            : this.trackAddMany([entity], collection, mergeStrategy);
+    }
+    /**
+     * Track multiple entities before removing them with the intention of deleting them on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param keys The primary keys of the entities to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteMany(keys, collection, mergeStrategy) {
+        if (mergeStrategy === MergeStrategy.IgnoreChanges ||
+            keys == null ||
+            keys.length === 0) {
+            return collection; // nothing to track
+        }
+        let didMutate = false;
+        const entityMap = collection.entities;
+        const changeState = keys.reduce((chgState, id) => {
+            const originalValue = entityMap[id];
+            if (originalValue) {
+                const trackedChange = chgState[id];
+                if (trackedChange) {
+                    if (trackedChange.changeType === ChangeType.Added) {
+                        // Special case: stop tracking an added entity that you delete
+                        // The caller must also detect this, remove it immediately from the collection
+                        // and skip attempt to delete on the server.
+                        cloneChgStateOnce();
+                        delete chgState[id];
+                    }
+                    else if (trackedChange.changeType === ChangeType.Updated) {
+                        // Special case: switch change type from Updated to Deleted.
+                        cloneChgStateOnce();
+                        chgState[id] = { ...chgState[id], changeType: ChangeType.Deleted };
+                    }
+                }
+                else {
+                    // Start tracking this entity
+                    cloneChgStateOnce();
+                    chgState[id] = { changeType: ChangeType.Deleted, originalValue };
+                }
+            }
+            return chgState;
+            function cloneChgStateOnce() {
+                if (!didMutate) {
+                    didMutate = true;
+                    chgState = { ...chgState };
+                }
+            }
+        }, collection.changeState);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Track an entity before it is removed with the intention of deleting it on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param key The primary key of the entity to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteOne(key, collection, mergeStrategy) {
+        return key == null
+            ? collection
+            : this.trackDeleteMany([key], collection, mergeStrategy);
+    }
+    /**
+     * Track multiple entities before updating them in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param updates The entities to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateMany(updates, collection, mergeStrategy) {
+        if (mergeStrategy === MergeStrategy.IgnoreChanges ||
+            updates == null ||
+            updates.length === 0) {
+            return collection; // nothing to track
+        }
+        let didMutate = false;
+        const entityMap = collection.entities;
+        const changeState = updates.reduce((chgState, update) => {
+            const { id, changes: entity } = update;
+            if (id == null || id === '') {
+                throw new Error(`${collection.entityName} entity update requires a key to be tracked`);
+            }
+            const originalValue = entityMap[id];
+            // Only track if it is in the collection. Silently ignore if it is not.
+            // @ngrx/entity adapter would also silently ignore.
+            // Todo: should missing update entity really be reported as an error?
+            if (originalValue) {
+                const trackedChange = chgState[id];
+                if (!trackedChange) {
+                    if (!didMutate) {
+                        didMutate = true;
+                        chgState = { ...chgState };
+                    }
+                    chgState[id] = { changeType: ChangeType.Updated, originalValue };
+                }
+            }
+            return chgState;
+        }, collection.changeState);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Track an entity before updating it in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param update The entity to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateOne(update, collection, mergeStrategy) {
+        return update == null
+            ? collection
+            : this.trackUpdateMany([update], collection, mergeStrategy);
+    }
+    /**
+     * Track multiple entities before upserting (adding and updating) them to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entities to add or update. They must be complete entities with ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertMany(entities, collection, mergeStrategy) {
+        if (mergeStrategy === MergeStrategy.IgnoreChanges ||
+            entities == null ||
+            entities.length === 0) {
+            return collection; // nothing to track
+        }
+        let didMutate = false;
+        const entityMap = collection.entities;
+        const changeState = entities.reduce((chgState, entity) => {
+            const id = this.selectId(entity);
+            if (id == null || id === '') {
+                throw new Error(`${collection.entityName} entity upsert requires a key to be tracked`);
+            }
+            const trackedChange = chgState[id];
+            if (!trackedChange) {
+                if (!didMutate) {
+                    didMutate = true;
+                    chgState = { ...chgState };
+                }
+                const originalValue = entityMap[id];
+                chgState[id] =
+                    originalValue == null
+                        ? { changeType: ChangeType.Added }
+                        : { changeType: ChangeType.Updated, originalValue };
+            }
+            return chgState;
+        }, collection.changeState);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Track an entity before upsert (adding and updating) it to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entity to add or update. It must be a complete entity with its id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertOne(entity, collection, mergeStrategy) {
+        return entity == null
+            ? collection
+            : this.trackUpsertMany([entity], collection, mergeStrategy);
+    }
+    // #endregion track methods
+    // #region undo methods
+    /**
+     * Revert the unsaved changes for all collection.
+     * Harmless when there are no entity changes to undo.
+     * @param collection The entity collection
+     */
+    undoAll(collection) {
+        const ids = Object.keys(collection.changeState);
+        const { remove, upsert } = ids.reduce((acc, id) => {
+            const changeState = acc.chgState[id];
+            switch (changeState.changeType) {
+                case ChangeType.Added:
+                    acc.remove.push(id);
+                    break;
+                case ChangeType.Deleted:
+                    const removed = changeState.originalValue;
+                    if (removed) {
+                        acc.upsert.push(removed);
+                    }
+                    break;
+                case ChangeType.Updated:
+                    acc.upsert.push(changeState.originalValue);
+                    break;
+            }
+            return acc;
+        }, 
+        // entitiesToUndo
+        {
+            remove: [],
+            upsert: [],
+            chgState: collection.changeState,
+        });
+        collection = this.adapter.removeMany(remove, collection);
+        collection = this.adapter.upsertMany(upsert, collection);
+        return { ...collection, changeState: {} };
+    }
+    /**
+     * Revert the unsaved changes for the given entities.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrIdList The entities to revert or their ids.
+     * @param collection The entity collection
+     */
+    undoMany(entityOrIdList, collection) {
+        if (entityOrIdList == null || entityOrIdList.length === 0) {
+            return collection; // nothing to undo
+        }
+        let didMutate = false;
+        const { changeState, remove, upsert } = entityOrIdList.reduce((acc, entityOrId) => {
+            let chgState = acc.changeState;
+            const id = typeof entityOrId === 'object'
+                ? this.selectId(entityOrId)
+                : entityOrId;
+            const change = chgState[id];
+            if (change) {
+                if (!didMutate) {
+                    chgState = { ...chgState };
+                    didMutate = true;
+                }
+                delete chgState[id]; // clear tracking of this entity
+                acc.changeState = chgState;
+                switch (change.changeType) {
+                    case ChangeType.Added:
+                        acc.remove.push(id);
+                        break;
+                    case ChangeType.Deleted:
+                        const removed = change.originalValue;
+                        if (removed) {
+                            acc.upsert.push(removed);
+                        }
+                        break;
+                    case ChangeType.Updated:
+                        acc.upsert.push(change.originalValue);
+                        break;
+                }
+            }
+            return acc;
+        }, 
+        // entitiesToUndo
+        {
+            remove: [],
+            upsert: [],
+            changeState: collection.changeState,
+        });
+        collection = this.adapter.removeMany(remove, collection);
+        collection = this.adapter.upsertMany(upsert, collection);
+        return didMutate ? { ...collection, changeState } : collection;
+    }
+    /**
+     * Revert the unsaved changes for the given entity.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrId The entity to revert or its id.
+     * @param collection The entity collection
+     */
+    undoOne(entityOrId, collection) {
+        return entityOrId == null
+            ? collection
+            : this.undoMany([entityOrId], collection);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-change-tracker-base.js","sourceRoot":"","sources":["../../../../../../modules/data/src/reducers/entity-change-tracker-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityAdapter, IdSelector, Update } from '@ngrx/entity';\n\nimport { ChangeType, EntityCollection } from './entity-collection';\nimport { defaultSelectId } from '../utils/utilities';\nimport { EntityChangeTracker } from './entity-change-tracker';\nimport { MergeStrategy } from '../actions/merge-strategy';\nimport { UpdateResponseData } from '../actions/update-response-data';\n\n/**\n * The default implementation of EntityChangeTracker with\n * methods for tracking, committing, and reverting/undoing unsaved entity changes.\n * Used by EntityCollectionReducerMethods which should call tracker methods BEFORE modifying the collection.\n * See EntityChangeTracker docs.\n */\nexport class EntityChangeTrackerBase<T> implements EntityChangeTracker<T> {\n  constructor(\n    private adapter: EntityAdapter<T>,\n    private selectId: IdSelector<T>\n  ) {\n    /** Extract the primary key (id); default to `id` */\n    this.selectId = selectId || defaultSelectId;\n  }\n\n  // #region commit methods\n  /**\n   * Commit all changes as when the collection has been completely reloaded from the server.\n   * Harmless when there are no entity changes to commit.\n   * @param collection The entity collection\n   */\n  commitAll(collection: EntityCollection<T>): EntityCollection<T> {\n    return Object.keys(collection.changeState).length === 0\n      ? collection\n      : { ...collection, changeState: {} };\n  }\n\n  /**\n   * Commit changes for the given entities as when they have been refreshed from the server.\n   * Harmless when there are no entity changes to commit.\n   * @param entityOrIdList The entities to clear tracking or their ids.\n   * @param collection The entity collection\n   */\n  commitMany(\n    entityOrIdList: (number | string | T)[],\n    collection: EntityCollection<T>\n  ): EntityCollection<T> {\n    if (entityOrIdList == null || entityOrIdList.length === 0) {\n      return collection; // nothing to commit\n    }\n    let didMutate = false;\n    const changeState = entityOrIdList.reduce((chgState, entityOrId) => {\n      const id =\n        typeof entityOrId === 'object'\n          ? this.selectId(entityOrId)\n          : (entityOrId as string | number);\n      if (chgState[id]) {\n        if (!didMutate) {\n          chgState = { ...chgState };\n          didMutate = true;\n        }\n        delete chgState[id];\n      }\n      return chgState;\n    }, collection.changeState);\n\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Commit changes for the given entity as when it have been refreshed from the server.\n   * Harmless when no entity changes to commit.\n   * @param entityOrId The entity to clear tracking or its id.\n   * @param collection The entity collection\n   */\n  commitOne(\n    entityOrId: number | string | T,\n    collection: EntityCollection<T>\n  ): EntityCollection<T> {\n    return entityOrId == null\n      ? collection\n      : this.commitMany([entityOrId], collection);\n  }\n\n  // #endregion commit methods\n\n  // #region merge query\n  /**\n   * Merge query results into the collection, adjusting the ChangeState per the mergeStrategy.\n   * @param entities Entities returned from querying the server.\n   * @param collection The entity collection\n   * @param [mergeStrategy] How to merge a queried entity when the corresponding entity in the collection has an unsaved change.\n   * Defaults to MergeStrategy.PreserveChanges.\n   * @returns The merged EntityCollection.\n   */\n  mergeQueryResults(\n    entities: T[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return this.mergeServerUpserts(\n      entities,\n      collection,\n      MergeStrategy.PreserveChanges,\n      mergeStrategy\n    );\n  }\n  // #endregion merge query results\n\n  // #region merge save results\n  /**\n   * Merge result of saving new entities into the collection, adjusting the ChangeState per the mergeStrategy.\n   * The default is MergeStrategy.OverwriteChanges.\n   * @param entities Entities returned from saving new entities to the server.\n   * @param collection The entity collection\n   * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.\n   * Defaults to MergeStrategy.OverwriteChanges.\n   * @returns The merged EntityCollection.\n   */\n  mergeSaveAdds(\n    entities: T[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return this.mergeServerUpserts(\n      entities,\n      collection,\n      MergeStrategy.OverwriteChanges,\n      mergeStrategy\n    );\n  }\n\n  /**\n   * Merge successful result of deleting entities on the server that have the given primary keys\n   * Clears the entity changeState for those keys unless the MergeStrategy is ignoreChanges.\n   * @param entities keys primary keys of the entities to remove/delete.\n   * @param collection The entity collection\n   * @param [mergeStrategy] How to adjust change tracking when the corresponding entity in the collection has an unsaved change.\n   * Defaults to MergeStrategy.OverwriteChanges.\n   * @returns The merged EntityCollection.\n   */\n  mergeSaveDeletes(\n    keys: (number | string)[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    mergeStrategy =\n      mergeStrategy == null ? MergeStrategy.OverwriteChanges : mergeStrategy;\n    // same logic for all non-ignore merge strategies: always clear (commit) the changes\n    const deleteIds = keys as string[]; // make TypeScript happy\n    collection =\n      mergeStrategy === MergeStrategy.IgnoreChanges\n        ? collection\n        : this.commitMany(deleteIds, collection);\n    return this.adapter.removeMany(deleteIds, collection);\n  }\n\n  /**\n   * Merge result of saving updated entities into the collection, adjusting the ChangeState per the mergeStrategy.\n   * The default is MergeStrategy.OverwriteChanges.\n   * @param updateResponseData Entity response data returned from saving updated entities to the server.\n   * @param collection The entity collection\n   * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.\n   * Defaults to MergeStrategy.OverwriteChanges.\n   * @param [skipUnchanged] True means skip update if server didn't change it. False by default.\n   * If the update was optimistic and the server didn't make more changes of its own\n   * then the updates are already in the collection and shouldn't make them again.\n   * @returns The merged EntityCollection.\n   */\n  mergeSaveUpdates(\n    updateResponseData: UpdateResponseData<T>[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy,\n    skipUnchanged = false\n  ): EntityCollection<T> {\n    if (updateResponseData == null || updateResponseData.length === 0) {\n      return collection; // nothing to merge.\n    }\n\n    let didMutate = false;\n    let changeState = collection.changeState;\n    mergeStrategy =\n      mergeStrategy == null ? MergeStrategy.OverwriteChanges : mergeStrategy;\n    let updates: Update<T>[];\n\n    switch (mergeStrategy) {\n      case MergeStrategy.IgnoreChanges:\n        updates = filterChanged(updateResponseData);\n        return this.adapter.updateMany(updates, collection);\n\n      case MergeStrategy.OverwriteChanges:\n        changeState = updateResponseData.reduce((chgState, update) => {\n          const oldId = update.id;\n          const change = chgState[oldId];\n          if (change) {\n            if (!didMutate) {\n              chgState = { ...chgState };\n              didMutate = true;\n            }\n            delete chgState[oldId];\n          }\n          return chgState;\n        }, collection.changeState);\n\n        collection = didMutate ? { ...collection, changeState } : collection;\n\n        updates = filterChanged(updateResponseData);\n        return this.adapter.updateMany(updates, collection);\n\n      case MergeStrategy.PreserveChanges: {\n        const updateableEntities = [] as UpdateResponseData<T>[];\n        changeState = updateResponseData.reduce((chgState, update) => {\n          const oldId = update.id;\n          const change = chgState[oldId];\n          if (change) {\n            // Tracking a change so update original value but not the current value\n            if (!didMutate) {\n              chgState = { ...chgState };\n              didMutate = true;\n            }\n            const newId = this.selectId(update.changes as T);\n            const oldChangeState = change;\n            // If the server changed the id, register the new \"originalValue\" under the new id\n            // and remove the change tracked under the old id.\n            if (newId !== oldId) {\n              delete chgState[oldId];\n            }\n            const newOrigValue = {\n              ...(oldChangeState!.originalValue as any),\n              ...(update.changes as any),\n            };\n            (chgState as any)[newId] = {\n              ...oldChangeState,\n              originalValue: newOrigValue,\n            };\n          } else {\n            updateableEntities.push(update);\n          }\n          return chgState;\n        }, collection.changeState);\n        collection = didMutate ? { ...collection, changeState } : collection;\n\n        updates = filterChanged(updateableEntities);\n        return this.adapter.updateMany(updates, collection);\n      }\n    }\n\n    /**\n     * Conditionally keep only those updates that have additional server changes.\n     * (e.g., for optimistic saves because they updates are already in the current collection)\n     * Strip off the `changed` property.\n     * @responseData Entity response data from server.\n     * May be an UpdateResponseData<T>, a subclass of Update<T> with a 'changed' flag.\n     * @returns Update<T> (without the changed flag)\n     */\n    function filterChanged(responseData: UpdateResponseData<T>[]): Update<T>[] {\n      if (skipUnchanged === true) {\n        // keep only those updates that the server changed (knowable if is UpdateResponseData<T>)\n        responseData = responseData.filter((r) => r.changed === true);\n      }\n      // Strip unchanged property from responseData, leaving just the pure Update<T>\n      // TODO: Remove? probably not necessary as the Update isn't stored and adapter will ignore `changed`.\n      return responseData.map((r) => ({ id: r.id as any, changes: r.changes }));\n    }\n  }\n\n  /**\n   * Merge result of saving upserted entities into the collection, adjusting the ChangeState per the mergeStrategy.\n   * The default is MergeStrategy.OverwriteChanges.\n   * @param entities Entities returned from saving upserts to the server.\n   * @param collection The entity collection\n   * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.\n   * Defaults to MergeStrategy.OverwriteChanges.\n   * @returns The merged EntityCollection.\n   */\n  mergeSaveUpserts(\n    entities: T[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return this.mergeServerUpserts(\n      entities,\n      collection,\n      MergeStrategy.OverwriteChanges,\n      mergeStrategy\n    );\n  }\n  // #endregion merge save results\n\n  // #region query & save helpers\n  /**\n   *\n   * @param entities Entities to merge\n   * @param collection Collection into which entities are merged\n   * @param defaultMergeStrategy How to merge when action's MergeStrategy is unspecified\n   * @param [mergeStrategy] The action's MergeStrategy\n   */\n  private mergeServerUpserts(\n    entities: T[],\n    collection: EntityCollection<T>,\n    defaultMergeStrategy: MergeStrategy,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    if (entities == null || entities.length === 0) {\n      return collection; // nothing to merge.\n    }\n\n    let didMutate = false;\n    let changeState = collection.changeState;\n    mergeStrategy =\n      mergeStrategy == null ? defaultMergeStrategy : mergeStrategy;\n\n    switch (mergeStrategy) {\n      case MergeStrategy.IgnoreChanges:\n        return this.adapter.upsertMany(entities, collection);\n\n      case MergeStrategy.OverwriteChanges:\n        collection = this.adapter.upsertMany(entities, collection);\n\n        changeState = entities.reduce((chgState, entity) => {\n          const id = this.selectId(entity);\n          const change = chgState[id];\n          if (change) {\n            if (!didMutate) {\n              chgState = { ...chgState };\n              didMutate = true;\n            }\n            delete chgState[id];\n          }\n          return chgState;\n        }, collection.changeState);\n\n        return didMutate ? { ...collection, changeState } : collection;\n\n      case MergeStrategy.PreserveChanges: {\n        const upsertEntities = [] as T[];\n        changeState = entities.reduce((chgState, entity) => {\n          const id = this.selectId(entity);\n          const change = chgState[id];\n          if (change) {\n            if (!didMutate) {\n              chgState = {\n                ...chgState,\n                [id]: {\n                  ...chgState[id]!,\n                  originalValue: entity,\n                },\n              };\n              didMutate = true;\n            }\n          } else {\n            upsertEntities.push(entity);\n          }\n          return chgState;\n        }, collection.changeState);\n\n        collection = this.adapter.upsertMany(upsertEntities, collection);\n        return didMutate ? { ...collection, changeState } : collection;\n      }\n    }\n  }\n  // #endregion query & save helpers\n\n  // #region track methods\n  /**\n   * Track multiple entities before adding them to the collection.\n   * Does NOT add to the collection (the reducer's job).\n   * @param entities The entities to add. They must all have their ids.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackAddMany(\n    entities: T[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    if (\n      mergeStrategy === MergeStrategy.IgnoreChanges ||\n      entities == null ||\n      entities.length === 0\n    ) {\n      return collection; // nothing to track\n    }\n    let didMutate = false;\n    const changeState = entities.reduce((chgState, entity) => {\n      const id = this.selectId(entity);\n      if (id == null || id === '') {\n        throw new Error(\n          `${collection.entityName} entity add requires a key to be tracked`\n        );\n      }\n      const trackedChange = chgState[id];\n\n      if (!trackedChange) {\n        if (!didMutate) {\n          didMutate = true;\n          chgState = { ...chgState };\n        }\n        chgState[id] = { changeType: ChangeType.Added };\n      }\n      return chgState;\n    }, collection.changeState);\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Track an entity before adding it to the collection.\n   * Does NOT add to the collection (the reducer's job).\n   * @param entity The entity to add. It must have an id.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   * If not specified, implementation supplies a default strategy.\n   */\n  trackAddOne(\n    entity: T,\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return entity == null\n      ? collection\n      : this.trackAddMany([entity], collection, mergeStrategy);\n  }\n\n  /**\n   * Track multiple entities before removing them with the intention of deleting them on the server.\n   * Does NOT remove from the collection (the reducer's job).\n   * @param keys The primary keys of the entities to delete.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackDeleteMany(\n    keys: (number | string)[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    if (\n      mergeStrategy === MergeStrategy.IgnoreChanges ||\n      keys == null ||\n      keys.length === 0\n    ) {\n      return collection; // nothing to track\n    }\n    let didMutate = false;\n    const entityMap = collection.entities;\n    const changeState = keys.reduce((chgState, id) => {\n      const originalValue = entityMap[id];\n      if (originalValue) {\n        const trackedChange = chgState[id];\n        if (trackedChange) {\n          if (trackedChange.changeType === ChangeType.Added) {\n            // Special case: stop tracking an added entity that you delete\n            // The caller must also detect this, remove it immediately from the collection\n            // and skip attempt to delete on the server.\n            cloneChgStateOnce();\n            delete chgState[id];\n          } else if (trackedChange.changeType === ChangeType.Updated) {\n            // Special case: switch change type from Updated to Deleted.\n            cloneChgStateOnce();\n            chgState[id] = { ...chgState[id], changeType: ChangeType.Deleted };\n          }\n        } else {\n          // Start tracking this entity\n          cloneChgStateOnce();\n          chgState[id] = { changeType: ChangeType.Deleted, originalValue };\n        }\n      }\n      return chgState;\n\n      function cloneChgStateOnce() {\n        if (!didMutate) {\n          didMutate = true;\n          chgState = { ...chgState };\n        }\n      }\n    }, collection.changeState);\n\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Track an entity before it is removed with the intention of deleting it on the server.\n   * Does NOT remove from the collection (the reducer's job).\n   * @param key The primary key of the entity to delete.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackDeleteOne(\n    key: number | string,\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return key == null\n      ? collection\n      : this.trackDeleteMany([key], collection, mergeStrategy);\n  }\n\n  /**\n   * Track multiple entities before updating them in the collection.\n   * Does NOT update the collection (the reducer's job).\n   * @param updates The entities to update.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackUpdateMany(\n    updates: Update<T>[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    if (\n      mergeStrategy === MergeStrategy.IgnoreChanges ||\n      updates == null ||\n      updates.length === 0\n    ) {\n      return collection; // nothing to track\n    }\n    let didMutate = false;\n    const entityMap = collection.entities;\n    const changeState = updates.reduce((chgState, update) => {\n      const { id, changes: entity } = update;\n      if (id == null || id === '') {\n        throw new Error(\n          `${collection.entityName} entity update requires a key to be tracked`\n        );\n      }\n      const originalValue = entityMap[id];\n      // Only track if it is in the collection. Silently ignore if it is not.\n      // @ngrx/entity adapter would also silently ignore.\n      // Todo: should missing update entity really be reported as an error?\n      if (originalValue) {\n        const trackedChange = chgState[id];\n        if (!trackedChange) {\n          if (!didMutate) {\n            didMutate = true;\n            chgState = { ...chgState };\n          }\n          chgState[id] = { changeType: ChangeType.Updated, originalValue };\n        }\n      }\n      return chgState;\n    }, collection.changeState);\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Track an entity before updating it in the collection.\n   * Does NOT update the collection (the reducer's job).\n   * @param update The entity to update.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackUpdateOne(\n    update: Update<T>,\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return update == null\n      ? collection\n      : this.trackUpdateMany([update], collection, mergeStrategy);\n  }\n\n  /**\n   * Track multiple entities before upserting (adding and updating) them to the collection.\n   * Does NOT update the collection (the reducer's job).\n   * @param entities The entities to add or update. They must be complete entities with ids.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackUpsertMany(\n    entities: T[],\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    if (\n      mergeStrategy === MergeStrategy.IgnoreChanges ||\n      entities == null ||\n      entities.length === 0\n    ) {\n      return collection; // nothing to track\n    }\n    let didMutate = false;\n    const entityMap = collection.entities;\n    const changeState = entities.reduce((chgState, entity) => {\n      const id = this.selectId(entity);\n      if (id == null || id === '') {\n        throw new Error(\n          `${collection.entityName} entity upsert requires a key to be tracked`\n        );\n      }\n      const trackedChange = chgState[id];\n\n      if (!trackedChange) {\n        if (!didMutate) {\n          didMutate = true;\n          chgState = { ...chgState };\n        }\n\n        const originalValue = entityMap[id];\n        chgState[id] =\n          originalValue == null\n            ? { changeType: ChangeType.Added }\n            : { changeType: ChangeType.Updated, originalValue };\n      }\n      return chgState;\n    }, collection.changeState);\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Track an entity before upsert (adding and updating) it to the collection.\n   * Does NOT update the collection (the reducer's job).\n   * @param entities The entity to add or update. It must be a complete entity with its id.\n   * @param collection The entity collection\n   * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.\n   */\n  trackUpsertOne(\n    entity: T,\n    collection: EntityCollection<T>,\n    mergeStrategy?: MergeStrategy\n  ): EntityCollection<T> {\n    return entity == null\n      ? collection\n      : this.trackUpsertMany([entity], collection, mergeStrategy);\n  }\n  // #endregion track methods\n\n  // #region undo methods\n  /**\n   * Revert the unsaved changes for all collection.\n   * Harmless when there are no entity changes to undo.\n   * @param collection The entity collection\n   */\n  undoAll(collection: EntityCollection<T>): EntityCollection<T> {\n    const ids = Object.keys(collection.changeState);\n\n    const { remove, upsert } = ids.reduce(\n      (acc, id) => {\n        const changeState = acc.chgState[id]!;\n        switch (changeState.changeType) {\n          case ChangeType.Added:\n            acc.remove.push(id);\n            break;\n          case ChangeType.Deleted:\n            const removed = changeState!.originalValue;\n            if (removed) {\n              acc.upsert.push(removed);\n            }\n            break;\n          case ChangeType.Updated:\n            acc.upsert.push(changeState!.originalValue!);\n            break;\n        }\n        return acc;\n      },\n      // entitiesToUndo\n      {\n        remove: [] as (number | string)[],\n        upsert: [] as T[],\n        chgState: collection.changeState,\n      }\n    );\n\n    collection = this.adapter.removeMany(remove as string[], collection);\n    collection = this.adapter.upsertMany(upsert, collection);\n\n    return { ...collection, changeState: {} };\n  }\n\n  /**\n   * Revert the unsaved changes for the given entities.\n   * Harmless when there are no entity changes to undo.\n   * @param entityOrIdList The entities to revert or their ids.\n   * @param collection The entity collection\n   */\n  undoMany(\n    entityOrIdList: (number | string | T)[],\n    collection: EntityCollection<T>\n  ): EntityCollection<T> {\n    if (entityOrIdList == null || entityOrIdList.length === 0) {\n      return collection; // nothing to undo\n    }\n    let didMutate = false;\n\n    const { changeState, remove, upsert } = entityOrIdList.reduce(\n      (acc, entityOrId) => {\n        let chgState = acc.changeState;\n        const id =\n          typeof entityOrId === 'object'\n            ? this.selectId(entityOrId)\n            : (entityOrId as string | number);\n        const change = chgState[id]!;\n        if (change) {\n          if (!didMutate) {\n            chgState = { ...chgState };\n            didMutate = true;\n          }\n          delete chgState[id]; // clear tracking of this entity\n          acc.changeState = chgState;\n          switch (change.changeType) {\n            case ChangeType.Added:\n              acc.remove.push(id);\n              break;\n            case ChangeType.Deleted:\n              const removed = change!.originalValue;\n              if (removed) {\n                acc.upsert.push(removed);\n              }\n              break;\n            case ChangeType.Updated:\n              acc.upsert.push(change!.originalValue!);\n              break;\n          }\n        }\n        return acc;\n      },\n      // entitiesToUndo\n      {\n        remove: [] as (number | string)[],\n        upsert: [] as T[],\n        changeState: collection.changeState,\n      }\n    );\n\n    collection = this.adapter.removeMany(remove as string[], collection);\n    collection = this.adapter.upsertMany(upsert, collection);\n    return didMutate ? { ...collection, changeState } : collection;\n  }\n\n  /**\n   * Revert the unsaved changes for the given entity.\n   * Harmless when there are no entity changes to undo.\n   * @param entityOrId The entity to revert or its id.\n   * @param collection The entity collection\n   */\n  undoOne(\n    entityOrId: number | string | T,\n    collection: EntityCollection<T>\n  ): EntityCollection<T> {\n    return entityOrId == null\n      ? collection\n      : this.undoMany([entityOrId], collection);\n  }\n  // #endregion undo methods\n}\n"]}