@ember-data/store 4.12.0 → 4.12.2

package/addon/{index-8b77b852.js → index-0b6637cb.js}

@@ -2,11 +2,11 @@ import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { assert, warn, deprecate } from '@ember/debug';
 import { dasherize } from '@ember/string';
 import { getOwner, setOwner } from '@ember/application';
+import EmberObject, { get, set } from '@ember/object';
 import { _backburner } from '@ember/runloop';
 import { tracked } from '@glimmer/tracking';
-import { subscribe, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
+import { addToTransaction, subscribe, addTransactionCB } from '@ember-data/tracking/-private';
 import { tagForProperty } from '@ember/-internals/metal';
-import { get, set } from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { compare } from '@ember/utils';
 import { dirtyTag } from '@glimmer/validator';
@@ -200,6 +200,7 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
         return document;
       }
       const data = recordArrayManager.createArray({
+        type: request.url,
         identifiers: document.data,
         doc: document,
         query: request
@@ -213,6 +214,7 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
     let managed = recordArrayManager._keyedArrays.get(identifier.lid);
     if (!managed) {
       managed = recordArrayManager.createArray({
+        type: identifier.lid,
         identifiers: document.data,
         doc: document
       });
@@ -1084,205 +1086,11 @@ function detectMerge(typesCache, identifier, data, newId, lids) {
   }
   return false;
 }
-let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
-function isCacheOperationValue(value) {
-  return CacheOperations.has(value);
-}
-function runLoopIsFlushing() {
-  //@ts-expect-error
-  return !!_backburner.currentInstance && _backburner._autorun !== true;
-}
-const Cache = new Map();
-const Tokens = new Map();
-// TODO this isn't importable anyway, remove and use a map on the manager?
-function unsubscribe(token) {
-  let identifier = Tokens.get(token);
-  if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-    if (!identifier) {
-      // eslint-disable-next-line no-console
-      console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
-    }
-  }
-  if (identifier) {
-    Tokens.delete(token);
-    const map = Cache.get(identifier);
-    map?.delete(token);
-  }
-}
+var _class$2, _descriptor$2;
 
 /**
- * The NotificationManager provides the ability to subscribe to
- * changes to Cache state.
- *
- * This Feature is what allows EmberData to create subscriptions that
- * work with any framework or change-notification system.
- *
- * @class NotificationManager
- * @public
- */
-class NotificationManager {
-  constructor(store) {
-    this.store = store;
-    this.isDestroyed = false;
-    this._buffered = new Map();
-    this._hasFlush = false;
-  }
-
-  /**
-   * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
-   *
-   * ```ts
-   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-   *
-   * export interface NotificationCallback {
-   *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
-   *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-   *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
-   * }
-   * export interface ResourceOperationCallback {
-   *   // resource updates
-   *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
-   * }
-   * export interface DocumentOperationCallback {
-   *   // document updates
-   *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
-   * }
-   * ```
-   *
-   * @method subscribe
-   * @public
-   * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
-   * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
-   * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
-   */
-
-  subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
-    let map = Cache.get(identifier);
-    if (!map) {
-      map = new Map();
-      Cache.set(identifier, map);
-    }
-    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
-      _tokenRef: tokenId++
-    } : {};
-    map.set(unsubToken, callback);
-    Tokens.set(unsubToken, identifier);
-    return unsubToken;
-  }
-
-  /**
-   * remove a previous subscription
-   *
-   * @method unsubscribe
-   * @public
-   * @param {UnsubscribeToken} token
-   */
-  unsubscribe(token) {
-    if (!this.isDestroyed) {
-      unsubscribe(token);
-    }
-  }
-
-  /**
-   * Custom Caches and Application Code should not call this method directly.
-   *
-   * @method notify
-   * @param identifier
-   * @param value
-   * @param key
-   * @return {Boolean} whether a notification was delivered to any subscribers
-   * @private
-   */
-
-  notify(identifier, value, key) {
-    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
-    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
-      if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-        // eslint-disable-next-line no-console
-        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
-      }
-      return false;
-    }
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
-    }
-    const hasSubscribers = Boolean(Cache.get(identifier)?.size);
-    if (isCacheOperationValue(value) || hasSubscribers) {
-      let buffer = this._buffered.get(identifier);
-      if (!buffer) {
-        buffer = [];
-        this._buffered.set(identifier, buffer);
-      }
-      buffer.push([value, key]);
-      void this._scheduleNotify();
-    }
-    return hasSubscribers;
-  }
-  _onNextFlush(cb) {
-    this._onFlushCB = cb;
-  }
-  _scheduleNotify() {
-    const asyncFlush = this.store._enableAsyncFlush;
-    if (this._hasFlush) {
-      if (asyncFlush !== false && !runLoopIsFlushing()) {
-        return;
-      }
-    }
-    if (asyncFlush && !runLoopIsFlushing()) {
-      this._hasFlush = true;
-      return;
-    }
-    this._flush();
-  }
-  _flush() {
-    if (this._buffered.size) {
-      this._buffered.forEach((states, identifier) => {
-        states.forEach(args => {
-          // @ts-expect-error
-          this._flushNotification(identifier, args[0], args[1]);
-        });
-      });
-      this._buffered = new Map();
-    }
-    this._hasFlush = false;
-    this._onFlushCB?.();
-    this._onFlushCB = undefined;
-  }
-  _flushNotification(identifier, value, key) {
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
-    }
-
-    // TODO for documents this will need to switch based on Identifier kind
-    if (isCacheOperationValue(value)) {
-      let callbackMap = Cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
-      if (callbackMap) {
-        callbackMap.forEach(cb => {
-          cb(identifier, value);
-        });
-      }
-    }
-    let callbackMap = Cache.get(identifier);
-    if (!callbackMap || !callbackMap.size) {
-      return false;
-    }
-    callbackMap.forEach(cb => {
-      // @ts-expect-error overload doesn't narrow within body
-      cb(identifier, value, key);
-    });
-    return true;
-  }
-  destroy() {
-    this.isDestroyed = true;
-    Tokens.clear();
-    Cache.clear();
-  }
-}
-var _class$2, _descriptor$2;
+  @module @ember-data/store
+*/
 /**
   @module @ember-data/store
 */
@@ -1310,7 +1118,7 @@ let RecordReference = (_class$2 = class RecordReference {
     });
   }
   destroy() {
-    unsubscribe(this.___token);
+    this.store.notifications.unsubscribe(this.___token);
   }
   get type() {
     return this.identifier().type;
@@ -1992,8 +1800,20 @@ class NonSingletonCacheManager {
    * @public
    * @param identifier
    */
-  willCommit(identifier) {
-    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+  willCommit(identifier, context) {
+    // called by something V1
+    if (!isStableIdentifier(identifier)) {
+      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
+    }
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+
+    // TODO deprecate return value
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      cache.willCommit();
+    } else {
+      assert(`Cannot call a v2 cache willCommit from a v1 cache`, !!context);
+      cache.willCommit(identifier, context);
+    }
   }
 
   /**
@@ -2005,14 +1825,34 @@ class NonSingletonCacheManager {
    * @param identifier
    * @param data
    */
-  didCommit(identifier, data) {
-    // called by something V1
-    if (!isStableIdentifier(identifier)) {
-      data = identifier;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    }
+  didCommit(identifier, result) {
     const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.didCommit(data) : cache.didCommit(identifier, data);
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      // called by something V1
+      if (!isStableIdentifier(identifier)) {
+        cache.didCommit(identifier);
+        return {
+          data: _classPrivateFieldBase(this, _identifier)[_identifier]
+        };
+      }
+      cache.didCommit(result.content?.data);
+      return {
+        data: _classPrivateFieldBase(this, _identifier)[_identifier]
+      };
+    } else {
+      // called by something V1
+      if (!isStableIdentifier(identifier)) {
+        cache.didCommit(_classPrivateFieldBase(this, _identifier)[_identifier], {
+          content: {
+            data: identifier
+          }
+        });
+        return {
+          data: _classPrivateFieldBase(this, _identifier)[_identifier]
+        };
+      }
+      return cache.didCommit(identifier, result);
+    }
   }
 
   /**
@@ -2484,11 +2324,11 @@ class SingletonCacheManager {
   clientDidCreate(identifier, options) {
     return _classPrivateFieldBase(this, _cache3)[_cache3].clientDidCreate(identifier, options);
   }
-  willCommit(identifier) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].willCommit(identifier);
+  willCommit(identifier, context) {
+    _classPrivateFieldBase(this, _cache3)[_cache3].willCommit(identifier, context);
   }
-  didCommit(identifier, data) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].didCommit(identifier, data);
+  didCommit(identifier, result) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].didCommit(identifier, result);
   }
   commitWasRejected(identifier, errors) {
     _classPrivateFieldBase(this, _cache3)[_cache3].commitWasRejected(identifier, errors);
@@ -3658,6 +3498,203 @@ class ShimModelClass {
     });
   }
 }
+let tokenId = 0;
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+function isCacheOperationValue(value) {
+  return CacheOperations.has(value);
+}
+function runLoopIsFlushing() {
+  //@ts-expect-error
+  return !!_backburner.currentInstance && _backburner._autorun !== true;
+}
+function _unsubscribe(tokens, token, cache) {
+  let identifier = tokens.get(token);
+  if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+    if (!identifier) {
+      // eslint-disable-next-line no-console
+      console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
+    }
+  }
+  if (identifier) {
+    tokens.delete(token);
+    const map = cache.get(identifier);
+    map?.delete(token);
+  }
+}
+
+/**
+ * The NotificationManager provides the ability to subscribe to
+ * changes to Cache state.
+ *
+ * This Feature is what allows EmberData to create subscriptions that
+ * work with any framework or change-notification system.
+ *
+ * @class NotificationManager
+ * @public
+ */
+class NotificationManager {
+  constructor(store) {
+    this.store = store;
+    this.isDestroyed = false;
+    this._buffered = new Map();
+    this._hasFlush = false;
+    this._cache = new Map();
+    this._tokens = new Map();
+  }
+
+  /**
+   * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
+   *
+   * ```ts
+   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+   *
+   * export interface NotificationCallback {
+   *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
+   *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+   *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
+   * }
+   * export interface ResourceOperationCallback {
+   *   // resource updates
+   *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+   * }
+   * export interface DocumentOperationCallback {
+   *   // document updates
+   *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+   * }
+   * ```
+   *
+   * @method subscribe
+   * @public
+   * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
+   * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
+   * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
+   */
+
+  subscribe(identifier, callback) {
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
+    let map = this._cache.get(identifier);
+    if (!map) {
+      map = new Map();
+      this._cache.set(identifier, map);
+    }
+    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
+      _tokenRef: tokenId++
+    } : {};
+    map.set(unsubToken, callback);
+    this._tokens.set(unsubToken, identifier);
+    return unsubToken;
+  }
+
+  /**
+   * remove a previous subscription
+   *
+   * @method unsubscribe
+   * @public
+   * @param {UnsubscribeToken} token
+   */
+  unsubscribe(token) {
+    if (!this.isDestroyed) {
+      _unsubscribe(this._tokens, token, this._cache);
+    }
+  }
+
+  /**
+   * Custom Caches and Application Code should not call this method directly.
+   *
+   * @method notify
+   * @param identifier
+   * @param value
+   * @param key
+   * @return {Boolean} whether a notification was delivered to any subscribers
+   * @private
+   */
+
+  notify(identifier, value, key) {
+    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
+    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
+      if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+        // eslint-disable-next-line no-console
+        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
+      }
+      return false;
+    }
+    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
+    }
+    const hasSubscribers = Boolean(this._cache.get(identifier)?.size);
+    if (isCacheOperationValue(value) || hasSubscribers) {
+      let buffer = this._buffered.get(identifier);
+      if (!buffer) {
+        buffer = [];
+        this._buffered.set(identifier, buffer);
+      }
+      buffer.push([value, key]);
+      void this._scheduleNotify();
+    }
+    return hasSubscribers;
+  }
+  _onNextFlush(cb) {
+    this._onFlushCB = cb;
+  }
+  _scheduleNotify() {
+    const asyncFlush = this.store._enableAsyncFlush;
+    if (this._hasFlush) {
+      if (asyncFlush !== false && !runLoopIsFlushing()) {
+        return;
+      }
+    }
+    if (asyncFlush && !runLoopIsFlushing()) {
+      this._hasFlush = true;
+      return;
+    }
+    this._flush();
+  }
+  _flush() {
+    if (this._buffered.size) {
+      this._buffered.forEach((states, identifier) => {
+        states.forEach(args => {
+          // @ts-expect-error
+          this._flushNotification(identifier, args[0], args[1]);
+        });
+      });
+      this._buffered = new Map();
+    }
+    this._hasFlush = false;
+    this._onFlushCB?.();
+    this._onFlushCB = undefined;
+  }
+  _flushNotification(identifier, value, key) {
+    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
+    }
+
+    // TODO for documents this will need to switch based on Identifier kind
+    if (isCacheOperationValue(value)) {
+      let callbackMap = this._cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
+      if (callbackMap) {
+        callbackMap.forEach(cb => {
+          cb(identifier, value);
+        });
+      }
+    }
+    let callbackMap = this._cache.get(identifier);
+    if (!callbackMap || !callbackMap.size) {
+      return false;
+    }
+    callbackMap.forEach(cb => {
+      // @ts-expect-error overload doesn't narrow within body
+      cb(identifier, value, key);
+    });
+    return true;
+  }
+  destroy() {
+    this.isDestroyed = true;
+    this._tokens.clear();
+    this._cache.clear();
+  }
+}
 const PromiseArrayProxy = ArrayProxy.extend(PromiseProxyMixin);
 const PromiseObjectProxy = ObjectProxy.extend(PromiseProxyMixin);
 var _dec, _class$1, _descriptor$1;
@@ -3821,7 +3858,7 @@ const MUTATE = Symbol('#update');
 const NOTIFY = Symbol('#notify');
 const IS_COLLECTION = Symbol.for('Collection');
 function notifyArray(arr) {
-  arr[IDENTIFIER_ARRAY_TAG].ref = null;
+  addToTransaction(arr[IDENTIFIER_ARRAY_TAG]);
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
     // eslint-disable-next-line
     dirtyTag(tagForProperty(arr, 'length'));
@@ -3842,6 +3879,11 @@ let Tag = (_class = class Tag {
 
   constructor() {
     _initializerDefineProperty(this, "ref", _descriptor, this);
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      const [arr, prop] = arguments;
+      this._debug_base = arr.constructor.name + ':' + String(arr.modelName);
+      this._debug_prop = prop;
+    }
     this.shouldReset = false;
     this.t = false;
   }
@@ -3961,7 +4003,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     this.isDestroyed = false;
     this._updatingPromise = null;
     this[IS_COLLECTION] = true;
-    this[IDENTIFIER_ARRAY_TAG] = new Tag();
     this[SOURCE] = void 0;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     let self = this;
@@ -3969,6 +4010,8 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     this.store = options.store;
     this._manager = options.manager;
     this[SOURCE] = options.identifiers;
+    // @ts-expect-error
+    this[IDENTIFIER_ARRAY_TAG] = macroCondition(getOwnConfig().env.DEBUG) ? new Tag(this, 'length') : new Tag();
     const store = options.store;
     const boundFns = new Map();
     const _TAG = this[IDENTIFIER_ARRAY_TAG];
@@ -4602,7 +4645,6 @@ function isPromiseRecord$1(record) {
 /**
   @module @ember-data/store
 */
-const RecordArraysCache = new Map();
 const FAKE_ARR = {};
 const SLICE_BATCH_SIZE = 1200;
 /**
@@ -4668,7 +4710,7 @@ class RecordArrayManager {
     this._pending = new Map();
     this._staged = new Map();
     this._keyedArrays = new Map();
-    this._identifiers = RecordArraysCache;
+    this._identifiers = new Map();
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       if (type === 'added') {
         this.identifierAdded(identifier);
@@ -4735,7 +4777,7 @@ class RecordArrayManager {
     let array = new Collection(options);
     this._managed.add(array);
     if (config.identifiers) {
-      associate(array, config.identifiers);
+      associate(this._identifiers, array, config.identifiers);
     }
     return array;
   }
@@ -4759,7 +4801,7 @@ class RecordArrayManager {
     const allPending = this._pending;
     let pending = new Map();
     if (includeManaged) {
-      let managed = RecordArraysCache.get(identifier);
+      let managed = this._identifiers.get(identifier);
       if (managed) {
         managed.forEach(arr => {
           let changes = allPending.get(arr);
@@ -4809,8 +4851,8 @@ class RecordArrayManager {
     array.meta = payload.meta || null;
     array.links = payload.links || null;
     array.isLoaded = true;
-    disassociate(array, old);
-    associate(array, identifiers);
+    disassociate(this._identifiers, array, old);
+    associate(this._identifiers, array, identifiers);
   }
   identifierAdded(identifier) {
     let changeSets = this._getPendingFor(identifier, false);
@@ -4852,7 +4894,7 @@ class RecordArrayManager {
     this._live.forEach(array => array.destroy());
     this._managed.forEach(array => array.destroy());
     this._managed.clear();
-    RecordArraysCache.clear();
+    this._identifiers.clear();
   }
   destroy() {
     this.isDestroying = true;
@@ -4863,24 +4905,24 @@ class RecordArrayManager {
     this.store.notifications.unsubscribe(this._subscription);
   }
 }
-function associate(array, identifiers) {
+function associate(ArraysCache, array, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
-    let cache = RecordArraysCache.get(identifier);
+    let cache = ArraysCache.get(identifier);
     if (!cache) {
       cache = new Set();
-      RecordArraysCache.set(identifier, cache);
+      ArraysCache.set(identifier, cache);
     }
     cache.add(array);
   }
 }
-function disassociate(array, identifiers) {
+function disassociate(ArraysCache, array, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
-    disassociateIdentifier(array, identifiers[i]);
+    disassociateIdentifier(ArraysCache, array, identifiers[i]);
   }
 }
-function disassociateIdentifier(array, identifier) {
-  let cache = RecordArraysCache.get(identifier);
+function disassociateIdentifier(ArraysCache, array, identifier) {
+  let cache = ArraysCache.get(identifier);
   if (cache) {
     cache.delete(array);
   }
@@ -4897,7 +4939,9 @@ function sync(array, changes) {
       }
       adds.push(key);
     } else {
-      removes.push(key);
+      if (state.includes(key)) {
+        removes.push(key);
+      }
     }
   });
   if (removes.length) {
@@ -5150,9 +5194,8 @@ let _Cache;
 
   @class Store
   @public
-*/
-
-class Store {
+*/ // @ts-expect-error
+class Store extends EmberObject {
   /**
    * Provides access to the NotificationManager associated
    * with this Store instance.
@@ -5251,13 +5294,27 @@ class Store {
 
   // DEBUG-only properties
 
+  // @ts-expect-error
+  get isDestroying() {
+    return this._isDestroying;
+  }
+  set isDestroying(value) {
+    this._isDestroying = value;
+  }
+  // @ts-expect-error
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
+  set isDestroyed(value) {
+    this._isDestroyed = value;
+  }
+
   /**
     @method init
     @private
   */
   constructor(createArgs) {
-    this.isDestroying = false;
-    this.isDestroyed = false;
+    super(createArgs);
     Object.assign(this, createArgs);
     this.identifierCache = new IdentifierCache();
     this.notifications = new NotificationManager(this);
@@ -5274,6 +5331,8 @@ class Store {
     this._serializerCache = Object.create(null);
     this._modelFactoryCache = Object.create(null);
     this._documentCache = new Map();
+    this.isDestroying = false;
+    this.isDestroyed = false;
   }
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
@@ -6675,12 +6734,11 @@ class Store {
         // during unload
         if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
           const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
-          let graph = peekGraph(this);
+          const graph = peekGraph(this);
           if (graph) {
             graph.identifiers.clear();
           }
         }
-        this.notifications.destroy();
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
@@ -6983,7 +7041,6 @@ class Store {
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
-    cache.willCommit(identifier);
     if (isDSModel(record)) {
       record.errors.clear();
     }
@@ -6996,7 +7053,7 @@ class Store {
     } else if (cache.isDeleted(identifier)) {
       operation = 'deleteRecord';
     }
-    return this.request({
+    const request = {
       op: operation,
       data: {
         options,
@@ -7005,7 +7062,13 @@ class Store {
       cacheOptions: {
         [SkipCache]: true
       }
-    }).then(document => document.content);
+    };
+
+    // we lie here on the type because legacy doesn't have enough context
+    cache.willCommit(identifier, {
+      request
+    });
+    return this.request(request).then(document => document.content);
   }
 
   /**
@@ -7205,6 +7268,8 @@ class Store {
     }
     return null;
   }
+
+  // @ts-expect-error
   destroy() {
     if (this.isDestroyed) {
       // @ember/test-helpers will call destroy multiple times
@@ -7231,6 +7296,7 @@ class Store {
         graph.destroy();
       }
     }
+    this.notifications.destroy();
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
     this.unloadAll();