@ember-data/store 4.12.0-alpha.7 → 4.12.0-alpha.8

package/addon/{index-bebb407b.js → index-12f1f6c0.js}

@@ -38,6 +38,26 @@ function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
 
+/*
+ * Returns the Cache instance associated with a given
+ * Model or Identifier
+ */
+
+const CacheForIdentifierCache = new Map();
+function setCacheFor(identifier, cache) {
+  assert(`Illegal set of identifier`, !CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache);
+  CacheForIdentifierCache.set(identifier, cache);
+}
+function removeRecordDataFor(identifier) {
+  CacheForIdentifierCache.delete(identifier);
+}
+function peekCache(instance) {
+  if (CacheForIdentifierCache.has(instance)) {
+    return CacheForIdentifierCache.get(instance);
+  }
+  return null;
+}
+
 /**
   @module @ember-data/store
 */
@@ -386,6 +406,7 @@ class IdentifierCache {
     @returns {StableRecordIdentifier}
     @public
   */
+
   getOrCreateRecordIdentifier(resource) {
     return this._getRecordIdentifier(resource, true);
   }
@@ -421,7 +442,7 @@ class IdentifierCache {
     }
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
-      console.log(`Identifiers: createded identifier ${String(identifier)} for newly generated resource`, data);
+      console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
     }
     return identifier;
   }
@@ -708,6 +729,10 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   return desc;
 }
 let tokenId = 0;
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+function isCacheOperationValue(value) {
+  return CacheOperations.has(value);
+}
 const Cache = new Map();
 const Tokens = new Map();
 // TODO this isn't importable anyway, remove and use a map on the manager?
@@ -763,7 +788,7 @@ class NotificationManager {
    * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
    */
   subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, isStableIdentifier(identifier));
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier));
     let map = Cache.get(identifier);
     if (!map) {
       map = new Map();
@@ -790,27 +815,46 @@ class NotificationManager {
     }
   }
 
-  // deactivated type signature overloads because pass-through was failing to match any. Bring back if possible.
-  // notify(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships', key?: string): boolean;
-  // notify(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'state'): boolean;
+  /**
+   * 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');
+    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
     if (!isStableIdentifier(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);
+        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(`Notifying: ${String(identifier)}\t${value}\t${key}`);
+      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('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;
@@ -1025,14 +1069,49 @@ var id = 0;
 function _classPrivateFieldKey(name) {
   return "__private_" + id++ + "_" + name;
 }
-var _store = /*#__PURE__*/_classPrivateFieldKey("store");
-var _recordData = /*#__PURE__*/_classPrivateFieldKey("recordData");
-var _identifier = /*#__PURE__*/_classPrivateFieldKey("identifier");
-var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
+function legacyCachePut(store, doc) {
+  const jsonApiDoc = doc.data;
+  let ret;
+  store._join(() => {
+    let included = jsonApiDoc.included;
+    let i, length;
+    if (included) {
+      for (i = 0, length = included.length; i < length; i++) {
+        store._instanceCache.loadData(included[i]);
+      }
+    }
+    if (Array.isArray(jsonApiDoc.data)) {
+      length = jsonApiDoc.data.length;
+      let identifiers = [];
+      for (i = 0; i < length; i++) {
+        identifiers.push(store._instanceCache.loadData(jsonApiDoc.data[i]));
+      }
+      ret = {
+        data: identifiers
+      };
+      return;
+    }
+    if (jsonApiDoc.data === null) {
+      ret = {
+        data: null
+      };
+      return;
+    }
+    assert(`Expected an object in the 'data' property in a call to 'push', but was ${typeof jsonApiDoc.data}`, typeof jsonApiDoc.data === 'object');
+    ret = {
+      data: store._instanceCache.loadData(jsonApiDoc.data)
+    };
+    return;
+  });
+  return ret;
+}
+
 /**
- * The CacheManager wraps a Cache
- * enforcing that only the public API surface area
- * is exposed.
+ * The CacheManager wraps a Cache enforcing that only
+ * the public API surface area is exposed.
+ *
+ * Hence, it is the value of `Store.cache`, wrapping
+ * the cache instance returned by `Store.createCache`.
  *
  * This class is the the return value of both the
  * `recordDataFor` function supplied to the store
@@ -1069,11 +1148,15 @@ var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
  * @class CacheManager
  * @public
  */
+var _store = /*#__PURE__*/_classPrivateFieldKey("store");
+var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
+var _identifier = /*#__PURE__*/_classPrivateFieldKey("identifier");
+var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
 class NonSingletonCacheManager {
   get managedVersion() {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].version || '1';
+    return _classPrivateFieldBase(this, _cache)[_cache].version || '1';
   }
-  constructor(store, _recordData2, identifier) {
+  constructor(store, _cache2, identifier) {
     Object.defineProperty(this, _isDeprecated, {
       value: _isDeprecated2
     });
@@ -1082,7 +1165,7 @@ class NonSingletonCacheManager {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _recordData, {
+    Object.defineProperty(this, _cache, {
       writable: true,
       value: void 0
     });
@@ -1091,9 +1174,9 @@ class NonSingletonCacheManager {
       value: void 0
     });
     _classPrivateFieldBase(this, _store)[_store] = store;
-    _classPrivateFieldBase(this, _recordData)[_recordData] = _recordData2;
+    _classPrivateFieldBase(this, _cache)[_cache] = _cache2;
     _classPrivateFieldBase(this, _identifier)[_identifier] = identifier;
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_recordData2)) {
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_cache2)) {
       deprecate(`This RecordData uses the deprecated V1 RecordData Spec. Upgrade to V2 to maintain compatibility.`, false, {
         id: 'ember-data:deprecate-v1-cache',
         until: '5.0',
@@ -1105,11 +1188,46 @@ class NonSingletonCacheManager {
       });
     }
   }
+
+  /**
+   * Cache the response to a request
+   *
+   * Unlike `store.push` which has UPSERT
+   * semantics, `put` has `replace` semantics similar to
+   * the `http` method `PUT`
+   *
+   * the individually cacheabl
+   * e resource data it may contain
+   * should upsert, but the document data surrounding it should
+   * fully replace any existing information
+   *
+   * Note that in order to support inserting arbitrary data
+   * to the cache that did not originate from a request `put`
+   * should expect to sometimes encounter a document with only
+   * a `data` member and therefor must not assume the existence
+   * of `request` and `response` on the document.
+   *
+   * @method put
+   * @param {StructuredDocument} doc
+   * @returns {ResourceDocument}
+   * @public
+   */
+  put(doc) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      if (doc instanceof Error) {
+        // in legacy we don't know how to handle this
+        throw doc;
+      }
+      return legacyCachePut(_classPrivateFieldBase(this, _store)[_store], doc);
+    }
+    return cache.put(doc);
+  }
   // Cache
   // =====
 
   /**
-   * Retrieve the identifier for this v1 recordData
+   * Retrieve the identifier for this v1 cache
    *
    * DEPRECATED Caches should not be assumed to be 1:1 with resources
    *
@@ -1124,25 +1242,41 @@ class NonSingletonCacheManager {
   /**
    * Push resource data from a remote source into the cache for this identifier
    *
+   * DEPRECATED Use upsert. Caches should not be assumed to be 1:1 with resources
+   *
    * @method pushData
+   * @param data
+   * @param hasRecord
+   * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+   * @public
+   * @deprecated
+   */
+  pushData(data, hasRecord) {
+    return this.upsert(_classPrivateFieldBase(this, _identifier)[_identifier], data, hasRecord);
+  }
+
+  /**
+   * Push resource data from a remote source into the cache for this identifier
+   *
+   * @method upsert
    * @public
    * @param identifier
    * @param data
    * @param hasRecord
    * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
    */
-  pushData(identifier, data, hasRecord) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
+  upsert(identifier, data, hasRecord) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
     // called by something V1
     if (!isStableIdentifier(identifier)) {
       data = identifier;
       hasRecord = data;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.pushData(data, hasRecord);
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.pushData(data, hasRecord);
     }
-    return recordData.pushData(identifier, data, hasRecord);
+    return cache.upsert(identifier, data, hasRecord);
   }
 
   /**
@@ -1151,17 +1285,17 @@ class NonSingletonCacheManager {
    * Note: currently the only valid operation is a MergeOperation
    * which occurs when a collision of identifiers is detected.
    *
-   * @method sync
+   * @method patch
    * @public
    * @param op the operation to perform
    * @returns {void}
    */
-  sync(op) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
+  patch(op) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
       return;
     }
-    recordData.sync(op);
+    cache.patch(op);
   }
 
   /**
@@ -1174,25 +1308,25 @@ class NonSingletonCacheManager {
    */
   // isCollection is only needed for interop with v1 cache
   update(operation, isResource) {
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_classPrivateFieldBase(this, _recordData)[_recordData])) {
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_classPrivateFieldBase(this, _cache)[_cache])) {
       const cache = _classPrivateFieldBase(this, _store)[_store]._instanceCache;
       switch (operation.op) {
         case 'addToRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].addToHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)), operation.index);
+          _classPrivateFieldBase(this, _cache)[_cache].addToHasMany(operation.field, operation.value.map(i => cache.getResourceCache(i)), operation.index);
           return;
         case 'removeFromRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].removeFromHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)));
+          _classPrivateFieldBase(this, _cache)[_cache].removeFromHasMany(operation.field, operation.value.map(i => cache.getResourceCache(i)));
           return;
         case 'replaceRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].setDirtyHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)));
+          _classPrivateFieldBase(this, _cache)[_cache].setDirtyHasMany(operation.field, operation.value.map(i => cache.getResourceCache(i)));
           return;
         case 'replaceRelatedRecord':
           if (isResource) {
-            _classPrivateFieldBase(this, _recordData)[_recordData].setDirtyBelongsTo(operation.field, operation.value ? cache.getRecordData(operation.value) : null);
+            _classPrivateFieldBase(this, _cache)[_cache].setDirtyBelongsTo(operation.field, operation.value ? cache.getResourceCache(operation.value) : null);
             return;
           }
-          _classPrivateFieldBase(this, _recordData)[_recordData].removeFromHasMany(operation.field, [cache.getRecordData(operation.prior)]);
-          _classPrivateFieldBase(this, _recordData)[_recordData].addToHasMany(operation.field, [cache.getRecordData(operation.value)], operation.index);
+          _classPrivateFieldBase(this, _cache)[_cache].removeFromHasMany(operation.field, [cache.getResourceCache(operation.prior)]);
+          _classPrivateFieldBase(this, _cache)[_cache].addToHasMany(operation.field, [cache.getResourceCache(operation.value)], operation.index);
           return;
         case 'sortRelatedRecords':
           return;
@@ -1200,7 +1334,7 @@ class NonSingletonCacheManager {
           return;
       }
     } else {
-      _classPrivateFieldBase(this, _recordData)[_recordData].update(operation);
+      _classPrivateFieldBase(this, _cache)[_cache].update(operation);
     }
   }
 
@@ -1221,15 +1355,15 @@ class NonSingletonCacheManager {
       options = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
 
     // TODO deprecate return value
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      recordData.clientDidCreate();
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      cache.clientDidCreate();
       // if a V2 is calling a V1 we need to call both methods
-      return recordData._initRecordCreateOptions(options);
+      return cache._initRecordCreateOptions(options);
     } else {
-      return recordData.clientDidCreate(identifier, options);
+      return cache.clientDidCreate(identifier, options);
     }
   }
 
@@ -1245,9 +1379,9 @@ class NonSingletonCacheManager {
    * @param options
    */
   _initRecordCreateOptions(options) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData._initRecordCreateOptions(options);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache._initRecordCreateOptions(options);
     }
   }
 
@@ -1260,7 +1394,7 @@ class NonSingletonCacheManager {
    * @param identifier
    */
   willCommit(identifier) {
-    _classPrivateFieldBase(this, _recordData)[_recordData].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1278,8 +1412,8 @@ class NonSingletonCacheManager {
       data = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.didCommit(data) : recordData.didCommit(identifier, data);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.didCommit(data) : cache.didCommit(identifier, data);
   }
 
   /**
@@ -1292,7 +1426,7 @@ class NonSingletonCacheManager {
    * @param errors
    */
   commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _recordData)[_recordData].commitWasRejected(identifier || _classPrivateFieldBase(this, _identifier)[_identifier], errors);
+    _classPrivateFieldBase(this, _cache)[_cache].commitWasRejected(identifier || _classPrivateFieldBase(this, _identifier)[_identifier], errors);
   }
 
   /**
@@ -1304,11 +1438,11 @@ class NonSingletonCacheManager {
    * @param identifier
    */
   unloadRecord(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      recordData.unloadRecord();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      cache.unloadRecord();
     } else {
-      recordData.unloadRecord(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+      cache.unloadRecord(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
     }
   }
 
@@ -1330,8 +1464,8 @@ class NonSingletonCacheManager {
       propertyName = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.getAttr(propertyName) : recordData.getAttr(identifier, propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.getAttr(propertyName) : cache.getAttr(identifier, propertyName);
   }
 
   /**
@@ -1344,8 +1478,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setAttr(identifier, propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyAttribute(propertyName, value) : recordData.setAttr(identifier, propertyName, value);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyAttribute(propertyName, value) : cache.setAttr(identifier, propertyName, value);
   }
 
   /**
@@ -1361,8 +1495,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyAttribute(propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyAttribute(propertyName, value) : recordData.setAttr(_classPrivateFieldBase(this, _identifier)[_identifier], propertyName, value);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyAttribute(propertyName, value) : cache.setAttr(_classPrivateFieldBase(this, _identifier)[_identifier], propertyName, value);
   }
 
   /**
@@ -1377,11 +1511,11 @@ class NonSingletonCacheManager {
    * @returns
    */
   changedAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.changedAttributes();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.changedAttributes();
     }
-    return recordData.changedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    return cache.changedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1394,11 +1528,11 @@ class NonSingletonCacheManager {
    * @returns
    */
   changedAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.changedAttributes();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.changedAttributes();
     }
-    return recordData.changedAttrs(identifier);
+    return cache.changedAttrs(identifier);
   }
 
   /**
@@ -1412,8 +1546,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   hasChangedAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.hasChangedAttributes() : recordData.hasChangedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1425,8 +1559,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   hasChangedAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.hasChangedAttributes() : recordData.hasChangedAttrs(identifier);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(identifier);
   }
 
   /**
@@ -1440,8 +1574,8 @@ class NonSingletonCacheManager {
    * @returns
    */
   rollbackAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.rollbackAttributes() : recordData.rollbackAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1453,8 +1587,8 @@ class NonSingletonCacheManager {
    * @returns the names of attributes that were restored
    */
   rollbackAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.rollbackAttributes() : recordData.rollbackAttrs(identifier);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(identifier);
   }
 
   // Relationships
@@ -1476,12 +1610,12 @@ class NonSingletonCacheManager {
    * @returns resource relationship object
    */
   getRelationship(identifier, propertyName, isCollection = false) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
       let isBelongsTo = !isCollection;
-      return isBelongsTo ? recordData.getBelongsTo(propertyName) : recordData.getHasMany(propertyName);
+      return isBelongsTo ? cache.getBelongsTo(propertyName) : cache.getHasMany(propertyName);
     }
-    return recordData.getRelationship(identifier, propertyName);
+    return cache.getRelationship(identifier, propertyName);
   }
 
   /**
@@ -1496,12 +1630,12 @@ class NonSingletonCacheManager {
    * @returns single resource relationship object
    */
   getBelongsTo(propertyName) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.getBelongsTo(propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.getBelongsTo(propertyName);
     } else {
       let identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-      return recordData.getRelationship(identifier, propertyName);
+      return cache.getRelationship(identifier, propertyName);
     }
   }
 
@@ -1517,12 +1651,12 @@ class NonSingletonCacheManager {
    * @returns single resource relationship object
    */
   getHasMany(propertyName) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.getHasMany(propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.getHasMany(propertyName);
     } else {
       let identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-      return recordData.getRelationship(identifier, propertyName);
+      return cache.getRelationship(identifier, propertyName);
     }
   }
 
@@ -1538,8 +1672,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyBelongsTo(propertyName, value) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyBelongsTo(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyBelongsTo(propertyName, value) : cache.update({
       op: 'replaceRelatedRecord',
       record: _classPrivateFieldBase(this, _identifier)[_identifier],
       field: propertyName,
@@ -1563,8 +1697,8 @@ class NonSingletonCacheManager {
    */
   addToHasMany(propertyName, value, idx) {
     const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.addToHasMany(propertyName, value, idx) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.addToHasMany(propertyName, value, idx) : cache.update({
       op: 'addToRelatedRecords',
       field: propertyName,
       record: identifier,
@@ -1585,8 +1719,8 @@ class NonSingletonCacheManager {
    */
   removeFromHasMany(propertyName, value) {
     const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.removeFromHasMany(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.removeFromHasMany(propertyName, value) : cache.update({
       op: 'removeFromRelatedRecords',
       record: identifier,
       field: propertyName,
@@ -1606,8 +1740,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyHasMany(propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyHasMany(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyHasMany(propertyName, value) : cache.update({
       op: 'replaceRelatedRecords',
       record: _classPrivateFieldBase(this, _identifier)[_identifier],
       field: propertyName,
@@ -1632,8 +1766,8 @@ class NonSingletonCacheManager {
       isDeleted = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setIsDeleted(isDeleted) : recordData.setIsDeleted(identifier, isDeleted);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setIsDeleted(isDeleted) : cache.setIsDeleted(identifier, isDeleted);
   }
 
   /**
@@ -1645,7 +1779,7 @@ class NonSingletonCacheManager {
    * @returns
    */
   getErrors(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].getErrors(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1657,8 +1791,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isEmpty(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.isEmpty?.(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]) || false : recordData.isEmpty(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.isEmpty?.(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]) || false : cache.isEmpty(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1671,7 +1805,7 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isNew(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isNew(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1684,7 +1818,7 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isDeleted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1697,106 +1831,99 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isDeletionCommitted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 }
-function _isDeprecated2(recordData) {
-  let version = recordData.version || '1';
+function _isDeprecated2(cache) {
+  let version = cache.version || '1';
   return version !== this.version;
 }
-var _recordDatas = /*#__PURE__*/_classPrivateFieldKey("recordDatas");
-var _recordData3 = /*#__PURE__*/_classPrivateFieldKey("recordData");
+var _cache3 = /*#__PURE__*/_classPrivateFieldKey("cache");
 class SingletonCacheManager {
-  constructor() {
-    Object.defineProperty(this, _recordData3, {
-      value: _recordData4
-    });
+  constructor(cache) {
     this.version = '2';
-    Object.defineProperty(this, _recordDatas, {
+    Object.defineProperty(this, _cache3, {
       writable: true,
       value: void 0
     });
-    _classPrivateFieldBase(this, _recordDatas)[_recordDatas] = new Map();
+    _classPrivateFieldBase(this, _cache3)[_cache3] = cache;
   }
-  _addRecordData(identifier, recordData) {
-    _classPrivateFieldBase(this, _recordDatas)[_recordDatas].set(identifier, recordData);
+  put(doc) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].put(doc);
   }
+
   // Cache
   // =====
 
-  pushData(identifier, data, hasRecord) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).pushData(identifier, data, hasRecord);
+  upsert(identifier, data, hasRecord) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].upsert(identifier, data, hasRecord);
   }
-  sync(op) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](op.record).sync(op);
+  patch(op) {
+    _classPrivateFieldBase(this, _cache3)[_cache3].patch(op);
   }
   clientDidCreate(identifier, options) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).clientDidCreate(identifier, options);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].clientDidCreate(identifier, options);
   }
   willCommit(identifier) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).willCommit(identifier);
+    _classPrivateFieldBase(this, _cache3)[_cache3].willCommit(identifier);
   }
   didCommit(identifier, data) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).didCommit(identifier, data);
+    _classPrivateFieldBase(this, _cache3)[_cache3].didCommit(identifier, data);
   }
   commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).commitWasRejected(identifier, errors);
+    _classPrivateFieldBase(this, _cache3)[_cache3].commitWasRejected(identifier, errors);
   }
   unloadRecord(identifier) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).unloadRecord(identifier);
+    _classPrivateFieldBase(this, _cache3)[_cache3].unloadRecord(identifier);
   }
 
   // Attrs
   // =====
 
   getAttr(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getAttr(identifier, propertyName);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getAttr(identifier, propertyName);
   }
   setAttr(identifier, propertyName, value) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).setAttr(identifier, propertyName, value);
+    _classPrivateFieldBase(this, _cache3)[_cache3].setAttr(identifier, propertyName, value);
   }
   changedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).changedAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].changedAttrs(identifier);
   }
   hasChangedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).hasChangedAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].hasChangedAttrs(identifier);
   }
   rollbackAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).rollbackAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].rollbackAttrs(identifier);
   }
   getRelationship(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getRelationship(identifier, propertyName);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getRelationship(identifier, propertyName);
   }
   update(operation) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](operation.record).update(operation);
+    _classPrivateFieldBase(this, _cache3)[_cache3].update(operation);
   }
 
   // State
   // =============
 
   setIsDeleted(identifier, isDeleted) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).setIsDeleted(identifier, isDeleted);
+    _classPrivateFieldBase(this, _cache3)[_cache3].setIsDeleted(identifier, isDeleted);
   }
   getErrors(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getErrors(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getErrors(identifier);
   }
   isEmpty(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isEmpty(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isEmpty(identifier);
   }
   isNew(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isNew(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isNew(identifier);
   }
   isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isDeleted(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeleted(identifier);
   }
   isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isDeletionCommitted(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeletionCommitted(identifier);
   }
 }
-function _recordData4(identifier) {
-  assert(`No RecordData Yet Exists!`, _classPrivateFieldBase(this, _recordDatas)[_recordDatas].has(identifier));
-  return _classPrivateFieldBase(this, _recordDatas)[_recordDatas].get(identifier);
-}
 function constructResource(type, id, lid) {
   if (typeof type === 'object' && type !== null) {
     let resource = type;
@@ -1887,10 +2014,9 @@ class LegacyWrapper {
       this._scheduleNotification(identifier, key);
       return;
     }
+
+    // @ts-expect-error
     this._store.notifications.notify(identifier, namespace, key);
-    if (namespace === 'state') {
-      this._store.recordArrayManager.identifierChanged(identifier);
-    }
   }
   notifyErrorsChange(type, id, lid) {
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
@@ -2006,7 +2132,6 @@ class LegacyWrapper {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     this._store.notifications.notify(identifier, 'state');
-    this._store.recordArrayManager.identifierChanged(identifier);
   }
   recordDataFor(type, id, lid) {
     let identifier;
@@ -2029,12 +2154,14 @@ class LegacyWrapper {
       assert(`Expected a stable identifier`, isStableIdentifier(type));
       identifier = type;
     }
-    const recordData = this._store._instanceCache.getRecordData(identifier);
-    if (!id && !lid) {
-      recordData.clientDidCreate(identifier);
-      this._store.recordArrayManager.identifierAdded(identifier);
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
+      if (!id && !lid && typeof type === 'string') {
+        cache.clientDidCreate(identifier);
+        this._store.recordArrayManager.identifierAdded(identifier);
+      }
     }
-    return recordData;
+    return cache;
   }
   setRecordId(type, id, lid) {
     let identifier;
@@ -2154,17 +2281,27 @@ class V2CacheStoreWrapper {
       this._scheduleNotification(identifier, key);
       return;
     }
+
+    // @ts-expect-error
     this._store.notifications.notify(identifier, namespace, key);
-    if (namespace === 'state') {
-      this._store.recordArrayManager.identifierChanged(identifier);
-    }
   }
   getSchemaDefinitionService() {
     return this._store.getSchemaDefinitionService();
   }
   recordDataFor(identifier) {
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+      deprecate(`StoreWrapper.recordDataFor is deprecated. With Singleton Cache, this method is no longer needed as the caller is its own cache reference.`, false, {
+        for: '@ember-data/store',
+        id: 'ember-data:deprecate-record-data-for',
+        since: {
+          available: '4.10',
+          enabled: '4.10'
+        },
+        until: '5.0'
+      });
+    }
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    return this._store._instanceCache.getRecordData(identifier);
+    return macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : void 0;
   }
   setRecordId(identifier, id) {
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
@@ -2274,7 +2411,8 @@ class Snapshot {
      */
     this.modelName = identifier.type;
     if (hasRecord) {
-      this._changedAttributes = this._store._instanceCache.getRecordData(identifier).changedAttrs(identifier);
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+      this._changedAttributes = cache.changedAttrs(identifier);
     }
   }
 
@@ -2296,14 +2434,14 @@ class Snapshot {
     if (this.__attributes !== null) {
       return this.__attributes;
     }
-    let attributes = this.__attributes = Object.create(null);
+    const attributes = this.__attributes = Object.create(null);
     const {
       identifier
     } = this;
-    let attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
-    let recordData = this._store._instanceCache.getRecordData(identifier);
+    const attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
     attrs.forEach(keyName => {
-      attributes[keyName] = recordData.getAttr(identifier, keyName);
+      attributes[keyName] = cache.getAttr(identifier, keyName);
     });
     return attributes;
   }
@@ -2317,11 +2455,11 @@ class Snapshot {
    */
 
   get isNew() {
-    const recordData = this._store._instanceCache.peek({
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.peek({
       identifier: this.identifier,
-      bucket: 'recordData'
-    });
-    return recordData?.isNew(this.identifier) || false;
+      bucket: 'resourceCache'
+    }) : this._store.cache;
+    return cache?.isNew(this.identifier) || false;
   }
 
   /**
@@ -2449,7 +2587,8 @@ class Snapshot {
     let data = value && value.data;
     let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
     if (value && value.data !== undefined) {
-      if (inverseIdentifier && !store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? inverseIdentifier && store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+      if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
         if (returnModeIsId) {
           result = inverseIdentifier.id;
         } else {
@@ -2527,7 +2666,8 @@ class Snapshot {
       results = [];
       value.data.forEach(member => {
         let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
-        if (!store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
+        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+        if (!cache.isDeleted(inverseIdentifier)) {
           if (returnModeIsIds) {
             results.push(inverseIdentifier.id);
           } else {
@@ -2635,26 +2775,6 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_AC
 function assertIdentifierHasId(identifier) {
   assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
 }
-
-/*
- * Returns the RecordData instance associated with a given
- * Model or Identifier
- */
-
-const RecordDataForIdentifierCache = new Map();
-function setRecordDataFor(identifier, recordData) {
-  assert(`Illegal set of identifier`, !RecordDataForIdentifierCache.has(identifier) || RecordDataForIdentifierCache.get(identifier) === recordData);
-  RecordDataForIdentifierCache.set(identifier, recordData);
-}
-function removeRecordDataFor(identifier) {
-  RecordDataForIdentifierCache.delete(identifier);
-}
-function recordDataFor(instance) {
-  if (RecordDataForIdentifierCache.has(instance)) {
-    return RecordDataForIdentifierCache.get(instance);
-  }
-  return null;
-}
 let _peekGraph;
 if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
   let __peekGraph;
@@ -2724,16 +2844,18 @@ class InstanceCache {
   constructor(store) {
     this.__instances = {
       record: new Map(),
-      recordData: new Map(),
+      resourceCache: new Map(),
       reference: new WeakMap()
     };
     this.store = store;
     this._storeWrapper = new CacheStoreWrapper(this.store);
-    this.__recordDataFor = resource => {
-      // TODO enforce strict
-      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource);
-      return this.getRecordData(identifier);
-    };
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+      this.__cacheFor = resource => {
+        // TODO enforce strict
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource);
+        return this.getResourceCache(identifier);
+      };
+    }
     store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
       let keptIdentifier = identifier;
       if (identifier.id !== matchedIdentifier.id) {
@@ -2746,11 +2868,11 @@ class InstanceCache {
       // check for duplicate entities
       let keptHasRecord = this.__instances.record.has(keptIdentifier);
       let staleHasRecord = this.__instances.record.has(staleIdentifier);
-      let keptRecordData = this.__instances.recordData.get(keptIdentifier) || null;
-      let staleRecordData = this.__instances.recordData.get(staleIdentifier) || null;
+      let keptResourceCache = this.__instances.resourceCache.get(keptIdentifier) || null;
+      let staleResourceCache = this.__instances.resourceCache.get(staleIdentifier) || null;
 
       // we cannot merge entities when both have records
-      // (this may not be strictly true, we could probably swap the recordData the record points at)
+      // (this may not be strictly true, we could probably swap the cache data the record points at)
       if (keptHasRecord && staleHasRecord) {
         // TODO we probably don't need to throw these errors anymore
         // we can probably just "swap" what data source the abandoned
@@ -2761,23 +2883,27 @@ class InstanceCache {
         }
         assert(`Failed to update the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${String(matchedIdentifier.lid)})'`);
       }
-      let recordData = keptRecordData || staleRecordData;
-      if (recordData) {
-        recordData.sync({
+      let resourceCache = keptResourceCache || staleResourceCache;
+      if (resourceCache) {
+        resourceCache.patch({
+          op: 'mergeIdentifiers',
+          record: staleIdentifier,
+          value: keptIdentifier
+        });
+      } else if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+        this.store.cache.patch({
           op: 'mergeIdentifiers',
           record: staleIdentifier,
           value: keptIdentifier
         });
       } else if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
-        // TODO notify cache always, this requires it always being a singleton
-        // and not ever specific to one record-data
-        this.store.__private_singleton_recordData?.sync({
+        this.store.cache.patch({
           op: 'mergeIdentifiers',
           record: staleIdentifier,
           value: keptIdentifier
         });
       }
-      if (staleRecordData === null) {
+      if (staleResourceCache === null) {
         return keptIdentifier;
       }
 
@@ -2805,10 +2931,27 @@ class InstanceCache {
     let record = this.__instances.record.get(identifier);
     if (!record) {
       assert(`Cannot create a new record instance while the store is being destroyed`, !this.store.isDestroying && !this.store.isDestroyed);
-      const recordData = this.getRecordData(identifier);
-      record = this.store.instantiateRecord(identifier, properties || {}, this.__recordDataFor, this.store.notifications);
+      const cache = this.getResourceCache(identifier);
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_INSTANTIATE_RECORD_ARGS)) {
+        if (this.store.instantiateRecord.length > 2) {
+          deprecate(`Expected store.instantiateRecord to have an arity of 2. recordDataFor and notificationManager args have been deprecated.`, false, {
+            for: '@ember-data/store',
+            id: 'ember-data:deprecate-instantiate-record-args',
+            since: {
+              available: '4.12',
+              enabled: '4.12'
+            },
+            until: '5.0'
+          });
+        }
+        record = this.store.instantiateRecord(identifier, properties || {},
+        // @ts-expect-error
+        this.__cacheFor, this.store.notifications);
+      } else {
+        record = this.store.instantiateRecord(identifier, properties || {});
+      }
       setRecordIdentifier(record, identifier);
-      setRecordDataFor(record, recordData);
+      setCacheFor(record, cache);
       StoreMap.set(record, this.store);
       this.__instances.record.set(identifier, record);
       if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
@@ -2818,49 +2961,49 @@ class InstanceCache {
     }
     return record;
   }
-  getRecordData(identifier) {
-    let recordData = this.__instances.recordData.get(identifier);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      if (!recordData && this.store.createRecordDataFor.length > 2) {
-        deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createRecordDataFor(<identifier>, <storeWrapper>)`, false, {
-          id: 'ember-data:deprecate-v1cache-store-apis',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            enabled: '4.7',
-            available: '4.7'
-          }
-        });
-        let recordDataInstance = this.store.createRecordDataFor(identifier.type, identifier.id,
-        // @ts-expect-error
-        identifier.lid, this._storeWrapper);
-        if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-          recordData = new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-        } else {
-          recordData = this.__cacheManager = this.__cacheManager || new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-        }
-      }
+  getResourceCache(identifier) {
+    if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
+      const cache = this.store.cache;
+      setCacheFor(identifier, cache);
+      this.__instances.resourceCache.set(identifier, cache);
+      return cache;
     }
-    if (!recordData) {
-      let recordDataInstance = this.store.createRecordDataFor(identifier, this._storeWrapper);
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-        recordData = new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-      } else {
-        if (macroCondition(isDevelopingApp())) {
-          recordData = this.__cacheManager = this.__cacheManager || new SingletonCacheManager();
-          recordData._addRecordData(identifier, recordDataInstance);
-        } else {
-          recordData = recordDataInstance;
+    let cache = this.__instances.resourceCache.get(identifier);
+    if (cache) {
+      return cache;
+    }
+    if (this.store.createRecordDataFor) {
+      deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createCache(<storeWrapper>)`, false, {
+        id: 'ember-data:deprecate-v1-cache',
+        for: 'ember-data',
+        until: '5.0',
+        since: {
+          enabled: '4.12',
+          available: '4.12'
+        }
+      });
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
+        if (this.store.createRecordDataFor.length > 2) {
+          let cacheInstance = this.store.createRecordDataFor(identifier.type, identifier.id,
+          // @ts-expect-error
+          identifier.lid, this._storeWrapper);
+          cache = new NonSingletonCacheManager(this.store, cacheInstance, identifier);
         }
       }
-      setRecordDataFor(identifier, recordData);
-      this.__instances.recordData.set(identifier, recordData);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: created RecordData for ${String(identifier)}`);
+      if (!cache) {
+        let cacheInstance = this.store.createRecordDataFor(identifier, this._storeWrapper);
+        cache = cacheInstance.version === '2' ? cacheInstance : new NonSingletonCacheManager(this.store, cacheInstance, identifier);
       }
+    } else {
+      cache = this.store.cache;
     }
-    return recordData;
+    setCacheFor(identifier, cache);
+    this.__instances.resourceCache.set(identifier, cache);
+    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      // eslint-disable-next-line no-console
+      console.log(`InstanceCache: created Cache for ${String(identifier)}`);
+    }
+    return cache;
   }
   getReference(identifier) {
     let cache = this.__instances.reference;
@@ -2872,16 +3015,16 @@ class InstanceCache {
     return reference;
   }
   recordIsLoaded(identifier, filterDeleted = false) {
-    const recordData = this.__instances.recordData.get(identifier);
-    if (!recordData) {
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) : this.cache;
+    if (!cache) {
       return false;
     }
-    const isNew = recordData.isNew(identifier);
-    const isEmpty = recordData.isEmpty(identifier);
+    const isNew = cache.isNew(identifier);
+    const isEmpty = cache.isEmpty(identifier);
 
     // if we are new we must consider ourselves loaded
     if (isNew) {
-      return !recordData.isDeleted(identifier);
+      return !cache.isDeleted(identifier);
     }
     // even if we have a past request, if we are now empty we are not loaded
     // typically this is true after an unloadRecord call
@@ -2890,23 +3033,8 @@ class InstanceCache {
     // we should consider allowing for something to be loaded that is simply "not empty".
     // which is how RecordState currently handles this case; however, RecordState is buggy
     // in that it does not account for unloading.
-    return filterDeleted && recordData.isDeletionCommitted(identifier) ? false : !isEmpty;
-
-    /*
-    const req = this.store.getRequestStateService();
-    const fulfilled = req.getLastRequestForRecord(identifier);
-    const isLocallyLoaded = !isEmpty;
-    const isLoading =
-      !isLocallyLoaded &&
-      fulfilled === null &&
-      req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
-     if (isEmpty || (filterDeleted && recordData.isDeletionCommitted(identifier)) || isLoading) {
-      return false;
-    }
-     return true;
-    */
+    return filterDeleted && cache.isDeletionCommitted(identifier) ? false : !isEmpty;
   }
-
   createSnapshot(identifier, options = {}) {
     return new Snapshot(options, identifier, this.store);
   }
@@ -2920,6 +3048,9 @@ class InstanceCache {
       }
     }
     this.store.identifierCache.forgetRecordIdentifier(identifier);
+    this.__instances.resourceCache.delete(identifier);
+    removeRecordDataFor(identifier);
+    this.store._fetchManager.clearEntries(identifier);
     if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
       // eslint-disable-next-line no-console
       console.log(`InstanceCache: disconnected ${String(identifier)}`);
@@ -2942,7 +3073,7 @@ class InstanceCache {
     // TODO is this join still necessary?
     this.store._join(() => {
       const record = this.__instances.record.get(identifier);
-      const recordData = this.__instances.recordData.get(identifier);
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) : this.cache;
       if (record) {
         this.store.teardownRecord(record);
         this.__instances.record.delete(identifier);
@@ -2954,20 +3085,18 @@ class InstanceCache {
           console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
         }
       }
-      let removeFromRecordArray = true;
-      if (recordData) {
-        removeFromRecordArray = !recordData.isDeletionCommitted(identifier);
-        recordData.unloadRecord(identifier);
-        this.__instances.recordData.delete(identifier);
+      if (cache) {
+        cache.unloadRecord(identifier);
+        this.__instances.resourceCache.delete(identifier);
         removeRecordDataFor(identifier);
+        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+          // eslint-disable-next-line no-console
+          console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
+        }
       } else {
-        removeFromRecordArray = false;
         this.disconnect(identifier);
       }
       this.store._fetchManager.clearEntries(identifier);
-      if (removeFromRecordArray) {
-        this.store.recordArrayManager.identifierRemoved(identifier);
-      }
       if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
@@ -2977,19 +3106,22 @@ class InstanceCache {
     });
   }
   clear(type) {
-    const typeCache = this.store.identifierCache._cache.types;
+    const cache = this.store.identifierCache._cache;
     if (type === undefined) {
-      this.__instances.recordData.forEach((value, identifier) => {
+      // it would be cool if we could just de-ref cache here
+      // but probably would require WeakRef models to do so.
+      cache.lids.forEach(identifier => {
         this.unloadRecord(identifier);
       });
     } else {
+      const typeCache = cache.types;
       let identifiers = typeCache[type]?.lid;
-      const rds = this.__instances.recordData;
+      // const rds = this.__instances.resourceCache;
       if (identifiers) {
         identifiers.forEach(identifier => {
-          if (rds.has(identifier)) {
-            this.unloadRecord(identifier);
-          }
+          // if (rds.has(identifier)) {
+          this.unloadRecord(identifier);
+          // }
           // TODO we don't remove the identifier, should we?
         });
       }
@@ -3052,7 +3184,7 @@ class InstanceCache {
       });
     }
 
-    // TODO update recordData if needed ?
+    // TODO update resource cache if needed ?
     // TODO handle consequences of identifier merge for notifications
     this.store.notifications.notify(identifier, 'identity');
   }
@@ -3081,24 +3213,18 @@ class InstanceCache {
     } else {
       identifier = this.store.identifierCache.getOrCreateRecordIdentifier(data);
     }
-    const recordData = this.getRecordData(identifier);
-    if (recordData.isNew(identifier)) {
-      this.store.notifications.notify(identifier, 'identity');
-    }
+    const cache = this.getResourceCache(identifier);
     const hasRecord = this.__instances.record.has(identifier);
-    recordData.pushData(identifier, data, hasRecord);
-    if (!isUpdate) {
-      this.store.recordArrayManager.identifierAdded(identifier);
-    }
+    cache.upsert(identifier, data, hasRecord);
     return identifier;
   }
 }
-function _recordDataIsFullDeleted(identifier, recordData) {
-  return recordData.isDeletionCommitted(identifier) || recordData.isNew(identifier) && recordData.isDeleted(identifier);
+function _resourceIsFullDeleted(identifier, cache) {
+  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
 }
-function recordDataIsFullyDeleted(cache, identifier) {
-  let recordData = cache.__instances.recordData.get(identifier);
-  return !recordData || _recordDataIsFullDeleted(identifier, recordData);
+function resourceIsFullyDeleted(instanceCache, identifier) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  return !cache || _resourceIsFullDeleted(identifier, cache);
 }
 
 /*
@@ -3133,7 +3259,8 @@ function preloadData(store, identifier, preload) {
       jsonPayload.attributes[key] = preloadValue;
     }
   });
-  store._instanceCache.getRecordData(identifier).pushData(identifier, jsonPayload);
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(identifier) : store.cache;
+  cache.upsert(identifier, jsonPayload);
 }
 function preloadRelationship(schema, preloadValue) {
   const relatedType = schema.type;
@@ -3164,14 +3291,14 @@ function _convertPreloadRelationshipToJSON(value, type) {
   // and allow identifiers to be used
   return recordIdentifierFor(value);
 }
-function _isEmpty(cache, identifier) {
-  const recordData = cache.__instances.recordData.get(identifier);
-  if (!recordData) {
+function _isEmpty(instanceCache, identifier) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  if (!cache) {
     return true;
   }
-  const isNew = recordData.isNew(identifier);
-  const isDeleted = recordData.isDeleted(identifier);
-  const isEmpty = recordData.isEmpty(identifier);
+  const isNew = cache.isNew(identifier);
+  const isDeleted = cache.isDeleted(identifier);
+  const isEmpty = cache.isEmpty(identifier);
   return (!isNew || isDeleted) && isEmpty;
 }
 function _isLoading(cache, identifier) {
@@ -3185,7 +3312,7 @@ function _isLoading(cache, identifier) {
 function _clearCaches() {
   RecordCache.clear();
   StoreMap.clear();
-  RecordDataForIdentifierCache.clear();
+  CacheForIdentifierCache.clear();
 }
 let _modelForMixin;
 if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
@@ -4113,7 +4240,7 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_ARRAY_LIKE)) {
     return this;
   };
   IdentifierArray.prototype.setObjects = function (objects) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'clear', 'length = 0');
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'setObjects', '`arr.length = 0; arr.push(objects);`');
     assert(`${this.DEPRECATED_CLASS_NAME}.setObjects expects to receive an array as its argument`, Array.isArray(objects));
     this.splice(0, this.length);
     this.push(...objects);
@@ -4368,6 +4495,15 @@ class RecordArrayManager {
     this._pending = new Map();
     this._staged = new Map();
     this._identifiers = RecordArraysCache;
+    this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
+      if (type === 'added') {
+        this.identifierAdded(identifier);
+      } else if (type === 'removed') {
+        this.identifierRemoved(identifier);
+      } else if (type === 'state') {
+        this.identifierChanged(identifier);
+      }
+    });
   }
   _syncArray(array) {
     const pending = this._pending.get(array);
@@ -4549,6 +4685,8 @@ class RecordArrayManager {
     this.clear();
     this._live.clear();
     this.isDestroyed = true;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    this.store.notifications.unsubscribe(this._subscription);
   }
 }
 function associate(array, identifiers) {
@@ -4973,14 +5111,14 @@ class FetchManager {
       }
       return identifier;
     }, error => {
-      const recordData = store._instanceCache.peek({
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.peek({
         identifier,
-        bucket: 'recordData'
-      });
-      if (!recordData || recordData.isEmpty(identifier) || isLoading) {
+        bucket: 'resourceCache'
+      }) : store.cache;
+      if (!cache || cache.isEmpty(identifier) || isLoading) {
         let isReleasable = true;
         if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
-          if (!recordData) {
+          if (!cache) {
             const graphFor = importSync('@ember-data/graph/-private').graphFor;
             const graph = graphFor(store);
             isReleasable = graph.isReleasable(identifier);
@@ -4989,7 +5127,7 @@ class FetchManager {
             }
           }
         }
-        if (recordData || isReleasable) {
+        if (cache || isReleasable) {
           store._instanceCache.unloadRecord(identifier);
         }
       }
@@ -5468,87 +5606,25 @@ function freeze(obj) {
   }
   return obj;
 }
-/**
-  The store contains all of the data for records loaded from the server.
-  It is also responsible for creating instances of `Model` that wrap
-  the individual data for a record, so that they can be bound to in your
-  Handlebars templates.
-
-  Define your application's store like this:
-
-  ```app/services/store.js
-  import Store from '@ember-data/store';
-
-  export default class MyStore extends Store {}
-  ```
-
-  Most Ember.js applications will only have a single `Store` that is
-  automatically created by their `Ember.Application`.
-
-  You can retrieve models from the store in several ways. To retrieve a record
-  for a specific id, use `Store`'s `findRecord()` method:
-
-  ```javascript
-  store.findRecord('person', 123).then(function (person) {
-  });
-  ```
-
-  By default, the store will talk to your backend using a standard
-  REST mechanism. You can customize how the store talks to your
-  backend by specifying a custom adapter:
-
-  ```app/adapters/application.js
-  import Adapter from '@ember-data/adapter';
-
-  export default class ApplicationAdapter extends Adapter {
-  }
-  ```
-
-  You can learn more about writing a custom adapter by reading the `Adapter`
-  documentation.
-
-  ### Store createRecord() vs. push() vs. pushPayload()
-
-  The store provides multiple ways to create new record objects. They have
-  some subtle differences in their use which are detailed below:
-
-  [createRecord](../methods/createRecord?anchor=createRecord) is used for creating new
-  records on the client side. This will return a new record in the
-  `created.uncommitted` state. In order to persist this record to the
-  backend, you will need to call `record.save()`.
-
-  [push](../methods/push?anchor=push) is used to notify Ember Data's store of new or
-  updated records that exist in the backend. This will return a record
-  in the `loaded.saved` state. The primary use-case for `store#push` is
-  to notify Ember Data about record updates (full or partial) that happen
-  outside of the normal adapter methods (for example
-  [SSE](http://dev.w3.org/html5/eventsource/) or [Web
-  Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)).
-
-  [pushPayload](../methods/pushPayload?anchor=pushPayload) is a convenience wrapper for
-  `store#push` that will deserialize payloads if the
-  Serializer implements a `pushPayload` method.
-
-  Note: When creating a new record using any of the above methods
-  Ember Data will update `RecordArray`s such as those returned by
-  `store#peekAll()` or `store#findAll()`. This means any
-  data bindings or computed properties that depend on the RecordArray
-  will automatically be synced to include the new or updated record
-  values.
+class Store {
+  /**
+   * Provides access to the NotificationManager associated
+   * with this Store instance.
+   *
+   * The NotificationManager can be used to subscribe to
+   * changes to the cache.
+   *
+   * @property {NotificationManager} notifications
+   * @public
+   */
 
-  @main @ember-data/store
-  @class Store
-  @public
-  @extends Ember.Service
-*/
+  // DEBUG-only properties
 
-class Store {
   /**
     @method init
     @private
   */
   constructor(createArgs) {
-    this.__private_singleton_recordData = void 0;
     this.isDestroying = false;
     this.isDestroyed = false;
     Object.assign(this, createArgs);
@@ -5564,12 +5640,12 @@ class Store {
      * @public
      */
     this.identifierCache = new IdentifierCache();
+    this.notifications = new NotificationManager(this);
 
     // private but maybe useful to be here, somewhat intimate
     this.recordArrayManager = new RecordArrayManager({
       store: this
     });
-    this.notifications = new NotificationManager(this);
 
     // private
     this._fetchManager = new FetchManager(this);
@@ -5667,22 +5743,22 @@ class Store {
    * @method instantiateRecord (hook)
    * @param identifier
    * @param createRecordArgs
-   * @param recordDataFor
-   * @param notificationManager
+   * @param recordDataFor deprecated use this.cache
+   * @param notificationManager deprecated use this.notifications
    * @returns A record instance
    * @public
    */
-  instantiateRecord(identifier, createRecordArgs, recordDataFor, notificationManager) {
+  instantiateRecord(identifier, createRecordArgs) {
     if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
       let modelName = identifier.type;
-      let recordData = this._instanceCache.getRecordData(identifier);
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(identifier) : this.cache;
       // TODO deprecate allowing unknown args setting
       let createOptions = {
         _createProps: createRecordArgs,
         // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
         _secretInit: {
           identifier,
-          recordData,
+          cache,
           store: this,
           cb: secretInit
         }
@@ -5904,10 +5980,9 @@ class Store {
           assert(`The id ${properties.id} has already been used with another '${normalizedModelName}' record.`, !identifier);
         }
         const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
-        const recordData = this._instanceCache.getRecordData(identifier);
-        const createOptions = normalizeProperties(this, identifier, properties, recordData.managedVersion === '1');
-        const resultProps = recordData.clientDidCreate(identifier, createOptions);
-        this.recordArrayManager.identifierAdded(identifier);
+        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(identifier) : this.cache;
+        const createOptions = normalizeProperties(this, identifier, properties, cache.managedVersion === '1');
+        const resultProps = cache.clientDidCreate(identifier, createOptions);
         record = this._instanceCache.getRecord(identifier, resultProps);
       });
     });
@@ -5932,14 +6007,14 @@ class Store {
       assertDestroyingStore(this, 'deleteRecord');
     }
     const identifier = peekRecordIdentifier(record);
-    const recordData = identifier && this._instanceCache.peek({
+    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
       identifier,
-      bucket: 'recordData'
-    });
-    assert(`expected a recordData instance to exist for the record`, recordData);
+      bucket: 'resourceCache'
+    }) : this.cache);
+    assert(`expected a cache instance to exist for the record`, cache);
     this._join(() => {
-      recordData.setIsDeleted(identifier, true);
-      if (recordData.isNew(identifier)) {
+      cache.setIsDeleted(identifier, true);
+      if (cache.isNew(identifier)) {
         _backburner.join(() => {
           this._instanceCache.unloadRecord(identifier);
         });
@@ -7088,31 +7163,17 @@ class Store {
     }
     let ret;
     this._join(() => {
-      let included = jsonApiDoc.included;
-      let i, length;
-      if (included) {
-        for (i = 0, length = included.length; i < length; i++) {
-          this._instanceCache.loadData(included[i]);
-        }
-      }
-      if (Array.isArray(jsonApiDoc.data)) {
-        length = jsonApiDoc.data.length;
-        let identifiers = new Array(length);
-        for (i = 0; i < length; i++) {
-          identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
-        }
-        ret = identifiers;
-        return;
-      }
-      if (jsonApiDoc.data === null) {
-        ret = null;
-        return;
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
+        ret = legacyCachePut(this, {
+          data: jsonApiDoc
+        });
+      } else {
+        ret = this.cache.put({
+          data: jsonApiDoc
+        });
       }
-      assert(`Expected an object in the 'data' property in a call to 'push' for ${jsonApiDoc.type}, but was ${typeof jsonApiDoc.data}`, typeof jsonApiDoc.data === 'object');
-      ret = this._instanceCache.loadData(jsonApiDoc.data);
-      return;
     });
-    return ret;
+    return ret.data;
   }
 
   /**
@@ -7197,21 +7258,21 @@ class Store {
   saveRecord(record, options = {}) {
     assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
     let identifier = recordIdentifierFor(record);
-    let recordData = identifier && this._instanceCache.peek({
+    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
       identifier,
-      bucket: 'recordData'
-    });
-    if (!recordData) {
+      bucket: 'resourceCache'
+    }) : this.cache);
+    if (!cache) {
       // this commonly means we're disconnected
       // but just in case we reject here to prevent bad things.
       return reject(`Record Is Disconnected`);
     }
     // TODO we used to check if the record was destroyed here
-    assert(`Cannot initiate a save request for an unloaded record: ${identifier}`, recordData && this._instanceCache.recordIsLoaded(identifier));
-    if (recordDataIsFullyDeleted(this._instanceCache, identifier)) {
+    assert(`Cannot initiate a save request for an unloaded record: ${identifier}`, cache && this._instanceCache.recordIsLoaded(identifier));
+    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return resolve(record);
     }
-    recordData.willCommit(identifier);
+    cache.willCommit(identifier);
     if (isDSModel(record)) {
       record.errors.clear();
     }
@@ -7219,9 +7280,9 @@ class Store {
       options = {};
     }
     let operation = 'updateRecord';
-    if (recordData.isNew(identifier)) {
+    if (cache.isNew(identifier)) {
       operation = 'createRecord';
-    } else if (recordData.isDeleted(identifier)) {
+    } else if (cache.isDeleted(identifier)) {
       operation = 'deleteRecord';
     }
     const saveOptions = Object.assign({
@@ -7257,18 +7318,15 @@ class Store {
         if (!data) {
           assert(`Your ${identifier.type} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`, identifier.id);
         }
-        const cache = this.identifierCache;
+        const identifierCache = this.identifierCache;
         let actualIdentifier = identifier;
         if (operation !== 'deleteRecord' && data) {
-          actualIdentifier = cache.updateRecordIdentifier(identifier, data);
+          actualIdentifier = identifierCache.updateRecordIdentifier(identifier, data);
         }
 
         //We first make sure the primary data has been updated
-        const recordData = this._instanceCache.getRecordData(actualIdentifier);
-        recordData.didCommit(identifier, data);
-        if (operation === 'deleteRecord') {
-          this.recordArrayManager.identifierRemoved(actualIdentifier);
-        }
+        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(actualIdentifier) : this.cache;
+        cache.didCommit(identifier, data);
         if (payload && payload.included) {
           this._push({
             data: null,
@@ -7291,49 +7349,60 @@ class Store {
 
   /**
    * Instantiation hook allowing applications or addons to configure the store
-   * to utilize a custom RecordData implementation.
+   * to utilize a custom Cache implementation.
    *
-   * @method createRecordDataFor (hook)
+   * This hook should not be called directly by consuming applications or libraries.
+   * Use `Store.cache` to access the Cache instance.
+   *
+   * @method createCache (hook)
    * @public
-   * @param identifier
    * @param storeWrapper
+   * @returns {Cache}
    */
-  createRecordDataFor(identifier, storeWrapper) {
+  createCache(storeWrapper) {
     if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
-      // we can't greedily use require as this causes
-      // a cycle we can't easily fix (or clearly pin point) at present.
-      //
-      // it can be reproduced in partner tests by running
-      // node ./scripts/packages-for-commit.js && pnpm test-external:ember-observer
       if (_Cache === undefined) {
-        _Cache = importSync('@ember-data/json-api/-private').Cache;
+        _Cache = importSync('@ember-data/json-api').Cache;
       }
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-        if (arguments.length === 4) {
-          deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createRecordDataFor(<identifier>, <storeWrapper>)`, false, {
-            id: 'ember-data:deprecate-v1cache-store-apis',
-            for: 'ember-data',
-            until: '5.0',
-            since: {
-              enabled: '4.7',
-              available: '4.7'
-            }
-          });
-          identifier = this.identifierCache.getOrCreateRecordIdentifier({
-            type: arguments[0],
-            id: arguments[1],
-            lid: arguments[2]
-          });
-          storeWrapper = arguments[3];
-        }
+      return new _Cache(storeWrapper);
+    }
+    assert(`Expected store.createCache to be implemented but it wasn't`);
+  }
+
+  /**
+   * Returns the cache instance associated to this Store, instantiates the Cache
+   * if necessary via `Store.createCache`
+   *
+   * @property {Cache} cache
+   * @public
+   */
+  get cache() {
+    let {
+      cache
+    } = this._instanceCache;
+    if (!cache) {
+      cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
+      if (macroCondition(isDevelopingApp())) {
+        cache = new SingletonCacheManager(cache);
       }
-      this.__private_singleton_recordData = this.__private_singleton_recordData || new _Cache(storeWrapper);
-      this.__private_singleton_recordData.createCache(identifier);
-      return this.__private_singleton_recordData;
     }
-    assert(`Expected store.createRecordDataFor to be implemented but it wasn't`);
+    return cache;
   }
 
+  /**
+   * [DEPRECATED] use Store.createCache
+   *
+   * Instantiation hook allowing applications or addons to configure the store
+   * to utilize a custom RecordData implementation.
+   *
+   * @method createRecordDataFor (hook)
+   * @deprecated
+   * @public
+   * @param identifier
+   * @param storeWrapper
+   * @returns {Cache}
+   */
+
   /**
     `normalize` converts a json payload into the normalized form that
     [push](../methods/push?anchor=push) expects.
@@ -7548,9 +7617,9 @@ function adapterDidInvalidate(store, identifier, error) {
       error.errors = errorsHashToArray(errorsHash);
     }
   }
-  const recordData = store._instanceCache.getRecordData(identifier);
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(identifier) : store.cache;
   if (error.errors) {
-    assert(`Expected the RecordData implementation for ${identifier} to have a getErrors(identifier) method for retreiving errors.`, typeof recordData.getErrors === 'function');
+    assert(`Expected the RecordData implementation for ${identifier} to have a getErrors(identifier) method for retreiving errors.`, typeof cache.getErrors === 'function');
     let jsonApiErrors = error.errors;
     if (jsonApiErrors.length === 0) {
       jsonApiErrors = [{
@@ -7561,9 +7630,9 @@ function adapterDidInvalidate(store, identifier, error) {
         }
       }];
     }
-    recordData.commitWasRejected(identifier, jsonApiErrors);
+    cache.commitWasRejected(identifier, jsonApiErrors);
   } else {
-    recordData.commitWasRejected(identifier);
+    cache.commitWasRejected(identifier);
   }
 }
 function makeArray(value) {
@@ -7651,7 +7720,7 @@ function extractIdentifierFromRecord(recordOrPromiseRecord, isForV1 = false) {
   if (!recordOrPromiseRecord) {
     return null;
   }
-  const extract = isForV1 ? recordDataFor : recordIdentifierFor;
+  const extract = isForV1 ? peekCache : recordIdentifierFor;
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
     if (isPromiseRecord(recordOrPromiseRecord)) {
       let content = recordOrPromiseRecord.content;
@@ -7673,10 +7742,10 @@ function extractIdentifierFromRecord(recordOrPromiseRecord, isForV1 = false) {
 function isPromiseRecord(record) {
   return !!record.then;
 }
-function secretInit(record, recordData, identifier, store) {
+function secretInit(record, cache, identifier, store) {
   setRecordIdentifier(record, identifier);
   StoreMap.set(record, store);
-  setRecordDataFor(record, recordData);
+  setCacheFor(record, cache);
 }
 function normalizeModelName(modelName) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
@@ -7693,4 +7762,4 @@ function normalizeModelName(modelName) {
   }
   assert(`normalizeModelName support has been removed`);
 }
-export { Collection as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, Snapshot as a, setIdentifierGenerationMethod as b, setIdentifierUpdateMethod as c, setIdentifierForgetMethod as d, setIdentifierResetMethod as e, coerceId as f, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, SnapshotRecordArray as l, recordDataFor as m, normalizeModelName as n, removeRecordDataFor as o, recordIdentifierFor as r, storeFor as s };
+export { Collection as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, Snapshot as a, setIdentifierGenerationMethod as b, setIdentifierUpdateMethod as c, setIdentifierForgetMethod as d, setIdentifierResetMethod as e, coerceId as f, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, SnapshotRecordArray as l, removeRecordDataFor as m, normalizeModelName as n, peekCache as p, recordIdentifierFor as r, storeFor as s };