@ngrx/data 15.3.0 → 16.0.0-beta.0

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

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityActionFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityActionFactory }); }
+}
+export { EntityActionFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityActionFactory, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWFjdGlvbi1mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRhL3NyYy9hY3Rpb25zL2VudGl0eS1hY3Rpb24tZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVEzQyxNQUNhLG1CQUFtQjtJQXVCOUIsNENBQTRDO0lBQzVDLE1BQU0sQ0FDSixhQUE4QyxFQUM5QyxRQUFtQixFQUNuQixJQUFRLEVBQ1IsT0FBNkI7UUFFN0IsTUFBTSxPQUFPLEdBQ1gsT0FBTyxhQUFhLEtBQUssUUFBUTtZQUMvQixDQUFDLENBQUU7Z0JBQ0MsR0FBRyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7Z0JBQ2xCLFVBQVUsRUFBRSxhQUFhO2dCQUN6QixRQUFRO2dCQUNSLElBQUk7YUFDc0I7WUFDOUIsQ0FBQyxDQUFDLGFBQWEsQ0FBQztRQUNwQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVEOzs7O09BSUc7SUFDTyxVQUFVLENBQVUsT0FBK0I7UUFDM0QsTUFBTSxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsR0FBRyxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBQzlDLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDZixNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7U0FDdkQ7UUFDRCxJQUFJLFFBQVEsSUFBSSxJQUFJLEVBQUU7WUFDcEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1NBQ3BEO1FBQ0QsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxHQUFHLElBQUksVUFBVSxDQUFDLENBQUM7UUFDaEUsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILGdCQUFnQixDQUNkLElBQWtCLEVBQ2xCLGFBQThDO1FBRTlDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLEdBQUcsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLGFBQWEsRUFBRSxDQUFDLENBQUM7SUFDNUQsQ0FBQztJQUVELGdCQUFnQixDQUFDLEVBQVUsRUFBRSxHQUFXO1FBQ3RDLE9BQU8sSUFBSSxHQUFHLEtBQUssRUFBRSxFQUFFLENBQUM7UUFDeEIsc0VBQXNFO0lBQ3hFLENBQUM7c0lBMUVVLG1CQUFtQjswSUFBbkIsbUJBQW1COztTQUFuQixtQkFBbUI7Z0dBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRW50aXR5T3AgfSBmcm9tICcuL2VudGl0eS1vcCc7XG5pbXBvcnQge1xuICBFbnRpdHlBY3Rpb24sXG4gIEVudGl0eUFjdGlvbk9wdGlvbnMsXG4gIEVudGl0eUFjdGlvblBheWxvYWQsXG59IGZyb20gJy4vZW50aXR5LWFjdGlvbic7XG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRW50aXR5QWN0aW9uRmFjdG9yeSB7XG4gIC8qKlxuICAgKiBDcmVhdGUgYW4gRW50aXR5QWN0aW9uIHRvIHBlcmZvcm0gYW4gb3BlcmF0aW9uIChvcCkgZm9yIGEgcGFydGljdWxhciBlbnRpdHkgdHlwZVxuICAgKiAoZW50aXR5TmFtZSkgd2l0aCBvcHRpb25hbCBkYXRhIGFuZCBvdGhlciBvcHRpb25hbCBmbGFnc1xuICAgKiBAcGFyYW0gZW50aXR5TmFtZSBOYW1lIG9mIHRoZSBlbnRpdHkgdHlwZVxuICAgKiBAcGFyYW0gZW50aXR5T3AgT3BlcmF0aW9uIHRvIHBlcmZvcm0gKEVudGl0eU9wKVxuICAgKiBAcGFyYW0gW2RhdGFdIGRhdGEgZm9yIHRoZSBvcGVyYXRpb25cbiAgICogQHBhcmFtIFtvcHRpb25zXSBhZGRpdGlvbmFsIG9wdGlvbnNcbiAgICovXG4gIGNyZWF0ZTxQID0gYW55PihcbiAgICBlbnRpdHlOYW1lOiBzdHJpbmcsXG4gICAgZW50aXR5T3A6IEVudGl0eU9wLFxuICAgIGRhdGE/OiBQLFxuICAgIG9wdGlvbnM/OiBFbnRpdHlBY3Rpb25PcHRpb25zXG4gICk6IEVudGl0eUFjdGlvbjxQPjtcblxuICAvKipcbiAgICogQ3JlYXRlIGFuIEVudGl0eUFjdGlvbiB0byBwZXJmb3JtIGFuIG9wZXJhdGlvbiAob3ApIGZvciBhIHBhcnRpY3VsYXIgZW50aXR5IHR5cGVcbiAgICogKGVudGl0eU5hbWUpIHdpdGggb3B0aW9uYWwgZGF0YSBhbmQgb3RoZXIgb3B0aW9uYWwgZmxhZ3NcbiAgICogQHBhcmFtIHBheWxvYWQgRGVmaW5lcyB0aGUgRW50aXR5QWN0aW9uIGFuZCBpdHMgb3B0aW9uc1xuICAgKi9cbiAgY3JlYXRlPFAgPSBhbnk+KHBheWxvYWQ6IEVudGl0eUFjdGlvblBheWxvYWQ8UD4pOiBFbnRpdHlBY3Rpb248UD47XG5cbiAgLy8gcG9seW1vcnBoaWMgY3JlYXRlIGZvciB0aGUgdHdvIHNpZ25hdHVyZXNcbiAgY3JlYXRlPFAgPSBhbnk+KFxuICAgIG5hbWVPclBheWxvYWQ6IEVudGl0eUFjdGlvblBheWxvYWQ8UD4gfCBzdHJpbmcsXG4gICAgZW50aXR5T3A/OiBFbnRpdHlPcCxcbiAgICBkYXRhPzogUCxcbiAgICBvcHRpb25zPzogRW50aXR5QWN0aW9uT3B0aW9uc1xuICApOiBFbnRpdHlBY3Rpb248UD4ge1xuICAgIGNvbnN0IHBheWxvYWQ6IEVudGl0eUFjdGlvblBheWxvYWQ8UD4gPVxuICAgICAgdHlwZW9mIG5hbWVPclBheWxvYWQgPT09ICdzdHJpbmcnXG4gICAgICAgID8gKHtcbiAgICAgICAgICAgIC4uLihvcHRpb25zIHx8IHt9KSxcbiAgICAgICAgICAgIGVudGl0eU5hbWU6IG5hbWVPclBheWxvYWQsXG4gICAgICAgICAgICBlbnRpdHlPcCxcbiAgICAgICAgICAgIGRhdGEsXG4gICAgICAgICAgfSBhcyBFbnRpdHlBY3Rpb25QYXlsb2FkPFA+KVxuICAgICAgICA6IG5hbWVPclBheWxvYWQ7XG4gICAgcmV0dXJuIHRoaXMuY3JlYXRlQ29yZShwYXlsb2FkKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDcmVhdGUgYW4gRW50aXR5QWN0aW9uIHRvIHBlcmZvcm0gYW4gb3BlcmF0aW9uIChvcCkgZm9yIGEgcGFydGljdWxhciBlbnRpdHkgdHlwZVxuICAgKiAoZW50aXR5TmFtZSkgd2l0aCBvcHRpb25hbCBkYXRhIGFuZCBvdGhlciBvcHRpb25hbCBmbGFnc1xuICAgKiBAcGFyYW0gcGF5bG9hZCBEZWZpbmVzIHRoZSBFbnRpdHlBY3Rpb24gYW5kIGl0cyBvcHRpb25zXG4gICAqL1xuICBwcm90ZWN0ZWQgY3JlYXRlQ29yZTxQID0gYW55PihwYXlsb2FkOiBFbnRpdHlBY3Rpb25QYXlsb2FkPFA+KSB7XG4gICAgY29uc3QgeyBlbnRpdHlOYW1lLCBlbnRpdHlPcCwgdGFnIH0gPSBwYXlsb2FkO1xuICAgIGlmICghZW50aXR5TmFtZSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdNaXNzaW5nIGVudGl0eSBuYW1lIGZvciBuZXcgYWN0aW9uJyk7XG4gICAgfVxuICAgIGlmIChlbnRpdHlPcCA9PSBudWxsKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ01pc3NpbmcgRW50aXR5T3AgZm9yIG5ldyBhY3Rpb24nKTtcbiAgICB9XG4gICAgY29uc3QgdHlwZSA9IHRoaXMuZm9ybWF0QWN0aW9uVHlwZShlbnRpdHlPcCwgdGFnIHx8IGVudGl0eU5hbWUpO1xuICAgIHJldHVybiB7IHR5cGUsIHBheWxvYWQgfTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDcmVhdGUgYW4gRW50aXR5QWN0aW9uIGZyb20gYW5vdGhlciBFbnRpdHlBY3Rpb24sIHJlcGxhY2luZyBwcm9wZXJ0aWVzIHdpdGggdGhvc2UgZnJvbSBuZXdQYXlsb2FkO1xuICAgKiBAcGFyYW0gZnJvbSBTb3VyY2UgYWN0aW9uIHRoYXQgaXMgdGhlIGJhc2UgZm9yIHRoZSBuZXcgYWN0aW9uXG4gICAqIEBwYXJhbSBuZXdQcm9wZXJ0aWVzIE5ldyBFbnRpdHlBY3Rpb24gcHJvcGVydGllcyB0aGF0IHJlcGxhY2UgdGhlIHNvdXJjZSBhY3Rpb24gcHJvcGVydGllc1xuICAgKi9cbiAgY3JlYXRlRnJvbUFjdGlvbjxQID0gYW55PihcbiAgICBmcm9tOiBFbnRpdHlBY3Rpb24sXG4gICAgbmV3UHJvcGVydGllczogUGFydGlhbDxFbnRpdHlBY3Rpb25QYXlsb2FkPFA+PlxuICApOiBFbnRpdHlBY3Rpb248UD4ge1xuICAgIHJldHVybiB0aGlzLmNyZWF0ZSh7IC4uLmZyb20ucGF5bG9hZCwgLi4ubmV3UHJvcGVydGllcyB9KTtcbiAgfVxuXG4gIGZvcm1hdEFjdGlvblR5cGUob3A6IHN0cmluZywgdGFnOiBzdHJpbmcpIHtcbiAgICByZXR1cm4gYFske3RhZ31dICR7b3B9YDtcbiAgICAvLyByZXR1cm4gYCR7b3B9IFske3RhZ31dYC50b1VwcGVyQ2FzZSgpOyAvLyBleGFtcGxlIG9mIGFuIGFsdGVybmF0aXZlXG4gIH1cbn1cbiJdfQ==

package/esm2022/src/actions/entity-action-guard.mjs

@@ -0,0 +1,130 @@
+/**
+ * Guard methods that ensure EntityAction payload is as expected.
+ * Each method returns that payload if it passes the guard or
+ * throws an error.
+ */
+export class EntityActionGuard {
+    constructor(entityName, selectId) {
+        this.entityName = entityName;
+        this.selectId = selectId;
+    }
+    /** Throw if the action payload is not an entity with a valid key */
+    mustBeEntity(action) {
+        const data = this.extractData(action);
+        if (!data) {
+            return this.throwError(action, `should have a single entity.`);
+        }
+        const id = this.selectId(data);
+        if (this.isNotKeyType(id)) {
+            this.throwError(action, `has a missing or invalid entity key (id)`);
+        }
+        return data;
+    }
+    /** Throw if the action payload is not an array of entities with valid keys */
+    mustBeEntities(action) {
+        const data = this.extractData(action);
+        if (!Array.isArray(data)) {
+            return this.throwError(action, `should be an array of entities`);
+        }
+        data.forEach((entity, i) => {
+            const id = this.selectId(entity);
+            if (this.isNotKeyType(id)) {
+                const msg = `, item ${i + 1}, does not have a valid entity key (id)`;
+                this.throwError(action, msg);
+            }
+        });
+        return data;
+    }
+    /** Throw if the action payload is not a single, valid key */
+    mustBeKey(action) {
+        const data = this.extractData(action);
+        if (data === undefined) {
+            throw new Error(`should be a single entity key`);
+        }
+        if (this.isNotKeyType(data)) {
+            throw new Error(`is not a valid key (id)`);
+        }
+        return data;
+    }
+    /** Throw if the action payload is not an array of valid keys */
+    mustBeKeys(action) {
+        const data = this.extractData(action);
+        if (!Array.isArray(data)) {
+            return this.throwError(action, `should be an array of entity keys (id)`);
+        }
+        data.forEach((id, i) => {
+            if (this.isNotKeyType(id)) {
+                const msg = `${this.entityName} ', item ${i + 1}, is not a valid entity key (id)`;
+                this.throwError(action, msg);
+            }
+        });
+        return data;
+    }
+    /** Throw if the action payload is not an update with a valid key (id) */
+    mustBeUpdate(action) {
+        const data = this.extractData(action);
+        if (!data) {
+            return this.throwError(action, `should be a single entity update`);
+        }
+        const { id, changes } = data;
+        const id2 = this.selectId(changes);
+        if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {
+            this.throwError(action, `has a missing or invalid entity key (id)`);
+        }
+        return data;
+    }
+    /** Throw if the action payload is not an array of updates with valid keys (ids) */
+    mustBeUpdates(action) {
+        const data = this.extractData(action);
+        if (!Array.isArray(data)) {
+            return this.throwError(action, `should be an array of entity updates`);
+        }
+        data.forEach((item, i) => {
+            const { id, changes } = item;
+            const id2 = this.selectId(changes);
+            if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {
+                this.throwError(action, `, item ${i + 1}, has a missing or invalid entity key (id)`);
+            }
+        });
+        return data;
+    }
+    /** Throw if the action payload is not an update response with a valid key (id) */
+    mustBeUpdateResponse(action) {
+        const data = this.extractData(action);
+        if (!data) {
+            return this.throwError(action, `should be a single entity update`);
+        }
+        const { id, changes } = data;
+        const id2 = this.selectId(changes);
+        if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {
+            this.throwError(action, `has a missing or invalid entity key (id)`);
+        }
+        return data;
+    }
+    /** Throw if the action payload is not an array of update responses with valid keys (ids) */
+    mustBeUpdateResponses(action) {
+        const data = this.extractData(action);
+        if (!Array.isArray(data)) {
+            return this.throwError(action, `should be an array of entity updates`);
+        }
+        data.forEach((item, i) => {
+            const { id, changes } = item;
+            const id2 = this.selectId(changes);
+            if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {
+                this.throwError(action, `, item ${i + 1}, has a missing or invalid entity key (id)`);
+            }
+        });
+        return data;
+    }
+    extractData(action) {
+        return action.payload && action.payload.data;
+    }
+    /** Return true if this key (id) is invalid */
+    isNotKeyType(id) {
+        return typeof id !== 'string' && typeof id !== 'number';
+    }
+    throwError(action, msg) {
+        throw new Error(`${this.entityName} EntityAction guard for "${action.type}": payload ${msg}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-action-guard.js","sourceRoot":"","sources":["../../../../../../modules/data/src/actions/entity-action-guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { IdSelector, Update } from '@ngrx/entity';\n\nimport { EntityAction } from './entity-action';\nimport { UpdateResponseData } from '../actions/update-response-data';\n\n/**\n * Guard methods that ensure EntityAction payload is as expected.\n * Each method returns that payload if it passes the guard or\n * throws an error.\n */\nexport class EntityActionGuard<T> {\n  constructor(private entityName: string, private selectId: IdSelector<T>) {}\n\n  /** Throw if the action payload is not an entity with a valid key */\n  mustBeEntity(action: EntityAction<T>): T {\n    const data = this.extractData(action);\n    if (!data) {\n      return this.throwError(action, `should have a single entity.`);\n    }\n    const id = this.selectId(data);\n    if (this.isNotKeyType(id)) {\n      this.throwError(action, `has a missing or invalid entity key (id)`);\n    }\n    return data as T;\n  }\n\n  /** Throw if the action payload is not an array of entities with valid keys */\n  mustBeEntities(action: EntityAction<T[]>): T[] {\n    const data = this.extractData(action);\n    if (!Array.isArray(data)) {\n      return this.throwError(action, `should be an array of entities`);\n    }\n    data.forEach((entity, i) => {\n      const id = this.selectId(entity);\n      if (this.isNotKeyType(id)) {\n        const msg = `, item ${i + 1}, does not have a valid entity key (id)`;\n        this.throwError(action, msg);\n      }\n    });\n    return data;\n  }\n\n  /** Throw if the action payload is not a single, valid key */\n  mustBeKey(action: EntityAction<string | number>): string | number | never {\n    const data = this.extractData(action);\n    if (data === undefined) {\n      throw new Error(`should be a single entity key`);\n    }\n    if (this.isNotKeyType(data)) {\n      throw new Error(`is not a valid key (id)`);\n    }\n    return data;\n  }\n\n  /** Throw if the action payload is not an array of valid keys */\n  mustBeKeys(action: EntityAction<(string | number)[]>): (string | number)[] {\n    const data = this.extractData(action);\n    if (!Array.isArray(data)) {\n      return this.throwError(action, `should be an array of entity keys (id)`);\n    }\n    data.forEach((id, i) => {\n      if (this.isNotKeyType(id)) {\n        const msg = `${this.entityName} ', item ${\n          i + 1\n        }, is not a valid entity key (id)`;\n        this.throwError(action, msg);\n      }\n    });\n    return data;\n  }\n\n  /** Throw if the action payload is not an update with a valid key (id) */\n  mustBeUpdate(action: EntityAction<Update<T>>): Update<T> {\n    const data = this.extractData(action);\n    if (!data) {\n      return this.throwError(action, `should be a single entity update`);\n    }\n    const { id, changes } = data;\n    const id2 = this.selectId(changes as T);\n    if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {\n      this.throwError(action, `has a missing or invalid entity key (id)`);\n    }\n    return data;\n  }\n\n  /** Throw if the action payload is not an array of updates with valid keys (ids) */\n  mustBeUpdates(action: EntityAction<Update<T>[]>): Update<T>[] {\n    const data = this.extractData(action);\n    if (!Array.isArray(data)) {\n      return this.throwError(action, `should be an array of entity updates`);\n    }\n    data.forEach((item, i) => {\n      const { id, changes } = item;\n      const id2 = this.selectId(changes as T);\n      if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {\n        this.throwError(\n          action,\n          `, item ${i + 1}, has a missing or invalid entity key (id)`\n        );\n      }\n    });\n    return data;\n  }\n\n  /** Throw if the action payload is not an update response with a valid key (id) */\n  mustBeUpdateResponse(\n    action: EntityAction<UpdateResponseData<T>>\n  ): UpdateResponseData<T> {\n    const data = this.extractData(action);\n    if (!data) {\n      return this.throwError(action, `should be a single entity update`);\n    }\n    const { id, changes } = data;\n    const id2 = this.selectId(changes as T);\n    if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {\n      this.throwError(action, `has a missing or invalid entity key (id)`);\n    }\n    return data;\n  }\n\n  /** Throw if the action payload is not an array of update responses with valid keys (ids) */\n  mustBeUpdateResponses(\n    action: EntityAction<UpdateResponseData<T>[]>\n  ): UpdateResponseData<T>[] {\n    const data = this.extractData(action);\n    if (!Array.isArray(data)) {\n      return this.throwError(action, `should be an array of entity updates`);\n    }\n    data.forEach((item, i) => {\n      const { id, changes } = item;\n      const id2 = this.selectId(changes as T);\n      if (this.isNotKeyType(id) || this.isNotKeyType(id2)) {\n        this.throwError(\n          action,\n          `, item ${i + 1}, has a missing or invalid entity key (id)`\n        );\n      }\n    });\n    return data;\n  }\n\n  private extractData<T>(action: EntityAction<T>) {\n    return action.payload && action.payload.data;\n  }\n\n  /** Return true if this key (id) is invalid */\n  private isNotKeyType(id: any) {\n    return typeof id !== 'string' && typeof id !== 'number';\n  }\n\n  private throwError(action: EntityAction, msg: string): never {\n    throw new Error(\n      `${this.entityName} EntityAction guard for \"${action.type}\": payload ${msg}`\n    );\n  }\n}\n"]}

package/esm2022/src/dataservices/default-data.service.mjs

@@ -0,0 +1,210 @@
+import { Injectable, isDevMode, Optional } from '@angular/core';
+import { HttpHeaders, 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 * 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.
+ * Assumes a common REST-y web API
+ */
+export class DefaultDataService {
+    get name() {
+        return this._name;
+    }
+    constructor(entityName, http, httpUrlGenerator, config) {
+        this.http = http;
+        this.httpUrlGenerator = httpUrlGenerator;
+        this.getDelay = 0;
+        this.saveDelay = 0;
+        this.timeout = 0;
+        this.trailingSlashEndpoints = false;
+        this._name = `${entityName} DefaultDataService`;
+        this.entityName = entityName;
+        const { root = 'api', delete404OK = true, getDelay = 0, saveDelay = 0, timeout: to = 0, trailingSlashEndpoints = false, } = config || {};
+        this.delete404OK = delete404OK;
+        this.entityUrl = httpUrlGenerator.entityResource(entityName, root, trailingSlashEndpoints);
+        this.entitiesUrl = httpUrlGenerator.collectionResource(entityName, root);
+        this.getDelay = getDelay;
+        this.saveDelay = saveDelay;
+        this.timeout = to;
+    }
+    add(entity, options) {
+        const entityOrError = entity || new Error(`No "${this.entityName}" entity to add`);
+        return this.execute('POST', this.entityUrl, entityOrError, null, options);
+    }
+    delete(key, options) {
+        let err;
+        if (key == null) {
+            err = new Error(`No "${this.entityName}" key to delete`);
+        }
+        return this.execute('DELETE', this.entityUrl + key, err, null, options).pipe(
+        // forward the id of deleted entity as the result of the HTTP DELETE
+        map((result) => key));
+    }
+    getAll(options) {
+        return this.execute('GET', this.entitiesUrl, null, options);
+    }
+    getById(key, options) {
+        let err;
+        if (key == null) {
+            err = new Error(`No "${this.entityName}" key to get`);
+        }
+        return this.execute('GET', this.entityUrl + key, err, null, options);
+    }
+    getWithQuery(queryParams, options) {
+        const qParams = typeof queryParams === 'string'
+            ? { fromString: queryParams }
+            : { fromObject: queryParams };
+        const params = new HttpParams(qParams);
+        return this.execute('GET', this.entitiesUrl, undefined, { params }, options);
+    }
+    update(update, options) {
+        const id = update && update.id;
+        const updateOrError = id == null
+            ? new Error(`No "${this.entityName}" update data or id`)
+            : update.changes;
+        return this.execute('PUT', this.entityUrl + id, updateOrError, null, options);
+    }
+    // Important! Only call if the backend service supports upserts as a POST to the target URL
+    upsert(entity, options) {
+        const entityOrError = entity || new Error(`No "${this.entityName}" entity to upsert`);
+        return this.execute('POST', this.entityUrl, entityOrError, null, options);
+    }
+    execute(method, url, data, // data, error, or undefined/null
+    options, // options or undefined/null
+    httpOptions // these override any options passed via options
+    ) {
+        let entityActionHttpClientOptions = undefined;
+        if (httpOptions) {
+            entityActionHttpClientOptions = {
+                headers: httpOptions?.httpHeaders
+                    ? new HttpHeaders(httpOptions?.httpHeaders)
+                    : undefined,
+                params: httpOptions?.httpParams
+                    ? new HttpParams(httpOptions?.httpParams)
+                    : undefined,
+            };
+        }
+        // Now we may have:
+        // options: containing headers, params, or any other allowed http options already in angular's api
+        // entityActionHttpClientOptions: headers and params in angular's api
+        // We therefore need to merge these so that the action ones override the
+        // existing keys where applicable.
+        // If any options have been specified, pass them to http client. Note
+        // the new http options, if specified, will override any options passed
+        // from the deprecated options parameter
+        let mergedOptions = undefined;
+        if (options || entityActionHttpClientOptions) {
+            if (isDevMode() && options && entityActionHttpClientOptions) {
+                console.warn('@ngrx/data: options.httpParams will be merged with queryParams when both are are provided to getWithQuery(). In the event of a conflict HttpOptions.httpParams will override queryParams`. The queryParams parameter of getWithQuery() will be removed in next major release.');
+            }
+            mergedOptions = {
+                ...options,
+                headers: entityActionHttpClientOptions?.headers ?? options?.headers,
+                params: entityActionHttpClientOptions?.params ?? options?.params,
+            };
+        }
+        const req = {
+            method,
+            url,
+            data,
+            options: mergedOptions,
+        };
+        if (data instanceof Error) {
+            return this.handleError(req)(data);
+        }
+        let result$;
+        switch (method) {
+            case 'DELETE': {
+                result$ = this.http.delete(url, mergedOptions);
+                if (this.saveDelay) {
+                    result$ = result$.pipe(delay(this.saveDelay));
+                }
+                break;
+            }
+            case 'GET': {
+                result$ = this.http.get(url, mergedOptions);
+                if (this.getDelay) {
+                    result$ = result$.pipe(delay(this.getDelay));
+                }
+                break;
+            }
+            case 'POST': {
+                result$ = this.http.post(url, data, mergedOptions);
+                if (this.saveDelay) {
+                    result$ = result$.pipe(delay(this.saveDelay));
+                }
+                break;
+            }
+            // N.B.: It must return an Update<T>
+            case 'PUT': {
+                result$ = this.http.put(url, data, mergedOptions);
+                if (this.saveDelay) {
+                    result$ = result$.pipe(delay(this.saveDelay));
+                }
+                break;
+            }
+            default: {
+                const error = new Error('Unimplemented HTTP method, ' + method);
+                result$ = throwError(error);
+            }
+        }
+        if (this.timeout) {
+            result$ = result$.pipe(timeout(this.timeout + this.saveDelay));
+        }
+        return result$.pipe(catchError(this.handleError(req)));
+    }
+    handleError(reqData) {
+        return (err) => {
+            const ok = this.handleDelete404(err, reqData);
+            if (ok) {
+                return ok;
+            }
+            const error = new DataServiceError(err, reqData);
+            return throwError(error);
+        };
+    }
+    handleDelete404(error, reqData) {
+        if (error.status === 404 &&
+            reqData.method === 'DELETE' &&
+            this.delete404OK) {
+            return of({});
+        }
+        return undefined;
+    }
+}
+/**
+ * Create a basic, generic entity data service
+ * suitable for persistence of most entities.
+ * Assumes a common REST-y web API
+ */
+class DefaultDataServiceFactory {
+    constructor(http, httpUrlGenerator, config) {
+        this.http = http;
+        this.httpUrlGenerator = httpUrlGenerator;
+        this.config = config;
+        config = config || {};
+        httpUrlGenerator.registerHttpResourceUrls(config.entityHttpResourceUrls);
+    }
+    /**
+     * Create a default {EntityCollectionDataService} for the given entity type
+     * @param entityName {string} Name of the entity type for this data service
+     */
+    create(entityName) {
+        return new DefaultDataService(entityName, this.http, this.httpUrlGenerator, this.config);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: DefaultDataServiceFactory, deps: [{ token: i1.HttpClient }, { token: i2.HttpUrlGenerator }, { token: i3.DefaultDataServiceConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: DefaultDataServiceFactory }); }
+}
+export { DefaultDataServiceFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", 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, isDevMode, Optional } from '@angular/core';\nimport {\n  HttpClient,\n  HttpErrorResponse,\n  HttpHeaders,\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  HttpOptions,\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  protected trailingSlashEndpoints = false;\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      trailingSlashEndpoints = false,\n    } = config || {};\n    this.delete404OK = delete404OK;\n    this.entityUrl = httpUrlGenerator.entityResource(\n      entityName,\n      root,\n      trailingSlashEndpoints\n    );\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, options?: HttpOptions): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to add`);\n    return this.execute('POST', this.entityUrl, entityOrError, null, options);\n  }\n\n  delete(\n    key: number | string,\n    options?: HttpOptions\n  ): Observable<number | string> {\n    let err: Error | undefined;\n    if (key == null) {\n      err = new Error(`No \"${this.entityName}\" key to delete`);\n    }\n\n    return this.execute(\n      'DELETE',\n      this.entityUrl + key,\n      err,\n      null,\n      options\n    ).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(options?: HttpOptions): Observable<T[]> {\n    return this.execute('GET', this.entitiesUrl, null, options);\n  }\n\n  getById(key: number | string, options?: HttpOptions): 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, null, options);\n  }\n\n  getWithQuery(\n    queryParams: QueryParams | string | undefined,\n    options?: HttpOptions\n  ): Observable<T[]> {\n    const qParams =\n      typeof queryParams === 'string'\n        ? { fromString: queryParams }\n        : { fromObject: queryParams };\n    const params = new HttpParams(qParams);\n\n    return this.execute(\n      'GET',\n      this.entitiesUrl,\n      undefined,\n      { params },\n      options\n    );\n  }\n\n  update(update: Update<T>, options?: HttpOptions): 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(\n      'PUT',\n      this.entityUrl + id,\n      updateOrError,\n      null,\n      options\n    );\n  }\n\n  // Important! Only call if the backend service supports upserts as a POST to the target URL\n  upsert(entity: T, options?: HttpOptions): Observable<T> {\n    const entityOrError =\n      entity || new Error(`No \"${this.entityName}\" entity to upsert`);\n    return this.execute('POST', this.entityUrl, entityOrError, null, options);\n  }\n\n  protected execute(\n    method: HttpMethods,\n    url: string,\n    data?: any, // data, error, or undefined/null\n    options?: any, // options or undefined/null\n    httpOptions?: HttpOptions // these override any options passed via options\n  ): Observable<any> {\n    let entityActionHttpClientOptions: any = undefined;\n    if (httpOptions) {\n      entityActionHttpClientOptions = {\n        headers: httpOptions?.httpHeaders\n          ? new HttpHeaders(httpOptions?.httpHeaders)\n          : undefined,\n        params: httpOptions?.httpParams\n          ? new HttpParams(httpOptions?.httpParams)\n          : undefined,\n      };\n    }\n\n    // Now we may have:\n    // options: containing headers, params, or any other allowed http options already in angular's api\n    // entityActionHttpClientOptions: headers and params in angular's api\n\n    // We therefore need to merge these so that the action ones override the\n    // existing keys where applicable.\n\n    // If any options have been specified, pass them to http client. Note\n    // the new http options, if specified, will override any options passed\n    // from the deprecated options parameter\n    let mergedOptions: any = undefined;\n    if (options || entityActionHttpClientOptions) {\n      if (isDevMode() && options && entityActionHttpClientOptions) {\n        console.warn(\n          '@ngrx/data: options.httpParams will be merged with queryParams when both are are provided to getWithQuery(). In the event of a conflict HttpOptions.httpParams will override queryParams`. The queryParams parameter of getWithQuery() will be removed in next major release.'\n        );\n      }\n\n      mergedOptions = {\n        ...options,\n        headers: entityActionHttpClientOptions?.headers ?? options?.headers,\n        params: entityActionHttpClientOptions?.params ?? options?.params,\n      };\n    }\n\n    const req: RequestData = {\n      method,\n      url,\n      data,\n      options: mergedOptions,\n    };\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, mergedOptions);\n        if (this.saveDelay) {\n          result$ = result$.pipe(delay(this.saveDelay));\n        }\n        break;\n      }\n      case 'GET': {\n        result$ = this.http.get(url, mergedOptions);\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, mergedOptions);\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, mergedOptions);\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/esm2022/src/dataservices/entity-cache-data.service.mjs

@@ -0,0 +1,147 @@
+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
+ */
+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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCacheDataService, deps: [{ token: i1.EntityDefinitionService }, { token: i2.HttpClient }, { token: i3.DefaultDataServiceConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCacheDataService }); }
+}
+export { EntityCacheDataService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", 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 =\n        this.entityDefinitionService.getDefinition(entityName).selectId;\n      this.idSelectors[entityName] = idSelector;\n    }\n    return idSelector;\n  }\n  // #endregion helpers\n}\n"]}