breeze-client 2.2.2 → 3.0.0

package/{fesm2022/breeze-client-mixin-save-queuing.mjs → mixins/mixin-save-queuing.js}

@@ -1,367 +1,495 @@
-import { EntityState, breeze } from 'breeze-client';
-
-//#region Copyright, Version, and Description
-function enableSaveQueuing(em, enable = true) {
-    let saveQueuing = em['_saveQueueing'] ||
-        (em['_saveQueuing'] = new SaveQueuing(em));
-    enable = (enable === undefined) ? true : enable;
-    saveQueuing._isEnabled = enable;
-    if (enable) {
-        // delegate to save changes queuing
-        em.saveChanges = saveChangesWithQueuing;
-    }
-    else {
-        // revert to the native EntityManager.saveChanges
-        em.saveChanges = em['_saveQueuing'].baseSaveChanges;
-    }
-}
-/**
- * Replacement for EntityManager.saveChanges
- * This version queues saveChanges calls while a real save is in progress
- **/
-function saveChangesWithQueuing(entities, saveOptions) {
-    try {
-        // `this` is an EntityManager
-        let saveQueuing = this._saveQueuing;
-        if (saveQueuing.isSaving) {
-            // save in progress; queue the save for later
-            return saveQueuing.queueSaveChanges(entities);
-        }
-        else {
-            // note that save is in progress; then save
-            saveQueuing.isSaving = true;
-            saveQueuing.saveOptions = saveOptions;
-            return saveQueuing.saveChanges(entities, saveOptions);
-        }
-    }
-    catch (err) {
-        return Promise.reject(err);
-    }
-}
-///////// SaveQueuing /////////
-class SaveQueuing {
-    entityManager;
-    baseSaveChanges;
-    isSaving;
-    _isEnabled;
-    activeSaveDeferred;
-    nextSaveDeferred;
-    activeSaveMemo;
-    nextSaveMemo;
-    saveOptions;
-    constructor(entityManager) {
-        this.entityManager = entityManager;
-        this.baseSaveChanges = entityManager.saveChanges;
-        this.isSaving = false;
-    }
-    isEnabled() {
-        return this._isEnabled;
-    }
-    getSavedNothingResult() {
-        return { entities: [], keyMappings: [] };
-    }
-    queueSaveChanges(entities) {
-        let self = this; // `this` is a SaveQueuing
-        let em = self.entityManager;
-        let changes = entities || em.getChanges();
-        if (changes.length === 0) {
-            return Promise.resolve(this.getSavedNothingResult());
-        }
-        let valError = em.saveChangesValidateOnClient(changes);
-        if (valError) {
-            return Promise.reject(valError);
-        }
-        let saveMemo = self.nextSaveMemo || (self.nextSaveMemo = new SaveMemo());
-        memoizeChanges();
-        let deferred = self.nextSaveDeferred || (self.nextSaveDeferred = new Deferred());
-        return deferred.promise;
-        function memoizeChanges() {
-            if (changes.length === 0) {
-                return;
-            }
-            let queuedChanges = saveMemo.queuedChanges;
-            changes.forEach(e => {
-                if (!e.entityAspect.isBeingSaved && queuedChanges.indexOf(e) === -1) {
-                    queuedChanges.push(e);
-                }
-            });
-            saveMemo.updateEntityMemos(changes);
-        }
-    }
-    saveChanges(entities, saveOptions) {
-        let self = this; // `this` is a SaveQueuing
-        let promise = self.baseSaveChanges.call(self.entityManager, entities, saveOptions || self.saveOptions)
-            .then(function (saveResult) { return self.saveSucceeded(saveResult); })
-            .then(null, function (error) { console.log(error); return self.saveFailed(error); });
-        rememberAddedOriginalValues(entities); // do it after ... so don't send OrigValues to the server
-        return promise;
-        function rememberAddedOriginalValues(entities) {
-            // added entities normally don't have original values but these will now
-            let added = entities ?
-                entities.filter(function (e) { return e.entityAspect.entityState.isAdded(); }) :
-                self.entityManager.getEntities(null, EntityState.Added);
-            added.forEach(entity => {
-                let props = entity.entityType.dataProperties;
-                let originalValues = entity.entityAspect.originalValues;
-                props.forEach(dp => {
-                    if (dp.isPartOfKey) {
-                        return;
-                    }
-                    originalValues[dp.name] = entity.getProperty(dp.name);
-                });
-            });
-        }
-    }
-    saveSucceeded(saveResult) {
-        let self = this; // `this` is a SaveQueueing
-        let activeSaveDeferred = self.activeSaveDeferred;
-        let nextSaveDeferred = self.nextSaveDeferred;
-        let nextSaveMemo = self.nextSaveMemo;
-        // prepare as if nothing queued or left to save
-        self.isSaving = false;
-        self.activeSaveDeferred = null;
-        self.activeSaveMemo = null;
-        self.nextSaveDeferred = null;
-        self.nextSaveMemo = null;
-        if (nextSaveMemo) {
-            // a save was queued since last save returned
-            nextSaveMemo.pkFixup(saveResult.keyMappings);
-            nextSaveMemo.applyToSavedEntities(self.entityManager, saveResult.entities);
-            // remove detached entities from queuedChanges
-            let queuedChanges = nextSaveMemo.queuedChanges.filter(e => {
-                return !e.entityAspect.entityState.isDetached();
-            });
-            if (queuedChanges.length > 0) {
-                // save again
-                self.isSaving = true;
-                // remember the queued changes that triggered this save
-                self.activeSaveDeferred = nextSaveDeferred;
-                self.activeSaveMemo = nextSaveMemo;
-                self.saveChanges(queuedChanges, this.saveOptions);
-            }
-            else if (nextSaveDeferred) {
-                nextSaveDeferred.resolve(this.getSavedNothingResult());
-            }
-        }
-        if (activeSaveDeferred) {
-            activeSaveDeferred.resolve(saveResult);
-        }
-        return saveResult; // for the current promise chain
-    }
-    saveFailed(error) {
-        let self = this; // `this` is a SaveQueueing
-        error = new QueuedSaveFailedError(error, self);
-        let activeSaveDeferred = self.activeSaveDeferred;
-        let nextSaveDeferred = self.nextSaveDeferred;
-        self.isSaving = false;
-        self.activeSaveDeferred = null;
-        self.activeSaveMemo = null;
-        self.nextSaveDeferred = null;
-        self.nextSaveMemo = null;
-        if (activeSaveDeferred) {
-            activeSaveDeferred.reject(error);
-        }
-        if (nextSaveDeferred) {
-            nextSaveDeferred.reject(error);
-        }
-        return Promise.reject(error); // let promise chain hear error
-    }
-}
-/// for backward compat with older Promise implementation
-class Deferred {
-    resolve;
-    reject;
-    promise;
-    constructor() {
-        this.promise = new Promise(function (resolve, reject) {
-            this.resolve = resolve;
-            this.reject = reject;
-        }.bind(this));
-    }
-}
-////////// QueuedSaveFailedError /////////
-// Error sub-class thrown when rejecting queued saves.
-class QueuedSaveFailedError extends Error {
-    name = "QueuedSaveFailedError";
-    innerError;
-    message;
-    failedSaveMemo;
-    nextSaveMemo;
-    // Error sub-class thrown when rejecting queued saves.
-    // `innerError` is the actual save error
-    // `failedSaveMemo` is the saveMemo that prompted this save
-    // `nextSaveMemo` holds queued changes accumulated since that save.
-    // You may try to recover using this info. Good luck with that.
-    constructor(errObject, saveQueuing) {
-        super();
-        this.innerError = errObject;
-        this.message = "Queued save failed: " + errObject.message;
-        this.failedSaveMemo = saveQueuing.activeSaveMemo;
-        this.nextSaveMemo = saveQueuing.nextSaveMemo;
-    }
-}
-////////// SaveMemo ////////////////
-// SaveMemo is a record of changes for a queued save, consisting of:
-//   entityMemos:   info about entities that are being saved and
-//                  have been changed since the save started
-//   queuedChanges: entities that are queued for save but
-//                  are not currently being saved
-class SaveMemo {
-    entityMemos;
-    queuedChanges;
-    constructor() {
-        this.entityMemos = {};
-        this.queuedChanges = [];
-    }
-    applyToSavedEntities(entityManager, savedEntities) {
-        let entityMemos = this.entityMemos; // `this` is a SaveMemo
-        let queuedChanges = this.queuedChanges;
-        let restorePublishing = this.disableManagerPublishing(entityManager);
-        try {
-            savedEntities.forEach(saved => {
-                let key = this.makeEntityMemoKey(saved);
-                let entityMemo = entityMemos[key];
-                let resave = entityMemo && entityMemo.applyToSavedEntity(saved);
-                if (resave) {
-                    queuedChanges.push(saved);
-                }
-            });
-        }
-        finally {
-            restorePublishing();
-            // D#2651 hasChanges will be wrong if changes made while save in progress
-            let hasChanges = queuedChanges.length > 0;
-            // Must use breeze internal method to properly set this flag true
-            if (hasChanges) {
-                entityManager._setHasChanges(true);
-            }
-        }
-    }
-    disableManagerPublishing(manager) {
-        let Event = breeze.Event;
-        Event.enable('entityChanged', manager, false);
-        Event.enable('hasChangesChanged', manager, false);
-        return function restorePublishing() {
-            Event.enable('entityChanged', manager, true);
-            Event.enable('hasChangesChanged', manager, true);
-        };
-    }
-    pkFixup(keyMappings) {
-        let entityMemos = this.entityMemos; // `this` is a SaveMemo
-        keyMappings.forEach(km => {
-            let type = km.entityTypeName;
-            let tempKey = type + '|' + km.tempValue;
-            if (entityMemos[tempKey]) {
-                entityMemos[type + '|' + km.realValue] = entityMemos[tempKey];
-                delete entityMemos[tempKey];
-            }
-            for (let memoKey in entityMemos) {
-                entityMemos[memoKey].fkFixup(km);
-            }
-        });
-    }
-    makeEntityMemoKey(entity) {
-        let entityKey = entity.entityAspect.getKey();
-        return entityKey.entityType.name + '|' + entityKey.values;
-    }
-    updateEntityMemos(changes) {
-        let entityMemos = this.entityMemos; // `this` is a SaveMemo
-        changes.forEach(change => {
-            // only update entityMemo for entity being save
-            if (!change.entityAspect.isBeingSaved) {
-                return;
-            }
-            let key = this.makeEntityMemoKey(change);
-            let entityMemo = entityMemos[key] || (entityMemos[key] = new EntityMemo(change));
-            entityMemo.update();
-        });
-    }
-}
-///////// EntityMemo Type ///////////////
-// Information about an entity that is being saved
-// and which has been changed since that save started
-class EntityMemo {
-    entity;
-    pendingChanges;
-    isDeleted;
-    constructor(entity) {
-        this.entity = entity;
-        this.pendingChanges = {};
-    }
-    applyToSavedEntity(saved) {
-        let entityMemo = this;
-        let aspect = saved.entityAspect;
-        if (aspect.entityState.isDetached()) {
-            return false;
-        }
-        else if (entityMemo.isDeleted) {
-            aspect.setDeleted();
-            return true;
-        }
-        // treat entity with pending changes as modified
-        let props = Object.keys(entityMemo.pendingChanges);
-        if (props.length === 0) {
-            return false;
-        }
-        let originalValues = aspect.originalValues;
-        props.forEach(name => {
-            originalValues[name] = saved.getProperty(name);
-            saved.setProperty(name, entityMemo.pendingChanges[name]);
-        });
-        aspect.setModified();
-        return true;
-    }
-    fkFixup(keyMapping) {
-        let entityMemo = this;
-        let type = entityMemo.entity.entityType;
-        let fkProps = type.foreignKeyProperties;
-        fkProps.forEach(fkProp => {
-            if (fkProp.parentType.name === keyMapping.entityTypeName &&
-                entityMemo.pendingChanges[fkProp.name] === keyMapping.tempValue) {
-                entityMemo.pendingChanges[fkProp.name] = keyMapping.realValue;
-            }
-        });
-    }
-    // update the entityMemo of changes to an entity being saved
-    // so that we know how to save it again later
-    update() {
-        let entityMemo = this;
-        let props;
-        let entity = entityMemo.entity;
-        let aspect = entity.entityAspect;
-        let stateName = aspect.entityState.name;
-        switch (stateName) {
-            case 'Added':
-                let originalValues = aspect.originalValues;
-                props = entity.entityType.dataProperties;
-                props.forEach(dp => {
-                    if (dp.isPartOfKey) {
-                        return;
-                    }
-                    let name = dp.name;
-                    let value = entity.getProperty(name);
-                    if (originalValues[name] !== value) {
-                        entityMemo.pendingChanges[name] = value;
-                    }
-                });
-                break;
-            case 'Deleted':
-                entityMemo.isDeleted = true;
-                entityMemo.pendingChanges = {};
-                break;
-            case 'Modified':
-                props = Object.keys(aspect.originalValues);
-                props.forEach(name => {
-                    entityMemo.pendingChanges[name] = entity.getProperty(name);
-                });
-                break;
-        }
-    }
+//#region Copyright, Version, and Description
+/*
+ * Copyright 2015-2026 IdeaBlade, Inc.  All Rights Reserved.
+ * Use, reproduction, distribution, and modification of this code is subject to the terms and
+ * conditions of the IdeaBlade Breeze license, available at http://www.breezejs.com/license
+ *
+ * Author: Ward Bell
+ * Version: 2.0.6 Steve Schmitt - convert to TypeScript, move to breeze-client repo, change enableSaveQueuing function
+ * Version: 2.0.5 Ward Bell
+ * --------------------------------------------------------------------------------
+ * Adds "Save Queuing" capability to new EntityManagers
+ *
+ * Save Queuing automatically queues and defers an EntityManager.saveChanges call
+ * when another save is in progress for that manager and the server has not yet responded.
+ * This feature is helpful when your app needs to allow rapid, continuous changes
+ * to entities that may be in the process of being saved.
+ *
+ * Without "Save Queuing", an EntityManager will throw an exception
+ * when you call saveChanges for an entity which is currently being saved.
+ *
+ * !!! Use with caution !!!
+ * It is usually better to disable user input while a save is in progress.
+ * Save Queuing may be appropriate for simple "auto-save" scenarios
+ * when the save latency is "short" (under a few seconds).
+ *
+ * Save Queuing is NOT intended for occassionally disconnected or offline scenarios.
+ *
+ * Save Queuing is experimental. It will not become a part of BreezeJS core
+ * but might become an official Breeze plugin in future
+ * although not necessarily in this form or with this API
+ *
+ * Must call EntityManager.enableSaveQueuing(true) to turn it on;
+ * EntityManager.enableSaveQueuing(false) restores the manager's original
+ * saveChanges method as it was at the time saveQueuing was first enabled.
+ *
+ * This module adds "enableSaveQueuing" to the EntityManager prototype.
+ * Calling "enableSaveQueuing(true)" adds a new _saveQueuing object
+ * to the manager instance.
+ *
+ * See DocCode:saveQueuingTests.js
+ * https://github.com/Breeze/breeze.js.samples/blob/master/net/DocCode/DocCode/tests/saveQueuingTests.js
+ *
+ * LIMITATIONS
+ * - Can't handle changes to the primary key (dangerous in any case)
+ * - Assumes promises. Does not support the (deprecated) success and fail callbacks
+ * - Does not queue saveOptions. The first one is re-used for all queued saves.
+ * - Does not deal with export/import of entities while save is inflight
+ * - Does not deal with rejectChanges while save is in flight
+ * - Does not support parallel saves even when the change-sets are independent.
+ *   The native saveChanges allows such saves.
+ *   SaveQueuing does not; too complex and doesn't fit the primary scenario anyway.
+ * - The resolved saveResult is the saveResult of the last completed save
+ * - A queued save that might have succeeded if saved immediately
+ *   may fail because the server no longer accepts it later
+ * - Prior to Breeze v.1.5.3, a queued save that might have succeeded
+ *   if saved immediately will fail if subsequently attempt to save
+ *   an invalid entity. Can detect and circumvent after v.1.5.3.
+ *
+ * All members of EntityManager._saveQueuing are internal;
+ * touch them at your own risk.
+ */
+//#endregion
+import { EntityState, BreezeEvent } from '../breeze.js';
+/**
+ * Turns save queuing on or off for one {@link EntityManager}.
+ *
+ * With it on, a `saveChanges` call made while another save is still in flight is held back
+ * rather than rejected, and sent as a single follow-up save when the first one returns. Each
+ * promise resolves with the result of the save that carried its changes.
+ *
+ * It also keeps edits made *during* a save. Without queuing those are overwritten by the
+ * server's values when the save result merges back, leaving the entity `Unchanged` and
+ * `hasChanges()` false - so nothing tells the application that a change was lost. A foreign key
+ * set during a save is carried over too: if the parent's row is still being inserted, the queued
+ * save substitutes the key the server assigned for the temporary one.
+ *
+ * Intended for short-latency auto-save. It is not an offline story, it reuses the first save's
+ * {@link SaveOptions}, and it does not cope with `rejectChanges`, export/import or primary-key
+ * changes while a save is in flight. Disabling user input for the duration of a save is usually
+ * the better answer; this is for applications that cannot.
+ *
+ * @param em - The manager to wrap. Its `saveChanges` is replaced, and restored when disabled.
+ * @param enable - `false` puts the manager's own `saveChanges` back. Calling this more than
+ *   once on the same manager, in either direction, is harmless.
+ *
+ * @example
+ * ```ts
+ * import { enableSaveQueuing } from 'breeze-client/mixin-save-queuing';
+ *
+ * enableSaveQueuing(em, true);
+ *
+ * const first = em.saveChanges();   // sent now
+ * order.shipName = 'changed';       // typed while that save is out
+ * const second = em.saveChanges();  // queued, and sent when the first returns
+ * ```
+ *
+ * @see {@link QueuedSaveFailedError}, which every pending promise rejects with if a queued
+ *   save fails.
+ */
+export function enableSaveQueuing(em, enable = true) {
+    const emx = em;
+    let saveQueuing = emx['_saveQueuing'] ||
+        (emx['_saveQueuing'] = new SaveQueuing(em));
+    enable = (enable === undefined) ? true : enable;
+    saveQueuing._isEnabled = enable;
+    if (enable) {
+        // delegate to save changes queuing
+        em.saveChanges = saveChangesWithQueuing;
+    }
+    else {
+        // revert to the native EntityManager.saveChanges
+        em.saveChanges = emx['_saveQueuing'].baseSaveChanges;
+    }
 }
-
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Replacement for EntityManager.saveChanges
+ * This version queues saveChanges calls while a real save is in progress
  */
-
-export { QueuedSaveFailedError, enableSaveQueuing };
-//# sourceMappingURL=breeze-client-mixin-save-queuing.mjs.map
+function saveChangesWithQueuing(entities, saveOptions) {
+    try {
+        // `this` is an EntityManager
+        let saveQueuing = this._saveQueuing;
+        if (saveQueuing.isSaving) {
+            // save in progress; queue the save for later
+            return saveQueuing.queueSaveChanges(entities);
+        }
+        else {
+            // note that save is in progress; then save
+            saveQueuing.isSaving = true;
+            saveQueuing.saveOptions = saveOptions;
+            return saveQueuing.saveChanges(entities, saveOptions);
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}
+///////// SaveQueuing /////////
+class SaveQueuing {
+    entityManager;
+    baseSaveChanges;
+    isSaving;
+    _isEnabled;
+    // null means 'nothing active / nothing queued'; these are reset to null between saves
+    activeSaveDeferred;
+    nextSaveDeferred;
+    activeSaveMemo;
+    nextSaveMemo;
+    saveOptions;
+    constructor(entityManager) {
+        this.entityManager = entityManager;
+        this.baseSaveChanges = entityManager.saveChanges;
+        this.isSaving = false;
+    }
+    isEnabled() {
+        return this._isEnabled;
+    }
+    getSavedNothingResult() {
+        return { entities: [], keyMappings: [] };
+    }
+    queueSaveChanges(entities) {
+        let self = this; // `this` is a SaveQueuing
+        let em = self.entityManager;
+        let changes = entities || em.getChanges();
+        if (changes.length === 0) {
+            return Promise.resolve(this.getSavedNothingResult());
+        }
+        let valError = em.saveChangesValidateOnClient(changes);
+        if (valError) {
+            return Promise.reject(valError);
+        }
+        let saveMemo = self.nextSaveMemo || (self.nextSaveMemo = new SaveMemo());
+        memoizeChanges();
+        let deferred = self.nextSaveDeferred || (self.nextSaveDeferred = new Deferred());
+        return deferred.promise;
+        function memoizeChanges() {
+            if (changes.length === 0) {
+                return;
+            }
+            let queuedChanges = saveMemo.queuedChanges;
+            changes.forEach(e => {
+                if (!e.entityAspect.isBeingSaved) {
+                    queuedChanges.add(e);
+                }
+            });
+            saveMemo.updateEntityMemos(changes);
+        }
+    }
+    saveChanges(entities, saveOptions) {
+        let self = this; // `this` is a SaveQueuing
+        let promise = self.baseSaveChanges.call(self.entityManager, entities, saveOptions || self.saveOptions)
+            .then(function (saveResult) { return self.saveSucceeded(saveResult); })
+            .then(null, function (error) { console.log(error); return self.saveFailed(error); });
+        rememberAddedOriginalValues(entities); // do it after ... so don't send OrigValues to the server
+        return promise;
+        function rememberAddedOriginalValues(entities) {
+            // added entities normally don't have original values but these will now
+            let added = entities ?
+                entities.filter(function (e) { return e.entityAspect.entityState.isAdded(); }) :
+                self.entityManager.getEntities(undefined, EntityState.Added);
+            added.forEach(entity => {
+                let props = entity.entityType.dataProperties;
+                let originalValues = entity.entityAspect.originalValues;
+                props.forEach(dp => {
+                    if (dp.isPartOfKey) {
+                        return;
+                    }
+                    originalValues[dp.name] = entity.getProperty(dp.name);
+                });
+            });
+        }
+    }
+    saveSucceeded(saveResult) {
+        let self = this; // `this` is a SaveQueueing
+        let activeSaveDeferred = self.activeSaveDeferred;
+        let nextSaveDeferred = self.nextSaveDeferred;
+        let nextSaveMemo = self.nextSaveMemo;
+        // prepare as if nothing queued or left to save
+        self.isSaving = false;
+        self.activeSaveDeferred = null;
+        self.activeSaveMemo = null;
+        self.nextSaveDeferred = null;
+        self.nextSaveMemo = null;
+        if (nextSaveMemo) {
+            // a save was queued since last save returned
+            nextSaveMemo.pkFixup(saveResult.keyMappings);
+            nextSaveMemo.applyToSavedEntities(self.entityManager, saveResult.entities);
+            // remove detached entities from queuedChanges
+            let queuedChanges = Array.from(nextSaveMemo.queuedChanges).filter(e => {
+                return !e.entityAspect.entityState.isDetached();
+            });
+            if (queuedChanges.length > 0) {
+                // save again
+                self.isSaving = true;
+                // remember the queued changes that triggered this save
+                self.activeSaveDeferred = nextSaveDeferred;
+                self.activeSaveMemo = nextSaveMemo;
+                self.saveChanges(queuedChanges, this.saveOptions);
+            }
+            else if (nextSaveDeferred) {
+                nextSaveDeferred.resolve(this.getSavedNothingResult());
+            }
+        }
+        if (activeSaveDeferred) {
+            activeSaveDeferred.resolve(saveResult);
+        }
+        return saveResult; // for the current promise chain
+    }
+    saveFailed(error) {
+        let self = this; // `this` is a SaveQueueing
+        error = new QueuedSaveFailedError(error, self);
+        let activeSaveDeferred = self.activeSaveDeferred;
+        let nextSaveDeferred = self.nextSaveDeferred;
+        self.isSaving = false;
+        self.activeSaveDeferred = null;
+        self.activeSaveMemo = null;
+        self.nextSaveDeferred = null;
+        self.nextSaveMemo = null;
+        if (activeSaveDeferred) {
+            activeSaveDeferred.reject(error);
+        }
+        if (nextSaveDeferred) {
+            nextSaveDeferred.reject(error);
+        }
+        return Promise.reject(error); // let promise chain hear error
+    }
+}
+/// for backward compat with older Promise implementation
+class Deferred {
+    resolve;
+    reject;
+    promise;
+    constructor() {
+        this.promise = new Promise(function (resolve, reject) {
+            this.resolve = resolve;
+            this.reject = reject;
+        }.bind(this));
+    }
+}
+/**
+ * What every pending promise rejects with when a queued save fails.
+ *
+ * One failure rejects the whole queue, because the saves behind it were built on the assumption
+ * that the one in front succeeded. Read {@link QueuedSaveFailedError.innerError} for what
+ * actually went wrong; the two memos are there for an application that wants to attempt a
+ * recovery, and are the mixin's internal bookkeeping rather than a documented shape.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await em.saveChanges();
+ * } catch (e) {
+ *   if (e instanceof QueuedSaveFailedError) {
+ *     console.error(e.innerError);
+ *   }
+ * }
+ * ```
+ */
+export class QueuedSaveFailedError extends Error {
+    /** Always `"QueuedSaveFailedError"`, so the error can be recognized by name as well as with
+    `instanceof`. */
+    name = "QueuedSaveFailedError";
+    /** The error the underlying save actually failed with. */
+    innerError;
+    /** `"Queued save failed: "` followed by {@link QueuedSaveFailedError.innerError}'s message. */
+    message;
+    /** The changes that were in the save that failed. */
+    failedSaveMemo;
+    /** The changes queued up behind it, which were never sent. */
+    nextSaveMemo;
+    /** Created by save queuing when a queued save fails; applications receive it rather than
+    create it. `errObject` is the error the save failed with. */
+    constructor(errObject, saveQueuing) {
+        super();
+        this.innerError = errObject;
+        this.message = "Queued save failed: " + errObject.message;
+        this.failedSaveMemo = saveQueuing.activeSaveMemo;
+        this.nextSaveMemo = saveQueuing.nextSaveMemo;
+    }
+}
+////////// SaveMemo ////////////////
+// SaveMemo is a record of changes for a queued save, consisting of:
+//   entityMemos:   info about entities that are being saved and
+//                  have been changed since the save started
+//   queuedChanges: entities that are queued for save but
+//                  are not currently being saved
+class SaveMemo {
+    /** Keyed by 'entityTypeName|keyValues'. A Map: keys are data, entries are added,
+        renamed on pk fixup, and deleted. */
+    entityMemos;
+    /** A Set, so that queuing the same entity twice is both free and impossible: this is a
+        membership test per change per queued entity, which as an array was quadratic. Iteration
+        order is insertion order, so the entities are still saved in the order they were queued. */
+    queuedChanges;
+    constructor() {
+        this.entityMemos = new Map();
+        this.queuedChanges = new Set();
+    }
+    applyToSavedEntities(entityManager, savedEntities) {
+        let entityMemos = this.entityMemos; // `this` is a SaveMemo
+        let queuedChanges = this.queuedChanges;
+        let restorePublishing = this.disableManagerPublishing(entityManager);
+        try {
+            savedEntities.forEach(saved => {
+                let key = this.makeEntityMemoKey(saved);
+                let entityMemo = entityMemos.get(key);
+                let resave = entityMemo && entityMemo.applyToSavedEntity(saved);
+                if (resave) {
+                    queuedChanges.add(saved);
+                }
+            });
+        }
+        finally {
+            restorePublishing();
+            // D#2651 hasChanges will be wrong if changes made while save in progress
+            let hasChanges = queuedChanges.size > 0;
+            // Must use breeze internal method to properly set this flag true
+            if (hasChanges) {
+                entityManager._setHasChanges(true);
+            }
+        }
+    }
+    disableManagerPublishing(manager) {
+        let Event = BreezeEvent;
+        Event.enable('entityChanged', manager, false);
+        Event.enable('hasChangesChanged', manager, false);
+        return function restorePublishing() {
+            Event.enable('entityChanged', manager, true);
+            Event.enable('hasChangesChanged', manager, true);
+        };
+    }
+    pkFixup(keyMappings) {
+        let entityMemos = this.entityMemos; // `this` is a SaveMemo
+        keyMappings.forEach(km => {
+            let type = km.entityTypeName;
+            let tempKey = type + '|' + km.tempValue;
+            const memo = entityMemos.get(tempKey);
+            if (memo) {
+                entityMemos.set(type + '|' + km.realValue, memo);
+                entityMemos.delete(tempKey);
+            }
+            entityMemos.forEach(m => m.fkFixup(km));
+        });
+    }
+    makeEntityMemoKey(entity) {
+        let entityKey = entity.entityAspect.getKey();
+        return entityKey.entityType.name + '|' + entityKey.values;
+    }
+    updateEntityMemos(changes) {
+        let entityMemos = this.entityMemos; // `this` is a SaveMemo
+        changes.forEach(change => {
+            // only update entityMemo for entity being save
+            if (!change.entityAspect.isBeingSaved) {
+                return;
+            }
+            let key = this.makeEntityMemoKey(change);
+            let entityMemo = entityMemos.get(key);
+            if (!entityMemo) {
+                entityMemo = new EntityMemo(change);
+                entityMemos.set(key, entityMemo);
+            }
+            entityMemo.update();
+        });
+    }
+}
+///////// EntityMemo Type ///////////////
+// Information about an entity that is being saved
+// and which has been changed since that save started
+class EntityMemo {
+    entity;
+    pendingChanges;
+    isDeleted;
+    constructor(entity) {
+        this.entity = entity;
+        this.pendingChanges = {};
+    }
+    applyToSavedEntity(saved) {
+        let entityMemo = this;
+        let aspect = saved.entityAspect;
+        if (aspect.entityState.isDetached()) {
+            return false;
+        }
+        else if (entityMemo.isDeleted) {
+            aspect.setDeleted();
+            return true;
+        }
+        // treat entity with pending changes as modified
+        let props = Object.keys(entityMemo.pendingChanges);
+        if (props.length === 0) {
+            return false;
+        }
+        let originalValues = aspect.originalValues;
+        props.forEach(name => {
+            originalValues[name] = saved.getProperty(name);
+            saved.setProperty(name, entityMemo.pendingChanges[name]);
+        });
+        aspect.setModified();
+        return true;
+    }
+    fkFixup(keyMapping) {
+        let entityMemo = this;
+        let type = entityMemo.entity.entityType;
+        let fkProps = type.foreignKeyProperties;
+        fkProps.forEach(fkProp => {
+            // The type this foreign key points *at*. `fkProp.parentType` is the type that declares it,
+            // which is what this used to compare and is only ever the same type for a self-referencing
+            // key - so an ordinary foreign key set during a save kept its temporary value and the
+            // queued save sent a negative key to the server. `relatedNavigationProperty` covers the
+            // usual case; a unidirectional 1-n has only the inverse, whose parent is the target.
+            const relatedType = fkProp.relatedNavigationProperty
+                ? fkProp.relatedNavigationProperty.entityType
+                : fkProp.inverseNavigationProperty && fkProp.inverseNavigationProperty.parentType;
+            if (relatedType && relatedType.name === keyMapping.entityTypeName &&
+                entityMemo.pendingChanges[fkProp.name] === keyMapping.tempValue) {
+                entityMemo.pendingChanges[fkProp.name] = keyMapping.realValue;
+            }
+        });
+    }
+    // update the entityMemo of changes to an entity being saved
+    // so that we know how to save it again later
+    update() {
+        let entityMemo = this;
+        let props;
+        let entity = entityMemo.entity;
+        let aspect = entity.entityAspect;
+        let stateName = aspect.entityState.name;
+        switch (stateName) {
+            case 'Added':
+                let originalValues = aspect.originalValues;
+                props = entity.entityType.dataProperties;
+                props.forEach(dp => {
+                    if (dp.isPartOfKey) {
+                        return;
+                    }
+                    let name = dp.name;
+                    let value = entity.getProperty(name);
+                    if (originalValues[name] !== value) {
+                        entityMemo.pendingChanges[name] = value;
+                    }
+                });
+                break;
+            case 'Deleted':
+                entityMemo.isDeleted = true;
+                entityMemo.pendingChanges = {};
+                break;
+            case 'Modified':
+                props = Object.keys(aspect.originalValues);
+                props.forEach(name => {
+                    entityMemo.pendingChanges[name] = entity.getProperty(name);
+                });
+                break;
+        }
+    }
+}
+//# sourceMappingURL=mixin-save-queuing.js.map