@ngrx/data 12.5.1 → 13.0.1

package/esm2020/ngrx-data.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdyeC1kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRhL25ncngtZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/src/actions/entity-action-factory.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EntityActionFactory {
+    // polymorphic create for the two signatures
+    create(nameOrPayload, entityOp, data, options) {
+        const payload = typeof nameOrPayload === 'string'
+            ? {
+                ...(options || {}),
+                entityName: nameOrPayload,
+                entityOp,
+                data,
+            }
+            : nameOrPayload;
+        return this.createCore(payload);
+    }
+    /**
+     * Create an EntityAction to perform an operation (op) for a particular entity type
+     * (entityName) with optional data and other optional flags
+     * @param payload Defines the EntityAction and its options
+     */
+    createCore(payload) {
+        const { entityName, entityOp, tag } = payload;
+        if (!entityName) {
+            throw new Error('Missing entity name for new action');
+        }
+        if (entityOp == null) {
+            throw new Error('Missing EntityOp for new action');
+        }
+        const type = this.formatActionType(entityOp, tag || entityName);
+        return { type, payload };
+    }
+    /**
+     * Create an EntityAction from another EntityAction, replacing properties with those from newPayload;
+     * @param from Source action that is the base for the new action
+     * @param newProperties New EntityAction properties that replace the source action properties
+     */
+    createFromAction(from, newProperties) {
+        return this.create({ ...from.payload, ...newProperties });
+    }
+    formatActionType(op, tag) {
+        return `[${tag}] ${op}`;
+        // return `${op} [${tag}]`.toUpperCase(); // example of an alternative
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EntityActionFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityActionFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ EntityActionFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityActionFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityActionFactory, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWFjdGlvbi1mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRhL3NyYy9hY3Rpb25zL2VudGl0eS1hY3Rpb24tZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVMzQyxNQUFNLE9BQU8sbUJBQW1CO0lBdUI5Qiw0Q0FBNEM7SUFDNUMsTUFBTSxDQUNKLGFBQThDLEVBQzlDLFFBQW1CLEVBQ25CLElBQVEsRUFDUixPQUE2QjtRQUU3QixNQUFNLE9BQU8sR0FDWCxPQUFPLGFBQWEsS0FBSyxRQUFRO1lBQy9CLENBQUMsQ0FBRTtnQkFDQyxHQUFHLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQztnQkFDbEIsVUFBVSxFQUFFLGFBQWE7Z0JBQ3pCLFFBQVE7Z0JBQ1IsSUFBSTthQUNzQjtZQUM5QixDQUFDLENBQUMsYUFBYSxDQUFDO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNPLFVBQVUsQ0FBVSxPQUErQjtRQUMzRCxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUM7UUFDOUMsSUFBSSxDQUFDLFVBQVUsRUFBRTtZQUNmLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztTQUN2RDtRQUNELElBQUksUUFBUSxJQUFJLElBQUksRUFBRTtZQUNwQixNQUFNLElBQUksS0FBSyxDQUFDLGlDQUFpQyxDQUFDLENBQUM7U0FDcEQ7UUFDRCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLEdBQUcsSUFBSSxVQUFVLENBQUMsQ0FBQztRQUNoRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsZ0JBQWdCLENBQ2QsSUFBa0IsRUFDbEIsYUFBOEM7UUFFOUMsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxFQUFFLEdBQUcsYUFBYSxFQUFFLENBQUMsQ0FBQztJQUM1RCxDQUFDO0lBRUQsZ0JBQWdCLENBQUMsRUFBVSxFQUFFLEdBQVc7UUFDdEMsT0FBTyxJQUFJLEdBQUcsS0FBSyxFQUFFLEVBQUUsQ0FBQztRQUN4QixzRUFBc0U7SUFDeEUsQ0FBQzs7c0pBMUVVLG1CQUFtQjswSkFBbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBRC9CLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEVudGl0eU9wIH0gZnJvbSAnLi9lbnRpdHktb3AnO1xuaW1wb3J0IHtcbiAgRW50aXR5QWN0aW9uLFxuICBFbnRpdHlBY3Rpb25PcHRpb25zLFxuICBFbnRpdHlBY3Rpb25QYXlsb2FkLFxufSBmcm9tICcuL2VudGl0eS1hY3Rpb24nO1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEVudGl0eUFjdGlvbkZhY3Rvcnkge1xuICAvKipcbiAgICogQ3JlYXRlIGFuIEVudGl0eUFjdGlvbiB0byBwZXJmb3JtIGFuIG9wZXJhdGlvbiAob3ApIGZvciBhIHBhcnRpY3VsYXIgZW50aXR5IHR5cGVcbiAgICogKGVudGl0eU5hbWUpIHdpdGggb3B0aW9uYWwgZGF0YSBhbmQgb3RoZXIgb3B0aW9uYWwgZmxhZ3NcbiAgICogQHBhcmFtIGVudGl0eU5hbWUgTmFtZSBvZiB0aGUgZW50aXR5IHR5cGVcbiAgICogQHBhcmFtIGVudGl0eU9wIE9wZXJhdGlvbiB0byBwZXJmb3JtIChFbnRpdHlPcClcbiAgICogQHBhcmFtIFtkYXRhXSBkYXRhIGZvciB0aGUgb3BlcmF0aW9uXG4gICAqIEBwYXJhbSBbb3B0aW9uc10gYWRkaXRpb25hbCBvcHRpb25zXG4gICAqL1xuICBjcmVhdGU8UCA9IGFueT4oXG4gICAgZW50aXR5TmFtZTogc3RyaW5nLFxuICAgIGVudGl0eU9wOiBFbnRpdHlPcCxcbiAgICBkYXRhPzogUCxcbiAgICBvcHRpb25zPzogRW50aXR5QWN0aW9uT3B0aW9uc1xuICApOiBFbnRpdHlBY3Rpb248UD47XG5cbiAgLyoqXG4gICAqIENyZWF0ZSBhbiBFbnRpdHlBY3Rpb24gdG8gcGVyZm9ybSBhbiBvcGVyYXRpb24gKG9wKSBmb3IgYSBwYXJ0aWN1bGFyIGVudGl0eSB0eXBlXG4gICAqIChlbnRpdHlOYW1lKSB3aXRoIG9wdGlvbmFsIGRhdGEgYW5kIG90aGVyIG9wdGlvbmFsIGZsYWdzXG4gICAqIEBwYXJhbSBwYXlsb2FkIERlZmluZXMgdGhlIEVudGl0eUFjdGlvbiBhbmQgaXRzIG9wdGlvbnNcbiAgICovXG4gIGNyZWF0ZTxQID0gYW55PihwYXlsb2FkOiBFbnRpdHlBY3Rpb25QYXlsb2FkPFA+KTogRW50aXR5QWN0aW9uPFA+O1xuXG4gIC8vIHBvbHltb3JwaGljIGNyZWF0ZSBmb3IgdGhlIHR3byBzaWduYXR1cmVzXG4gIGNyZWF0ZTxQID0gYW55PihcbiAgICBuYW1lT3JQYXlsb2FkOiBFbnRpdHlBY3Rpb25QYXlsb2FkPFA+IHwgc3RyaW5nLFxuICAgIGVudGl0eU9wPzogRW50aXR5T3AsXG4gICAgZGF0YT86IFAsXG4gICAgb3B0aW9ucz86IEVudGl0eUFjdGlvbk9wdGlvbnNcbiAgKTogRW50aXR5QWN0aW9uPFA+IHtcbiAgICBjb25zdCBwYXlsb2FkOiBFbnRpdHlBY3Rpb25QYXlsb2FkPFA+ID1cbiAgICAgIHR5cGVvZiBuYW1lT3JQYXlsb2FkID09PSAnc3RyaW5nJ1xuICAgICAgICA/ICh7XG4gICAgICAgICAgICAuLi4ob3B0aW9ucyB8fCB7fSksXG4gICAgICAgICAgICBlbnRpdHlOYW1lOiBuYW1lT3JQYXlsb2FkLFxuICAgICAgICAgICAgZW50aXR5T3AsXG4gICAgICAgICAgICBkYXRhLFxuICAgICAgICAgIH0gYXMgRW50aXR5QWN0aW9uUGF5bG9hZDxQPilcbiAgICAgICAgOiBuYW1lT3JQYXlsb2FkO1xuICAgIHJldHVybiB0aGlzLmNyZWF0ZUNvcmUocGF5bG9hZCk7XG4gIH1cblxuICAvKipcbiAgICogQ3JlYXRlIGFuIEVudGl0eUFjdGlvbiB0byBwZXJmb3JtIGFuIG9wZXJhdGlvbiAob3ApIGZvciBhIHBhcnRpY3VsYXIgZW50aXR5IHR5cGVcbiAgICogKGVudGl0eU5hbWUpIHdpdGggb3B0aW9uYWwgZGF0YSBhbmQgb3RoZXIgb3B0aW9uYWwgZmxhZ3NcbiAgICogQHBhcmFtIHBheWxvYWQgRGVmaW5lcyB0aGUgRW50aXR5QWN0aW9uIGFuZCBpdHMgb3B0aW9uc1xuICAgKi9cbiAgcHJvdGVjdGVkIGNyZWF0ZUNvcmU8UCA9IGFueT4ocGF5bG9hZDogRW50aXR5QWN0aW9uUGF5bG9hZDxQPikge1xuICAgIGNvbnN0IHsgZW50aXR5TmFtZSwgZW50aXR5T3AsIHRhZyB9ID0gcGF5bG9hZDtcbiAgICBpZiAoIWVudGl0eU5hbWUpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignTWlzc2luZyBlbnRpdHkgbmFtZSBmb3IgbmV3IGFjdGlvbicpO1xuICAgIH1cbiAgICBpZiAoZW50aXR5T3AgPT0gbnVsbCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdNaXNzaW5nIEVudGl0eU9wIGZvciBuZXcgYWN0aW9uJyk7XG4gICAgfVxuICAgIGNvbnN0IHR5cGUgPSB0aGlzLmZvcm1hdEFjdGlvblR5cGUoZW50aXR5T3AsIHRhZyB8fCBlbnRpdHlOYW1lKTtcbiAgICByZXR1cm4geyB0eXBlLCBwYXlsb2FkIH07XG4gIH1cblxuICAvKipcbiAgICogQ3JlYXRlIGFuIEVudGl0eUFjdGlvbiBmcm9tIGFub3RoZXIgRW50aXR5QWN0aW9uLCByZXBsYWNpbmcgcHJvcGVydGllcyB3aXRoIHRob3NlIGZyb20gbmV3UGF5bG9hZDtcbiAgICogQHBhcmFtIGZyb20gU291cmNlIGFjdGlvbiB0aGF0IGlzIHRoZSBiYXNlIGZvciB0aGUgbmV3IGFjdGlvblxuICAgKiBAcGFyYW0gbmV3UHJvcGVydGllcyBOZXcgRW50aXR5QWN0aW9uIHByb3BlcnRpZXMgdGhhdCByZXBsYWNlIHRoZSBzb3VyY2UgYWN0aW9uIHByb3BlcnRpZXNcbiAgICovXG4gIGNyZWF0ZUZyb21BY3Rpb248UCA9IGFueT4oXG4gICAgZnJvbTogRW50aXR5QWN0aW9uLFxuICAgIG5ld1Byb3BlcnRpZXM6IFBhcnRpYWw8RW50aXR5QWN0aW9uUGF5bG9hZDxQPj5cbiAgKTogRW50aXR5QWN0aW9uPFA+IHtcbiAgICByZXR1cm4gdGhpcy5jcmVhdGUoeyAuLi5mcm9tLnBheWxvYWQsIC4uLm5ld1Byb3BlcnRpZXMgfSk7XG4gIH1cblxuICBmb3JtYXRBY3Rpb25UeXBlKG9wOiBzdHJpbmcsIHRhZzogc3RyaW5nKSB7XG4gICAgcmV0dXJuIGBbJHt0YWd9XSAke29wfWA7XG4gICAgLy8gcmV0dXJuIGAke29wfSBbJHt0YWd9XWAudG9VcHBlckNhc2UoKTsgLy8gZXhhbXBsZSBvZiBhbiBhbHRlcm5hdGl2ZVxuICB9XG59XG4iXX0=

package/esm2020/src/actions/entity-cache-action.mjs

@@ -0,0 +1,116 @@
+export { ChangeSetOperation } from './entity-cache-change-set';
+import { MergeStrategy } from '../actions/merge-strategy';
+export var EntityCacheAction;
+(function (EntityCacheAction) {
+    EntityCacheAction["CLEAR_COLLECTIONS"] = "@ngrx/data/entity-cache/clear-collections";
+    EntityCacheAction["LOAD_COLLECTIONS"] = "@ngrx/data/entity-cache/load-collections";
+    EntityCacheAction["MERGE_QUERY_SET"] = "@ngrx/data/entity-cache/merge-query-set";
+    EntityCacheAction["SET_ENTITY_CACHE"] = "@ngrx/data/entity-cache/set-cache";
+    EntityCacheAction["SAVE_ENTITIES"] = "@ngrx/data/entity-cache/save-entities";
+    EntityCacheAction["SAVE_ENTITIES_CANCEL"] = "@ngrx/data/entity-cache/save-entities-cancel";
+    EntityCacheAction["SAVE_ENTITIES_CANCELED"] = "@ngrx/data/entity-cache/save-entities-canceled";
+    EntityCacheAction["SAVE_ENTITIES_ERROR"] = "@ngrx/data/entity-cache/save-entities-error";
+    EntityCacheAction["SAVE_ENTITIES_SUCCESS"] = "@ngrx/data/entity-cache/save-entities-success";
+})(EntityCacheAction || (EntityCacheAction = {}));
+/**
+ * Clear the collections identified in the collectionSet.
+ * @param [collections] Array of names of the collections to clear.
+ * If empty array, does nothing. If no array, clear all collections.
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+export class ClearCollections {
+    constructor(collections, tag) {
+        this.type = EntityCacheAction.CLEAR_COLLECTIONS;
+        this.payload = { collections, tag };
+    }
+}
+/**
+ * Create entity cache action that loads multiple entity collections at the same time.
+ * before any selectors$ observables emit.
+ * @param querySet The collections to load, typically the result of a query.
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ * in the form of a map of entity collections.
+ */
+export class LoadCollections {
+    constructor(collections, tag) {
+        this.type = EntityCacheAction.LOAD_COLLECTIONS;
+        this.payload = { collections, tag };
+    }
+}
+/**
+ * Create entity cache action that merges entities from a query result
+ * that returned entities from multiple collections.
+ * Corresponding entity cache reducer should add and update all collections
+ * at the same time, before any selectors$ observables emit.
+ * @param querySet The result of the query in the form of a map of entity collections.
+ * These are the entity data to merge into the respective collections.
+ * @param mergeStrategy How to merge a queried entity when it is already in the collection.
+ * The default is MergeStrategy.PreserveChanges
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+export class MergeQuerySet {
+    constructor(querySet, mergeStrategy, tag) {
+        this.type = EntityCacheAction.MERGE_QUERY_SET;
+        this.payload = {
+            querySet,
+            mergeStrategy: mergeStrategy === null ? MergeStrategy.PreserveChanges : mergeStrategy,
+            tag,
+        };
+    }
+}
+/**
+ * Create entity cache action for replacing the entire entity cache.
+ * Dangerous because brute force but useful as when re-hydrating an EntityCache
+ * from local browser storage when the application launches.
+ * @param cache New state of the entity cache
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+export class SetEntityCache {
+    constructor(cache, tag) {
+        this.cache = cache;
+        this.type = EntityCacheAction.SET_ENTITY_CACHE;
+        this.payload = { cache, tag };
+    }
+}
+// #region SaveEntities
+export class SaveEntities {
+    constructor(changeSet, url, options) {
+        this.type = EntityCacheAction.SAVE_ENTITIES;
+        options = options || {};
+        if (changeSet) {
+            changeSet.tag = changeSet.tag || options.tag;
+        }
+        this.payload = { changeSet, url, ...options, tag: changeSet.tag };
+    }
+}
+export class SaveEntitiesCancel {
+    constructor(correlationId, reason, entityNames, tag) {
+        this.type = EntityCacheAction.SAVE_ENTITIES_CANCEL;
+        this.payload = { correlationId, reason, entityNames, tag };
+    }
+}
+export class SaveEntitiesCanceled {
+    constructor(correlationId, reason, tag) {
+        this.type = EntityCacheAction.SAVE_ENTITIES_CANCELED;
+        this.payload = { correlationId, reason, tag };
+    }
+}
+export class SaveEntitiesError {
+    constructor(error, originalAction) {
+        this.type = EntityCacheAction.SAVE_ENTITIES_ERROR;
+        const correlationId = originalAction.payload.correlationId;
+        this.payload = { error, originalAction, correlationId };
+    }
+}
+export class SaveEntitiesSuccess {
+    constructor(changeSet, url, options) {
+        this.type = EntityCacheAction.SAVE_ENTITIES_SUCCESS;
+        options = options || {};
+        if (changeSet) {
+            changeSet.tag = changeSet.tag || options.tag;
+        }
+        this.payload = { changeSet, url, ...options, tag: changeSet.tag };
+    }
+}
+// #endregion SaveEntities
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-cache-action.js","sourceRoot":"","sources":["../../../../../../modules/data/src/actions/entity-cache-action.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Actions dedicated to the EntityCache as a whole\n */\nimport { Action } from '@ngrx/store';\n\nimport { ChangeSet, ChangeSetOperation } from './entity-cache-change-set';\nexport { ChangeSet, ChangeSetOperation } from './entity-cache-change-set';\n\nimport { DataServiceError } from '../dataservices/data-service-error';\nimport { EntityActionOptions } from '../actions/entity-action';\nimport { EntityCache } from '../reducers/entity-cache';\nimport { MergeStrategy } from '../actions/merge-strategy';\n\nexport enum EntityCacheAction {\n  CLEAR_COLLECTIONS = '@ngrx/data/entity-cache/clear-collections',\n  LOAD_COLLECTIONS = '@ngrx/data/entity-cache/load-collections',\n  MERGE_QUERY_SET = '@ngrx/data/entity-cache/merge-query-set',\n  SET_ENTITY_CACHE = '@ngrx/data/entity-cache/set-cache',\n\n  SAVE_ENTITIES = '@ngrx/data/entity-cache/save-entities',\n  SAVE_ENTITIES_CANCEL = '@ngrx/data/entity-cache/save-entities-cancel',\n  SAVE_ENTITIES_CANCELED = '@ngrx/data/entity-cache/save-entities-canceled',\n  SAVE_ENTITIES_ERROR = '@ngrx/data/entity-cache/save-entities-error',\n  SAVE_ENTITIES_SUCCESS = '@ngrx/data/entity-cache/save-entities-success',\n}\n\n/**\n * Hash of entities keyed by EntityCollection name,\n * typically the result of a query that returned results from a multi-collection query\n * that will be merged into an EntityCache via the `MergeQuerySet` action.\n */\nexport interface EntityCacheQuerySet {\n  [entityName: string]: any[];\n}\n\n/**\n * Clear the collections identified in the collectionSet.\n * @param [collections] Array of names of the collections to clear.\n * If empty array, does nothing. If no array, clear all collections.\n * @param [tag] Optional tag to identify the operation from the app perspective.\n */\nexport class ClearCollections implements Action {\n  readonly payload: { collections?: string[]; tag?: string };\n  readonly type = EntityCacheAction.CLEAR_COLLECTIONS;\n\n  constructor(collections?: string[], tag?: string) {\n    this.payload = { collections, tag };\n  }\n}\n\n/**\n * Create entity cache action that loads multiple entity collections at the same time.\n * before any selectors$ observables emit.\n * @param querySet The collections to load, typically the result of a query.\n * @param [tag] Optional tag to identify the operation from the app perspective.\n * in the form of a map of entity collections.\n */\nexport class LoadCollections implements Action {\n  readonly payload: { collections: EntityCacheQuerySet; tag?: string };\n  readonly type = EntityCacheAction.LOAD_COLLECTIONS;\n\n  constructor(collections: EntityCacheQuerySet, tag?: string) {\n    this.payload = { collections, tag };\n  }\n}\n\n/**\n * Create entity cache action that merges entities from a query result\n * that returned entities from multiple collections.\n * Corresponding entity cache reducer should add and update all collections\n * at the same time, before any selectors$ observables emit.\n * @param querySet The result of the query in the form of a map of entity collections.\n * These are the entity data to merge into the respective collections.\n * @param mergeStrategy How to merge a queried entity when it is already in the collection.\n * The default is MergeStrategy.PreserveChanges\n * @param [tag] Optional tag to identify the operation from the app perspective.\n */\nexport class MergeQuerySet implements Action {\n  readonly payload: {\n    querySet: EntityCacheQuerySet;\n    mergeStrategy?: MergeStrategy;\n    tag?: string;\n  };\n\n  readonly type = EntityCacheAction.MERGE_QUERY_SET;\n\n  constructor(\n    querySet: EntityCacheQuerySet,\n    mergeStrategy?: MergeStrategy,\n    tag?: string\n  ) {\n    this.payload = {\n      querySet,\n      mergeStrategy:\n        mergeStrategy === null ? MergeStrategy.PreserveChanges : mergeStrategy,\n      tag,\n    };\n  }\n}\n\n/**\n * Create entity cache action for replacing the entire entity cache.\n * Dangerous because brute force but useful as when re-hydrating an EntityCache\n * from local browser storage when the application launches.\n * @param cache New state of the entity cache\n * @param [tag] Optional tag to identify the operation from the app perspective.\n */\nexport class SetEntityCache implements Action {\n  readonly payload: { cache: EntityCache; tag?: string };\n  readonly type = EntityCacheAction.SET_ENTITY_CACHE;\n\n  constructor(public readonly cache: EntityCache, tag?: string) {\n    this.payload = { cache, tag };\n  }\n}\n\n// #region SaveEntities\nexport class SaveEntities implements Action {\n  readonly payload: {\n    readonly changeSet: ChangeSet;\n    readonly url: string;\n    readonly correlationId?: any;\n    readonly isOptimistic?: boolean;\n    readonly mergeStrategy?: MergeStrategy;\n    readonly tag?: string;\n    error?: Error;\n    skip?: boolean; // not used\n  };\n  readonly type = EntityCacheAction.SAVE_ENTITIES;\n\n  constructor(\n    changeSet: ChangeSet,\n    url: string,\n    options?: EntityActionOptions\n  ) {\n    options = options || {};\n    if (changeSet) {\n      changeSet.tag = changeSet.tag || options.tag;\n    }\n    this.payload = { changeSet, url, ...options, tag: changeSet.tag };\n  }\n}\n\nexport class SaveEntitiesCancel implements Action {\n  readonly payload: {\n    readonly correlationId: any;\n    readonly reason?: string;\n    readonly entityNames?: string[];\n    readonly tag?: string;\n  };\n  readonly type = EntityCacheAction.SAVE_ENTITIES_CANCEL;\n\n  constructor(\n    correlationId: any,\n    reason?: string,\n    entityNames?: string[],\n    tag?: string\n  ) {\n    this.payload = { correlationId, reason, entityNames, tag };\n  }\n}\n\nexport class SaveEntitiesCanceled implements Action {\n  readonly payload: {\n    readonly correlationId: any;\n    readonly reason?: string;\n    readonly tag?: string;\n  };\n  readonly type = EntityCacheAction.SAVE_ENTITIES_CANCELED;\n\n  constructor(correlationId: any, reason?: string, tag?: string) {\n    this.payload = { correlationId, reason, tag };\n  }\n}\n\nexport class SaveEntitiesError {\n  readonly payload: {\n    readonly error: DataServiceError;\n    readonly originalAction: SaveEntities;\n    readonly correlationId: any;\n  };\n  readonly type = EntityCacheAction.SAVE_ENTITIES_ERROR;\n  constructor(error: DataServiceError, originalAction: SaveEntities) {\n    const correlationId = originalAction.payload.correlationId;\n    this.payload = { error, originalAction, correlationId };\n  }\n}\n\nexport class SaveEntitiesSuccess implements Action {\n  readonly payload: {\n    readonly changeSet: ChangeSet;\n    readonly url: string;\n    readonly correlationId?: any;\n    readonly isOptimistic?: boolean;\n    readonly mergeStrategy?: MergeStrategy;\n    readonly tag?: string;\n    error?: Error;\n    skip?: boolean; // not used\n  };\n  readonly type = EntityCacheAction.SAVE_ENTITIES_SUCCESS;\n\n  constructor(\n    changeSet: ChangeSet,\n    url: string,\n    options?: EntityActionOptions\n  ) {\n    options = options || {};\n    if (changeSet) {\n      changeSet.tag = changeSet.tag || options.tag;\n    }\n    this.payload = { changeSet, url, ...options, tag: changeSet.tag };\n  }\n}\n// #endregion SaveEntities\n"]}

package/esm2020/src/actions/entity-cache-change-set.mjs

@@ -0,0 +1,50 @@
+export var ChangeSetOperation;
+(function (ChangeSetOperation) {
+    ChangeSetOperation["Add"] = "Add";
+    ChangeSetOperation["Delete"] = "Delete";
+    ChangeSetOperation["Update"] = "Update";
+    ChangeSetOperation["Upsert"] = "Upsert";
+})(ChangeSetOperation || (ChangeSetOperation = {}));
+/**
+ * Factory to create a ChangeSetItem for a ChangeSetOperation
+ */
+export class ChangeSetItemFactory {
+    /** Create the ChangeSetAdd for new entities of the given entity type */
+    add(entityName, entities) {
+        entities = Array.isArray(entities) ? entities : entities ? [entities] : [];
+        return { entityName, op: ChangeSetOperation.Add, entities };
+    }
+    /** Create the ChangeSetDelete for primary keys of the given entity type */
+    delete(entityName, keys) {
+        const ids = Array.isArray(keys)
+            ? keys
+            : keys
+                ? [keys]
+                : [];
+        return { entityName, op: ChangeSetOperation.Delete, entities: ids };
+    }
+    /** Create the ChangeSetUpdate for Updates of entities of the given entity type */
+    update(entityName, updates) {
+        updates = Array.isArray(updates) ? updates : updates ? [updates] : [];
+        return { entityName, op: ChangeSetOperation.Update, entities: updates };
+    }
+    /** Create the ChangeSetUpsert for new or existing entities of the given entity type */
+    upsert(entityName, entities) {
+        entities = Array.isArray(entities) ? entities : entities ? [entities] : [];
+        return { entityName, op: ChangeSetOperation.Upsert, entities };
+    }
+}
+/**
+ * Instance of a factory to create a ChangeSetItem for a ChangeSetOperation
+ */
+export const changeSetItemFactory = new ChangeSetItemFactory();
+/**
+ * Return ChangeSet after filtering out null and empty ChangeSetItems.
+ * @param changeSet ChangeSet with changes to filter
+ */
+export function excludeEmptyChangeSetItems(changeSet) {
+    changeSet = changeSet && changeSet.changes ? changeSet : { changes: [] };
+    const changes = changeSet.changes.filter((c) => c != null && c.entities && c.entities.length > 0);
+    return { ...changeSet, changes };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/src/dataservices/default-data.service.js → esm2020/src/dataservices/default-data.service.mjs}

@@ -1,10 +1,12 @@
 import { Injectable, Optional } from '@angular/core';
-import { HttpClient, HttpParams, } from '@angular/common/http';
+import { HttpParams, } from '@angular/common/http';
 import { of, throwError } from 'rxjs';
 import { catchError, delay, map, timeout } from 'rxjs/operators';
 import { DataServiceError } from './data-service-error';
-import { DefaultDataServiceConfig } from './default-data-service-config';
-import { HttpUrlGenerator } from './http-url-generator';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./http-url-generator";
+import * as i3 from "./default-data-service-config";
 /**
  * A basic, generic entity data service
  * suitable for persistence of most entities.
@@ -159,20 +161,11 @@ export class DefaultDataServiceFactory {
         return new DefaultDataService(entityName, this.http, this.httpUrlGenerator, this.config);
     }
 }
-/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
-DefaultDataServiceFactory.decorators = [
-    { type: Injectable }
-];
-/**
- * @type {function(): !Array<(null|{
- *   type: ?,
- *   decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>),
- * })>}
- * @nocollapse
- */
-DefaultDataServiceFactory.ctorParameters = () => [
-    { type: HttpClient },
-    { type: HttpUrlGenerator },
-    { type: DefaultDataServiceConfig, decorators: [{ type: Optional }] }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-data.service.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dataservices/default-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport {\n  HttpClient,\n  HttpErrorResponse,\n  HttpParams,\n} from '@angular/common/http';\n\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, delay, map, timeout } from 'rxjs/operators';\n\nimport { Update } from '@ngrx/entity';\n\nimport { DataServiceError } from './data-service-error';\nimport { DefaultDataServiceConfig } from './default-data-service-config';\nimport {\n  EntityCollectionDataService,\n  HttpMethods,\n  QueryParams,\n  RequestData,\n} from './interfaces';\nimport { HttpUrlGenerator } from './http-url-generator';\n\n/**\n * A basic, generic entity data service\n * suitable for persistence of most entities.\n * Assumes a common REST-y web API\n */\nexport class DefaultDataService<T> implements EntityCollectionDataService<T> {\n  protected _name: string;\n  protected delete404OK: boolean;\n  protected entityName: string;\n  protected entityUrl: string;\n  protected entitiesUrl: string;\n  protected getDelay = 0;\n  protected saveDelay = 0;\n  protected timeout = 0;\n\n  get name() {\n    return this._name;\n  }\n\n  constructor(\n    entityName: string,\n    protected http: HttpClient,\n    protected httpUrlGenerator: HttpUrlGenerator,\n    config?: DefaultDataServiceConfig\n  ) {\n    this._name = `${entityName} DefaultDataService`;\n    this.entityName = entityName;\n    const {\n      root = 'api',\n      delete404OK = true,\n      getDelay = 0,\n      saveDelay = 0,\n      timeout: to = 0,\n    } = config || {};\n    this.delete404OK = delete404OK;\n    this.entityUrl = httpUrlGenerator.entityResource(entityName, root);\n    this.entitiesUrl = httpUrlGenerator.collectionResource(entityName, root);\n    this.getDelay = getDelay;\n    this.saveDelay = saveDelay;\n    this.timeout = to;\n  }\n\n  add(entity: T): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to add`);\n    return this.execute('POST', this.entityUrl, entityOrError);\n  }\n\n  delete(key: number | string): Observable<number | string> {\n    let err: Error | undefined;\n    if (key == null) {\n      err = new Error(`No \"${this.entityName}\" key to delete`);\n    }\n    return this.execute('DELETE', this.entityUrl + key, err).pipe(\n      // forward the id of deleted entity as the result of the HTTP DELETE\n      map((result) => key as number | string)\n    );\n  }\n\n  getAll(): Observable<T[]> {\n    return this.execute('GET', this.entitiesUrl);\n  }\n\n  getById(key: number | string): Observable<T> {\n    let err: Error | undefined;\n    if (key == null) {\n      err = new Error(`No \"${this.entityName}\" key to get`);\n    }\n    return this.execute('GET', this.entityUrl + key, err);\n  }\n\n  getWithQuery(queryParams: QueryParams | string): Observable<T[]> {\n    const qParams =\n      typeof queryParams === 'string'\n        ? { fromString: queryParams }\n        : { fromObject: queryParams };\n    const params = new HttpParams(qParams);\n    return this.execute('GET', this.entitiesUrl, undefined, { params });\n  }\n\n  update(update: Update<T>): Observable<T> {\n    const id = update && update.id;\n    const updateOrError =\n      id == null\n        ? new Error(`No \"${this.entityName}\" update data or id`)\n        : update.changes;\n    return this.execute('PUT', this.entityUrl + id, updateOrError);\n  }\n\n  // Important! Only call if the backend service supports upserts as a POST to the target URL\n  upsert(entity: T): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to upsert`);\n    return this.execute('POST', this.entityUrl, entityOrError);\n  }\n\n  protected execute(\n    method: HttpMethods,\n    url: string,\n    data?: any, // data, error, or undefined/null\n    options?: any\n  ): Observable<any> {\n    const req: RequestData = { method, url, data, options };\n\n    if (data instanceof Error) {\n      return this.handleError(req)(data);\n    }\n\n    let result$: Observable<ArrayBuffer>;\n\n    switch (method) {\n      case 'DELETE': {\n        result$ = this.http.delete(url, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      case 'GET': {\n        result$ = this.http.get(url, options);\n        if (this.getDelay) {\n          result$ = result$.pipe(delay(this.getDelay));\n        }\n        break;\n      }\n      case 'POST': {\n        result$ = this.http.post(url, data, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      // N.B.: It must return an Update<T>\n      case 'PUT': {\n        result$ = this.http.put(url, data, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      default: {\n        const error = new Error('Unimplemented HTTP method, ' + method);\n        result$ = throwError(error);\n      }\n    }\n    if (this.timeout) {\n      result$ = result$.pipe(timeout(this.timeout + this.saveDelay));\n    }\n    return result$.pipe(catchError(this.handleError(req)));\n  }\n\n  private handleError(reqData: RequestData) {\n    return (err: any) => {\n      const ok = this.handleDelete404(err, reqData);\n      if (ok) {\n        return ok;\n      }\n      const error = new DataServiceError(err, reqData);\n      return throwError(error);\n    };\n  }\n\n  private handleDelete404(error: HttpErrorResponse, reqData: RequestData) {\n    if (\n      error.status === 404 &&\n      reqData.method === 'DELETE' &&\n      this.delete404OK\n    ) {\n      return of({});\n    }\n    return undefined;\n  }\n}\n\n/**\n * Create a basic, generic entity data service\n * suitable for persistence of most entities.\n * Assumes a common REST-y web API\n */\n@Injectable()\nexport class DefaultDataServiceFactory {\n  constructor(\n    protected http: HttpClient,\n    protected httpUrlGenerator: HttpUrlGenerator,\n    @Optional() protected config?: DefaultDataServiceConfig\n  ) {\n    config = config || {};\n    httpUrlGenerator.registerHttpResourceUrls(config.entityHttpResourceUrls);\n  }\n\n  /**\n   * Create a default {EntityCollectionDataService} for the given entity type\n   * @param entityName {string} Name of the entity type for this data service\n   */\n  create<T>(entityName: string): EntityCollectionDataService<T> {\n    return new DefaultDataService<T>(\n      entityName,\n      this.http,\n      this.httpUrlGenerator,\n      this.config\n    );\n  }\n}\n"]}
+/** @nocollapse */ /** @nocollapse */ DefaultDataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DefaultDataServiceFactory, deps: [{ token: i1.HttpClient }, { token: i2.HttpUrlGenerator }, { token: i3.DefaultDataServiceConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DefaultDataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DefaultDataServiceFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DefaultDataServiceFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.HttpUrlGenerator }, { type: i3.DefaultDataServiceConfig, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-data.service.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dataservices/default-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport {\n  HttpClient,\n  HttpErrorResponse,\n  HttpParams,\n} from '@angular/common/http';\n\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, delay, map, timeout } from 'rxjs/operators';\n\nimport { Update } from '@ngrx/entity';\n\nimport { DataServiceError } from './data-service-error';\nimport { DefaultDataServiceConfig } from './default-data-service-config';\nimport {\n  EntityCollectionDataService,\n  HttpMethods,\n  QueryParams,\n  RequestData,\n} from './interfaces';\nimport { HttpUrlGenerator } from './http-url-generator';\n\n/**\n * A basic, generic entity data service\n * suitable for persistence of most entities.\n * Assumes a common REST-y web API\n */\nexport class DefaultDataService<T> implements EntityCollectionDataService<T> {\n  protected _name: string;\n  protected delete404OK: boolean;\n  protected entityName: string;\n  protected entityUrl: string;\n  protected entitiesUrl: string;\n  protected getDelay = 0;\n  protected saveDelay = 0;\n  protected timeout = 0;\n\n  get name() {\n    return this._name;\n  }\n\n  constructor(\n    entityName: string,\n    protected http: HttpClient,\n    protected httpUrlGenerator: HttpUrlGenerator,\n    config?: DefaultDataServiceConfig\n  ) {\n    this._name = `${entityName} DefaultDataService`;\n    this.entityName = entityName;\n    const {\n      root = 'api',\n      delete404OK = true,\n      getDelay = 0,\n      saveDelay = 0,\n      timeout: to = 0,\n    } = config || {};\n    this.delete404OK = delete404OK;\n    this.entityUrl = httpUrlGenerator.entityResource(entityName, root);\n    this.entitiesUrl = httpUrlGenerator.collectionResource(entityName, root);\n    this.getDelay = getDelay;\n    this.saveDelay = saveDelay;\n    this.timeout = to;\n  }\n\n  add(entity: T): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to add`);\n    return this.execute('POST', this.entityUrl, entityOrError);\n  }\n\n  delete(key: number | string): Observable<number | string> {\n    let err: Error | undefined;\n    if (key == null) {\n      err = new Error(`No \"${this.entityName}\" key to delete`);\n    }\n    return this.execute('DELETE', this.entityUrl + key, err).pipe(\n      // forward the id of deleted entity as the result of the HTTP DELETE\n      map((result) => key as number | string)\n    );\n  }\n\n  getAll(): Observable<T[]> {\n    return this.execute('GET', this.entitiesUrl);\n  }\n\n  getById(key: number | string): Observable<T> {\n    let err: Error | undefined;\n    if (key == null) {\n      err = new Error(`No \"${this.entityName}\" key to get`);\n    }\n    return this.execute('GET', this.entityUrl + key, err);\n  }\n\n  getWithQuery(queryParams: QueryParams | string): Observable<T[]> {\n    const qParams =\n      typeof queryParams === 'string'\n        ? { fromString: queryParams }\n        : { fromObject: queryParams };\n    const params = new HttpParams(qParams);\n    return this.execute('GET', this.entitiesUrl, undefined, { params });\n  }\n\n  update(update: Update<T>): Observable<T> {\n    const id = update && update.id;\n    const updateOrError =\n      id == null\n        ? new Error(`No \"${this.entityName}\" update data or id`)\n        : update.changes;\n    return this.execute('PUT', this.entityUrl + id, updateOrError);\n  }\n\n  // Important! Only call if the backend service supports upserts as a POST to the target URL\n  upsert(entity: T): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to upsert`);\n    return this.execute('POST', this.entityUrl, entityOrError);\n  }\n\n  protected execute(\n    method: HttpMethods,\n    url: string,\n    data?: any, // data, error, or undefined/null\n    options?: any\n  ): Observable<any> {\n    const req: RequestData = { method, url, data, options };\n\n    if (data instanceof Error) {\n      return this.handleError(req)(data);\n    }\n\n    let result$: Observable<ArrayBuffer>;\n\n    switch (method) {\n      case 'DELETE': {\n        result$ = this.http.delete(url, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      case 'GET': {\n        result$ = this.http.get(url, options);\n        if (this.getDelay) {\n          result$ = result$.pipe(delay(this.getDelay));\n        }\n        break;\n      }\n      case 'POST': {\n        result$ = this.http.post(url, data, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      // N.B.: It must return an Update<T>\n      case 'PUT': {\n        result$ = this.http.put(url, data, options);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      default: {\n        const error = new Error('Unimplemented HTTP method, ' + method);\n        result$ = throwError(error);\n      }\n    }\n    if (this.timeout) {\n      result$ = result$.pipe(timeout(this.timeout + this.saveDelay));\n    }\n    return result$.pipe(catchError(this.handleError(req)));\n  }\n\n  private handleError(reqData: RequestData) {\n    return (err: any) => {\n      const ok = this.handleDelete404(err, reqData);\n      if (ok) {\n        return ok;\n      }\n      const error = new DataServiceError(err, reqData);\n      return throwError(error);\n    };\n  }\n\n  private handleDelete404(error: HttpErrorResponse, reqData: RequestData) {\n    if (\n      error.status === 404 &&\n      reqData.method === 'DELETE' &&\n      this.delete404OK\n    ) {\n      return of({});\n    }\n    return undefined;\n  }\n}\n\n/**\n * Create a basic, generic entity data service\n * suitable for persistence of most entities.\n * Assumes a common REST-y web API\n */\n@Injectable()\nexport class DefaultDataServiceFactory {\n  constructor(\n    protected http: HttpClient,\n    protected httpUrlGenerator: HttpUrlGenerator,\n    @Optional() protected config?: DefaultDataServiceConfig\n  ) {\n    config = config || {};\n    httpUrlGenerator.registerHttpResourceUrls(config.entityHttpResourceUrls);\n  }\n\n  /**\n   * Create a default {EntityCollectionDataService} for the given entity type\n   * @param entityName {string} Name of the entity type for this data service\n   */\n  create<T>(entityName: string): EntityCollectionDataService<T> {\n    return new DefaultDataService<T>(\n      entityName,\n      this.http,\n      this.httpUrlGenerator,\n      this.config\n    );\n  }\n}\n"]}

package/esm2020/src/dataservices/entity-cache-data.service.mjs

@@ -0,0 +1,146 @@
+import { Injectable, Optional } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, delay, map, timeout } from 'rxjs/operators';
+import { ChangeSetOperation, excludeEmptyChangeSetItems, } from '../actions/entity-cache-change-set';
+import { DataServiceError } from './data-service-error';
+import * as i0 from "@angular/core";
+import * as i1 from "../entity-metadata/entity-definition.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "./default-data-service-config";
+const updateOp = ChangeSetOperation.Update;
+/**
+ * Default data service for making remote service calls targeting the entire EntityCache.
+ * See EntityDataService for services that target a single EntityCollection
+ */
+export class EntityCacheDataService {
+    constructor(entityDefinitionService, http, config) {
+        this.entityDefinitionService = entityDefinitionService;
+        this.http = http;
+        this.idSelectors = {};
+        this.saveDelay = 0;
+        this.timeout = 0;
+        const { saveDelay = 0, timeout: to = 0 } = config || {};
+        this.saveDelay = saveDelay;
+        this.timeout = to;
+    }
+    /**
+     * Save changes to multiple entities across one or more entity collections.
+     * Server endpoint must understand the essential SaveEntities protocol,
+     * in particular the ChangeSet interface (except for Update<T>).
+     * This implementation extracts the entity changes from a ChangeSet Update<T>[] and sends those.
+     * It then reconstructs Update<T>[] in the returned observable result.
+     * @param changeSet  An array of SaveEntityItems.
+     * Each SaveEntityItem describe a change operation for one or more entities of a single collection,
+     * known by its 'entityName'.
+     * @param url The server endpoint that receives this request.
+     */
+    saveEntities(changeSet, url) {
+        changeSet = this.filterChangeSet(changeSet);
+        // Assume server doesn't understand @ngrx/entity Update<T> structure;
+        // Extract the entity changes from the Update<T>[] and restore on the return from server
+        changeSet = this.flattenUpdates(changeSet);
+        let result$ = this.http
+            .post(url, changeSet)
+            .pipe(map((result) => this.restoreUpdates(result)), catchError(this.handleError({ method: 'POST', url, data: changeSet })));
+        if (this.timeout) {
+            result$ = result$.pipe(timeout(this.timeout));
+        }
+        if (this.saveDelay) {
+            result$ = result$.pipe(delay(this.saveDelay));
+        }
+        return result$;
+    }
+    // #region helpers
+    handleError(reqData) {
+        return (err) => {
+            const error = new DataServiceError(err, reqData);
+            return throwError(error);
+        };
+    }
+    /**
+     * Filter changeSet to remove unwanted ChangeSetItems.
+     * This implementation excludes null and empty ChangeSetItems.
+     * @param changeSet ChangeSet with changes to filter
+     */
+    filterChangeSet(changeSet) {
+        return excludeEmptyChangeSetItems(changeSet);
+    }
+    /**
+     * Convert the entities in update changes from @ngrx Update<T> structure to just T.
+     * Reverse of restoreUpdates().
+     */
+    flattenUpdates(changeSet) {
+        let changes = changeSet.changes;
+        if (changes.length === 0) {
+            return changeSet;
+        }
+        let hasMutated = false;
+        changes = changes.map((item) => {
+            if (item.op === updateOp && item.entities.length > 0) {
+                hasMutated = true;
+                return {
+                    ...item,
+                    entities: item.entities.map((u) => u.changes),
+                };
+            }
+            else {
+                return item;
+            }
+        });
+        return hasMutated ? { ...changeSet, changes } : changeSet;
+    }
+    /**
+     * Convert the flattened T entities in update changes back to @ngrx Update<T> structures.
+     * Reverse of flattenUpdates().
+     */
+    restoreUpdates(changeSet) {
+        if (changeSet == null) {
+            // Nothing? Server probably responded with 204 - No Content because it made no changes to the inserted or updated entities
+            return changeSet;
+        }
+        let changes = changeSet.changes;
+        if (changes.length === 0) {
+            return changeSet;
+        }
+        let hasMutated = false;
+        changes = changes.map((item) => {
+            if (item.op === updateOp) {
+                // These are entities, not Updates; convert back to Updates
+                hasMutated = true;
+                const selectId = this.getIdSelector(item.entityName);
+                return {
+                    ...item,
+                    entities: item.entities.map((u) => ({
+                        id: selectId(u),
+                        changes: u,
+                    })),
+                };
+            }
+            else {
+                return item;
+            }
+        });
+        return hasMutated ? { ...changeSet, changes } : changeSet;
+    }
+    /**
+     * Get the id (primary key) selector function for an entity type
+     * @param entityName name of the entity type
+     */
+    getIdSelector(entityName) {
+        let idSelector = this.idSelectors[entityName];
+        if (!idSelector) {
+            idSelector = this.entityDefinitionService.getDefinition(entityName)
+                .selectId;
+            this.idSelectors[entityName] = idSelector;
+        }
+        return idSelector;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EntityCacheDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityCacheDataService, deps: [{ token: i1.EntityDefinitionService }, { token: i2.HttpClient }, { token: i3.DefaultDataServiceConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ EntityCacheDataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityCacheDataService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EntityCacheDataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityDefinitionService }, { type: i2.HttpClient }, { type: i3.DefaultDataServiceConfig, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-cache-data.service.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dataservices/entity-cache-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\n\nimport { Observable, throwError } from 'rxjs';\nimport { catchError, delay, map, timeout } from 'rxjs/operators';\n\nimport { IdSelector } from '@ngrx/entity';\n\nimport {\n  ChangeSetOperation,\n  ChangeSet,\n  ChangeSetItem,\n  ChangeSetUpdate,\n  excludeEmptyChangeSetItems,\n} from '../actions/entity-cache-change-set';\nimport { DataServiceError } from './data-service-error';\nimport { DefaultDataServiceConfig } from './default-data-service-config';\nimport { EntityDefinitionService } from '../entity-metadata/entity-definition.service';\nimport { RequestData } from './interfaces';\n\nconst updateOp = ChangeSetOperation.Update;\n\n/**\n * Default data service for making remote service calls targeting the entire EntityCache.\n * See EntityDataService for services that target a single EntityCollection\n */\n@Injectable()\nexport class EntityCacheDataService {\n  protected idSelectors: { [entityName: string]: IdSelector<any> } = {};\n  protected saveDelay = 0;\n  protected timeout = 0;\n\n  constructor(\n    protected entityDefinitionService: EntityDefinitionService,\n    protected http: HttpClient,\n    @Optional() config?: DefaultDataServiceConfig\n  ) {\n    const { saveDelay = 0, timeout: to = 0 } = config || {};\n    this.saveDelay = saveDelay;\n    this.timeout = to;\n  }\n\n  /**\n   * Save changes to multiple entities across one or more entity collections.\n   * Server endpoint must understand the essential SaveEntities protocol,\n   * in particular the ChangeSet interface (except for Update<T>).\n   * This implementation extracts the entity changes from a ChangeSet Update<T>[] and sends those.\n   * It then reconstructs Update<T>[] in the returned observable result.\n   * @param changeSet  An array of SaveEntityItems.\n   * Each SaveEntityItem describe a change operation for one or more entities of a single collection,\n   * known by its 'entityName'.\n   * @param url The server endpoint that receives this request.\n   */\n  saveEntities(changeSet: ChangeSet, url: string): Observable<ChangeSet> {\n    changeSet = this.filterChangeSet(changeSet);\n    // Assume server doesn't understand @ngrx/entity Update<T> structure;\n    // Extract the entity changes from the Update<T>[] and restore on the return from server\n    changeSet = this.flattenUpdates(changeSet);\n\n    let result$: Observable<ChangeSet> = this.http\n      .post<ChangeSet>(url, changeSet)\n      .pipe(\n        map((result) => this.restoreUpdates(result)),\n        catchError(this.handleError({ method: 'POST', url, data: changeSet }))\n      );\n\n    if (this.timeout) {\n      result$ = result$.pipe(timeout(this.timeout));\n    }\n\n    if (this.saveDelay) {\n      result$ = result$.pipe(delay(this.saveDelay));\n    }\n\n    return result$;\n  }\n\n  // #region helpers\n  protected handleError(reqData: RequestData) {\n    return (err: any) => {\n      const error = new DataServiceError(err, reqData);\n      return throwError(error);\n    };\n  }\n\n  /**\n   * Filter changeSet to remove unwanted ChangeSetItems.\n   * This implementation excludes null and empty ChangeSetItems.\n   * @param changeSet ChangeSet with changes to filter\n   */\n  protected filterChangeSet(changeSet: ChangeSet): ChangeSet {\n    return excludeEmptyChangeSetItems(changeSet);\n  }\n\n  /**\n   * Convert the entities in update changes from @ngrx Update<T> structure to just T.\n   * Reverse of restoreUpdates().\n   */\n  protected flattenUpdates(changeSet: ChangeSet): ChangeSet {\n    let changes = changeSet.changes;\n    if (changes.length === 0) {\n      return changeSet;\n    }\n    let hasMutated = false;\n    changes = changes.map((item) => {\n      if (item.op === updateOp && item.entities.length > 0) {\n        hasMutated = true;\n        return {\n          ...item,\n          entities: (item as ChangeSetUpdate).entities.map((u) => u.changes),\n        };\n      } else {\n        return item;\n      }\n    }) as ChangeSetItem[];\n    return hasMutated ? { ...changeSet, changes } : changeSet;\n  }\n\n  /**\n   * Convert the flattened T entities in update changes back to @ngrx Update<T> structures.\n   * Reverse of flattenUpdates().\n   */\n  protected restoreUpdates(changeSet: ChangeSet): ChangeSet {\n    if (changeSet == null) {\n      // Nothing? Server probably responded with 204 - No Content because it made no changes to the inserted or updated entities\n      return changeSet;\n    }\n    let changes = changeSet.changes;\n    if (changes.length === 0) {\n      return changeSet;\n    }\n    let hasMutated = false;\n    changes = changes.map((item) => {\n      if (item.op === updateOp) {\n        // These are entities, not Updates; convert back to Updates\n        hasMutated = true;\n        const selectId = this.getIdSelector(item.entityName);\n        return {\n          ...item,\n          entities: item.entities.map((u: any) => ({\n            id: selectId(u),\n            changes: u,\n          })),\n        } as ChangeSetUpdate;\n      } else {\n        return item;\n      }\n    }) as ChangeSetItem[];\n    return hasMutated ? { ...changeSet, changes } : changeSet;\n  }\n\n  /**\n   * Get the id (primary key) selector function for an entity type\n   * @param entityName name of the entity type\n   */\n  protected getIdSelector(entityName: string) {\n    let idSelector = this.idSelectors[entityName];\n    if (!idSelector) {\n      idSelector = this.entityDefinitionService.getDefinition(entityName)\n        .selectId;\n      this.idSelectors[entityName] = idSelector;\n    }\n    return idSelector;\n  }\n  // #endregion helpers\n}\n"]}