@ngrx/data 15.4.0 → 16.0.0-beta.0

package/esm2022/src/effects/entity-cache-effects.mjs

@@ -0,0 +1,116 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { ofType, createEffect } from '@ngrx/effects';
+import { asyncScheduler, of, merge, race, } from 'rxjs';
+import { concatMap, catchError, delay, filter, map, mergeMap, } from 'rxjs/operators';
+import { DataServiceError } from '../dataservices/data-service-error';
+import { excludeEmptyChangeSetItems, } from '../actions/entity-cache-change-set';
+import { EntityOp } from '../actions/entity-op';
+import { EntityCacheAction, SaveEntitiesCanceled, SaveEntitiesError, SaveEntitiesSuccess, } from '../actions/entity-cache-action';
+import { ENTITY_EFFECTS_SCHEDULER } from './entity-effects-scheduler';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+import * as i2 from "../dataservices/entity-cache-data.service";
+import * as i3 from "../actions/entity-action-factory";
+import * as i4 from "../utils/interfaces";
+class EntityCacheEffects {
+    constructor(actions, dataService, entityActionFactory, logger, 
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    scheduler) {
+        this.actions = actions;
+        this.dataService = dataService;
+        this.entityActionFactory = entityActionFactory;
+        this.logger = logger;
+        this.scheduler = scheduler;
+        // See https://github.com/ReactiveX/rxjs/blob/master/doc/marble-testing.md
+        /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */
+        this.responseDelay = 10;
+        /**
+         * Observable of SAVE_ENTITIES_CANCEL actions with non-null correlation ids
+         */
+        this.saveEntitiesCancel$ = createEffect(() => this.actions.pipe(ofType(EntityCacheAction.SAVE_ENTITIES_CANCEL), filter((a) => a.payload.correlationId != null)), { dispatch: false });
+        // Concurrent persistence requests considered unsafe.
+        // `mergeMap` allows for concurrent requests which may return in any order
+        this.saveEntities$ = createEffect(() => this.actions.pipe(ofType(EntityCacheAction.SAVE_ENTITIES), mergeMap((action) => this.saveEntities(action))));
+    }
+    /**
+     * Perform the requested SaveEntities actions and return a scalar Observable<Action>
+     * that the effect should dispatch to the store after the server responds.
+     * @param action The SaveEntities action
+     */
+    saveEntities(action) {
+        const error = action.payload.error;
+        if (error) {
+            return this.handleSaveEntitiesError$(action)(error);
+        }
+        try {
+            const changeSet = excludeEmptyChangeSetItems(action.payload.changeSet);
+            const { correlationId, mergeStrategy, tag, url } = action.payload;
+            const options = { correlationId, mergeStrategy, tag };
+            if (changeSet.changes.length === 0) {
+                // nothing to save
+                return of(new SaveEntitiesSuccess(changeSet, url, options));
+            }
+            // Cancellation: returns Observable<SaveEntitiesCanceled> for a saveEntities action
+            // whose correlationId matches the cancellation correlationId
+            const c = this.saveEntitiesCancel$.pipe(filter((a) => correlationId === a.payload.correlationId), map((a) => new SaveEntitiesCanceled(correlationId, a.payload.reason, a.payload.tag)));
+            // Data: SaveEntities result as a SaveEntitiesSuccess action
+            const d = this.dataService.saveEntities(changeSet, url).pipe(concatMap((result) => this.handleSaveEntitiesSuccess$(action, this.entityActionFactory)(result)), catchError(this.handleSaveEntitiesError$(action)));
+            // Emit which ever gets there first; the other observable is terminated.
+            return race(c, d);
+        }
+        catch (err) {
+            return this.handleSaveEntitiesError$(action)(err);
+        }
+    }
+    /** return handler of error result of saveEntities, returning a scalar observable of error action */
+    handleSaveEntitiesError$(action) {
+        // Although error may return immediately,
+        // ensure observable takes some time,
+        // as app likely assumes asynchronous response.
+        return (err) => {
+            const error = err instanceof DataServiceError ? err : new DataServiceError(err, null);
+            return of(new SaveEntitiesError(error, action)).pipe(delay(this.responseDelay, this.scheduler || asyncScheduler));
+        };
+    }
+    /** return handler of the ChangeSet result of successful saveEntities() */
+    handleSaveEntitiesSuccess$(action, entityActionFactory) {
+        const { url, correlationId, mergeStrategy, tag } = action.payload;
+        const options = { correlationId, mergeStrategy, tag };
+        return (changeSet) => {
+            // DataService returned a ChangeSet with possible updates to the saved entities
+            if (changeSet) {
+                return of(new SaveEntitiesSuccess(changeSet, url, options));
+            }
+            // No ChangeSet = Server probably responded '204 - No Content' because
+            // it made no changes to the inserted/updated entities.
+            // Respond with success action best on the ChangeSet in the request.
+            changeSet = action.payload.changeSet;
+            // If pessimistic save, return success action with the original ChangeSet
+            if (!action.payload.isOptimistic) {
+                return of(new SaveEntitiesSuccess(changeSet, url, options));
+            }
+            // If optimistic save, avoid cache grinding by just turning off the loading flags
+            // for all collections in the original ChangeSet
+            const entityNames = changeSet.changes.reduce((acc, item) => acc.indexOf(item.entityName) === -1
+                ? acc.concat(item.entityName)
+                : acc, []);
+            return merge(entityNames.map((name) => entityActionFactory.create(name, EntityOp.SET_LOADING, false)));
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCacheEffects, deps: [{ token: i1.Actions }, { token: i2.EntityCacheDataService }, { token: i3.EntityActionFactory }, { token: i4.Logger }, { token: ENTITY_EFFECTS_SCHEDULER, 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: EntityCacheEffects }); }
+}
+export { EntityCacheEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCacheEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.EntityCacheDataService }, { type: i3.EntityActionFactory }, { type: i4.Logger }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENTITY_EFFECTS_SCHEDULER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-cache-effects.js","sourceRoot":"","sources":["../../../../../../modules/data/src/effects/entity-cache-effects.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Action } from '@ngrx/store';\nimport { Actions, ofType, createEffect } from '@ngrx/effects';\n\nimport {\n  asyncScheduler,\n  Observable,\n  of,\n  merge,\n  race,\n  SchedulerLike,\n} from 'rxjs';\nimport {\n  concatMap,\n  catchError,\n  delay,\n  filter,\n  map,\n  mergeMap,\n} from 'rxjs/operators';\n\nimport { DataServiceError } from '../dataservices/data-service-error';\nimport {\n  ChangeSet,\n  excludeEmptyChangeSetItems,\n} from '../actions/entity-cache-change-set';\nimport { EntityActionFactory } from '../actions/entity-action-factory';\nimport { EntityOp } from '../actions/entity-op';\n\nimport {\n  EntityCacheAction,\n  SaveEntities,\n  SaveEntitiesCancel,\n  SaveEntitiesCanceled,\n  SaveEntitiesError,\n  SaveEntitiesSuccess,\n} from '../actions/entity-cache-action';\nimport { EntityCacheDataService } from '../dataservices/entity-cache-data.service';\nimport { ENTITY_EFFECTS_SCHEDULER } from './entity-effects-scheduler';\nimport { Logger } from '../utils/interfaces';\n\n@Injectable()\nexport class EntityCacheEffects {\n  // See https://github.com/ReactiveX/rxjs/blob/master/doc/marble-testing.md\n  /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */\n  private responseDelay = 10;\n\n  constructor(\n    private actions: Actions,\n    private dataService: EntityCacheDataService,\n    private entityActionFactory: EntityActionFactory,\n    private logger: Logger,\n    /**\n     * Injecting an optional Scheduler that will be undefined\n     * in normal application usage, but its injected here so that you can mock out\n     * during testing using the RxJS TestScheduler for simulating passages of time.\n     */\n    @Optional()\n    @Inject(ENTITY_EFFECTS_SCHEDULER)\n    private scheduler: SchedulerLike\n  ) {}\n\n  /**\n   * Observable of SAVE_ENTITIES_CANCEL actions with non-null correlation ids\n   */\n  saveEntitiesCancel$: Observable<SaveEntitiesCancel> = createEffect(\n    () =>\n      this.actions.pipe(\n        ofType(EntityCacheAction.SAVE_ENTITIES_CANCEL),\n        filter((a: SaveEntitiesCancel) => a.payload.correlationId != null)\n      ),\n    { dispatch: false }\n  );\n\n  // Concurrent persistence requests considered unsafe.\n  // `mergeMap` allows for concurrent requests which may return in any order\n  saveEntities$: Observable<Action> = createEffect(() =>\n    this.actions.pipe(\n      ofType(EntityCacheAction.SAVE_ENTITIES),\n      mergeMap((action: SaveEntities) => this.saveEntities(action))\n    )\n  );\n\n  /**\n   * Perform the requested SaveEntities actions and return a scalar Observable<Action>\n   * that the effect should dispatch to the store after the server responds.\n   * @param action The SaveEntities action\n   */\n  saveEntities(action: SaveEntities): Observable<Action> {\n    const error = action.payload.error;\n    if (error) {\n      return this.handleSaveEntitiesError$(action)(error);\n    }\n    try {\n      const changeSet = excludeEmptyChangeSetItems(action.payload.changeSet);\n      const { correlationId, mergeStrategy, tag, url } = action.payload;\n      const options = { correlationId, mergeStrategy, tag };\n\n      if (changeSet.changes.length === 0) {\n        // nothing to save\n        return of(new SaveEntitiesSuccess(changeSet, url, options));\n      }\n\n      // Cancellation: returns Observable<SaveEntitiesCanceled> for a saveEntities action\n      // whose correlationId matches the cancellation correlationId\n      const c = this.saveEntitiesCancel$.pipe(\n        filter((a) => correlationId === a.payload.correlationId),\n        map(\n          (a) =>\n            new SaveEntitiesCanceled(\n              correlationId,\n              a.payload.reason,\n              a.payload.tag\n            )\n        )\n      );\n\n      // Data: SaveEntities result as a SaveEntitiesSuccess action\n      const d = this.dataService.saveEntities(changeSet, url).pipe(\n        concatMap((result) =>\n          this.handleSaveEntitiesSuccess$(\n            action,\n            this.entityActionFactory\n          )(result)\n        ),\n        catchError(this.handleSaveEntitiesError$(action))\n      );\n\n      // Emit which ever gets there first; the other observable is terminated.\n      return race(c, d);\n    } catch (err: any) {\n      return this.handleSaveEntitiesError$(action)(err);\n    }\n  }\n\n  /** return handler of error result of saveEntities, returning a scalar observable of error action */\n  private handleSaveEntitiesError$(\n    action: SaveEntities\n  ): (err: DataServiceError | Error) => Observable<Action> {\n    // Although error may return immediately,\n    // ensure observable takes some time,\n    // as app likely assumes asynchronous response.\n    return (err: DataServiceError | Error) => {\n      const error =\n        err instanceof DataServiceError ? err : new DataServiceError(err, null);\n      return of(new SaveEntitiesError(error, action)).pipe(\n        delay(this.responseDelay, this.scheduler || asyncScheduler)\n      );\n    };\n  }\n\n  /** return handler of the ChangeSet result of successful saveEntities() */\n  private handleSaveEntitiesSuccess$(\n    action: SaveEntities,\n    entityActionFactory: EntityActionFactory\n  ): (changeSet: ChangeSet) => Observable<Action> {\n    const { url, correlationId, mergeStrategy, tag } = action.payload;\n    const options = { correlationId, mergeStrategy, tag };\n\n    return (changeSet) => {\n      // DataService returned a ChangeSet with possible updates to the saved entities\n      if (changeSet) {\n        return of(new SaveEntitiesSuccess(changeSet, url, options));\n      }\n\n      // No ChangeSet = Server probably responded '204 - No Content' because\n      // it made no changes to the inserted/updated entities.\n      // Respond with success action best on the ChangeSet in the request.\n      changeSet = action.payload.changeSet;\n\n      // If pessimistic save, return success action with the original ChangeSet\n      if (!action.payload.isOptimistic) {\n        return of(new SaveEntitiesSuccess(changeSet, url, options));\n      }\n\n      // If optimistic save, avoid cache grinding by just turning off the loading flags\n      // for all collections in the original ChangeSet\n      const entityNames = changeSet.changes.reduce(\n        (acc, item) =>\n          acc.indexOf(item.entityName) === -1\n            ? acc.concat(item.entityName)\n            : acc,\n        [] as string[]\n      );\n      return merge(\n        entityNames.map((name) =>\n          entityActionFactory.create(name, EntityOp.SET_LOADING, false)\n        )\n      );\n    };\n  }\n}\n"]}

package/esm2022/src/effects/entity-effects.mjs

@@ -0,0 +1,149 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { createEffect } from '@ngrx/effects';
+import { asyncScheduler, of, race } from 'rxjs';
+import { catchError, delay, filter, map, mergeMap } from 'rxjs/operators';
+import { ENTITY_EFFECTS_SCHEDULER } from './entity-effects-scheduler';
+import { EntityOp, makeSuccessOp } from '../actions/entity-op';
+import { ofEntityOp } from '../actions/entity-action-operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+import * as i2 from "../dataservices/entity-data.service";
+import * as i3 from "../actions/entity-action-factory";
+import * as i4 from "../dataservices/persistence-result-handler.service";
+export const persistOps = [
+    EntityOp.QUERY_ALL,
+    EntityOp.QUERY_LOAD,
+    EntityOp.QUERY_BY_KEY,
+    EntityOp.QUERY_MANY,
+    EntityOp.SAVE_ADD_ONE,
+    EntityOp.SAVE_DELETE_ONE,
+    EntityOp.SAVE_UPDATE_ONE,
+    EntityOp.SAVE_UPSERT_ONE,
+];
+class EntityEffects {
+    constructor(actions, dataService, entityActionFactory, resultHandler, 
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    scheduler) {
+        this.actions = actions;
+        this.dataService = dataService;
+        this.entityActionFactory = entityActionFactory;
+        this.resultHandler = resultHandler;
+        this.scheduler = scheduler;
+        // See https://github.com/ReactiveX/rxjs/blob/master/doc/marble-testing.md
+        /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */
+        this.responseDelay = 10;
+        /**
+         * Observable of non-null cancellation correlation ids from CANCEL_PERSIST actions
+         */
+        this.cancel$ = createEffect(() => this.actions.pipe(ofEntityOp(EntityOp.CANCEL_PERSIST), map((action) => action.payload.correlationId), filter((id) => id != null)), { dispatch: false });
+        // `mergeMap` allows for concurrent requests which may return in any order
+        this.persist$ = createEffect(() => this.actions.pipe(ofEntityOp(persistOps), mergeMap((action) => this.persist(action))));
+    }
+    /**
+     * Perform the requested persistence operation and return a scalar Observable<Action>
+     * that the effect should dispatch to the store after the server responds.
+     * @param action A persistence operation EntityAction
+     */
+    persist(action) {
+        if (action.payload.skip) {
+            // Should not persist. Pretend it succeeded.
+            return this.handleSkipSuccess$(action);
+        }
+        if (action.payload.error) {
+            return this.handleError$(action)(action.payload.error);
+        }
+        try {
+            // Cancellation: returns Observable of CANCELED_PERSIST for a persistence EntityAction
+            // whose correlationId matches cancellation correlationId
+            const c = this.cancel$.pipe(filter((id) => action.payload.correlationId === id), map((id) => this.entityActionFactory.createFromAction(action, {
+                entityOp: EntityOp.CANCELED_PERSIST,
+            })));
+            // Data: entity collection DataService result as a successful persistence EntityAction
+            const d = this.callDataService(action).pipe(map(this.resultHandler.handleSuccess(action)), catchError(this.handleError$(action)));
+            // Emit which ever gets there first; the other observable is terminated.
+            return race(c, d);
+        }
+        catch (err) {
+            return this.handleError$(action)(err);
+        }
+    }
+    callDataService(action) {
+        const { entityName, entityOp, data, httpOptions } = action.payload;
+        const service = this.dataService.getService(entityName);
+        switch (entityOp) {
+            case EntityOp.QUERY_ALL:
+            case EntityOp.QUERY_LOAD:
+                return service.getAll(httpOptions);
+            case EntityOp.QUERY_BY_KEY:
+                return service.getById(data, httpOptions);
+            case EntityOp.QUERY_MANY:
+                return service.getWithQuery(data, httpOptions);
+            case EntityOp.SAVE_ADD_ONE:
+                return service.add(data, httpOptions);
+            case EntityOp.SAVE_DELETE_ONE:
+                return service.delete(data, httpOptions);
+            case EntityOp.SAVE_UPDATE_ONE:
+                const { id, changes } = data; // data must be Update<T>
+                return service.update(data, httpOptions).pipe(map((updatedEntity) => {
+                    // Return an Update<T> with updated entity data.
+                    // If server returned entity data, merge with the changes that were sent
+                    // and set the 'changed' flag to true.
+                    // If server did not return entity data,
+                    // assume it made no additional changes of its own, return the original changes,
+                    // and set the `changed` flag to `false`.
+                    const hasData = updatedEntity && Object.keys(updatedEntity).length > 0;
+                    const responseData = hasData
+                        ? { id, changes: { ...changes, ...updatedEntity }, changed: true }
+                        : { id, changes, changed: false };
+                    return responseData;
+                }));
+            case EntityOp.SAVE_UPSERT_ONE:
+                return service.upsert(data, httpOptions).pipe(map((upsertedEntity) => {
+                    const hasData = upsertedEntity && Object.keys(upsertedEntity).length > 0;
+                    return hasData ? upsertedEntity : data; // ensure a returned entity value.
+                }));
+            default:
+                throw new Error(`Persistence action "${entityOp}" is not implemented.`);
+        }
+    }
+    /**
+     * Handle error result of persistence operation on an EntityAction,
+     * returning a scalar observable of error action
+     */
+    handleError$(action) {
+        // Although error may return immediately,
+        // ensure observable takes some time,
+        // as app likely assumes asynchronous response.
+        return (error) => of(this.resultHandler.handleError(action)(error)).pipe(delay(this.responseDelay, this.scheduler || asyncScheduler));
+    }
+    /**
+     * Because EntityAction.payload.skip is true, skip the persistence step and
+     * return a scalar success action that looks like the operation succeeded.
+     */
+    handleSkipSuccess$(originalAction) {
+        const successOp = makeSuccessOp(originalAction.payload.entityOp);
+        const successAction = this.entityActionFactory.createFromAction(originalAction, {
+            entityOp: successOp,
+        });
+        // Although returns immediately,
+        // ensure observable takes one tick (by using a promise),
+        // as app likely assumes asynchronous response.
+        return of(successAction).pipe(delay(this.responseDelay, this.scheduler || asyncScheduler));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityEffects, deps: [{ token: i1.Actions }, { token: i2.EntityDataService }, { token: i3.EntityActionFactory }, { token: i4.PersistenceResultHandler }, { token: ENTITY_EFFECTS_SCHEDULER, 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: EntityEffects }); }
+}
+export { EntityEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.EntityDataService }, { type: i3.EntityActionFactory }, { type: i4.PersistenceResultHandler }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENTITY_EFFECTS_SCHEDULER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-effects.js","sourceRoot":"","sources":["../../../../../../modules/data/src/effects/entity-effects.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Action } from '@ngrx/store';\nimport { Actions, createEffect } from '@ngrx/effects';\nimport { Update } from '@ngrx/entity';\n\nimport { asyncScheduler, Observable, of, race, SchedulerLike } from 'rxjs';\nimport { catchError, delay, filter, map, mergeMap } from 'rxjs/operators';\n\nimport { EntityAction } from '../actions/entity-action';\nimport { EntityActionFactory } from '../actions/entity-action-factory';\nimport { ENTITY_EFFECTS_SCHEDULER } from './entity-effects-scheduler';\nimport { EntityOp, makeSuccessOp } from '../actions/entity-op';\nimport { ofEntityOp } from '../actions/entity-action-operators';\nimport { UpdateResponseData } from '../actions/update-response-data';\n\nimport { EntityDataService } from '../dataservices/entity-data.service';\nimport { PersistenceResultHandler } from '../dataservices/persistence-result-handler.service';\n\nexport const persistOps: EntityOp[] = [\n  EntityOp.QUERY_ALL,\n  EntityOp.QUERY_LOAD,\n  EntityOp.QUERY_BY_KEY,\n  EntityOp.QUERY_MANY,\n  EntityOp.SAVE_ADD_ONE,\n  EntityOp.SAVE_DELETE_ONE,\n  EntityOp.SAVE_UPDATE_ONE,\n  EntityOp.SAVE_UPSERT_ONE,\n];\n\n@Injectable()\nexport class EntityEffects {\n  // See https://github.com/ReactiveX/rxjs/blob/master/doc/marble-testing.md\n  /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */\n  private responseDelay = 10;\n\n  /**\n   * Observable of non-null cancellation correlation ids from CANCEL_PERSIST actions\n   */\n  cancel$: Observable<any> = createEffect(\n    () =>\n      this.actions.pipe(\n        ofEntityOp(EntityOp.CANCEL_PERSIST),\n        map((action: EntityAction) => action.payload.correlationId),\n        filter((id) => id != null)\n      ),\n    { dispatch: false }\n  );\n\n  // `mergeMap` allows for concurrent requests which may return in any order\n  persist$: Observable<Action> = createEffect(() =>\n    this.actions.pipe(\n      ofEntityOp(persistOps),\n      mergeMap((action) => this.persist(action))\n    )\n  );\n\n  constructor(\n    private actions: Actions<EntityAction>,\n    private dataService: EntityDataService,\n    private entityActionFactory: EntityActionFactory,\n    private resultHandler: PersistenceResultHandler,\n    /**\n     * Injecting an optional Scheduler that will be undefined\n     * in normal application usage, but its injected here so that you can mock out\n     * during testing using the RxJS TestScheduler for simulating passages of time.\n     */\n    @Optional()\n    @Inject(ENTITY_EFFECTS_SCHEDULER)\n    private scheduler: SchedulerLike\n  ) {}\n\n  /**\n   * Perform the requested persistence operation and return a scalar Observable<Action>\n   * that the effect should dispatch to the store after the server responds.\n   * @param action A persistence operation EntityAction\n   */\n  persist(action: EntityAction): Observable<Action> {\n    if (action.payload.skip) {\n      // Should not persist. Pretend it succeeded.\n      return this.handleSkipSuccess$(action);\n    }\n    if (action.payload.error) {\n      return this.handleError$(action)(action.payload.error);\n    }\n    try {\n      // Cancellation: returns Observable of CANCELED_PERSIST for a persistence EntityAction\n      // whose correlationId matches cancellation correlationId\n      const c = this.cancel$.pipe(\n        filter((id) => action.payload.correlationId === id),\n        map((id) =>\n          this.entityActionFactory.createFromAction(action, {\n            entityOp: EntityOp.CANCELED_PERSIST,\n          })\n        )\n      );\n\n      // Data: entity collection DataService result as a successful persistence EntityAction\n      const d = this.callDataService(action).pipe(\n        map(this.resultHandler.handleSuccess(action)),\n        catchError(this.handleError$(action))\n      );\n\n      // Emit which ever gets there first; the other observable is terminated.\n      return race(c, d);\n    } catch (err: any) {\n      return this.handleError$(action)(err);\n    }\n  }\n\n  private callDataService(action: EntityAction) {\n    const { entityName, entityOp, data, httpOptions } = action.payload;\n    const service = this.dataService.getService(entityName);\n    switch (entityOp) {\n      case EntityOp.QUERY_ALL:\n      case EntityOp.QUERY_LOAD:\n        return service.getAll(httpOptions);\n\n      case EntityOp.QUERY_BY_KEY:\n        return service.getById(data, httpOptions);\n\n      case EntityOp.QUERY_MANY:\n        return service.getWithQuery(data, httpOptions);\n\n      case EntityOp.SAVE_ADD_ONE:\n        return service.add(data, httpOptions);\n\n      case EntityOp.SAVE_DELETE_ONE:\n        return service.delete(data, httpOptions);\n\n      case EntityOp.SAVE_UPDATE_ONE:\n        const { id, changes } = data as Update<any>; // data must be Update<T>\n        return service.update(data, httpOptions).pipe(\n          map((updatedEntity: any) => {\n            // Return an Update<T> with updated entity data.\n            // If server returned entity data, merge with the changes that were sent\n            // and set the 'changed' flag to true.\n            // If server did not return entity data,\n            // assume it made no additional changes of its own, return the original changes,\n            // and set the `changed` flag to `false`.\n            const hasData =\n              updatedEntity && Object.keys(updatedEntity).length > 0;\n            const responseData: UpdateResponseData<any> = hasData\n              ? { id, changes: { ...changes, ...updatedEntity }, changed: true }\n              : { id, changes, changed: false };\n            return responseData;\n          })\n        );\n\n      case EntityOp.SAVE_UPSERT_ONE:\n        return service.upsert(data, httpOptions).pipe(\n          map((upsertedEntity: any) => {\n            const hasData =\n              upsertedEntity && Object.keys(upsertedEntity).length > 0;\n            return hasData ? upsertedEntity : data; // ensure a returned entity value.\n          })\n        );\n      default:\n        throw new Error(`Persistence action \"${entityOp}\" is not implemented.`);\n    }\n  }\n\n  /**\n   * Handle error result of persistence operation on an EntityAction,\n   * returning a scalar observable of error action\n   */\n  private handleError$(\n    action: EntityAction\n  ): (error: Error) => Observable<EntityAction> {\n    // Although error may return immediately,\n    // ensure observable takes some time,\n    // as app likely assumes asynchronous response.\n    return (error: Error) =>\n      of(this.resultHandler.handleError(action)(error)).pipe(\n        delay(this.responseDelay, this.scheduler || asyncScheduler)\n      );\n  }\n\n  /**\n   * Because EntityAction.payload.skip is true, skip the persistence step and\n   * return a scalar success action that looks like the operation succeeded.\n   */\n  private handleSkipSuccess$(\n    originalAction: EntityAction\n  ): Observable<EntityAction> {\n    const successOp = makeSuccessOp(originalAction.payload.entityOp);\n    const successAction = this.entityActionFactory.createFromAction(\n      originalAction,\n      {\n        entityOp: successOp,\n      }\n    );\n    // Although returns immediately,\n    // ensure observable takes one tick (by using a promise),\n    // as app likely assumes asynchronous response.\n    return of(successAction).pipe(\n      delay(this.responseDelay, this.scheduler || asyncScheduler)\n    );\n  }\n}\n"]}

package/esm2022/src/entity-data-without-effects.module.mjs

@@ -0,0 +1,28 @@
+import { NgModule } from '@angular/core';
+import { BASE_ENTITY_DATA_PROVIDERS, provideEntityDataConfig, } from './provide-entity-data';
+import * as i0 from "@angular/core";
+/**
+ * Module without effects or dataservices which means no HTTP calls
+ * This module helpful for internal testing.
+ * Also helpful for apps that handle server access on their own and
+ * therefore opt-out of @ngrx/effects for entities
+ */
+class EntityDataModuleWithoutEffects {
+    static forRoot(config) {
+        return {
+            ngModule: EntityDataModuleWithoutEffects,
+            providers: [provideEntityDataConfig(config)],
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModuleWithoutEffects, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModuleWithoutEffects }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModuleWithoutEffects, providers: [BASE_ENTITY_DATA_PROVIDERS] }); }
+}
+export { EntityDataModuleWithoutEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModuleWithoutEffects, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [BASE_ENTITY_DATA_PROVIDERS],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWRhdGEtd2l0aG91dC1lZmZlY3RzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL21vZHVsZXMvZGF0YS9zcmMvZW50aXR5LWRhdGEtd2l0aG91dC1lZmZlY3RzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXVCLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU5RCxPQUFPLEVBQ0wsMEJBQTBCLEVBQzFCLHVCQUF1QixHQUN4QixNQUFNLHVCQUF1QixDQUFDOztBQUUvQjs7Ozs7R0FLRztBQUNILE1BR2EsOEJBQThCO0lBQ3pDLE1BQU0sQ0FBQyxPQUFPLENBQ1osTUFBOEI7UUFFOUIsT0FBTztZQUNMLFFBQVEsRUFBRSw4QkFBOEI7WUFDeEMsU0FBUyxFQUFFLENBQUMsdUJBQXVCLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDN0MsQ0FBQztJQUNKLENBQUM7c0lBUlUsOEJBQThCO3VJQUE5Qiw4QkFBOEI7dUlBQTlCLDhCQUE4QixhQUY5QixDQUFDLDBCQUEwQixDQUFDOztTQUU1Qiw4QkFBOEI7Z0dBQTlCLDhCQUE4QjtrQkFIMUMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBQywwQkFBMEIsQ0FBQztpQkFDeEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2R1bGVXaXRoUHJvdmlkZXJzLCBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRW50aXR5RGF0YU1vZHVsZUNvbmZpZyB9IGZyb20gJy4vZW50aXR5LWRhdGEtY29uZmlnJztcbmltcG9ydCB7XG4gIEJBU0VfRU5USVRZX0RBVEFfUFJPVklERVJTLFxuICBwcm92aWRlRW50aXR5RGF0YUNvbmZpZyxcbn0gZnJvbSAnLi9wcm92aWRlLWVudGl0eS1kYXRhJztcblxuLyoqXG4gKiBNb2R1bGUgd2l0aG91dCBlZmZlY3RzIG9yIGRhdGFzZXJ2aWNlcyB3aGljaCBtZWFucyBubyBIVFRQIGNhbGxzXG4gKiBUaGlzIG1vZHVsZSBoZWxwZnVsIGZvciBpbnRlcm5hbCB0ZXN0aW5nLlxuICogQWxzbyBoZWxwZnVsIGZvciBhcHBzIHRoYXQgaGFuZGxlIHNlcnZlciBhY2Nlc3Mgb24gdGhlaXIgb3duIGFuZFxuICogdGhlcmVmb3JlIG9wdC1vdXQgb2YgQG5ncngvZWZmZWN0cyBmb3IgZW50aXRpZXNcbiAqL1xuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbQkFTRV9FTlRJVFlfREFUQV9QUk9WSURFUlNdLFxufSlcbmV4cG9ydCBjbGFzcyBFbnRpdHlEYXRhTW9kdWxlV2l0aG91dEVmZmVjdHMge1xuICBzdGF0aWMgZm9yUm9vdChcbiAgICBjb25maWc6IEVudGl0eURhdGFNb2R1bGVDb25maWdcbiAgKTogTW9kdWxlV2l0aFByb3ZpZGVyczxFbnRpdHlEYXRhTW9kdWxlV2l0aG91dEVmZmVjdHM+IHtcbiAgICByZXR1cm4ge1xuICAgICAgbmdNb2R1bGU6IEVudGl0eURhdGFNb2R1bGVXaXRob3V0RWZmZWN0cyxcbiAgICAgIHByb3ZpZGVyczogW3Byb3ZpZGVFbnRpdHlEYXRhQ29uZmlnKGNvbmZpZyldLFxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/entity-data.module.mjs

@@ -0,0 +1,29 @@
+import { NgModule } from '@angular/core';
+import { EntityDataModuleWithoutEffects } from './entity-data-without-effects.module';
+import { ENTITY_DATA_EFFECTS_PROVIDERS, provideEntityDataConfig, } from './provide-entity-data';
+import * as i0 from "@angular/core";
+/**
+ * entity-data main module includes effects and HTTP data services
+ * Configure with `forRoot`.
+ * No `forFeature` yet.
+ */
+class EntityDataModule {
+    static forRoot(config) {
+        return {
+            ngModule: EntityDataModule,
+            providers: [provideEntityDataConfig(config)],
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModule, imports: [EntityDataModuleWithoutEffects] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModule, providers: [ENTITY_DATA_EFFECTS_PROVIDERS], imports: [EntityDataModuleWithoutEffects] }); }
+}
+export { EntityDataModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDataModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [EntityDataModuleWithoutEffects],
+                    providers: [ENTITY_DATA_EFFECTS_PROVIDERS],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/entity-metadata/entity-definition.service.mjs

@@ -0,0 +1,94 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { createEntityDefinition } from './entity-definition';
+import { ENTITY_METADATA_TOKEN, } from './entity-metadata';
+import * as i0 from "@angular/core";
+/** Registry of EntityDefinitions for all cached entity types */
+class EntityDefinitionService {
+    constructor(entityMetadataMaps) {
+        /** {EntityDefinition} for all cached entity types */
+        this.definitions = {};
+        if (entityMetadataMaps) {
+            entityMetadataMaps.forEach((map) => this.registerMetadataMap(map));
+        }
+    }
+    /**
+     * Get (or create) a data service for entity type
+     * @param entityName - the name of the type
+     *
+     * Examples:
+     *   getDefinition('Hero'); // definition for Heroes, untyped
+     *   getDefinition<Hero>(`Hero`); // definition for Heroes, typed with Hero interface
+     */
+    getDefinition(entityName, shouldThrow = true) {
+        entityName = entityName.trim();
+        const definition = this.definitions[entityName];
+        if (!definition && shouldThrow) {
+            throw new Error(`No EntityDefinition for entity type "${entityName}".`);
+        }
+        return definition;
+    }
+    //////// Registration methods //////////
+    /**
+     * Create and register the {EntityDefinition} for the {EntityMetadata} of an entity type
+     * @param name - the name of the entity type
+     * @param definition - {EntityMetadata} for a collection for that entity type
+     *
+     * Examples:
+     *   registerMetadata(myHeroEntityDefinition);
+     */
+    registerMetadata(metadata) {
+        if (metadata) {
+            const definition = createEntityDefinition(metadata);
+            this.registerDefinition(definition);
+        }
+    }
+    /**
+     * Register an EntityMetadataMap.
+     * @param metadataMap - a map of entityType names to entity metadata
+     *
+     * Examples:
+     *   registerMetadataMap({
+     *     'Hero': myHeroMetadata,
+     *     Villain: myVillainMetadata
+     *   });
+     */
+    registerMetadataMap(metadataMap = {}) {
+        // The entity type name should be the same as the map key
+        Object.keys(metadataMap || {}).forEach((entityName) => this.registerMetadata({ entityName, ...metadataMap[entityName] }));
+    }
+    /**
+     * Register an {EntityDefinition} for an entity type
+     * @param definition - EntityDefinition of a collection for that entity type
+     *
+     * Examples:
+     *   registerDefinition('Hero', myHeroEntityDefinition);
+     */
+    registerDefinition(definition) {
+        this.definitions[definition.entityName] = definition;
+    }
+    /**
+     * Register a batch of EntityDefinitions.
+     * @param definitions - map of entityType name and associated EntityDefinitions to merge.
+     *
+     * Examples:
+     *   registerDefinitions({
+     *     'Hero': myHeroEntityDefinition,
+     *     Villain: myVillainEntityDefinition
+     *   });
+     */
+    registerDefinitions(definitions) {
+        Object.assign(this.definitions, definitions);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDefinitionService, deps: [{ token: ENTITY_METADATA_TOKEN, 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: EntityDefinitionService }); }
+}
+export { EntityDefinitionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityDefinitionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENTITY_METADATA_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/entity-services/entity-collection-service-elements-factory.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../dispatchers/entity-dispatcher-factory";
+import * as i2 from "../entity-metadata/entity-definition.service";
+import * as i3 from "../selectors/entity-selectors";
+import * as i4 from "../selectors/entity-selectors$";
+/** Creates the core elements of the EntityCollectionService for an entity type. */
+class EntityCollectionServiceElementsFactory {
+    constructor(entityDispatcherFactory, entityDefinitionService, entitySelectorsFactory, entitySelectors$Factory) {
+        this.entityDispatcherFactory = entityDispatcherFactory;
+        this.entityDefinitionService = entityDefinitionService;
+        this.entitySelectorsFactory = entitySelectorsFactory;
+        this.entitySelectors$Factory = entitySelectors$Factory;
+    }
+    /**
+     * Get the ingredients for making an EntityCollectionService for this entity type
+     * @param entityName - name of the entity type
+     */
+    create(entityName) {
+        entityName = entityName.trim();
+        const definition = this.entityDefinitionService.getDefinition(entityName);
+        const dispatcher = this.entityDispatcherFactory.create(entityName, definition.selectId, definition.entityDispatcherOptions);
+        const selectors = this.entitySelectorsFactory.create(definition.metadata);
+        const selectors$ = this.entitySelectors$Factory.create(entityName, selectors);
+        return {
+            dispatcher,
+            entityName,
+            selectors,
+            selectors$,
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceElementsFactory, deps: [{ token: i1.EntityDispatcherFactory }, { token: i2.EntityDefinitionService }, { token: i3.EntitySelectorsFactory }, { token: i4.EntitySelectors$Factory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceElementsFactory }); }
+}
+export { EntityCollectionServiceElementsFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceElementsFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityDispatcherFactory }, { type: i2.EntityDefinitionService }, { type: i3.EntitySelectorsFactory }, { type: i4.EntitySelectors$Factory }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/entity-services/entity-collection-service-factory.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { EntityCollectionServiceBase } from './entity-collection-service-base';
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-collection-service-elements-factory";
+/**
+ * Creates EntityCollectionService instances for
+ * a cached collection of T entities in the ngrx store.
+ */
+class EntityCollectionServiceFactory {
+    constructor(
+    /** Creates the core elements of the EntityCollectionService for an entity type. */
+    entityCollectionServiceElementsFactory) {
+        this.entityCollectionServiceElementsFactory = entityCollectionServiceElementsFactory;
+    }
+    /**
+     * Create an EntityCollectionService for an entity type
+     * @param entityName - name of the entity type
+     */
+    create(entityName) {
+        return new EntityCollectionServiceBase(entityName, this.entityCollectionServiceElementsFactory);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceFactory, deps: [{ token: i1.EntityCollectionServiceElementsFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceFactory }); }
+}
+export { EntityCollectionServiceFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-rc.2", ngImport: i0, type: EntityCollectionServiceFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityCollectionServiceElementsFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,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