@ngrx/data 15.4.0 → 16.0.0-rc.0

package/esm2022/src/entity-services/entity-services-base.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-services-elements";
+/* eslint-disable @typescript-eslint/member-ordering */
+/**
+ * Base/default class of a central registry of EntityCollectionServices for all entity types.
+ * Create your own subclass to add app-specific members for an improved developer experience.
+ *
+ * @usageNotes
+ * ```ts
+ * export class EntityServices extends EntityServicesBase {
+ *   constructor(entityServicesElements: EntityServicesElements) {
+ *     super(entityServicesElements);
+ *   }
+ *   // Extend with well-known, app entity collection services
+ *   // Convenience property to return a typed custom entity collection service
+ *   get companyService() {
+ *     return this.getEntityCollectionService<Model.Company>('Company') as CompanyService;
+ *   }
+ *   // Convenience dispatch methods
+ *   clearCompany(companyId: string) {
+ *     this.dispatch(new ClearCompanyAction(companyId));
+ *   }
+ * }
+ * ```
+ */
+class EntityServicesBase {
+    // Dear @ngrx/data developer: think hard before changing the constructor.
+    // Doing so will break apps that derive from this base class,
+    // and many apps will derive from this class.
+    //
+    // Do not give this constructor an implementation.
+    // Doing so makes it hard to mock classes that derive from this class.
+    // Use getter properties instead. For example, see entityCache$
+    constructor(entityServicesElements) {
+        this.entityServicesElements = entityServicesElements;
+        /** Registry of EntityCollectionService instances */
+        this.EntityCollectionServices = {};
+    }
+    // #region EntityServicesElement-based properties
+    /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */
+    get entityActionErrors$() {
+        return this.entityServicesElements.entityActionErrors$;
+    }
+    /** Observable of the entire entity cache */
+    get entityCache$() {
+        return this.entityServicesElements.entityCache$;
+    }
+    /** Factory to create a default instance of an EntityCollectionService */
+    get entityCollectionServiceFactory() {
+        return this.entityServicesElements.entityCollectionServiceFactory;
+    }
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent action reduced by the store.
+     */
+    get reducedActions$() {
+        return this.entityServicesElements.reducedActions$;
+    }
+    /** The ngrx store, scoped to the EntityCache */
+    get store() {
+        return this.entityServicesElements.store;
+    }
+    // #endregion EntityServicesElement-based properties
+    /** Dispatch any action to the store */
+    dispatch(action) {
+        this.store.dispatch(action);
+    }
+    /**
+     * Create a new default instance of an EntityCollectionService.
+     * Prefer getEntityCollectionService() unless you really want a new default instance.
+     * This one will NOT be registered with EntityServices!
+     * @param entityName {string} Name of the entity type of the service
+     */
+    createEntityCollectionService(entityName) {
+        return this.entityCollectionServiceFactory.create(entityName);
+    }
+    /** Get (or create) the singleton instance of an EntityCollectionService
+     * @param entityName {string} Name of the entity type of the service
+     */
+    getEntityCollectionService(entityName) {
+        let service = this.EntityCollectionServices[entityName];
+        if (!service) {
+            service = this.createEntityCollectionService(entityName);
+            this.EntityCollectionServices[entityName] = service;
+        }
+        return service;
+    }
+    /** Register an EntityCollectionService under its entity type name.
+     * Will replace a pre-existing service for that type.
+     * @param service {EntityCollectionService} The entity service
+     * @param serviceName {string} optional service name to use instead of the service's entityName
+     */
+    registerEntityCollectionService(service, serviceName) {
+        this.EntityCollectionServices[serviceName || service.entityName] = service;
+    }
+    /**
+     * Register entity services for several entity types at once.
+     * Will replace a pre-existing service for that type.
+     * @param entityCollectionServices {EntityCollectionServiceMap | EntityCollectionService<any>[]}
+     * EntityCollectionServices to register, either as a map or an array
+     */
+    registerEntityCollectionServices(entityCollectionServices) {
+        if (Array.isArray(entityCollectionServices)) {
+            entityCollectionServices.forEach((service) => this.registerEntityCollectionService(service));
+        }
+        else {
+            Object.keys(entityCollectionServices || {}).forEach((serviceName) => {
+                this.registerEntityCollectionService(entityCollectionServices[serviceName], serviceName);
+            });
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesBase, deps: [{ token: i1.EntityServicesElements }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesBase }); }
+}
+export { EntityServicesBase };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesBase, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityServicesElements }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-services-base.js","sourceRoot":"","sources":["../../../../../../modules/data/src/entity-services/entity-services-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAa3C,uDAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MACa,kBAAkB;IAC7B,yEAAyE;IACzE,6DAA6D;IAC7D,6CAA6C;IAC7C,EAAE;IACF,kDAAkD;IAClD,sEAAsE;IACtE,+DAA+D;IAC/D,YAAoB,sBAA8C;QAA9C,2BAAsB,GAAtB,sBAAsB,CAAwB;QAuClE,oDAAoD;QACnC,6BAAwB,GAA+B,EAAE,CAAC;IAxCN,CAAC;IAEtE,iDAAiD;IAEjD,oFAAoF;IACpF,IAAI,mBAAmB;QACrB,OAAO,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC;IACzD,CAAC;IAED,4CAA4C;IAC5C,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC;IAClD,CAAC;IAED,yEAAyE;IACzE,IAAI,8BAA8B;QAChC,OAAO,IAAI,CAAC,sBAAsB,CAAC,8BAA8B,CAAC;IACpE,CAAC;IAED;;;OAGG;IACH,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;IACrD,CAAC;IAED,gDAAgD;IAChD,IAAc,KAAK;QACjB,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC;IAC3C,CAAC;IAED,oDAAoD;IAEpD,uCAAuC;IACvC,QAAQ,CAAC,MAAc;QACrB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAKD;;;;;OAKG;IACO,6BAA6B,CAGrC,UAAkB;QAClB,OAAO,IAAI,CAAC,8BAA8B,CAAC,MAAM,CAAQ,UAAU,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACH,0BAA0B,CAGxB,UAAkB;QAClB,IAAI,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAC;QACxD,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,GAAG,IAAI,CAAC,6BAA6B,CAAQ,UAAU,CAAC,CAAC;YAChE,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC;SACrD;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACH,+BAA+B,CAC7B,OAAmC,EACnC,WAAoB;QAEpB,IAAI,CAAC,wBAAwB,CAAC,WAAW,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC;IAC7E,CAAC;IAED;;;;;OAKG;IACH,gCAAgC,CAC9B,wBAEkC;QAElC,IAAI,KAAK,CAAC,OAAO,CAAC,wBAAwB,CAAC,EAAE;YAC3C,wBAAwB,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC3C,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAAC,CAC9C,CAAC;SACH;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE;gBAClE,IAAI,CAAC,+BAA+B,CAClC,wBAAwB,CAAC,WAAW,CAAC,EACrC,WAAW,CACZ,CAAC;YACJ,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;iIAjHU,kBAAkB;qIAAlB,kBAAkB;;SAAlB,kBAAkB;2FAAlB,kBAAkB;kBAD9B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Action, Store } from '@ngrx/store';\n\nimport { Observable } from 'rxjs';\n\nimport { EntityAction } from '../actions/entity-action';\nimport { EntityCache } from '../reducers/entity-cache';\nimport { EntityCollectionService } from './entity-collection-service';\nimport { EntityCollectionServiceFactory } from './entity-collection-service-factory';\nimport { EntityCollectionServiceMap, EntityServices } from './entity-services';\nimport { EntitySelectors$ } from '../selectors/entity-selectors$';\nimport { EntityServicesElements } from './entity-services-elements';\n\n/* eslint-disable @typescript-eslint/member-ordering */\n\n/**\n * Base/default class of a central registry of EntityCollectionServices for all entity types.\n * Create your own subclass to add app-specific members for an improved developer experience.\n *\n * @usageNotes\n * ```ts\n * export class EntityServices extends EntityServicesBase {\n *   constructor(entityServicesElements: EntityServicesElements) {\n *     super(entityServicesElements);\n *   }\n *   // Extend with well-known, app entity collection services\n *   // Convenience property to return a typed custom entity collection service\n *   get companyService() {\n *     return this.getEntityCollectionService<Model.Company>('Company') as CompanyService;\n *   }\n *   // Convenience dispatch methods\n *   clearCompany(companyId: string) {\n *     this.dispatch(new ClearCompanyAction(companyId));\n *   }\n * }\n * ```\n */\n@Injectable()\nexport class EntityServicesBase implements EntityServices {\n  // Dear @ngrx/data developer: think hard before changing the constructor.\n  // Doing so will break apps that derive from this base class,\n  // and many apps will derive from this class.\n  //\n  // Do not give this constructor an implementation.\n  // Doing so makes it hard to mock classes that derive from this class.\n  // Use getter properties instead. For example, see entityCache$\n  constructor(private entityServicesElements: EntityServicesElements) {}\n\n  // #region EntityServicesElement-based properties\n\n  /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */\n  get entityActionErrors$(): Observable<EntityAction> {\n    return this.entityServicesElements.entityActionErrors$;\n  }\n\n  /** Observable of the entire entity cache */\n  get entityCache$(): Observable<EntityCache> | Store<EntityCache> {\n    return this.entityServicesElements.entityCache$;\n  }\n\n  /** Factory to create a default instance of an EntityCollectionService */\n  get entityCollectionServiceFactory(): EntityCollectionServiceFactory {\n    return this.entityServicesElements.entityCollectionServiceFactory;\n  }\n\n  /**\n   * Actions scanned by the store after it processed them with reducers.\n   * A replay observable of the most recent action reduced by the store.\n   */\n  get reducedActions$(): Observable<Action> {\n    return this.entityServicesElements.reducedActions$;\n  }\n\n  /** The ngrx store, scoped to the EntityCache */\n  protected get store(): Store<EntityCache> {\n    return this.entityServicesElements.store;\n  }\n\n  // #endregion EntityServicesElement-based properties\n\n  /** Dispatch any action to the store */\n  dispatch(action: Action) {\n    this.store.dispatch(action);\n  }\n\n  /** Registry of EntityCollectionService instances */\n  private readonly EntityCollectionServices: EntityCollectionServiceMap = {};\n\n  /**\n   * Create a new default instance of an EntityCollectionService.\n   * Prefer getEntityCollectionService() unless you really want a new default instance.\n   * This one will NOT be registered with EntityServices!\n   * @param entityName {string} Name of the entity type of the service\n   */\n  protected createEntityCollectionService<\n    T,\n    S$ extends EntitySelectors$<T> = EntitySelectors$<T>\n  >(entityName: string): EntityCollectionService<T> {\n    return this.entityCollectionServiceFactory.create<T, S$>(entityName);\n  }\n\n  /** Get (or create) the singleton instance of an EntityCollectionService\n   * @param entityName {string} Name of the entity type of the service\n   */\n  getEntityCollectionService<\n    T,\n    S$ extends EntitySelectors$<T> = EntitySelectors$<T>\n  >(entityName: string): EntityCollectionService<T> {\n    let service = this.EntityCollectionServices[entityName];\n    if (!service) {\n      service = this.createEntityCollectionService<T, S$>(entityName);\n      this.EntityCollectionServices[entityName] = service;\n    }\n    return service;\n  }\n\n  /** Register an EntityCollectionService under its entity type name.\n   * Will replace a pre-existing service for that type.\n   * @param service {EntityCollectionService} The entity service\n   * @param serviceName {string} optional service name to use instead of the service's entityName\n   */\n  registerEntityCollectionService<T>(\n    service: EntityCollectionService<T>,\n    serviceName?: string\n  ) {\n    this.EntityCollectionServices[serviceName || service.entityName] = service;\n  }\n\n  /**\n   * Register entity services for several entity types at once.\n   * Will replace a pre-existing service for that type.\n   * @param entityCollectionServices {EntityCollectionServiceMap | EntityCollectionService<any>[]}\n   * EntityCollectionServices to register, either as a map or an array\n   */\n  registerEntityCollectionServices(\n    entityCollectionServices:\n      | EntityCollectionServiceMap\n      | EntityCollectionService<any>[]\n  ): void {\n    if (Array.isArray(entityCollectionServices)) {\n      entityCollectionServices.forEach((service) =>\n        this.registerEntityCollectionService(service)\n      );\n    } else {\n      Object.keys(entityCollectionServices || {}).forEach((serviceName) => {\n        this.registerEntityCollectionService(\n          entityCollectionServices[serviceName],\n          serviceName\n        );\n      });\n    }\n  }\n}\n"]}

package/esm2022/src/entity-services/entity-services-elements.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-collection-service-factory";
+import * as i2 from "../dispatchers/entity-dispatcher-factory";
+import * as i3 from "../selectors/entity-selectors$";
+import * as i4 from "@ngrx/store";
+/** Core ingredients of an EntityServices class */
+class EntityServicesElements {
+    constructor(
+    /**
+     * Creates EntityCollectionService instances for
+     * a cached collection of T entities in the ngrx store.
+     */
+    entityCollectionServiceFactory, 
+    /** Creates EntityDispatchers for entity collections */
+    entityDispatcherFactory, 
+    /** Creates observable EntitySelectors$ for entity collections. */
+    entitySelectors$Factory, 
+    /** The ngrx store, scoped to the EntityCache */
+    store) {
+        this.entityCollectionServiceFactory = entityCollectionServiceFactory;
+        this.store = store;
+        this.entityActionErrors$ = entitySelectors$Factory.entityActionErrors$;
+        this.entityCache$ = entitySelectors$Factory.entityCache$;
+        this.reducedActions$ = entityDispatcherFactory.reducedActions$;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesElements, deps: [{ token: i1.EntityCollectionServiceFactory }, { token: i2.EntityDispatcherFactory }, { token: i3.EntitySelectors$Factory }, { token: i4.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesElements }); }
+}
+export { EntityServicesElements };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityServicesElements, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityCollectionServiceFactory }, { type: i2.EntityDispatcherFactory }, { type: i3.EntitySelectors$Factory }, { type: i4.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/reducers/entity-cache-reducer.mjs

@@ -0,0 +1,272 @@
+import { Injectable } from '@angular/core';
+import { EntityCacheAction, } from '../actions/entity-cache-action';
+import { ChangeSetOperation, } from '../actions/entity-cache-change-set';
+import { EntityOp } from '../actions/entity-op';
+import { MergeStrategy } from '../actions/merge-strategy';
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-collection-creator";
+import * as i2 from "./entity-collection-reducer-registry";
+import * as i3 from "../utils/interfaces";
+/**
+ * Creates the EntityCacheReducer via its create() method
+ */
+class EntityCacheReducerFactory {
+    constructor(entityCollectionCreator, entityCollectionReducerRegistry, logger) {
+        this.entityCollectionCreator = entityCollectionCreator;
+        this.entityCollectionReducerRegistry = entityCollectionReducerRegistry;
+        this.logger = logger;
+    }
+    /**
+     * Create the @ngrx/data entity cache reducer which either responds to entity cache level actions
+     * or (more commonly) delegates to an EntityCollectionReducer based on the action.payload.entityName.
+     */
+    create() {
+        // This technique ensures a named function appears in the debugger
+        return entityCacheReducer.bind(this);
+        function entityCacheReducer(entityCache = {}, action) {
+            // EntityCache actions
+            switch (action.type) {
+                case EntityCacheAction.CLEAR_COLLECTIONS: {
+                    return this.clearCollectionsReducer(entityCache, action);
+                }
+                case EntityCacheAction.LOAD_COLLECTIONS: {
+                    return this.loadCollectionsReducer(entityCache, action);
+                }
+                case EntityCacheAction.MERGE_QUERY_SET: {
+                    return this.mergeQuerySetReducer(entityCache, action);
+                }
+                case EntityCacheAction.SAVE_ENTITIES: {
+                    return this.saveEntitiesReducer(entityCache, action);
+                }
+                case EntityCacheAction.SAVE_ENTITIES_CANCEL: {
+                    return this.saveEntitiesCancelReducer(entityCache, action);
+                }
+                case EntityCacheAction.SAVE_ENTITIES_ERROR: {
+                    return this.saveEntitiesErrorReducer(entityCache, action);
+                }
+                case EntityCacheAction.SAVE_ENTITIES_SUCCESS: {
+                    return this.saveEntitiesSuccessReducer(entityCache, action);
+                }
+                case EntityCacheAction.SET_ENTITY_CACHE: {
+                    // Completely replace the EntityCache. Be careful!
+                    return action.payload.cache;
+                }
+            }
+            // Apply entity collection reducer if this is a valid EntityAction for a collection
+            const payload = action.payload;
+            if (payload && payload.entityName && payload.entityOp && !payload.error) {
+                return this.applyCollectionReducer(entityCache, action);
+            }
+            // Not a valid EntityAction
+            return entityCache;
+        }
+    }
+    /**
+     * Reducer to clear multiple collections at the same time.
+     * @param entityCache the entity cache
+     * @param action a ClearCollections action whose payload is an array of collection names.
+     * If empty array, does nothing. If no array, clears all the collections.
+     */
+    clearCollectionsReducer(entityCache, action) {
+        // eslint-disable-next-line prefer-const
+        let { collections, tag } = action.payload;
+        const entityOp = EntityOp.REMOVE_ALL;
+        if (!collections) {
+            // Collections is not defined. Clear all collections.
+            collections = Object.keys(entityCache);
+        }
+        entityCache = collections.reduce((newCache, entityName) => {
+            const payload = { entityName, entityOp };
+            const act = {
+                type: `[${entityName}] ${action.type}`,
+                payload,
+            };
+            newCache = this.applyCollectionReducer(newCache, act);
+            return newCache;
+        }, entityCache);
+        return entityCache;
+    }
+    /**
+     * Reducer to load collection in the form of a hash of entity data for multiple collections.
+     * @param entityCache the entity cache
+     * @param action a LoadCollections action whose payload is the QuerySet of entity collections to load
+     */
+    loadCollectionsReducer(entityCache, action) {
+        const { collections, tag } = action.payload;
+        const entityOp = EntityOp.ADD_ALL;
+        const entityNames = Object.keys(collections);
+        entityCache = entityNames.reduce((newCache, entityName) => {
+            const payload = {
+                entityName,
+                entityOp,
+                data: collections[entityName],
+            };
+            const act = {
+                type: `[${entityName}] ${action.type}`,
+                payload,
+            };
+            newCache = this.applyCollectionReducer(newCache, act);
+            return newCache;
+        }, entityCache);
+        return entityCache;
+    }
+    /**
+     * Reducer to merge query sets in the form of a hash of entity data for multiple collections.
+     * @param entityCache the entity cache
+     * @param action a MergeQuerySet action with the query set and a MergeStrategy
+     */
+    mergeQuerySetReducer(entityCache, action) {
+        // eslint-disable-next-line prefer-const
+        let { mergeStrategy, querySet, tag } = action.payload;
+        mergeStrategy =
+            mergeStrategy === null ? MergeStrategy.PreserveChanges : mergeStrategy;
+        const entityOp = EntityOp.QUERY_MANY_SUCCESS;
+        const entityNames = Object.keys(querySet);
+        entityCache = entityNames.reduce((newCache, entityName) => {
+            const payload = {
+                entityName,
+                entityOp,
+                data: querySet[entityName],
+                mergeStrategy,
+            };
+            const act = {
+                type: `[${entityName}] ${action.type}`,
+                payload,
+            };
+            newCache = this.applyCollectionReducer(newCache, act);
+            return newCache;
+        }, entityCache);
+        return entityCache;
+    }
+    // #region saveEntities reducers
+    saveEntitiesReducer(entityCache, action) {
+        const { changeSet, correlationId, isOptimistic, mergeStrategy, tag } = action.payload;
+        try {
+            changeSet.changes.forEach((item) => {
+                const entityName = item.entityName;
+                const payload = {
+                    entityName,
+                    entityOp: getEntityOp(item),
+                    data: item.entities,
+                    correlationId,
+                    isOptimistic,
+                    mergeStrategy,
+                    tag,
+                };
+                const act = {
+                    type: `[${entityName}] ${action.type}`,
+                    payload,
+                };
+                entityCache = this.applyCollectionReducer(entityCache, act);
+                if (act.payload.error) {
+                    throw act.payload.error;
+                }
+            });
+        }
+        catch (error) {
+            action.payload.error = error;
+        }
+        return entityCache;
+        function getEntityOp(item) {
+            switch (item.op) {
+                case ChangeSetOperation.Add:
+                    return EntityOp.SAVE_ADD_MANY;
+                case ChangeSetOperation.Delete:
+                    return EntityOp.SAVE_DELETE_MANY;
+                case ChangeSetOperation.Update:
+                    return EntityOp.SAVE_UPDATE_MANY;
+                case ChangeSetOperation.Upsert:
+                    return EntityOp.SAVE_UPSERT_MANY;
+            }
+        }
+    }
+    saveEntitiesCancelReducer(entityCache, action) {
+        // This implementation can only clear the loading flag for the collections involved
+        // If the save was optimistic, you'll have to compensate to fix the cache as you think necessary
+        return this.clearLoadingFlags(entityCache, action.payload.entityNames || []);
+    }
+    saveEntitiesErrorReducer(entityCache, action) {
+        const originalAction = action.payload.originalAction;
+        const originalChangeSet = originalAction.payload.changeSet;
+        // This implementation can only clear the loading flag for the collections involved
+        // If the save was optimistic, you'll have to compensate to fix the cache as you think necessary
+        const entityNames = originalChangeSet.changes.map((item) => item.entityName);
+        return this.clearLoadingFlags(entityCache, entityNames);
+    }
+    saveEntitiesSuccessReducer(entityCache, action) {
+        const { changeSet, correlationId, isOptimistic, mergeStrategy, tag } = action.payload;
+        changeSet.changes.forEach((item) => {
+            const entityName = item.entityName;
+            const payload = {
+                entityName,
+                entityOp: getEntityOp(item),
+                data: item.entities,
+                correlationId,
+                isOptimistic,
+                mergeStrategy,
+                tag,
+            };
+            const act = {
+                type: `[${entityName}] ${action.type}`,
+                payload,
+            };
+            entityCache = this.applyCollectionReducer(entityCache, act);
+        });
+        return entityCache;
+        function getEntityOp(item) {
+            switch (item.op) {
+                case ChangeSetOperation.Add:
+                    return EntityOp.SAVE_ADD_MANY_SUCCESS;
+                case ChangeSetOperation.Delete:
+                    return EntityOp.SAVE_DELETE_MANY_SUCCESS;
+                case ChangeSetOperation.Update:
+                    return EntityOp.SAVE_UPDATE_MANY_SUCCESS;
+                case ChangeSetOperation.Upsert:
+                    return EntityOp.SAVE_UPSERT_MANY_SUCCESS;
+            }
+        }
+    }
+    // #endregion saveEntities reducers
+    // #region helpers
+    /** Apply reducer for the action's EntityCollection (if the action targets a collection) */
+    applyCollectionReducer(cache = {}, action) {
+        const entityName = action.payload.entityName;
+        const collection = cache[entityName];
+        const reducer = this.entityCollectionReducerRegistry.getOrCreateReducer(entityName);
+        let newCollection;
+        try {
+            newCollection = collection
+                ? reducer(collection, action)
+                : reducer(this.entityCollectionCreator.create(entityName), action);
+        }
+        catch (error) {
+            this.logger.error(error);
+            action.payload.error = error;
+        }
+        return action.payload.error || collection === newCollection
+            ? cache
+            : { ...cache, [entityName]: newCollection };
+    }
+    /** Ensure loading is false for every collection in entityNames */
+    clearLoadingFlags(entityCache, entityNames) {
+        let isMutated = false;
+        entityNames.forEach((entityName) => {
+            const collection = entityCache[entityName];
+            if (collection.loading) {
+                if (!isMutated) {
+                    entityCache = { ...entityCache };
+                    isMutated = true;
+                }
+                entityCache[entityName] = { ...collection, loading: false };
+            }
+        });
+        return entityCache;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheReducerFactory, deps: [{ token: i1.EntityCollectionCreator }, { token: i2.EntityCollectionReducerRegistry }, { token: i3.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheReducerFactory }); }
+}
+export { EntityCacheReducerFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheReducerFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityCollectionCreator }, { type: i2.EntityCollectionReducerRegistry }, { type: i3.Logger }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-cache-reducer.js","sourceRoot":"","sources":["../../../../../../modules/data/src/reducers/entity-cache-reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Action, ActionReducer } from '@ngrx/store';\n\nimport { EntityAction } from '../actions/entity-action';\nimport { EntityCache } from './entity-cache';\n\nimport {\n  EntityCacheAction,\n  ClearCollections,\n  LoadCollections,\n  MergeQuerySet,\n  SaveEntities,\n  SaveEntitiesCancel,\n  SaveEntitiesError,\n  SaveEntitiesSuccess,\n} from '../actions/entity-cache-action';\n\nimport {\n  ChangeSetOperation,\n  ChangeSetItem,\n} from '../actions/entity-cache-change-set';\n\nimport { EntityCollection } from './entity-collection';\nimport { EntityCollectionCreator } from './entity-collection-creator';\nimport { EntityCollectionReducerRegistry } from './entity-collection-reducer-registry';\nimport { EntityOp } from '../actions/entity-op';\nimport { Logger } from '../utils/interfaces';\nimport { MergeStrategy } from '../actions/merge-strategy';\n\n/**\n * Creates the EntityCacheReducer via its create() method\n */\n@Injectable()\nexport class EntityCacheReducerFactory {\n  constructor(\n    private entityCollectionCreator: EntityCollectionCreator,\n    private entityCollectionReducerRegistry: EntityCollectionReducerRegistry,\n    private logger: Logger\n  ) {}\n\n  /**\n   * Create the @ngrx/data entity cache reducer which either responds to entity cache level actions\n   * or (more commonly) delegates to an EntityCollectionReducer based on the action.payload.entityName.\n   */\n  create(): ActionReducer<EntityCache, Action> {\n    // This technique ensures a named function appears in the debugger\n    return entityCacheReducer.bind(this);\n\n    function entityCacheReducer(\n      this: EntityCacheReducerFactory,\n      entityCache: EntityCache = {},\n      action: { type: string; payload?: any }\n    ): EntityCache {\n      // EntityCache actions\n      switch (action.type) {\n        case EntityCacheAction.CLEAR_COLLECTIONS: {\n          return this.clearCollectionsReducer(\n            entityCache,\n            action as ClearCollections\n          );\n        }\n\n        case EntityCacheAction.LOAD_COLLECTIONS: {\n          return this.loadCollectionsReducer(\n            entityCache,\n            action as LoadCollections\n          );\n        }\n\n        case EntityCacheAction.MERGE_QUERY_SET: {\n          return this.mergeQuerySetReducer(\n            entityCache,\n            action as MergeQuerySet\n          );\n        }\n\n        case EntityCacheAction.SAVE_ENTITIES: {\n          return this.saveEntitiesReducer(entityCache, action as SaveEntities);\n        }\n\n        case EntityCacheAction.SAVE_ENTITIES_CANCEL: {\n          return this.saveEntitiesCancelReducer(\n            entityCache,\n            action as SaveEntitiesCancel\n          );\n        }\n\n        case EntityCacheAction.SAVE_ENTITIES_ERROR: {\n          return this.saveEntitiesErrorReducer(\n            entityCache,\n            action as SaveEntitiesError\n          );\n        }\n\n        case EntityCacheAction.SAVE_ENTITIES_SUCCESS: {\n          return this.saveEntitiesSuccessReducer(\n            entityCache,\n            action as SaveEntitiesSuccess\n          );\n        }\n\n        case EntityCacheAction.SET_ENTITY_CACHE: {\n          // Completely replace the EntityCache. Be careful!\n          return action.payload.cache;\n        }\n      }\n\n      // Apply entity collection reducer if this is a valid EntityAction for a collection\n      const payload = action.payload;\n      if (payload && payload.entityName && payload.entityOp && !payload.error) {\n        return this.applyCollectionReducer(entityCache, action as EntityAction);\n      }\n\n      // Not a valid EntityAction\n      return entityCache;\n    }\n  }\n\n  /**\n   * Reducer to clear multiple collections at the same time.\n   * @param entityCache the entity cache\n   * @param action a ClearCollections action whose payload is an array of collection names.\n   * If empty array, does nothing. If no array, clears all the collections.\n   */\n  protected clearCollectionsReducer(\n    entityCache: EntityCache,\n    action: ClearCollections\n  ) {\n    // eslint-disable-next-line prefer-const\n    let { collections, tag } = action.payload;\n    const entityOp = EntityOp.REMOVE_ALL;\n\n    if (!collections) {\n      // Collections is not defined. Clear all collections.\n      collections = Object.keys(entityCache);\n    }\n\n    entityCache = collections.reduce((newCache, entityName) => {\n      const payload = { entityName, entityOp };\n      const act: EntityAction = {\n        type: `[${entityName}] ${action.type}`,\n        payload,\n      };\n      newCache = this.applyCollectionReducer(newCache, act);\n      return newCache;\n    }, entityCache);\n    return entityCache;\n  }\n\n  /**\n   * Reducer to load collection in the form of a hash of entity data for multiple collections.\n   * @param entityCache the entity cache\n   * @param action a LoadCollections action whose payload is the QuerySet of entity collections to load\n   */\n  protected loadCollectionsReducer(\n    entityCache: EntityCache,\n    action: LoadCollections\n  ) {\n    const { collections, tag } = action.payload;\n    const entityOp = EntityOp.ADD_ALL;\n    const entityNames = Object.keys(collections);\n    entityCache = entityNames.reduce((newCache, entityName) => {\n      const payload = {\n        entityName,\n        entityOp,\n        data: collections[entityName],\n      };\n      const act: EntityAction = {\n        type: `[${entityName}] ${action.type}`,\n        payload,\n      };\n      newCache = this.applyCollectionReducer(newCache, act);\n      return newCache;\n    }, entityCache);\n    return entityCache;\n  }\n\n  /**\n   * Reducer to merge query sets in the form of a hash of entity data for multiple collections.\n   * @param entityCache the entity cache\n   * @param action a MergeQuerySet action with the query set and a MergeStrategy\n   */\n  protected mergeQuerySetReducer(\n    entityCache: EntityCache,\n    action: MergeQuerySet\n  ) {\n    // eslint-disable-next-line prefer-const\n    let { mergeStrategy, querySet, tag } = action.payload;\n    mergeStrategy =\n      mergeStrategy === null ? MergeStrategy.PreserveChanges : mergeStrategy;\n    const entityOp = EntityOp.QUERY_MANY_SUCCESS;\n\n    const entityNames = Object.keys(querySet);\n    entityCache = entityNames.reduce((newCache, entityName) => {\n      const payload = {\n        entityName,\n        entityOp,\n        data: querySet[entityName],\n        mergeStrategy,\n      };\n      const act: EntityAction = {\n        type: `[${entityName}] ${action.type}`,\n        payload,\n      };\n      newCache = this.applyCollectionReducer(newCache, act);\n      return newCache;\n    }, entityCache);\n    return entityCache;\n  }\n\n  // #region saveEntities reducers\n  protected saveEntitiesReducer(\n    entityCache: EntityCache,\n    action: SaveEntities\n  ) {\n    const { changeSet, correlationId, isOptimistic, mergeStrategy, tag } =\n      action.payload;\n\n    try {\n      changeSet.changes.forEach((item) => {\n        const entityName = item.entityName;\n        const payload = {\n          entityName,\n          entityOp: getEntityOp(item),\n          data: item.entities,\n          correlationId,\n          isOptimistic,\n          mergeStrategy,\n          tag,\n        };\n\n        const act: EntityAction = {\n          type: `[${entityName}] ${action.type}`,\n          payload,\n        };\n        entityCache = this.applyCollectionReducer(entityCache, act);\n        if (act.payload.error) {\n          throw act.payload.error;\n        }\n      });\n    } catch (error: any) {\n      action.payload.error = error;\n    }\n\n    return entityCache;\n    function getEntityOp(item: ChangeSetItem) {\n      switch (item.op) {\n        case ChangeSetOperation.Add:\n          return EntityOp.SAVE_ADD_MANY;\n        case ChangeSetOperation.Delete:\n          return EntityOp.SAVE_DELETE_MANY;\n        case ChangeSetOperation.Update:\n          return EntityOp.SAVE_UPDATE_MANY;\n        case ChangeSetOperation.Upsert:\n          return EntityOp.SAVE_UPSERT_MANY;\n      }\n    }\n  }\n\n  protected saveEntitiesCancelReducer(\n    entityCache: EntityCache,\n    action: SaveEntitiesCancel\n  ) {\n    // This implementation can only clear the loading flag for the collections involved\n    // If the save was optimistic, you'll have to compensate to fix the cache as you think necessary\n    return this.clearLoadingFlags(\n      entityCache,\n      action.payload.entityNames || []\n    );\n  }\n\n  protected saveEntitiesErrorReducer(\n    entityCache: EntityCache,\n    action: SaveEntitiesError\n  ) {\n    const originalAction = action.payload.originalAction;\n    const originalChangeSet = originalAction.payload.changeSet;\n\n    // This implementation can only clear the loading flag for the collections involved\n    // If the save was optimistic, you'll have to compensate to fix the cache as you think necessary\n    const entityNames = originalChangeSet.changes.map(\n      (item) => item.entityName\n    );\n    return this.clearLoadingFlags(entityCache, entityNames);\n  }\n\n  protected saveEntitiesSuccessReducer(\n    entityCache: EntityCache,\n    action: SaveEntitiesSuccess\n  ) {\n    const { changeSet, correlationId, isOptimistic, mergeStrategy, tag } =\n      action.payload;\n\n    changeSet.changes.forEach((item) => {\n      const entityName = item.entityName;\n      const payload = {\n        entityName,\n        entityOp: getEntityOp(item),\n        data: item.entities,\n        correlationId,\n        isOptimistic,\n        mergeStrategy,\n        tag,\n      };\n\n      const act: EntityAction = {\n        type: `[${entityName}] ${action.type}`,\n        payload,\n      };\n      entityCache = this.applyCollectionReducer(entityCache, act);\n    });\n\n    return entityCache;\n    function getEntityOp(item: ChangeSetItem) {\n      switch (item.op) {\n        case ChangeSetOperation.Add:\n          return EntityOp.SAVE_ADD_MANY_SUCCESS;\n        case ChangeSetOperation.Delete:\n          return EntityOp.SAVE_DELETE_MANY_SUCCESS;\n        case ChangeSetOperation.Update:\n          return EntityOp.SAVE_UPDATE_MANY_SUCCESS;\n        case ChangeSetOperation.Upsert:\n          return EntityOp.SAVE_UPSERT_MANY_SUCCESS;\n      }\n    }\n  }\n  // #endregion saveEntities reducers\n\n  // #region helpers\n  /** Apply reducer for the action's EntityCollection (if the action targets a collection) */\n  private applyCollectionReducer(\n    cache: EntityCache = {},\n    action: EntityAction\n  ) {\n    const entityName = action.payload.entityName;\n    const collection = cache[entityName];\n    const reducer =\n      this.entityCollectionReducerRegistry.getOrCreateReducer(entityName);\n\n    let newCollection: EntityCollection;\n    try {\n      newCollection = collection\n        ? reducer(collection, action)\n        : reducer(this.entityCollectionCreator.create(entityName), action);\n    } catch (error: any) {\n      this.logger.error(error);\n      action.payload.error = error;\n    }\n\n    return action.payload.error || collection === newCollection!\n      ? cache\n      : { ...cache, [entityName]: newCollection! };\n  }\n\n  /** Ensure loading is false for every collection in entityNames */\n  private clearLoadingFlags(entityCache: EntityCache, entityNames: string[]) {\n    let isMutated = false;\n    entityNames.forEach((entityName) => {\n      const collection = entityCache[entityName];\n      if (collection.loading) {\n        if (!isMutated) {\n          entityCache = { ...entityCache };\n          isMutated = true;\n        }\n        entityCache[entityName] = { ...collection, loading: false };\n      }\n    });\n    return entityCache;\n  }\n  // #endregion helpers\n}\n"]}

package/esm2022/src/reducers/entity-collection-creator.mjs

@@ -0,0 +1,38 @@
+import { Injectable, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../entity-metadata/entity-definition.service";
+class EntityCollectionCreator {
+    constructor(entityDefinitionService) {
+        this.entityDefinitionService = entityDefinitionService;
+    }
+    /**
+     * Create the default collection for an entity type.
+     * @param entityName {string} entity type name
+     */
+    create(entityName) {
+        const def = this.entityDefinitionService &&
+            this.entityDefinitionService.getDefinition(entityName, false /*shouldThrow*/);
+        const initialState = def && def.initialState;
+        return (initialState || createEmptyEntityCollection(entityName));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCollectionCreator, deps: [{ token: i1.EntityDefinitionService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCollectionCreator }); }
+}
+export { EntityCollectionCreator };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCollectionCreator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityDefinitionService, decorators: [{
+                    type: Optional
+                }] }]; } });
+export function createEmptyEntityCollection(entityName) {
+    return {
+        entityName,
+        ids: [],
+        entities: {},
+        filter: undefined,
+        loaded: false,
+        loading: false,
+        changeState: {},
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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