@ember-data/store 5.0.0-alpha.1 → 5.0.0-alpha.3

package/addon/{index-8b77b852.js → store-service-d7c03635.js}

@@ -1,40 +1,14 @@
-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 { assert, warn } from '@ember/debug';
 import { _backburner } from '@ember/runloop';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { tracked } from '@glimmer/tracking';
+import { dasherize } from '@ember/string';
 import { subscribe, addToTransaction, 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';
 import Ember from 'ember';
-import { reads } from '@ember/object/computed';
-import ArrayProxy from '@ember/array/proxy';
-import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-import ObjectProxy from '@ember/object/proxy';
-
-/**
-  @module @ember-data/store
-*/
-
-/**
- This method normalizes a modelName into the format Ember Data uses
- internally by dasherizing it.
-
-  @method normalizeModelName
-  @static
-  @public
-  @deprecated
-  @for @ember-data/store
-  @param {String} modelName
-  @return {String} normalizedModelName
-*/
-function normalizeModelName$1(modelName) {
-  return dasherize(modelName);
-}
 function _initializerDefineProperty(target, property, descriptor, context) {
   if (!descriptor) return;
   Object.defineProperty(target, property, {
@@ -77,25 +51,25 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   }
   return desc;
 }
-var _class$3, _descriptor$3, _descriptor2$1, _descriptor3, _descriptor4, _store$1, _request;
+var _class$2, _descriptor$2, _descriptor2$1, _descriptor3, _descriptor4, _store, _request;
 function urlFromLink(link) {
   if (typeof link === 'string') return link;
   return link.href;
 }
-let Document = (_class$3 = (_store$1 = /*#__PURE__*/_classPrivateFieldKey("store"), _request = /*#__PURE__*/_classPrivateFieldKey("request"), class Document {
+let Document = (_class$2 = (_store = /*#__PURE__*/_classPrivateFieldKey("store"), _request = /*#__PURE__*/_classPrivateFieldKey("request"), class Document {
   constructor(store, identifier) {
     Object.defineProperty(this, _request, {
       value: _request2
     });
-    _initializerDefineProperty(this, "links", _descriptor$3, this);
+    _initializerDefineProperty(this, "links", _descriptor$2, this);
     _initializerDefineProperty(this, "data", _descriptor2$1, this);
     _initializerDefineProperty(this, "errors", _descriptor3, this);
     _initializerDefineProperty(this, "meta", _descriptor4, this);
-    Object.defineProperty(this, _store$1, {
+    Object.defineProperty(this, _store, {
       writable: true,
       value: void 0
     });
-    _classPrivateFieldBase(this, _store$1)[_store$1] = store;
+    _classPrivateFieldBase(this, _store)[_store] = store;
     this.identifier = identifier;
   }
   fetch(options = {}) {
@@ -133,33 +107,33 @@ let Document = (_class$3 = (_store$1 = /*#__PURE__*/_classPrivateFieldKey("store
     }
     return data;
   }
-}), (_descriptor$3 = _applyDecoratedDescriptor(_class$3.prototype, "links", [tracked], {
+}), (_descriptor$2 = _applyDecoratedDescriptor(_class$2.prototype, "links", [tracked], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-}), _descriptor2$1 = _applyDecoratedDescriptor(_class$3.prototype, "data", [tracked], {
+}), _descriptor2$1 = _applyDecoratedDescriptor(_class$2.prototype, "data", [tracked], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-}), _descriptor3 = _applyDecoratedDescriptor(_class$3.prototype, "errors", [tracked], {
+}), _descriptor3 = _applyDecoratedDescriptor(_class$2.prototype, "errors", [tracked], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-}), _descriptor4 = _applyDecoratedDescriptor(_class$3.prototype, "meta", [tracked], {
+}), _descriptor4 = _applyDecoratedDescriptor(_class$2.prototype, "meta", [tracked], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-})), _class$3);
+})), _class$2);
 async function _request2(link, options = {}) {
   const href = this.links?.[link];
   if (!href) {
     return null;
   }
-  const response = await _classPrivateFieldBase(this, _store$1)[_store$1].request(Object.assign(options, {
+  const response = await _classPrivateFieldBase(this, _store)[_store].request(Object.assign(options, {
     url: urlFromLink(href)
   }));
   return response.content;
@@ -439,6 +413,9 @@ const DEBUG_IDENTIFIER_BUCKET = Symbol('identifier-bucket');
 function isNonEmptyString(str) {
   return str && typeof str === 'string';
 }
+function normalizeModelName(modelName) {
+  return dasherize(modelName);
+}
 
 /**
   @module @ember-data/store
@@ -536,7 +513,7 @@ function defaultGenerationMethod(data, bucket) {
       } = data;
       // TODO: add test for id not a string
       if (isNonEmptyString(coerceId(id))) {
-        return `@lid:${normalizeModelName$1(type)}-${id}`;
+        return `@lid:${normalizeModelName(type)}-${id}`;
       }
     }
     return uuidv4();
@@ -641,7 +618,7 @@ class IdentifierCache {
 
     // `type` must always be present
     assert('resource.type needs to be a string', 'type' in resource && isNonEmptyString(resource.type));
-    let type = resource.type && normalizeModelName$1(resource.type);
+    let type = resource.type && normalizeModelName(resource.type);
     let id = coerceId(resource.id);
     let keyOptions = getTypeIndex(this._cache.types, type);
 
@@ -857,7 +834,7 @@ class IdentifierCache {
     if (!existingIdentifier) {
       // If the incoming type does not match the identifier type, we need to create an identifier for the incoming
       // data so we can merge the incoming data with the existing identifier, see #7325 and #7363
-      if (data.type && identifier.type !== normalizeModelName$1(data.type)) {
+      if (data.type && identifier.type !== normalizeModelName(data.type)) {
         let incomingDataResource = {
           ...data
         };
@@ -1019,7 +996,7 @@ function performRecordIdentifierUpdate(identifier, data, updateFn) {
       lid
     } = data;
     let id = 'id' in data ? data.id : undefined;
-    let type = 'type' in data && data.type && normalizeModelName$1(data.type);
+    let type = 'type' in data && data.type && normalizeModelName(data.type);
 
     // get the mutable instance behind our proxy wrapper
     let wrapper = identifier;
@@ -1069,7 +1046,7 @@ function detectMerge(typesCache, identifier, data, newId, lids) {
     let existingIdentifier = keyOptions.id.get(newId);
     return existingIdentifier !== undefined ? existingIdentifier : false;
   } else {
-    let newType = data.type && normalizeModelName$1(data.type);
+    let newType = data.type && normalizeModelName(data.type);
 
     // If the ids and type are the same but lid is not the same, we should trigger a merge of the identifiers
     if (id !== null && id === newId && newType === type && data.lid && data.lid !== lid) {
@@ -1282,7 +1259,7 @@ class NotificationManager {
     Cache.clear();
   }
 }
-var _class$2, _descriptor$2;
+var _class$1, _descriptor$1;
 /**
   @module @ember-data/store
 */
@@ -1294,13 +1271,13 @@ var _class$2, _descriptor$2;
    @public
    @extends Reference
 */
-let RecordReference = (_class$2 = class RecordReference {
+let RecordReference = (_class$1 = class RecordReference {
   // unsubscribe token given to us by the notification manager
 
   constructor(store, identifier) {
     this.___token = void 0;
     this.___identifier = void 0;
-    _initializerDefineProperty(this, "_ref", _descriptor$2, this);
+    _initializerDefineProperty(this, "_ref", _descriptor$1, this);
     this.store = store;
     this.___identifier = identifier;
     this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
@@ -1468,2342 +1445,1114 @@ let RecordReference = (_class$2 = class RecordReference {
     }
     assert(`Unable to fetch record of type ${this.type} without an id`);
   }
-}, _descriptor$2 = _applyDecoratedDescriptor(_class$2.prototype, "_ref", [tracked], {
+}, _descriptor$1 = _applyDecoratedDescriptor(_class$1.prototype, "_ref", [tracked], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: function () {
     return 0;
   }
-}), _class$2);
-function legacyCachePut(store, doc) {
-  const jsonApiDoc = doc.content;
-  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;
-}
+}), _class$1);
 
 /**
- * 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
- * hook `instantiateRecord`, and the `recordDataFor`
- * method on the `CacheStoreWrapper`. It is not
- * directly instantiatable.
- *
- * It handles translating between cache versions when
- * necessary, for instance when a Store is configured
- * to use both a v1 and a v2 cache depending on some
- * heuristic.
- *
- * Starting with the v2 spec, the cache is designed such
- * that it must be implemented as a singleton. However,
- * because the v1 spec was not designed for this whenever
- * we encounter any v1 cache we must wrap all caches, even
- * singletons, in non-singleton managers to preserve v1
- * compatibility.
- *
- * To avoid this performance penalty being paid by all
- * applications, singleton behavior may be opted-in via
- * the configuration supplied to your Ember application
- * at build time. This effectively removes support for
- * v1 caches.
- *
- * ```js
- * let app = new EmberApp(defaults, {
- *   emberData: {
- *     useSingletonManager: true
- *   },
- * });
- * ```
- *
- * @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, _cache)[_cache].version || '1';
-  }
-  constructor(store, _cache2, identifier) {
-    Object.defineProperty(this, _isDeprecated, {
-      value: _isDeprecated2
-    });
-    this.version = '2';
-    Object.defineProperty(this, _store, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _cache, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _identifier, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldBase(this, _store)[_store] = store;
-    _classPrivateFieldBase(this, _cache)[_cache] = _cache2;
-    _classPrivateFieldBase(this, _identifier)[_identifier] = identifier;
-    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',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        },
-        for: 'ember-data'
-      });
-    }
+  @module @ember-data/store
+*/
+
+class CacheStoreWrapper {
+  constructor(_store) {
+    this._store = _store;
+    this._willNotify = false;
+    this._pendingNotifies = new Map();
   }
-  // Cache Management
-  // ================
-  /**
-   * 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 `content` 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);
+  get identifierCache() {
+    return this._store.identifierCache;
   }
-
-  /**
-   * Perform an operation on the cache to update the remote state.
-   *
-   * Note: currently the only valid operation is a MergeOperation
-   * which occurs when a collision of identifiers is detected.
-   *
-   * @method patch
-   * @public
-   * @param op the operation to perform
-   * @returns {void}
-   */
-  patch(op) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+  _scheduleNotification(identifier, key) {
+    let pending = this._pendingNotifies.get(identifier);
+    if (!pending) {
+      pending = new Set();
+      this._pendingNotifies.set(identifier, pending);
+    }
+    pending.add(key);
+    if (this._willNotify === true) {
       return;
     }
-    cache.patch(op);
-  }
-
-  /**
-   * Update resource data with a local mutation. Currently supports operations
-   * on relationships only.
-   *
-   * @method mutate
-   * @public
-   * @param mutation
-   */
-  // isResource is only needed for interop with v1 cache
-  mutate(mutation, isResource) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      const instanceCache = _classPrivateFieldBase(this, _store)[_store]._instanceCache;
-      switch (mutation.op) {
-        case 'addToRelatedRecords':
-          cache.addToHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)), mutation.index);
-          return;
-        case 'removeFromRelatedRecords':
-          cache.removeFromHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)));
-          return;
-        case 'replaceRelatedRecords':
-          cache.setDirtyHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)));
-          return;
-        case 'replaceRelatedRecord':
-          if (isResource) {
-            cache.setDirtyBelongsTo(mutation.field, mutation.value ? instanceCache.getResourceCache(mutation.value) : null);
-            return;
-          }
-          cache.removeFromHasMany(mutation.field, [instanceCache.getResourceCache(mutation.prior)]);
-          cache.addToHasMany(mutation.field, [instanceCache.getResourceCache(mutation.value)], mutation.index);
-          return;
-        case 'sortRelatedRecords':
-          return;
-        default:
-          return;
-      }
+    this._willNotify = true;
+    // it's possible a cache adhoc notifies us,
+    // in which case we sync flush
+    if (this._store._cbs) {
+      this._store._schedule('notify', () => this._flushNotifications());
     } else {
-      cache.mutate(mutation);
+      this._flushNotifications();
     }
   }
-
-  /**
-   * Peek resource data from the Cache.
-   *
-   * In development, if the return value
-   * is JSON the return value
-   * will be deep-cloned and deep-frozen
-   * to prevent mutation thereby enforcing cache
-   * Immutability.
-   *
-   * This form of peek is useful for implementations
-   * that want to feed raw-data from cache to the UI
-   * or which want to interact with a blob of data
-   * directly from the presentation cache.
-   *
-   * An implementation might want to do this because
-   * de-referencing records which read from their own
-   * blob is generally safer because the record does
-   * not require retainining connections to the Store
-   * and Cache to present data on a per-field basis.
-   *
-   * This generally takes the place of `getAttr` as
-   * an API and may even take the place of `getRelationship`
-   * depending on implementation specifics, though this
-   * latter usage is less recommended due to the advantages
-   * of the Graph handling necessary entanglements and
-   * notifications for relational data.
-   *
-   * @method peek
-   * @public
-   * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-   * @returns {ResourceDocument | ResourceBlob | null} the known resource data
-   */
-
-  peek(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement peek`);
+  _flushNotifications() {
+    if (this._willNotify === false) {
+      return;
     }
-    return cache.peek(identifier);
+    let pending = this._pendingNotifies;
+    this._pendingNotifies = new Map();
+    this._willNotify = false;
+    pending.forEach((set, identifier) => {
+      set.forEach(key => {
+        this._store.notifications.notify(identifier, 'relationships', key);
+      });
+    });
   }
+  notifyChange(identifier, namespace, key) {
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
 
-  /**
-   * Peek the Cache for the existing request data associated with
-   * a cacheable request
-   *
-   * @method peekRequest
-   * @param {StableDocumentIdentifier}
-   * @returns {StableDocumentIdentifier | null}
-   * @public
-   */
-  peekRequest(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement peekRequest`);
+    // TODO do we still get value from this?
+    if (namespace === 'relationships' && key) {
+      this._scheduleNotification(identifier, key);
+      return;
     }
-    return cache.peekRequest(identifier);
-  }
 
-  /**
-   * 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
-   */
-  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](cache)) {
-      return cache.pushData(data, hasRecord);
-    }
-    return cache.upsert(identifier, data, hasRecord);
+    // @ts-expect-error
+    this._store.notifications.notify(identifier, namespace, key);
+  }
+  getSchemaDefinitionService() {
+    return this._store.getSchemaDefinitionService();
+  }
+  setRecordId(identifier, id) {
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    this._store._instanceCache.setRecordId(identifier, id);
+  }
+  hasRecord(identifier) {
+    return Boolean(this._store._instanceCache.peek(identifier));
+  }
+  disconnectRecord(identifier) {
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    this._store._instanceCache.disconnect(identifier);
+    this._pendingNotifies.delete(identifier);
   }
+}
+let _peekGraph;
+if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
+  let __peekGraph;
+  _peekGraph = wrapper => {
+    let a = importSync('@ember-data/graph/-private').peekGraph;
+    __peekGraph = __peekGraph || a;
+    return __peekGraph(wrapper);
+  };
+}
 
-  // Cache Forking Support
-  // =====================
+/**
+  @module @ember-data/store
+*/
 
-  /**
-   * Create a fork of the cache from the current state.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to fork at the Store level, which will
-   * utilize this method to fork the cache.
-   *
-   * @method fork
-   * @public
-   * @returns Promise<Cache>
-   */
-  fork() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement fork`);
-    }
-    return cache.fork();
-  }
+const RecordCache = new Map();
+function peekRecordIdentifier(record) {
+  return RecordCache.get(record);
+}
 
-  /**
-   * Merge a fork back into a parent Cache.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to merge at the Store level, which will
-   * utilize this method to merge the caches.
-   *
-   * @method merge
-   * @param {Cache} cache
-   * @public
-   * @returns Promise<void>
-   */
-  merge(updates) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement merge`);
+/**
+  Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
+  assigned to the given record instance.
+  ```js
+  import { recordIdentifierFor } from "@ember-data/store";
+  // ... gain access to a record, for instance with peekRecord or findRecord
+  const record = store.peekRecord("user", "1");
+  // get the identifier for the record (see docs for StableRecordIdentifier)
+  const identifier = recordIdentifierFor(record);
+  // access the identifier's properties.
+  const { id, type, lid } = identifier;
+  ```
+  @method recordIdentifierFor
+  @public
+  @static
+  @for @ember-data/store
+  @param {Object} record a record instance previously obstained from the store.
+  @returns {StableRecordIdentifier}
+ */
+function recordIdentifierFor(record) {
+  assert(`${String(record)} is not a record instantiated by @ember-data/store`, RecordCache.has(record));
+  return RecordCache.get(record);
+}
+function setRecordIdentifier(record, identifier) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (RecordCache.has(record) && RecordCache.get(record) !== identifier) {
+      throw new Error(`${String(record)} was already assigned an identifier`);
     }
-    return cache.merge(updates);
   }
 
-  /**
-   * Generate the list of changes applied to all
-   * record in the store.
-   *
-   * Each individual resource or document that has
-   * been mutated should be described as an individual
-   * `Change` entry in the returned array.
-   *
-   * A `Change` is described by an object containing up to
-   * three properties: (1) the `identifier` of the entity that
-   * changed; (2) the `op` code of that change being one of
-   * `upsert` or `remove`, and if the op is `upsert` a `patch`
-   * containing the data to merge into the cache for the given
-   * entity.
-   *
-   * This `patch` is opaque to the Store but should be understood
-   * by the Cache and may expect to be utilized by an Adapter
-   * when generating data during a `save` operation.
-   *
-   * It is generally recommended that the `patch` contain only
-   * the updated state, ignoring fields that are unchanged
-   *
-   * ```ts
-   * interface Change {
-   *  identifier: StableRecordIdentifier | StableDocumentIdentifier;
-   *  op: 'upsert' | 'remove';
-   *  patch?: unknown;
-   * }
-   * ```
-   *
-   * @method diff
-   * @public
-   */
-  diff() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement diff`);
-    }
-    return cache.diff();
-  }
+  /*
+  It would be nice to do a reverse check here that an identifier has not
+  previously been assigned a record; however, unload + rematerialization
+  prevents us from having a great way of doing so when CustomRecordClasses
+  don't necessarily give us access to a `isDestroyed` for dematerialized
+  instance.
+  */
 
-  // SSR Support
-  // ===========
+  RecordCache.set(record, identifier);
+}
+const StoreMap = new Map();
+function storeFor(record) {
+  const store = StoreMap.get(record);
+  assert(`A record in a disconnected state cannot utilize the store. This typically means the record has been destroyed, most commonly by unloading it.`, store);
+  return store;
+}
+class InstanceCache {
+  constructor(store) {
+    this.__instances = {
+      record: new Map(),
+      reference: new WeakMap()
+    };
+    this.store = store;
+    this._storeWrapper = new CacheStoreWrapper(this.store);
+    store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
+      let keptIdentifier = identifier;
+      if (identifier.id !== matchedIdentifier.id) {
+        keptIdentifier = 'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;
+      } else if (identifier.type !== matchedIdentifier.type) {
+        keptIdentifier = 'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
+      }
+      let staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
 
-  /**
-   * Serialize the entire contents of the Cache into a Stream
-   * which may be fed back into a new instance of the same Cache
-   * via `cache.hydrate`.
-   *
-   * @method dump
-   * @returns {Promise<ReadableStream>}
-   * @public
-   */
-  dump() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement dump`);
-    }
-    return cache.dump();
-  }
+      // check for duplicate entities
+      let keptHasRecord = this.__instances.record.has(keptIdentifier);
+      let staleHasRecord = this.__instances.record.has(staleIdentifier);
 
-  /**
-   * hydrate a Cache from a Stream with content previously serialized
-   * from another instance of the same Cache, resolving when hydration
-   * is complete.
-   *
-   * This method should expect to be called both in the context of restoring
-   * the Cache during application rehydration after SSR **AND** at unknown
-   * times during the lifetime of an already booted application when it is
-   * desired to bulk-load additional information into the cache. This latter
-   * behavior supports optimizing pre/fetching of data for route transitions
-   * via data-only SSR modes.
-   *
-   * @method hydrate
-   * @param {ReadableStream} stream
-   * @returns {Promise<void>}
-   * @public
-   */
-  hydrate(stream) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      throw new Error(`Expected cache to implement hydrate`);
-    }
-    return cache.hydrate(stream);
-  }
+      // we cannot merge entities when both have records
+      // (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
+        // record points at so long as
+        // it itself is not retained by the store in any way.
+        if ('id' in resourceData) {
+          throw new Error(`Failed to update the 'id' for the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to '${String(resourceData.id)}', because that id is already in use by '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`);
+        }
+        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)})'`);
+      }
+      this.store.cache.patch({
+        op: 'mergeIdentifiers',
+        record: staleIdentifier,
+        value: keptIdentifier
+      });
 
-  // Cache
-  // =====
+      /*
+      TODO @runspired consider adding this to make polymorphism even nicer
+      if (HAS_GRAPH_PACKAGE) {
+      if (identifier.type !== matchedIdentifier.type) {
+        const graphFor = importSync('@ember-data/graph/-private').graphFor;
+        graphFor(this).registerPolymorphicType(identifier.type, matchedIdentifier.type);
+      }
+      }
+      */
 
-  /**
-   * Retrieve the identifier for this v1 cache
-   *
-   * DEPRECATED Caches should not be assumed to be 1:1 with resources
-   *
-   * @method getResourceIdentifier
-   * @public
-   * @deprecated
-   */
-  getResourceIdentifier() {
-    return _classPrivateFieldBase(this, _identifier)[_identifier];
+      this.unloadRecord(staleIdentifier);
+      return keptIdentifier;
+    });
   }
-
-  /**
-   * 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);
+  peek(identifier) {
+    return this.__instances.record.get(identifier);
   }
-
-  // Resource Support
-  // ================
-
-  /**
-   * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
-   *
-   * It returns properties from options that should be set on the record during the create
-   * process. This return value behavior is deprecated.
-   *
-   * @method clientDidCreate
-   * @public
-   * @param identifier
-   * @param options
-   */
-  clientDidCreate(identifier, options) {
-    // called by something V1
-    if (!isStableIdentifier(identifier)) {
-      options = identifier;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    }
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-
-    // TODO deprecate return value
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      cache.clientDidCreate();
-      // if a V2 is calling a V1 we need to call both methods
-      return cache._initRecordCreateOptions(options);
-    } else {
-      return cache.clientDidCreate(identifier, options);
+  getRecord(identifier, properties) {
+    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 cache = this.store.cache;
+      setCacheFor(identifier, cache);
+      record = this.store.instantiateRecord(identifier, properties || {});
+      setRecordIdentifier(record, identifier);
+      setCacheFor(record, cache);
+      StoreMap.set(record, this.store);
+      this.__instances.record.set(identifier, record);
+      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+        // eslint-disable-next-line no-console
+        console.log(`InstanceCache: created Record for ${String(identifier)}`, properties);
+      }
     }
+    return record;
   }
-
-  /**
-   * Pass options to the cache that were supplied to a new record
-   * instantiated on the client.
-   *
-   * DEPRECATED: options are now passed via `clientDidCreate`
-   *
-   * @method clientDidCreate
-   * @public
-   * @deprecated
-   * @param options
-   */
-  _initRecordCreateOptions(options) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      return cache._initRecordCreateOptions(options);
+  getReference(identifier) {
+    let cache = this.__instances.reference;
+    let reference = cache.get(identifier);
+    if (!reference) {
+      reference = new RecordReference(this.store, identifier);
+      cache.set(identifier, reference);
     }
+    return reference;
   }
+  recordIsLoaded(identifier, filterDeleted = false) {
+    const cache = this.cache;
+    if (!cache) {
+      return false;
+    }
+    const isNew = cache.isNew(identifier);
+    const isEmpty = cache.isEmpty(identifier);
 
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * will be part of a save transaction.
-   *
-   * @method willCommit
-   * @public
-   * @param identifier
-   */
-  willCommit(identifier) {
-    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was successfully updated as part of a save transaction.
-   *
-   * @method didCommit
-   * @public
-   * @param identifier
-   * @param data
-   */
-  didCommit(identifier, data) {
-    // called by something V1
-    if (!isStableIdentifier(identifier)) {
-      data = identifier;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
+    // if we are new we must consider ourselves loaded
+    if (isNew) {
+      return !cache.isDeleted(identifier);
     }
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.didCommit(data) : cache.didCommit(identifier, data);
-  }
+    // even if we have a past request, if we are now empty we are not loaded
+    // typically this is true after an unloadRecord call
 
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was update via a save transaction failed.
-   *
-   * @method commitWasRejected
-   * @public
-   * @param identifier
-   * @param errors
-   */
-  commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _cache)[_cache].commitWasRejected(identifier || _classPrivateFieldBase(this, _identifier)[_identifier], errors);
+    // if we are not empty, not new && we have a fulfilled request then we are loaded
+    // 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 && cache.isDeletionCommitted(identifier) ? false : !isEmpty;
   }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that all data for a resource
-   * should be cleared.
-   *
-   * @method unloadRecord
-   * @public
-   * @param identifier
-   */
-  unloadRecord(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      cache.unloadRecord();
-    } else {
-      cache.unloadRecord(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+  disconnect(identifier) {
+    const record = this.__instances.record.get(identifier);
+    assert('Cannot destroy record while it is still materialized', !record || record.isDestroyed || record.isDestroying);
+    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
+      let graph = _peekGraph(this.store);
+      if (graph) {
+        graph.remove(identifier);
+      }
+    }
+    this.store.identifierCache.forgetRecordIdentifier(identifier);
+    removeRecordDataFor(identifier);
+    this.store._requestCache._clearEntries(identifier);
+    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      // eslint-disable-next-line no-console
+      console.log(`InstanceCache: disconnected ${String(identifier)}`);
     }
   }
+  unloadRecord(identifier) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      const requests = this.store.getRequestStateService().getPendingRequestsForRecord(identifier);
+      if (requests.some(req => {
+        return req.type === 'mutation';
+      })) {
+        assert(`You can only unload a record which is not inFlight. '${String(identifier)}'`);
+      }
+    }
+    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      // eslint-disable-next-line no-console
+      console.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
+    }
 
-  // Granular Resource Data APIs
-  // ===========================
-
-  /**
-   * Retrieve the data for an attribute from the cache
-   *
-   * @method getAttr
-   * @public
-   * @param identifier
-   * @param propertyName
-   * @returns {unknown}
-   */
-  getAttr(identifier, propertyName) {
-    // called by something V1
-    if (!isStableIdentifier(identifier)) {
-      propertyName = identifier;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
+    // TODO is this join still necessary?
+    this.store._join(() => {
+      const record = this.__instances.record.get(identifier);
+      const cache = this.cache;
+      if (record) {
+        this.store.teardownRecord(record);
+        this.__instances.record.delete(identifier);
+        StoreMap.delete(record);
+        RecordCache.delete(record);
+        removeRecordDataFor(record);
+        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+          // eslint-disable-next-line no-console
+          console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
+        }
+      }
+      if (cache) {
+        cache.unloadRecord(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 {
+        this.disconnect(identifier);
+      }
+      this.store._requestCache._clearEntries(identifier);
+      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+        // eslint-disable-next-line no-console
+        console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
+        // eslint-disable-next-line no-console
+        console.groupEnd();
+      }
+    });
+  }
+  clear(type) {
+    const cache = this.store.identifierCache._cache;
+    if (type === undefined) {
+      // 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;
+      if (identifiers) {
+        identifiers.forEach(identifier => {
+          // if (rds.has(identifier)) {
+          this.unloadRecord(identifier);
+          // }
+          // TODO we don't remove the identifier, should we?
+        });
+      }
     }
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.getAttr(propertyName) : cache.getAttr(identifier, propertyName);
   }
 
-  /**
-   * Mutate the data for an attribute in the cache
-   *
-   * @method setAttr
-   * @public
-   * @param identifier
-   * @param propertyName
-   * @param value
-   */
-  setAttr(identifier, propertyName, value) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyAttribute(propertyName, value) : cache.setAttr(identifier, propertyName, value);
-  }
+  // TODO this should move into something coordinating operations
+  setRecordId(identifier, id) {
+    const {
+      type,
+      lid
+    } = identifier;
+    let oldId = identifier.id;
 
-  /**
-   * Mutate the data for an attribute in the cache
-   *
-   * DEPRECATED use setAttr
-   *
-   * @method setDirtyAttribute
-   * @public
-   * @deprecated
-   * @param identifier
-   * @param propertyName
-   * @param value
-   */
-  setDirtyAttribute(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);
-  }
+    // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)
+    assert(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`, !(id === null && oldId === null));
 
-  /**
-   * Query the cache for the changed attributes of a resource.
-   *
-   * DEPRECATED use changedAttrs
-   *
-   * @method changedAttributes
-   * @public
-   * @deprecated
-   * @param identifier
-   * @returns
-   */
-  changedAttributes() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      return cache.changedAttributes();
-    }
-    return cache.changedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
-  }
+    // ID absolutely can't be different than oldID if oldID is not null
+    // TODO this assertion and restriction may not strictly be needed in the identifiers world
+    assert(`Cannot update the id for '${type}:${lid}' from '${String(oldId)}' to '${id}'.`, !(oldId !== null && id !== oldId));
 
-  /**
-   * Query the cache for the changed attributes of a resource.
-   *
-   * @method changedAttrs
-   * @public
-   * @deprecated
-   * @param identifier
-   * @returns
-   */
-  changedAttrs(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      return cache.changedAttributes();
+    // ID can be null if oldID is not null (altered ID in response for a record)
+    // however, this is more than likely a developer error.
+    if (oldId !== null && id === null) {
+      warn(`Your ${type} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null));
+      return;
+    }
+    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      // eslint-disable-next-line no-console
+      console.log(`InstanceCache: updating id to '${id}' for record ${String(identifier)}`);
+    }
+    let existingIdentifier = this.store.identifierCache.peekRecordIdentifier({
+      type,
+      id
+    });
+    assert(`'${type}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`, !existingIdentifier || existingIdentifier === identifier);
+    if (identifier.id === null) {
+      // TODO potentially this needs to handle merged result
+      this.store.identifierCache.updateRecordIdentifier(identifier, {
+        type,
+        id
+      });
     }
-    return cache.changedAttrs(identifier);
-  }
-
-  /**
-   * Query the cache for whether any mutated attributes exist
-   *
-   * DEPRECATED use hasChangedAttrs
-   *
-   * @method hasChangedAttributes
-   * @public
-   * @deprecated
-   * @returns {boolean}
-   */
-  hasChangedAttributes() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
-  }
 
-  /**
-   * Query the cache for whether any mutated attributes exist
-   *
-   * @method hasChangedAttrs
-   * @public
-   * @param identifier
-   * @returns {boolean}
-   */
-  hasChangedAttrs(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(identifier);
+    // TODO update resource cache if needed ?
+    // TODO handle consequences of identifier merge for notifications
+    this.store.notifications.notify(identifier, 'identity');
   }
+}
+function _resourceIsFullDeleted(identifier, cache) {
+  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
+}
+function resourceIsFullyDeleted(instanceCache, identifier) {
+  const cache = instanceCache.cache;
+  return !cache || _resourceIsFullDeleted(identifier, cache);
+}
 
-  /**
-   * Tell the cache to discard any uncommitted mutations to attributes
-   *
-   * DEPRECATED use rollbackAttrs
-   *
-   * @method rollbackAttributes
-   * @public
-   * @deprecated
-   * @returns
-   */
-  rollbackAttributes() {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
-  }
-
-  /**
-   * Tell the cache to discard any uncommitted mutations to attributes
-   *
-   * @method rollbackAttrs
-   * @public
-   * @param identifier
-   * @returns the names of attributes that were restored
-   */
-  rollbackAttrs(identifier) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(identifier);
-  }
+/*
+    When a find request is triggered on the store, the user can optionally pass in
+    attributes and relationships to be preloaded. These are meant to behave as if they
+    came back from the server, except the user obtained them out of band and is informing
+    the store of their existence. The most common use case is for supporting client side
+    nested URLs, such as `/posts/1/comments/2` so the user can do
+    `store.findRecord('comment', 2, { preload: { post: 1 } })` without having to fetch the post.
 
-  // Relationships
-  // =============
+    Preloaded data can be attributes and relationships passed in either as IDs or as actual
+    models.
+  */
 
-  // the third arg here is "private". In a world with only V2 it is not necessary
-  // but in one in which we must convert a call from V2 -> V1 it is required to do this
-  // or else to do nasty schema lookup things
-  // @runspired has implemented this concept in relationships spikes and is confident
-  // we do not need any signal about whether a relationship is a collection or not at this
-  // boundary
-  /**
-   * Query the cache for the current state of a relationship property
-   *
-   * @method getRelationship
-   * @public
-   * @param identifier
-   * @param propertyName
-   * @returns resource relationship object
-   */
-  getRelationship(identifier, propertyName, isCollection = false) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
-      let isBelongsTo = !isCollection;
-      return isBelongsTo ? cache.getBelongsTo(propertyName) : cache.getHasMany(propertyName);
+function preloadData(store, identifier, preload) {
+  let jsonPayload = {};
+  //TODO(Igor) consider the polymorphic case
+  const schemas = store.getSchemaDefinitionService();
+  const relationships = schemas.relationshipsDefinitionFor(identifier);
+  Object.keys(preload).forEach(key => {
+    let preloadValue = preload[key];
+    let relationshipMeta = relationships[key];
+    if (relationshipMeta) {
+      if (!jsonPayload.relationships) {
+        jsonPayload.relationships = {};
+      }
+      jsonPayload.relationships[key] = preloadRelationship(relationshipMeta, preloadValue);
+    } else {
+      if (!jsonPayload.attributes) {
+        jsonPayload.attributes = {};
+      }
+      jsonPayload.attributes[key] = preloadValue;
     }
-    return cache.getRelationship(identifier, propertyName);
+  });
+  const cache = store.cache;
+  const hasRecord = Boolean(store._instanceCache.peek(identifier));
+  cache.upsert(identifier, jsonPayload, hasRecord);
+}
+function preloadRelationship(schema, preloadValue) {
+  const relatedType = schema.type;
+  if (schema.kind === 'hasMany') {
+    assert('You need to pass in an array to set a hasMany property on a record', Array.isArray(preloadValue));
+    return {
+      data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
+    };
   }
+  assert('You should not pass in an array to set a belongsTo property on a record', !Array.isArray(preloadValue));
+  return {
+    data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
+  };
+}
 
-  /**
-   * Query the cache for the current state of a belongsTo field
-   *
-   * DEPRECATED use `getRelationship`
-   *
-   * @method getBelongsTo
-   * @public
-   * @deprecated
-   * @param propertyName
-   * @returns single resource relationship object
-   */
-  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 cache.getRelationship(identifier, propertyName);
+/*
+  findRecord('user', '1', { preload: { friends: ['1'] }});
+  findRecord('user', '1', { preload: { friends: [record] }});
+*/
+function _convertPreloadRelationshipToJSON(value, type) {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return {
+      type,
+      id: value
+    };
+  }
+  // TODO if not a record instance assert it's an identifier
+  // and allow identifiers to be used
+  return recordIdentifierFor(value);
+}
+function _clearCaches() {
+  RecordCache.clear();
+  StoreMap.clear();
+  CacheForIdentifierCache.clear();
+}
+let _modelForMixin;
+if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
+  let _found;
+  _modelForMixin = function () {
+    if (!_found) {
+      _found = importSync('@ember-data/model/-private')._modelForMixin;
     }
+    return _found(...arguments);
+  };
+}
+class DSModelSchemaDefinitionService {
+  constructor(store) {
+    this.store = store;
+    this._relationshipsDefCache = Object.create(null);
+    this._attributesDefCache = Object.create(null);
   }
 
-  /**
-   * Query the cache for the current state of a hasMany field
-   *
-   * DEPRECATED use `getRelationship`
-   *
-   * @method getHasMany
-   * @public
-   * @deprecated
-   * @param propertyName
-   * @returns single resource relationship object
-   */
-  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 cache.getRelationship(identifier, propertyName);
+  // Following the existing RD implementation
+  attributesDefinitionFor(identifier) {
+    let modelName, attributes;
+    modelName = identifier.type;
+    attributes = this._attributesDefCache[modelName];
+    if (attributes === undefined) {
+      let modelClass = this.store.modelFor(modelName);
+      let attributeMap = modelClass.attributes;
+      attributes = Object.create(null);
+      attributeMap.forEach((meta, name) => attributes[name] = meta);
+      this._attributesDefCache[modelName] = attributes;
     }
+    return attributes;
   }
 
-  /**
-   * Mutate the current state of a belongsTo relationship
-   *
-   * DEPRECATED use update
-   *
-   * @method setDirtyBelongsTo
-   * @public
-   * @deprecated
-   * @param propertyName
-   * @param value
-   */
-  setDirtyBelongsTo(propertyName, value) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyBelongsTo(propertyName, value) : cache.mutate({
-      op: 'replaceRelatedRecord',
-      record: _classPrivateFieldBase(this, _identifier)[_identifier],
-      field: propertyName,
-      value: value ? value.getResourceIdentifier() : null
-    });
+  // Following the existing RD implementation
+  relationshipsDefinitionFor(identifier) {
+    let modelName, relationships;
+    modelName = identifier.type;
+    relationships = this._relationshipsDefCache[modelName];
+    if (relationships === undefined) {
+      let modelClass = this.store.modelFor(modelName);
+      relationships = modelClass.relationshipsObject || null;
+      this._relationshipsDefCache[modelName] = relationships;
+    }
+    return relationships;
   }
-
-  /**
-   * Mutate the current state of a hasMany relationship by adding values
-   * An index may optionally be specified which the cache should use for
-   * where in the list to insert the records
-   *
-   * DEPRECATED use update
-   *
-   * @method addToHasMany
-   * @deprecated
-   * @public
-   * @param propertyName
-   * @param value
-   * @param idx
-   */
-  addToHasMany(propertyName, value, idx) {
-    const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.addToHasMany(propertyName, value, idx) : cache.mutate({
-      op: 'addToRelatedRecords',
-      field: propertyName,
-      record: identifier,
-      value: value.map(v => v.getResourceIdentifier())
-    });
+  doesTypeExist(modelName) {
+    let normalizedModelName = normalizeModelName(modelName);
+    let factory = getModelFactory(this.store, this.store._modelFactoryCache, normalizedModelName);
+    return factory !== null;
   }
-
-  /**
-   * Mutate the current state of a hasMany relationship by removing values.
-   *
-   * DEPRECATED use update
-   *
-   * @method removeFromHasMany
-   * @deprecated
-   * @public
-   * @param propertyName
-   * @param value
-   */
-  removeFromHasMany(propertyName, value) {
-    const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.removeFromHasMany(propertyName, value) : cache.mutate({
-      op: 'removeFromRelatedRecords',
-      record: identifier,
-      field: propertyName,
-      value: value.map(v => v.getResourceIdentifier())
-    });
+}
+function getModelFactory(store, cache, normalizedModelName) {
+  let factory = cache[normalizedModelName];
+  if (!factory) {
+    let owner = getOwner(store);
+    factory = owner.factoryFor(`model:${normalizedModelName}`);
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
+      if (!factory) {
+        //Support looking up mixins as base types for polymorphic relationships
+        factory = _modelForMixin(store, normalizedModelName);
+      }
+    }
+    if (!factory) {
+      // we don't cache misses in case someone wants to register a missing model
+      return null;
+    }
+    let klass = factory.class;
+    if (klass.isModel) {
+      let hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');
+      if (!hasOwnModelNameSet) {
+        Object.defineProperty(klass, 'modelName', {
+          value: normalizedModelName
+        });
+      }
+    }
+    cache[normalizedModelName] = factory;
   }
+  return factory;
+}
 
-  /**
-   * Mutate the current state of a hasMany relationship by replacing it entirely
-   *
-   * DEPRECATED use `setHasMany`
-   *
-   * @method setDirtyHasMany
-   * @public
-   * @deprecated
-   * @param propertyName
-   * @param value
-   */
-  setDirtyHasMany(propertyName, value) {
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyHasMany(propertyName, value) : cache.mutate({
-      op: 'replaceRelatedRecords',
-      record: _classPrivateFieldBase(this, _identifier)[_identifier],
-      field: propertyName,
-      value: value.map(rd => rd.getResourceIdentifier())
-    });
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap();
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
   }
-
-  // Resource State
-  // ===============
-
-  /**
-   * Update the cache state for the given resource to be marked as locally deleted,
-   * or remove such a mark.
-   *
-   * @method setIsDeleted
-   * @public
-   * @param identifier
-   * @param isDeleted
-   */
-  setIsDeleted(identifier, isDeleted) {
-    if (!isStableIdentifier(identifier)) {
-      isDeleted = identifier;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+function mapFromHash(hash) {
+  let map = new Map();
+  for (let i in hash) {
+    if (Object.prototype.hasOwnProperty.call(hash, i)) {
+      map.set(i, hash[i]);
     }
-    const cache = _classPrivateFieldBase(this, _cache)[_cache];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setIsDeleted(isDeleted) : cache.setIsDeleted(identifier, isDeleted);
   }
+  return map;
+}
 
-  /**
-   * Query the cache for any validation errors applicable to the given resource.
-   *
-   * @method getErrors
-   * @public
-   * @param identifier
-   * @returns
-   */
-  getErrors(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+// Mimics the static apis of DSModel
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+      type: this.modelName
+    });
+    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type: this.modelName
+    });
+    let fields = new Map();
+    Object.keys(attrs).forEach(key => fields.set(key, 'attribute'));
+    Object.keys(relationships).forEach(key => fields.set(key, relationships[key].kind));
+    return fields;
+  }
+  get attributes() {
+    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+      type: this.modelName
+    });
+    return mapFromHash(attrs);
+  }
+  get relationshipsByName() {
+    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type: this.modelName
+    });
+    return mapFromHash(relationships);
+  }
+  eachAttribute(callback, binding) {
+    let attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+      type: this.modelName
+    });
+    Object.keys(attrDefs).forEach(key => {
+      callback.call(binding, key, attrDefs[key]);
+    });
+  }
+  eachRelationship(callback, binding) {
+    let relationshipDefs = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type: this.modelName
+    });
+    Object.keys(relationshipDefs).forEach(key => {
+      callback.call(binding, key, relationshipDefs[key]);
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+      type: this.modelName
+    });
+    Object.keys(attrDefs).forEach(key => {
+      if (attrDefs[key].type) {
+        callback.call(binding, key, attrDefs[key].type);
+      }
+    });
+  }
+}
+var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
+/**
+ * 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`.
+ *
+ * It handles translating between cache versions when
+ * necessary, for instance when a Store is configured
+ * to use both a v1 and a v2 cache depending on some
+ * heuristic.
+ *
+ * Starting with the v2 spec, the cache is designed such
+ * that it must be implemented as a singleton.
+ *
+ * @class CacheManager
+ * @public
+ */
+class CacheManager {
+  constructor(cache) {
+    this.version = '2';
+    Object.defineProperty(this, _cache, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * Query the cache for whether a given resource has been deleted and that deletion
+     * has also been persisted.
+     *
+     * @method isDeletionCommitted
+     * @public
+     * @param identifier
+     * @returns {boolean}
+     */
+    this.isDel = void 0;
+    _classPrivateFieldBase(this, _cache)[_cache] = cache;
   }
 
+  // Cache Management
+  // ================
+
   /**
-   * Query the cache for whether a given resource has any available data
+   * Cache the response to a request
    *
-   * @method isEmpty
+   * 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 `content` member and therefor must not assume the existence
+   * of `request` and `response` on the document.
+   *
+   * @method put
+   * @param {StructuredDocument} doc
+   * @returns {ResourceDocument}
    * @public
-   * @param identifier
-   * @returns {boolean}
    */
-  isEmpty(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]);
+  put(doc) {
+    return _classPrivateFieldBase(this, _cache)[_cache].put(doc);
   }
 
   /**
-   * Query the cache for whether a given resource was created locally and not
-   * yet persisted.
+   * Perform an operation on the cache to update the remote state.
    *
-   * @method isNew
+   * Note: currently the only valid operation is a MergeOperation
+   * which occurs when a collision of identifiers is detected.
+   *
+   * @method patch
    * @public
-   * @param identifier
-   * @returns {boolean}
+   * @param op the operation to perform
+   * @returns {void}
    */
-  isNew(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+  patch(op) {
+    _classPrivateFieldBase(this, _cache)[_cache].patch(op);
   }
 
   /**
-   * Query the cache for whether a given resource is marked as deleted (but not
-   * necessarily persisted yet).
+   * Update resource data with a local mutation. Currently supports operations
+   * on relationships only.
    *
-   * @method isDeleted
+   * @method mutate
    * @public
-   * @param identifier
-   * @returns {boolean}
+   * @param mutation
    */
-  isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+  mutate(mutation) {
+    _classPrivateFieldBase(this, _cache)[_cache].mutate(mutation);
   }
 
   /**
-   * Query the cache for whether a given resource has been deleted and that deletion
-   * has also been persisted.
+   * Peek resource data from the Cache.
+   *
+   * In development, if the return value
+   * is JSON the return value
+   * will be deep-cloned and deep-frozen
+   * to prevent mutation thereby enforcing cache
+   * Immutability.
+   *
+   * This form of peek is useful for implementations
+   * that want to feed raw-data from cache to the UI
+   * or which want to interact with a blob of data
+   * directly from the presentation cache.
+   *
+   * An implementation might want to do this because
+   * de-referencing records which read from their own
+   * blob is generally safer because the record does
+   * not require retainining connections to the Store
+   * and Cache to present data on a per-field basis.
+   *
+   * This generally takes the place of `getAttr` as
+   * an API and may even take the place of `getRelationship`
+   * depending on implementation specifics, though this
+   * latter usage is less recommended due to the advantages
+   * of the Graph handling necessary entanglements and
+   * notifications for relational data.
    *
-   * @method isDeletionCommitted
+   * @method peek
    * @public
-   * @param identifier
-   * @returns {boolean}
+   * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
+   * @returns {ResourceDocument | ResourceBlob | null} the known resource data
    */
-  isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
-  }
-}
-function _isDeprecated2(cache) {
-  let version = cache.version || '1';
-  return version !== this.version;
-}
-var _cache3 = /*#__PURE__*/_classPrivateFieldKey("cache");
-class SingletonCacheManager {
-  constructor(cache) {
-    this.version = '2';
-    Object.defineProperty(this, _cache3, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldBase(this, _cache3)[_cache3] = cache;
-  }
-  put(doc) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].put(doc);
-  }
+
   peek(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].peek(identifier);
+    return _classPrivateFieldBase(this, _cache)[_cache].peek(identifier);
   }
+
+  /**
+   * Peek the Cache for the existing request data associated with
+   * a cacheable request
+   *
+   * @method peekRequest
+   * @param {StableDocumentIdentifier}
+   * @returns {StableDocumentIdentifier | null}
+   * @public
+   */
   peekRequest(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].peekRequest(identifier);
-  }
-  fork() {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].fork();
-  }
-  merge(cache) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].merge(cache);
-  }
-  diff() {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].diff();
-  }
-  dump() {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].dump();
-  }
-  hydrate(stream) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].hydrate(stream);
+    return _classPrivateFieldBase(this, _cache)[_cache].peekRequest(identifier);
   }
 
-  // Cache
-  // =====
-
+  /**
+   * 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
+   */
   upsert(identifier, data, hasRecord) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].upsert(identifier, data, hasRecord);
-  }
-  patch(op) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].patch(op);
-  }
-  clientDidCreate(identifier, options) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].clientDidCreate(identifier, options);
-  }
-  willCommit(identifier) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].willCommit(identifier);
-  }
-  didCommit(identifier, data) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].didCommit(identifier, data);
-  }
-  commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].commitWasRejected(identifier, errors);
-  }
-  unloadRecord(identifier) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].unloadRecord(identifier);
+    return _classPrivateFieldBase(this, _cache)[_cache].upsert(identifier, data, hasRecord);
   }
 
-  // Attrs
-  // =====
+  // Cache Forking Support
+  // =====================
 
-  getAttr(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].getAttr(identifier, propertyName);
-  }
-  setAttr(identifier, propertyName, value) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].setAttr(identifier, propertyName, value);
-  }
-  changedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].changedAttrs(identifier);
-  }
-  hasChangedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].hasChangedAttrs(identifier);
-  }
-  rollbackAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].rollbackAttrs(identifier);
-  }
-  getRelationship(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].getRelationship(identifier, propertyName);
-  }
-  mutate(mutation) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].mutate(mutation);
+  /**
+   * Create a fork of the cache from the current state.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to fork at the Store level, which will
+   * utilize this method to fork the cache.
+   *
+   * @method fork
+   * @public
+   * @returns Promise<Cache>
+   */
+  fork() {
+    return _classPrivateFieldBase(this, _cache)[_cache].fork();
   }
 
-  // State
-  // =============
-
-  setIsDeleted(identifier, isDeleted) {
-    _classPrivateFieldBase(this, _cache3)[_cache3].setIsDeleted(identifier, isDeleted);
-  }
-  getErrors(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].getErrors(identifier);
-  }
-  isEmpty(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].isEmpty(identifier);
-  }
-  isNew(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].isNew(identifier);
-  }
-  isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeleted(identifier);
-  }
-  isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeletionCommitted(identifier);
-  }
-}
-function constructResource(type, id, lid) {
-  if (typeof type === 'object' && type !== null) {
-    let resource = type;
-    if (isStableIdentifier(resource)) {
-      return resource;
-    }
-    if ('id' in resource) {
-      resource.id = coerceId(resource.id);
-    }
-    assert('Expected either id or lid to be a valid string', 'id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid));
-    assert('if id is present, the type must be a string', !('id' in resource) || typeof resource.type === 'string');
-    return resource;
-  } else {
-    const trueId = coerceId(id);
-    if (!isNonEmptyString(trueId)) {
-      if (isNonEmptyString(lid)) {
-        return {
-          lid
-        };
-      }
-      throw new Error('Expected either id or lid to be a valid string');
-    }
-    assert('type must be a string', typeof type === 'string');
-    if (isNonEmptyString(lid)) {
-      return {
-        type,
-        id: trueId,
-        lid
-      };
-    }
-    return {
-      type,
-      id: trueId
-    };
-  }
-}
-
-/**
-  @module @ember-data/store
-*/
-
-class LegacyWrapper {
-  constructor(_store) {
-    this._store = _store;
-    this._willNotify = false;
-    this._pendingNotifies = new Map();
-  }
-  get identifierCache() {
-    return this._store.identifierCache;
-  }
-  _scheduleNotification(identifier, key) {
-    let pending = this._pendingNotifies.get(identifier);
-    if (!pending) {
-      pending = new Set();
-      this._pendingNotifies.set(identifier, pending);
-    }
-    pending.add(key);
-    if (this._willNotify === true) {
-      return;
-    }
-    this._willNotify = true;
-    // it's possible a RecordData adhoc notifies us,
-    // in which case we sync flush
-    if (this._store._cbs) {
-      this._store._schedule('notify', () => this._flushNotifications());
-    } else {
-      this._flushNotifications();
-    }
-  }
-  _flushNotifications() {
-    if (this._willNotify === false) {
-      return;
-    }
-    let pending = this._pendingNotifies;
-    this._pendingNotifies = new Map();
-    this._willNotify = false;
-    pending.forEach((set, identifier) => {
-      set.forEach(key => {
-        this._store.notifications.notify(identifier, 'relationships', key);
-      });
-    });
-  }
-  notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
-
-    // TODO do we still get value from this?
-    if (namespace === 'relationships' && key) {
-      this._scheduleNotification(identifier, key);
-      return;
-    }
-
-    // @ts-expect-error
-    this._store.notifications.notify(identifier, namespace, key);
-  }
-  notifyErrorsChange(type, id, lid) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.notifyErrorsChange has been deprecated in favor of StoreWrapper.notifyChange`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._store.notifications.notify(identifier, 'errors');
-  }
-  attributesDefinitionFor(type) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.attributesDefinitionFor has been deprecated in favor of StoreWrapper.getSchemaDefinitionService().attributesDefinitionFor`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    return this._store.getSchemaDefinitionService().attributesDefinitionFor({
-      type
-    });
-  }
-  relationshipsDefinitionFor(type) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.relationshipsDefinitionFor has been deprecated in favor of StoreWrapper.getSchemaDefinitionService().relationshipsDefinitionFor`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    return this._store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type
-    });
-  }
-  getSchemaDefinitionService() {
-    return this._store.getSchemaDefinitionService();
-  }
-  notifyPropertyChange(type, id, lid, key) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.notifyPropertyChange has been deprecated in favor of StoreWrapper.notifyChange`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._store.notifications.notify(identifier, 'attributes', key);
-  }
-  notifyHasManyChange(type, id, lid, key) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.notifyHasManyChange has been deprecated in favor of StoreWrapper.notifyChange`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._scheduleNotification(identifier, key);
-  }
-  notifyBelongsToChange(type, id, lid, key) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.notifyBelongsToChange has been deprecated in favor of StoreWrapper.notifyChange`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._scheduleNotification(identifier, key);
-  }
-  notifyStateChange(type, id, lid, key) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.notifyStateChange has been deprecated in favor of StoreWrapper.notifyChange`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    this._store.notifications.notify(identifier, 'state');
-  }
-  recordDataFor(type, id, lid) {
-    let identifier;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      if (!isStableIdentifier(type)) {
-        // we also deprecate create capability. This behavior was problematic because
-        // there's no outside association between this RecordData and an Identifier.
-        // It's likely a mistake when we hit this codepath, but we said in an early
-        // RFC we'd allow this.
-        // With V2 we are enforcing someone to use the record-data and identifier-cache APIs to
-        // create a new identifier and then call clientDidCreate on the RecordData
-        // instead.
-        identifier = !id && !lid ? this.identifierCache.createIdentifierForNewRecord({
-          type: type
-        }) : this.identifierCache.getOrCreateRecordIdentifier(constructResource(type, id, lid));
-      } else {
-        identifier = type;
-      }
-    } else {
-      assert(`Expected a stable identifier`, isStableIdentifier(type));
-      identifier = type;
-    }
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? 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 cache;
-  }
-  setRecordId(type, id, lid) {
-    let identifier;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      if (!isStableIdentifier(type)) {
-        const modelName = normalizeModelName$1(type);
-        const resource = constructResource(modelName, null, coerceId(lid));
-        identifier = this.identifierCache.peekRecordIdentifier(resource);
-      } else {
-        identifier = type;
-      }
-    } else {
-      assert(`Expected a stable identifier`, isStableIdentifier(type));
-      identifier = type;
-    }
-    assert(`Unable to find an identifier to update the ID for for ${String(lid)}`, identifier);
-    this._store._instanceCache.setRecordId(identifier, id);
-  }
-  isRecordInUse(type, id, lid) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      deprecate(`StoreWrapper.isRecordInUSe has been deprecated in favor of StoreWrapper.hasRecord`, false, {
-        id: 'ember-data:deprecate-v1cache-store-apis',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-    const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.peekRecordIdentifier(resource);
-    const record = identifier && this._store._instanceCache.peek({
-      identifier,
-      bucket: 'record'
-    });
-    return record ? !(record.isDestroyed || record.isDestroying) : false;
-  }
-  hasRecord(identifier) {
-    return Boolean(this._store._instanceCache.peek({
-      identifier,
-      bucket: 'record'
-    }));
-  }
-  disconnectRecord(type, id, lid) {
-    let identifier;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      if (typeof type === 'string') {
-        deprecate(`StoreWrapper.disconnectRecord(<type>) has been deprecated in favor of StoreWrapper.disconnectRecord(<identifier>)`, false, {
-          id: 'ember-data:deprecate-v1cache-store-apis',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            enabled: '4.7',
-            available: '4.7'
-          }
-        });
-        let resource = constructResource(type, id, lid);
-        identifier = this.identifierCache.peekRecordIdentifier(resource);
-      } else {
-        identifier = type;
-      }
-    } else {
-      identifier = type;
-    }
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    this._store._instanceCache.disconnect(identifier);
-    this._pendingNotifies.delete(identifier);
-  }
-}
-class V2CacheStoreWrapper {
-  constructor(_store) {
-    this._store = _store;
-    this._willNotify = false;
-    this._pendingNotifies = new Map();
-  }
-  get identifierCache() {
-    return this._store.identifierCache;
-  }
-  _scheduleNotification(identifier, key) {
-    let pending = this._pendingNotifies.get(identifier);
-    if (!pending) {
-      pending = new Set();
-      this._pendingNotifies.set(identifier, pending);
-    }
-    pending.add(key);
-    if (this._willNotify === true) {
-      return;
-    }
-    this._willNotify = true;
-    // it's possible a cache adhoc notifies us,
-    // in which case we sync flush
-    if (this._store._cbs) {
-      this._store._schedule('notify', () => this._flushNotifications());
-    } else {
-      this._flushNotifications();
-    }
-  }
-  _flushNotifications() {
-    if (this._willNotify === false) {
-      return;
-    }
-    let pending = this._pendingNotifies;
-    this._pendingNotifies = new Map();
-    this._willNotify = false;
-    pending.forEach((set, identifier) => {
-      set.forEach(key => {
-        this._store.notifications.notify(identifier, 'relationships', key);
-      });
-    });
-  }
-  notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
-
-    // TODO do we still get value from this?
-    if (namespace === 'relationships' && key) {
-      this._scheduleNotification(identifier, key);
-      return;
-    }
-
-    // @ts-expect-error
-    this._store.notifications.notify(identifier, namespace, key);
-  }
-  getSchemaDefinitionService() {
-    return this._store.getSchemaDefinitionService();
-  }
-  recordDataFor(identifier) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-      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 macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : void 0;
-  }
-  setRecordId(identifier, id) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    this._store._instanceCache.setRecordId(identifier, id);
-  }
-  hasRecord(identifier) {
-    return Boolean(this._store._instanceCache.peek({
-      identifier,
-      bucket: 'record'
-    }));
-  }
-  disconnectRecord(identifier) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    this._store._instanceCache.disconnect(identifier);
-    this._pendingNotifies.delete(identifier);
-  }
-}
-const CacheStoreWrapper = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS) ? LegacyWrapper : V2CacheStoreWrapper;
-let _peekGraph;
-if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-  let __peekGraph;
-  _peekGraph = wrapper => {
-    let a = importSync('@ember-data/graph/-private').peekGraph;
-    __peekGraph = __peekGraph || a;
-    return __peekGraph(wrapper);
-  };
-}
-
-/**
-  @module @ember-data/store
-*/
-
-const RecordCache = new Map();
-function peekRecordIdentifier(record) {
-  return RecordCache.get(record);
-}
-
-/**
-  Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
-  assigned to the given record instance.
-  ```js
-  import { recordIdentifierFor } from "@ember-data/store";
-  // ... gain access to a record, for instance with peekRecord or findRecord
-  const record = store.peekRecord("user", "1");
-  // get the identifier for the record (see docs for StableRecordIdentifier)
-  const identifier = recordIdentifierFor(record);
-  // access the identifier's properties.
-  const { id, type, lid } = identifier;
-  ```
-  @method recordIdentifierFor
-  @public
-  @static
-  @for @ember-data/store
-  @param {Object} record a record instance previously obstained from the store.
-  @returns {StableRecordIdentifier}
- */
-function recordIdentifierFor(record) {
-  assert(`${String(record)} is not a record instantiated by @ember-data/store`, RecordCache.has(record));
-  return RecordCache.get(record);
-}
-function setRecordIdentifier(record, identifier) {
-  if (macroCondition(getOwnConfig().env.DEBUG)) {
-    if (RecordCache.has(record) && RecordCache.get(record) !== identifier) {
-      throw new Error(`${String(record)} was already assigned an identifier`);
-    }
-  }
-
-  /*
-  It would be nice to do a reverse check here that an identifier has not
-  previously been assigned a record; however, unload + rematerialization
-  prevents us from having a great way of doing so when CustomRecordClasses
-  don't necessarily give us access to a `isDestroyed` for dematerialized
-  instance.
-  */
-
-  RecordCache.set(record, identifier);
-}
-const StoreMap = new Map();
-function storeFor(record) {
-  const store = StoreMap.get(record);
-  assert(`A record in a disconnected state cannot utilize the store. This typically means the record has been destroyed, most commonly by unloading it.`, store);
-  return store;
-}
-class InstanceCache {
-  constructor(store) {
-    this.__instances = {
-      record: new Map(),
-      resourceCache: new Map(),
-      reference: new WeakMap()
-    };
-    this.store = store;
-    this._storeWrapper = new CacheStoreWrapper(this.store);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-      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) {
-        keptIdentifier = 'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;
-      } else if (identifier.type !== matchedIdentifier.type) {
-        keptIdentifier = 'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
-      }
-      let staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
-
-      // check for duplicate entities
-      let keptHasRecord = this.__instances.record.has(keptIdentifier);
-      let staleHasRecord = this.__instances.record.has(staleIdentifier);
-      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 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
-        // record points at so long as
-        // it itself is not retained by the store in any way.
-        if ('id' in resourceData) {
-          throw new Error(`Failed to update the 'id' for the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to '${String(resourceData.id)}', because that id is already in use by '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`);
-        }
-        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 resourceCache = keptResourceCache || staleResourceCache;
-      if (resourceCache) {
-        resourceCache.patch({
-          op: 'mergeIdentifiers',
-          record: staleIdentifier,
-          value: keptIdentifier
-        });
-      } else if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-        this.store.cache.patch({
-          op: 'mergeIdentifiers',
-          record: staleIdentifier,
-          value: keptIdentifier
-        });
-      } else if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
-        this.store.cache.patch({
-          op: 'mergeIdentifiers',
-          record: staleIdentifier,
-          value: keptIdentifier
-        });
-      }
-      if (staleResourceCache === null) {
-        return keptIdentifier;
-      }
-
-      /*
-      TODO @runspired consider adding this to make polymorphism even nicer
-      if (HAS_GRAPH_PACKAGE) {
-      if (identifier.type !== matchedIdentifier.type) {
-        const graphFor = importSync('@ember-data/graph/-private').graphFor;
-        graphFor(this).registerPolymorphicType(identifier.type, matchedIdentifier.type);
-      }
-      }
-      */
-
-      this.unloadRecord(staleIdentifier);
-      return keptIdentifier;
-    });
-  }
-  peek({
-    identifier,
-    bucket
-  }) {
-    return this.__instances[bucket]?.get(identifier);
-  }
-  getRecord(identifier, properties) {
-    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 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);
-      setCacheFor(record, cache);
-      StoreMap.set(record, this.store);
-      this.__instances.record.set(identifier, record);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: created Record for ${String(identifier)}`, properties);
-      }
-    }
-    return record;
-  }
-  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;
-    }
-    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);
-        }
-      }
-      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;
-    }
-    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;
-    let reference = cache.get(identifier);
-    if (!reference) {
-      reference = new RecordReference(this.store, identifier);
-      cache.set(identifier, reference);
-    }
-    return reference;
-  }
-  recordIsLoaded(identifier, filterDeleted = false) {
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) || this.cache : this.cache;
-    if (!cache) {
-      return false;
-    }
-    const isNew = cache.isNew(identifier);
-    const isEmpty = cache.isEmpty(identifier);
-
-    // if we are new we must consider ourselves loaded
-    if (isNew) {
-      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
-
-    // if we are not empty, not new && we have a fulfilled request then we are loaded
-    // 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 && cache.isDeletionCommitted(identifier) ? false : !isEmpty;
-  }
-  disconnect(identifier) {
-    const record = this.__instances.record.get(identifier);
-    assert('Cannot destroy record while it is still materialized', !record || record.isDestroyed || record.isDestroying);
-    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
-      let graph = _peekGraph(this.store);
-      if (graph) {
-        graph.remove(identifier);
-      }
-    }
-    this.store.identifierCache.forgetRecordIdentifier(identifier);
-    this.__instances.resourceCache.delete(identifier);
-    removeRecordDataFor(identifier);
-    this.store._requestCache._clearEntries(identifier);
-    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.log(`InstanceCache: disconnected ${String(identifier)}`);
-    }
-  }
-  unloadRecord(identifier) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      const requests = this.store.getRequestStateService().getPendingRequestsForRecord(identifier);
-      if (requests.some(req => {
-        return req.type === 'mutation';
-      })) {
-        assert(`You can only unload a record which is not inFlight. '${String(identifier)}'`);
-      }
-    }
-    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
-    }
-
-    // TODO is this join still necessary?
-    this.store._join(() => {
-      const record = this.__instances.record.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);
-        StoreMap.delete(record);
-        RecordCache.delete(record);
-        removeRecordDataFor(record);
-        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-          // eslint-disable-next-line no-console
-          console.log(`InstanceCache: destroyed record for ${String(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 {
-        this.disconnect(identifier);
-      }
-      this.store._requestCache._clearEntries(identifier);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
-        // eslint-disable-next-line no-console
-        console.groupEnd();
-      }
-    });
-  }
-  clear(type) {
-    const cache = this.store.identifierCache._cache;
-    if (type === undefined) {
-      // 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.resourceCache;
-      if (identifiers) {
-        identifiers.forEach(identifier => {
-          // if (rds.has(identifier)) {
-          this.unloadRecord(identifier);
-          // }
-          // TODO we don't remove the identifier, should we?
-        });
-      }
-    }
-  }
-
-  // TODO this should move into something coordinating operations
-  setRecordId(identifier, id) {
-    const {
-      type,
-      lid
-    } = identifier;
-    let oldId = identifier.id;
-
-    // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)
-    assert(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`, !(id === null && oldId === null));
-
-    // ID absolutely can't be different than oldID if oldID is not null
-    // TODO this assertion and restriction may not strictly be needed in the identifiers world
-    assert(`Cannot update the id for '${type}:${lid}' from '${String(oldId)}' to '${id}'.`, !(oldId !== null && id !== oldId));
-
-    // ID can be null if oldID is not null (altered ID in response for a record)
-    // however, this is more than likely a developer error.
-    if (oldId !== null && id === null) {
-      warn(`Your ${type} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null));
-      return;
-    }
-    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.log(`InstanceCache: updating id to '${id}' for record ${String(identifier)}`);
-    }
-    let existingIdentifier = this.store.identifierCache.peekRecordIdentifier({
-      type,
-      id
-    });
-    assert(`'${type}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`, !existingIdentifier || existingIdentifier === identifier);
-    if (identifier.id === null) {
-      // TODO potentially this needs to handle merged result
-      this.store.identifierCache.updateRecordIdentifier(identifier, {
-        type,
-        id
-      });
-    }
-
-    // TODO update resource cache if needed ?
-    // TODO handle consequences of identifier merge for notifications
-    this.store.notifications.notify(identifier, 'identity');
-  }
-
-  // TODO ths should be wrapped in a deprecation flag since cache.put
-  // handles this the rest of the time
-  loadData(data) {
-    let modelName = data.type;
-    assert(`You must include an 'id' for ${modelName} in an object passed to 'push'`, data.id !== null && data.id !== undefined && data.id !== '');
-    assert(`You tried to push data with a type '${modelName}' but no model could be found with that name.`, this.store.getSchemaDefinitionService().doesTypeExist(modelName));
-    const resource = constructResource(normalizeModelName$1(data.type), ensureStringId(data.id), coerceId(data.lid));
-    let identifier = this.store.identifierCache.peekRecordIdentifier(resource);
-    let isUpdate = false;
-
-    // store.push will be from empty
-    // findRecord will be from root.loading
-    // this cannot be loading state if we do not already have an identifier
-    // all else will be updates
-    if (identifier) {
-      const isLoading = _isLoading(this, identifier) || !this.recordIsLoaded(identifier);
-      isUpdate = !_isEmpty(this, identifier) && !isLoading;
-
-      // exclude store.push (root.empty) case
-      if (isUpdate || isLoading) {
-        identifier = this.store.identifierCache.updateRecordIdentifier(identifier, data);
-      }
-    } else {
-      identifier = this.store.identifierCache.getOrCreateRecordIdentifier(data);
-    }
-    const cache = this.getResourceCache(identifier);
-    const hasRecord = this.__instances.record.has(identifier);
-    cache.upsert(identifier, data, hasRecord);
-    return identifier;
+  /**
+   * Merge a fork back into a parent Cache.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to merge at the Store level, which will
+   * utilize this method to merge the caches.
+   *
+   * @method merge
+   * @param {Cache} cache
+   * @public
+   * @returns Promise<void>
+   */
+  merge(cache) {
+    return _classPrivateFieldBase(this, _cache)[_cache].merge(cache);
   }
-}
-function _resourceIsFullDeleted(identifier, cache) {
-  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
-}
-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);
-}
-
-/*
-    When a find request is triggered on the store, the user can optionally pass in
-    attributes and relationships to be preloaded. These are meant to behave as if they
-    came back from the server, except the user obtained them out of band and is informing
-    the store of their existence. The most common use case is for supporting client side
-    nested URLs, such as `/posts/1/comments/2` so the user can do
-    `store.findRecord('comment', 2, { preload: { post: 1 } })` without having to fetch the post.
-
-    Preloaded data can be attributes and relationships passed in either as IDs or as actual
-    models.
-  */
 
-function preloadData(store, identifier, preload) {
-  let jsonPayload = {};
-  //TODO(Igor) consider the polymorphic case
-  const schemas = store.getSchemaDefinitionService();
-  const relationships = schemas.relationshipsDefinitionFor(identifier);
-  Object.keys(preload).forEach(key => {
-    let preloadValue = preload[key];
-    let relationshipMeta = relationships[key];
-    if (relationshipMeta) {
-      if (!jsonPayload.relationships) {
-        jsonPayload.relationships = {};
-      }
-      jsonPayload.relationships[key] = preloadRelationship(relationshipMeta, preloadValue);
-    } else {
-      if (!jsonPayload.attributes) {
-        jsonPayload.attributes = {};
-      }
-      jsonPayload.attributes[key] = preloadValue;
-    }
-  });
-  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(identifier) : store.cache;
-  const hasRecord = Boolean(store._instanceCache.peek({
-    identifier,
-    bucket: 'record'
-  }));
-  cache.upsert(identifier, jsonPayload, hasRecord);
-}
-function preloadRelationship(schema, preloadValue) {
-  const relatedType = schema.type;
-  if (schema.kind === 'hasMany') {
-    assert('You need to pass in an array to set a hasMany property on a record', Array.isArray(preloadValue));
-    return {
-      data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
-    };
+  /**
+   * Generate the list of changes applied to all
+   * record in the store.
+   *
+   * Each individual resource or document that has
+   * been mutated should be described as an individual
+   * `Change` entry in the returned array.
+   *
+   * A `Change` is described by an object containing up to
+   * three properties: (1) the `identifier` of the entity that
+   * changed; (2) the `op` code of that change being one of
+   * `upsert` or `remove`, and if the op is `upsert` a `patch`
+   * containing the data to merge into the cache for the given
+   * entity.
+   *
+   * This `patch` is opaque to the Store but should be understood
+   * by the Cache and may expect to be utilized by an Adapter
+   * when generating data during a `save` operation.
+   *
+   * It is generally recommended that the `patch` contain only
+   * the updated state, ignoring fields that are unchanged
+   *
+   * ```ts
+   * interface Change {
+   *  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+   *  op: 'upsert' | 'remove';
+   *  patch?: unknown;
+   * }
+   * ```
+   *
+   * @method diff
+   * @public
+   */
+  diff() {
+    return _classPrivateFieldBase(this, _cache)[_cache].diff();
   }
-  assert('You should not pass in an array to set a belongsTo property on a record', !Array.isArray(preloadValue));
-  return {
-    data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
-  };
-}
 
-/*
-  findRecord('user', '1', { preload: { friends: ['1'] }});
-  findRecord('user', '1', { preload: { friends: [record] }});
-*/
-function _convertPreloadRelationshipToJSON(value, type) {
-  if (typeof value === 'string' || typeof value === 'number') {
-    return {
-      type,
-      id: value
-    };
-  }
-  // TODO if not a record instance assert it's an identifier
-  // and allow identifiers to be used
-  return recordIdentifierFor(value);
-}
-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 = cache.isNew(identifier);
-  const isDeleted = cache.isDeleted(identifier);
-  const isEmpty = cache.isEmpty(identifier);
-  return (!isNew || isDeleted) && isEmpty;
-}
-function _isLoading(cache, identifier) {
-  const req = cache.store.getRequestStateService();
-  // const fulfilled = req.getLastRequestForRecord(identifier);
-  const isLoaded = cache.recordIsLoaded(identifier);
-  return !isLoaded &&
-  // fulfilled === null &&
-  req.getPendingRequestsForRecord(identifier).some(req => req.type === 'query');
-}
-function _clearCaches() {
-  RecordCache.clear();
-  StoreMap.clear();
-  CacheForIdentifierCache.clear();
-}
-let _modelForMixin;
-if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-  let _found;
-  _modelForMixin = function () {
-    if (!_found) {
-      _found = importSync('@ember-data/model/-private')._modelForMixin;
-    }
-    return _found(...arguments);
-  };
-}
-class DSModelSchemaDefinitionService {
-  constructor(store) {
-    this.store = store;
-    this._relationshipsDefCache = Object.create(null);
-    this._attributesDefCache = Object.create(null);
-  }
+  // SSR Support
+  // ===========
 
-  // Following the existing RD implementation
-  attributesDefinitionFor(identifier) {
-    let modelName, attributes;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_STRING_ARG_SCHEMAS)) {
-      if (typeof identifier === 'string') {
-        deprecate(`attributesDefinitionFor expects either a record identifier or an argument of shape { type: string }, received a string.`, false, {
-          id: 'ember-data:deprecate-string-arg-schemas',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            enabled: '4.5',
-            available: '4.5'
-          }
-        });
-        modelName = identifier;
-      } else {
-        modelName = identifier.type;
-      }
-    } else {
-      modelName = identifier.type;
-    }
-    attributes = this._attributesDefCache[modelName];
-    if (attributes === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      let attributeMap = modelClass.attributes;
-      attributes = Object.create(null);
-      attributeMap.forEach((meta, name) => attributes[name] = meta);
-      this._attributesDefCache[modelName] = attributes;
-    }
-    return attributes;
+  /**
+   * Serialize the entire contents of the Cache into a Stream
+   * which may be fed back into a new instance of the same Cache
+   * via `cache.hydrate`.
+   *
+   * @method dump
+   * @returns {Promise<ReadableStream>}
+   * @public
+   */
+  dump() {
+    return _classPrivateFieldBase(this, _cache)[_cache].dump();
   }
 
-  // Following the existing RD implementation
-  relationshipsDefinitionFor(identifier) {
-    let modelName, relationships;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_STRING_ARG_SCHEMAS)) {
-      if (typeof identifier === 'string') {
-        deprecate(`relationshipsDefinitionFor expects either a record identifier or an argument of shape { type: string }, received a string.`, false, {
-          id: 'ember-data:deprecate-string-arg-schemas',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            enabled: '4.5',
-            available: '4.5'
-          }
-        });
-        modelName = identifier;
-      } else {
-        modelName = identifier.type;
-      }
-    } else {
-      modelName = identifier.type;
-    }
-    relationships = this._relationshipsDefCache[modelName];
-    if (relationships === undefined) {
-      let modelClass = this.store.modelFor(modelName);
-      relationships = modelClass.relationshipsObject || null;
-      this._relationshipsDefCache[modelName] = relationships;
-    }
-    return relationships;
-  }
-  doesTypeExist(modelName) {
-    let normalizedModelName = normalizeModelName$1(modelName);
-    let factory = getModelFactory(this.store, this.store._modelFactoryCache, normalizedModelName);
-    return factory !== null;
-  }
-}
-function getModelFactory(store, cache, normalizedModelName) {
-  let factory = cache[normalizedModelName];
-  if (!factory) {
-    let owner = getOwner(store);
-    factory = owner.factoryFor(`model:${normalizedModelName}`);
-    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      if (!factory) {
-        //Support looking up mixins as base types for polymorphic relationships
-        factory = _modelForMixin(store, normalizedModelName);
-      }
-    }
-    if (!factory) {
-      // we don't cache misses in case someone wants to register a missing model
-      return null;
-    }
-    let klass = factory.class;
-    if (klass.isModel) {
-      let hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');
-      if (!hasOwnModelNameSet) {
-        Object.defineProperty(klass, 'modelName', {
-          value: normalizedModelName
-        });
-      }
-    }
-    cache[normalizedModelName] = factory;
+  /**
+   * hydrate a Cache from a Stream with content previously serialized
+   * from another instance of the same Cache, resolving when hydration
+   * is complete.
+   *
+   * This method should expect to be called both in the context of restoring
+   * the Cache during application rehydration after SSR **AND** at unknown
+   * times during the lifetime of an already booted application when it is
+   * desired to bulk-load additional information into the cache. This latter
+   * behavior supports optimizing pre/fetching of data for route transitions
+   * via data-only SSR modes.
+   *
+   * @method hydrate
+   * @param {ReadableStream} stream
+   * @returns {Promise<void>}
+   * @public
+   */
+  hydrate(stream) {
+    return _classPrivateFieldBase(this, _cache)[_cache].hydrate(stream);
   }
-  return factory;
-}
 
-// if modelFor turns out to be a bottleneck we should replace with a Map
-// and clear it during store teardown.
-const AvailableShims = new WeakMap();
-function getShimClass(store, modelName) {
-  let shims = AvailableShims.get(store);
-  if (!shims) {
-    shims = Object.create(null);
-    AvailableShims.set(store, shims);
-  }
-  let shim = shims[modelName];
-  if (shim === undefined) {
-    shim = shims[modelName] = new ShimModelClass(store, modelName);
-  }
-  return shim;
-}
-function mapFromHash(hash) {
-  let map = new Map();
-  for (let i in hash) {
-    if (Object.prototype.hasOwnProperty.call(hash, i)) {
-      map.set(i, hash[i]);
-    }
+  // Cache
+  // =====
+
+  // Resource Support
+  // ================
+
+  /**
+   * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
+   *
+   * It returns properties from options that should be set on the record during the create
+   * process. This return value behavior is deprecated.
+   *
+   * @method clientDidCreate
+   * @public
+   * @param identifier
+   * @param options
+   */
+  clientDidCreate(identifier, options) {
+    return _classPrivateFieldBase(this, _cache)[_cache].clientDidCreate(identifier, options);
   }
-  return map;
-}
 
-// Mimics the static apis of DSModel
-class ShimModelClass {
-  constructor(store, modelName) {
-    this.__store = store;
-    this.modelName = modelName;
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * will be part of a save transaction.
+   *
+   * @method willCommit
+   * @public
+   * @param identifier
+   */
+  willCommit(identifier) {
+    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier);
   }
-  get fields() {
-    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
-      type: this.modelName
-    });
-    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
-    });
-    let fields = new Map();
-    Object.keys(attrs).forEach(key => fields.set(key, 'attribute'));
-    Object.keys(relationships).forEach(key => fields.set(key, relationships[key].kind));
-    return fields;
+
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * was successfully updated as part of a save transaction.
+   *
+   * @method didCommit
+   * @public
+   * @param identifier
+   * @param data
+   */
+  didCommit(identifier, data) {
+    _classPrivateFieldBase(this, _cache)[_cache].didCommit(identifier, data);
   }
-  get attributes() {
-    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
-      type: this.modelName
-    });
-    return mapFromHash(attrs);
+
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * was update via a save transaction failed.
+   *
+   * @method commitWasRejected
+   * @public
+   * @param identifier
+   * @param errors
+   */
+  commitWasRejected(identifier, errors) {
+    _classPrivateFieldBase(this, _cache)[_cache].commitWasRejected(identifier, errors);
   }
-  get relationshipsByName() {
-    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
-    });
-    return mapFromHash(relationships);
+
+  /**
+   * [LIFECYCLE] Signals to the cache that all data for a resource
+   * should be cleared.
+   *
+   * @method unloadRecord
+   * @public
+   * @param identifier
+   */
+  unloadRecord(identifier) {
+    _classPrivateFieldBase(this, _cache)[_cache].unloadRecord(identifier);
   }
-  eachAttribute(callback, binding) {
-    let attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
-      type: this.modelName
-    });
-    Object.keys(attrDefs).forEach(key => {
-      callback.call(binding, key, attrDefs[key]);
-    });
+
+  // Granular Resource Data APIs
+  // ===========================
+
+  /**
+   * Retrieve the data for an attribute from the cache
+   *
+   * @method getAttr
+   * @public
+   * @param identifier
+   * @param propertyName
+   * @returns {unknown}
+   */
+  getAttr(identifier, propertyName) {
+    return _classPrivateFieldBase(this, _cache)[_cache].getAttr(identifier, propertyName);
   }
-  eachRelationship(callback, binding) {
-    let relationshipDefs = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
-    });
-    Object.keys(relationshipDefs).forEach(key => {
-      callback.call(binding, key, relationshipDefs[key]);
-    });
+
+  /**
+   * Mutate the data for an attribute in the cache
+   *
+   * @method setAttr
+   * @public
+   * @param identifier
+   * @param propertyName
+   * @param value
+   */
+  setAttr(identifier, propertyName, value) {
+    _classPrivateFieldBase(this, _cache)[_cache].setAttr(identifier, propertyName, value);
   }
-  eachTransformedAttribute(callback, binding) {
-    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
-      type: this.modelName
-    });
-    Object.keys(attrDefs).forEach(key => {
-      if (attrDefs[key].type) {
-        callback.call(binding, key, attrDefs[key].type);
-      }
-    });
+
+  /**
+   * Query the cache for the changed attributes of a resource.
+   *
+   * @method changedAttrs
+   * @public
+   * @param identifier
+   * @returns
+   */
+  changedAttrs(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].changedAttrs(identifier);
   }
-}
-const PromiseArrayProxy = ArrayProxy.extend(PromiseProxyMixin);
-const PromiseObjectProxy = ObjectProxy.extend(PromiseProxyMixin);
-var _dec, _class$1, _descriptor$1;
 
-/**
-  @module @ember-data/store
-*/
+  /**
+   * Query the cache for whether any mutated attributes exist
+   *
+   * @method hasChangedAttrs
+   * @public
+   * @param identifier
+   * @returns {boolean}
+   */
+  hasChangedAttrs(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].hasChangedAttrs(identifier);
+  }
 
-/**
-  A `PromiseArray` is an object that acts like both an `Ember.Array`
-  and a promise. When the promise is resolved the resulting value
-  will be set to the `PromiseArray`'s `content` property. This makes
-  it easy to create data bindings with the `PromiseArray` that will be
-  updated when the promise resolves.
+  /**
+   * Tell the cache to discard any uncommitted mutations to attributes
+   *
+   * @method rollbackAttrs
+   * @public
+   * @param identifier
+   * @returns the names of attributes that were restored
+   */
+  rollbackAttrs(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].rollbackAttrs(identifier);
+  }
 
-  This class should not be imported and instantiated directly.
+  // Relationships
+  // =============
 
-  For more information see the [Ember.PromiseProxyMixin
-  documentation](/ember/release/classes/PromiseProxyMixin).
+  /**
+   * Query the cache for the current state of a relationship property
+   *
+   * @method getRelationship
+   * @public
+   * @param identifier
+   * @param propertyName
+   * @returns resource relationship object
+   */
+  getRelationship(identifier, propertyName) {
+    return _classPrivateFieldBase(this, _cache)[_cache].getRelationship(identifier, propertyName);
+  }
 
-  Example
+  // Resource State
+  // ===============
 
-  ```javascript
-  let promiseArray = PromiseArray.create({
-    promise: $.getJSON('/some/remote/data.json')
-  });
+  /**
+   * Update the cache state for the given resource to be marked as locally deleted,
+   * or remove such a mark.
+   *
+   * @method setIsDeleted
+   * @public
+   * @param identifier
+   * @param isDeleted
+   */
+  setIsDeleted(identifier, isDeleted) {
+    _classPrivateFieldBase(this, _cache)[_cache].setIsDeleted(identifier, isDeleted);
+  }
 
-  promiseArray.length; // 0
+  /**
+   * Query the cache for any validation errors applicable to the given resource.
+   *
+   * @method getErrors
+   * @public
+   * @param identifier
+   * @returns
+   */
+  getErrors(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier);
+  }
 
-  promiseArray.then(function() {
-    promiseArray.length; // 100
-  });
-  ```
+  /**
+   * Query the cache for whether a given resource has any available data
+   *
+   * @method isEmpty
+   * @public
+   * @param identifier
+   * @returns {boolean}
+   */
+  isEmpty(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].isEmpty(identifier);
+  }
 
-  @class PromiseArray
-  @public
-  @extends Ember.ArrayProxy
-  @uses Ember.PromiseProxyMixin
-*/
-let PromiseArray = (_dec = reads('content.meta'), (_class$1 = class PromiseArray extends PromiseArrayProxy {
-  constructor(...args) {
-    super(...args);
-    _initializerDefineProperty(this, "meta", _descriptor$1, this);
+  /**
+   * Query the cache for whether a given resource was created locally and not
+   * yet persisted.
+   *
+   * @method isNew
+   * @public
+   * @param identifier
+   * @returns {boolean}
+   */
+  isNew(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier);
   }
-}, _descriptor$1 = _applyDecoratedDescriptor(_class$1.prototype, "meta", [_dec], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-}), _class$1));
-function _promiseObject(promise) {
-  return PromiseObjectProxy.create({
-    promise
-  });
-}
-function _promiseArray(promise) {
-  return PromiseArray.create({
-    promise
-  });
-}
 
-// constructor is accessed in some internals but not including it in the copyright for the deprecation
-const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
-const ALLOWABLE_PROPS = ['__ec_yieldable__', '__ec_cancel__'];
-const PROXIED_ARRAY_PROPS = ['length', '[]', 'firstObject', 'lastObject', 'meta', 'content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
-const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
-function promiseArray(promise) {
-  const promiseObjectProxy = _promiseArray(promise);
-  if (macroCondition(!getOwnConfig().env.DEBUG)) {
-    return promiseObjectProxy;
-  }
-  const handler = {
-    get(target, prop, receiver) {
-      if (typeof prop === 'symbol') {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (ALLOWABLE_PROPS.includes(prop)) {
-        return target[prop];
-      }
-      if (!ALLOWABLE_METHODS.includes(prop)) {
-        deprecate(`Accessing ${prop} on this PromiseArray is deprecated. The return type is being changed from PromiseArray to a Promise. The only available methods to access on this promise are .then, .catch and .finally`, false, {
-          id: 'ember-data:deprecate-promise-proxies',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.7',
-            enabled: '4.7'
-          }
-        });
-      }
-      const value = target[prop];
-      if (value && typeof value === 'function' && typeof value.bind === 'function') {
-        return value.bind(target);
-      }
-      if (PROXIED_ARRAY_PROPS.includes(prop)) {
-        return value;
-      }
-      return undefined;
-    }
-  };
-  return new Proxy(promiseObjectProxy, handler);
-}
-const ProxySymbolString = String(Symbol.for('PROXY_CONTENT'));
-function promiseObject(promise) {
-  const promiseObjectProxy = _promiseObject(promise);
-  if (macroCondition(!getOwnConfig().env.DEBUG)) {
-    return promiseObjectProxy;
-  }
-  const handler = {
-    get(target, prop, receiver) {
-      if (typeof prop === 'symbol') {
-        if (String(prop) === ProxySymbolString) {
-          return;
-        }
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop === 'constructor') {
-        return target.constructor;
-      }
-      if (ALLOWABLE_PROPS.includes(prop)) {
-        return target[prop];
-      }
-      if (!ALLOWABLE_METHODS.includes(prop)) {
-        deprecate(`Accessing ${prop} on this PromiseObject is deprecated. The return type is being changed from PromiseObject to a Promise. The only available methods to access on this promise are .then, .catch and .finally`, false, {
-          id: 'ember-data:deprecate-promise-proxies',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.7',
-            enabled: '4.7'
-          }
-        });
-      } else {
-        return target[prop].bind(target);
-      }
-      if (PROXIED_OBJECT_PROPS.includes(prop)) {
-        return target[prop];
-      }
-      const value = get(target, prop);
-      if (value && typeof value === 'function' && typeof value.bind === 'function') {
-        return value.bind(receiver);
-      }
-      return undefined;
-    }
-  };
-  return new Proxy(promiseObjectProxy, handler);
+  /**
+   * Query the cache for whether a given resource is marked as deleted (but not
+   * necessarily persisted yet).
+   *
+   * @method isDeleted
+   * @public
+   * @param identifier
+   * @returns {boolean}
+   */
+  isDeleted(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier);
+  }
+  isDeletionCommitted(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier);
+  }
 }
 var _class, _descriptor, _class3, _descriptor2;
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
@@ -3853,17 +2602,6 @@ let Tag = (_class = class Tag {
     return null;
   }
 }), _class);
-function deprecateArrayLike(className, fnName, replName) {
-  deprecate(`The \`${fnName}\` method on the class ${className} is deprecated. Use the native array method \`${replName}\` instead.`, false, {
-    id: 'ember-data:deprecate-array-like',
-    until: '5.0',
-    since: {
-      enabled: '4.7',
-      available: '4.7'
-    },
-    for: 'ember-data'
-  });
-}
 function safeForEach(instance, arr, store, callback, target) {
   if (target === undefined) {
     target = null;
@@ -3915,14 +2653,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     notifyArray(this);
   }
 
-  /**
-   The modelClass represented by this record array.
-    @property type
-    @public
-    @deprecated
-   @type {subclass of Model}
-   */
-
   /**
     The store that created this record array.
      @property store
@@ -4051,15 +2781,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
           return fn;
         }
         if (prop in self) {
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_ARRAY_LIKE)) {
-            if (prop === 'firstObject') {
-              deprecateArrayLike(self.DEPRECATED_CLASS_NAME, prop, '[0]');
-              return receiver[0];
-            } else if (prop === 'lastObject') {
-              deprecateArrayLike(self.DEPRECATED_CLASS_NAME, prop, 'at(-1)');
-              return receiver[receiver.length - 1];
-            }
-          }
           if (prop === NOTIFY || prop === IDENTIFIER_ARRAY_TAG || prop === SOURCE) {
             return self[prop];
           }
@@ -4135,25 +2856,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
         return IdentifierArray.prototype;
       }
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_A_USAGE)) {
-      const meta = Ember.meta(this);
-      meta.hasMixin = mixin => {
-        deprecate(`Do not call A() on EmberData RecordArrays`, false, {
-          id: 'ember-data:no-a-with-array-like',
-          until: '5.0',
-          since: {
-            enabled: '4.7',
-            available: '4.7'
-          },
-          for: 'ember-data'
-        });
-        // @ts-expect-error ArrayMixin is more than a type
-        if (mixin === NativeArray || mixin === ArrayMixin) {
-          return true;
-        }
-        return false;
-      };
-    } else if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not call A() on EmberData RecordArrays`);
@@ -4219,13 +2922,10 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     ```
      @method save
     @public
-    @return {PromiseArray} promise
+    @return {Promise<IdentifierArray>} promise
   */
   save() {
     let promise = Promise.all(this.map(record => this.store.saveRecord(record))).then(() => this);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(promise);
-    }
     return promise;
   }
 }, (_descriptor2 = _applyDecoratedDescriptor(_class3.prototype, "isUpdating", [tracked], {
@@ -4236,27 +2936,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     return false;
   }
 }), _applyDecoratedDescriptor(_class3.prototype, "length", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class3.prototype, "length"), _class3.prototype)), _class3);
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
-  Object.defineProperty(IdentifierArray.prototype, 'type', {
-    get() {
-      deprecate(`Using RecordArray.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
-        id: 'ember-data:deprecate-snapshot-model-class-access',
-        until: '5.0',
-        for: 'ember-data',
-        since: {
-          available: '4.5.0',
-          enabled: '4.5.0'
-        }
-      });
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      if (!this.modelName) {
-        return null;
-      }
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-      return this.store.modelFor(this.modelName);
-    }
-  });
-}
 class Collection extends IdentifierArray {
   constructor(options) {
     super(options);
@@ -4276,9 +2955,6 @@ class Collection extends IdentifierArray {
     const promise = store.query(this.modelName, query, {
       _recordArray: this
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(promise);
-    }
     return promise;
   }
   destroy() {
@@ -4292,286 +2968,6 @@ Collection.prototype.query = null;
 
 // Ensure instanceof works correctly
 //Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
-
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_ARRAY_LIKE)) {
-  IdentifierArray.prototype.DEPRECATED_CLASS_NAME = 'RecordArray';
-  Collection.prototype.DEPRECATED_CLASS_NAME = 'RecordArray';
-  const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];
-  EmberObjectMethods.forEach(method => {
-    IdentifierArray.prototype[method] = function delegatedMethod(...args) {
-      deprecate(`The EmberObject ${method} method on the class ${this.DEPRECATED_CLASS_NAME} is deprecated. Use dot-notation javascript get/set access instead.`, false, {
-        id: 'ember-data:deprecate-array-like',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return Ember[method](this, ...args);
-    };
-  });
-  IdentifierArray.prototype.addObject = function (obj) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'addObject', 'push');
-    let index = this.indexOf(obj);
-    if (index === -1) {
-      this.push(obj);
-    }
-    return this;
-  };
-  IdentifierArray.prototype.addObjects = function (objs) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'addObjects', 'push');
-    objs.forEach(obj => {
-      let index = this.indexOf(obj);
-      if (index === -1) {
-        this.push(obj);
-      }
-    });
-    return this;
-  };
-  IdentifierArray.prototype.popObject = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'popObject', 'pop');
-    return this.pop();
-  };
-  IdentifierArray.prototype.pushObject = function (obj) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'pushObject', 'push');
-    this.push(obj);
-    return obj;
-  };
-  IdentifierArray.prototype.pushObjects = function (objs) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'pushObjects', 'push');
-    this.push(...objs);
-    return this;
-  };
-  IdentifierArray.prototype.shiftObject = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'shiftObject', 'shift');
-    return this.shift();
-  };
-  IdentifierArray.prototype.unshiftObject = function (obj) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'unshiftObject', 'unshift');
-    this.unshift(obj);
-    return obj;
-  };
-  IdentifierArray.prototype.unshiftObjects = function (objs) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'unshiftObjects', 'unshift');
-    this.unshift(...objs);
-    return this;
-  };
-  IdentifierArray.prototype.objectAt = function (index) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'objectAt', 'at');
-    //For negative index values go back from the end of the array
-    let arrIndex = Math.sign(index) === -1 ? this.length + index : index;
-    return this[arrIndex];
-  };
-  IdentifierArray.prototype.objectsAt = function (indeces) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'objectsAt', 'at');
-    return indeces.map(index => this.objectAt(index));
-  };
-  IdentifierArray.prototype.removeAt = function (index) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeAt', 'splice');
-    this.splice(index, 1);
-    return this;
-  };
-  IdentifierArray.prototype.insertAt = function (index, obj) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'insertAt', 'splice');
-    this.splice(index, 0, obj);
-    return this;
-  };
-  IdentifierArray.prototype.removeObject = function (obj) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObject', 'splice');
-    const index = this.indexOf(obj);
-    if (index !== -1) {
-      this.splice(index, 1);
-    }
-    return this;
-  };
-  IdentifierArray.prototype.removeObjects = function (objs) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeObjects', 'splice');
-    objs.forEach(obj => {
-      const index = this.indexOf(obj);
-      if (index !== -1) {
-        this.splice(index, 1);
-      }
-    });
-    return this;
-  };
-  IdentifierArray.prototype.toArray = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'toArray', 'slice');
-    return this.slice();
-  };
-  IdentifierArray.prototype.replace = function (idx, amt, objects) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'replace', 'splice');
-    if (objects) {
-      this.splice(idx, amt, ...objects);
-    } else {
-      this.splice(idx, amt);
-    }
-  };
-  IdentifierArray.prototype.clear = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'clear', 'length = 0');
-    this.splice(0, this.length);
-    return this;
-  };
-  IdentifierArray.prototype.setObjects = function (objects) {
-    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);
-    return this;
-  };
-  IdentifierArray.prototype.reverseObjects = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'reverseObjects', 'reverse');
-    this.reverse();
-    return this;
-  };
-  IdentifierArray.prototype.compact = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'compact', 'filter');
-    return this.filter(v => v !== null && v !== undefined);
-  };
-  IdentifierArray.prototype.any = function (callback, target) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'any', 'some');
-    return this.some(callback, target);
-  };
-  IdentifierArray.prototype.isAny = function (prop, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'isAny', 'some');
-    let hasValue = arguments.length === 2;
-    return this.some(v => hasValue ? v[prop] === value : v[prop] === true);
-  };
-  IdentifierArray.prototype.isEvery = function (prop, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'isEvery', 'every');
-    let hasValue = arguments.length === 2;
-    return this.every(v => hasValue ? v[prop] === value : v[prop] === true);
-  };
-  IdentifierArray.prototype.getEach = function (key) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'getEach', 'map');
-    return this.map(value => get(value, key));
-  };
-  IdentifierArray.prototype.mapBy = function (key) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'mapBy', 'map');
-    return this.map(value => get(value, key));
-  };
-  IdentifierArray.prototype.findBy = function (key, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'findBy', 'find');
-    if (arguments.length === 2) {
-      return this.find(val => {
-        return get(val, key) === value;
-      });
-    } else {
-      return this.find(val => Boolean(get(val, key)));
-    }
-  };
-  IdentifierArray.prototype.filterBy = function (key, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'filterBy', 'filter');
-    if (arguments.length === 2) {
-      return this.filter(record => {
-        return get(record, key) === value;
-      });
-    }
-    return this.filter(record => {
-      return Boolean(get(record, key));
-    });
-  };
-  IdentifierArray.prototype.sortBy = function (...sortKeys) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'sortBy', '.slice().sort');
-    return this.slice().sort((a, b) => {
-      for (let i = 0; i < sortKeys.length; i++) {
-        let key = sortKeys[i];
-        let propA = get(a, key);
-        let propB = get(b, key);
-        // return 1 or -1 else continue to the next sortKey
-        let compareValue = compare(propA, propB);
-        if (compareValue) {
-          return compareValue;
-        }
-      }
-      return 0;
-    });
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.invoke = function (key, ...args) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'invoke', 'forEach');
-    return this.map(value => value[key](...args));
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.addArrayObserver = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'addArrayObserver', 'derived state or reacting at the change source');
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.removeArrayObserver = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeArrayObserver', 'derived state or reacting at the change source');
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.arrayContentWillChange = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'arrayContentWillChange', 'derived state or reacting at the change source');
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.arrayContentDidChange = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'arrayContentDidChange', 'derived state or reacting at the change source.');
-  };
-  IdentifierArray.prototype.reject = function (callback, target) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'reject', 'filter');
-    assert('`reject` expects a function as first argument.', typeof callback === 'function');
-    return this.filter((...args) => {
-      return !callback.apply(target, args);
-    });
-  };
-  IdentifierArray.prototype.rejectBy = function (key, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'rejectBy', 'filter');
-    if (arguments.length === 2) {
-      return this.filter(record => {
-        return get(record, key) !== value;
-      });
-    }
-    return this.filter(record => {
-      return !get(record, key);
-    });
-  };
-  IdentifierArray.prototype.setEach = function (key, value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'setEach', 'forEach');
-    this.forEach(item => set(item, key, value));
-  };
-  IdentifierArray.prototype.uniq = function () {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'uniq', 'filter');
-    // all current managed arrays are already enforced as unique
-    return this.slice();
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.uniqBy = function (key) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'uniqBy', 'filter');
-    // all current managed arrays are already enforced as unique
-    let seen = new Set();
-    let result = [];
-    this.forEach(item => {
-      let value = get(item, key);
-      if (seen.has(value)) {
-        return;
-      }
-      seen.add(value);
-      result.push(item);
-    });
-    return result;
-  };
-  IdentifierArray.prototype.without = function (value) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'without', 'slice');
-    const newArr = this.slice();
-    const index = this.indexOf(value);
-    if (index !== -1) {
-      newArr.splice(index, 1);
-    }
-    return newArr;
-  };
-
-  // @ts-expect-error
-  IdentifierArray.prototype.firstObject = null;
-  // @ts-expect-error
-  IdentifierArray.prototype.lastObject = null;
-}
 function assertRecordPassedToHasMany(record) {
   assert(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`, function () {
     try {
@@ -4582,21 +2978,12 @@ function assertRecordPassedToHasMany(record) {
     }
   }());
 }
-function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
-  if (!recordOrPromiseRecord) {
+function extractIdentifierFromRecord$1(record) {
+  if (!record) {
     return null;
   }
-  if (isPromiseRecord$1(recordOrPromiseRecord)) {
-    let content = recordOrPromiseRecord.content;
-    assert('You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo relationship.', content !== undefined && content !== null);
-    assertRecordPassedToHasMany(content);
-    return recordIdentifierFor(content);
-  }
-  assertRecordPassedToHasMany(recordOrPromiseRecord);
-  return recordIdentifierFor(recordOrPromiseRecord);
-}
-function isPromiseRecord$1(record) {
-  return !!record.then;
+  assertRecordPassedToHasMany(record);
+  return recordIdentifierFor(record);
 }
 
 /**
@@ -5123,6 +3510,42 @@ class RequestStateService {
     return null;
   }
 }
+function constructResource(type, id, lid) {
+  if (typeof type === 'object' && type !== null) {
+    let resource = type;
+    if (isStableIdentifier(resource)) {
+      return resource;
+    }
+    if ('id' in resource) {
+      resource.id = coerceId(resource.id);
+    }
+    assert('Expected either id or lid to be a valid string', 'id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid));
+    assert('if id is present, the type must be a string', !('id' in resource) || typeof resource.type === 'string');
+    return resource;
+  } else {
+    const trueId = coerceId(id);
+    if (!isNonEmptyString(trueId)) {
+      if (isNonEmptyString(lid)) {
+        return {
+          lid
+        };
+      }
+      throw new Error('Expected either id or lid to be a valid string');
+    }
+    assert('type must be a string', typeof type === 'string');
+    if (isNonEmptyString(lid)) {
+      return {
+        type,
+        id: trueId,
+        lid
+      };
+    }
+    return {
+      type,
+      id: trueId
+    };
+  }
+}
 
 /**
   @module @ember-data/store
@@ -5414,7 +3837,7 @@ class Store {
   instantiateRecord(identifier, createRecordArgs) {
     if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       let modelName = identifier.type;
-      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(identifier) : this.cache;
+      const cache = this.cache;
       // TODO deprecate allowing unknown args setting
       let createOptions = {
         _createProps: createRecordArgs,
@@ -5614,7 +4037,7 @@ class Store {
     assert(`You need to pass a model name to the store's modelFor method`, modelName);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
     if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      let normalizedModelName = normalizeModelName$1(modelName);
+      let normalizedModelName = normalizeModelName(modelName);
       let maybeFactory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
 
       // for factorFor factory/class split
@@ -5670,7 +4093,7 @@ class Store {
     let record;
     _backburner.join(() => {
       this._join(() => {
-        let normalizedModelName = normalizeModelName$1(modelName);
+        let normalizedModelName = normalizeModelName(modelName);
         let properties = {
           ...inputProperties
         };
@@ -5700,8 +4123,8 @@ class Store {
           assert(`The id ${properties.id} has already been used with another '${normalizedModelName}' record.`, !identifier);
         }
         const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
-        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 cache = this.cache;
+        const createOptions = normalizeProperties(this, identifier, properties);
         const resultProps = cache.clientDidCreate(identifier, createOptions);
         record = this._instanceCache.getRecord(identifier, resultProps);
       });
@@ -5727,11 +4150,8 @@ class Store {
       assertDestroyingStore(this, 'deleteRecord');
     }
     const identifier = peekRecordIdentifier(record);
-    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
-      identifier,
-      bucket: 'resourceCache'
-    }) : this.cache);
-    assert(`expected a cache instance to exist for the record`, cache);
+    const cache = this.cache;
+    assert(`expected the record to be connected to a cache`, identifier);
     this._join(() => {
       cache.setIsDeleted(identifier, true);
       if (cache.isNew(identifier)) {
@@ -5765,43 +4185,6 @@ class Store {
     }
   }
 
-  /**
-    @method find
-    @param {String} modelName
-    @param {String|Integer} id
-    @param {Object} options
-    @return {Promise} promise
-    @deprecated
-    @private
-  */
-  find(modelName, id, options) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'find');
-    }
-    // The default `model` hook in Route calls `find(modelName, id)`,
-    // that's why we have to keep this method around even though `findRecord` is
-    // the public way to get a record by modelName and id.
-    assert(`Using store.find(type) has been removed. Use store.findAll(modelName) to retrieve all records for a given type.`, arguments.length !== 1);
-    assert(`Calling store.find(modelName, id, { preload: preload }) is no longer supported. Use store.findRecord(modelName, id, { preload: preload }) instead.`, !options);
-    assert(`You need to pass the model name and id to the store's find method`, arguments.length === 2);
-    assert(`You cannot pass '${id}' as id to the store's find method`, typeof id === 'string' || typeof id === 'number');
-    assert(`Calling store.find() with a query object is no longer supported. Use store.query() instead.`, typeof id !== 'object');
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_STORE_FIND)) {
-      deprecate(`Using store.find is deprecated, use store.findRecord instead. Likely this means you are relying on the implicit store fetching behavior of routes unknowingly.`, false, {
-        id: 'ember-data:deprecate-store-find',
-        since: {
-          available: '4.5',
-          enabled: '4.5'
-        },
-        for: 'ember-data',
-        until: '5.0'
-      });
-      return this.findRecord(modelName, id);
-    }
-    assert(`store.find has been removed. Use store.findRecord instead.`);
-  }
-
   /**
     This method returns a record for a given identifier or type and id combination.
      The `findRecord` method will always resolve its promise with the same
@@ -6093,7 +4476,7 @@ class Store {
       options = id;
     } else {
       assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`, typeof resource === 'string');
-      const type = normalizeModelName$1(resource);
+      const type = normalizeModelName(resource);
       const normalizedId = ensureStringId(id);
       resource = constructResource(type, normalizedId);
     }
@@ -6120,11 +4503,6 @@ class Store {
         [SkipCache]: true
       }
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseObject(promise.then(document => {
-        return document.content;
-      }));
-    }
     return promise.then(document => {
       return document.content;
     });
@@ -6168,7 +4546,7 @@ class Store {
     if (arguments.length === 1 && isMaybeIdentifier(resource)) {
       resourceIdentifier = resource;
     } else {
-      const type = normalizeModelName$1(resource);
+      const type = normalizeModelName(resource);
       const normalizedId = ensureStringId(id);
       resourceIdentifier = constructResource(type, normalizedId);
     }
@@ -6225,7 +4603,7 @@ class Store {
     }
     assert(`You need to pass a model name to the store's peekRecord method`, identifier);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${identifier}`, typeof identifier === 'string');
-    const type = normalizeModelName$1(identifier);
+    const type = normalizeModelName(identifier);
     const normalizedId = ensureStringId(id);
     const resource = {
       type,
@@ -6236,52 +4614,6 @@ class Store {
     return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
   }
 
-  /**
-   This method returns true if a record for a given modelName and id is already
-   loaded in the store. Use this function to know beforehand if a findRecord()
-   will result in a request or that it will be a cache hit.
-    Example
-    ```javascript
-   store.hasRecordForId('post', 1); // false
-   store.findRecord('post', 1).then(function() {
-     store.hasRecordForId('post', 1); // true
-   });
-   ```
-     @method hasRecordForId
-    @deprecated
-    @public
-    @param {String} modelName
-    @param {(String|Integer)} id
-    @return {Boolean}
-  */
-  hasRecordForId(modelName, id) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HAS_RECORD)) {
-      deprecate(`store.hasRecordForId has been deprecated in favor of store.peekRecord`, false, {
-        id: 'ember-data:deprecate-has-record-for-id',
-        since: {
-          available: '4.5',
-          enabled: '4.5'
-        },
-        until: '5.0',
-        for: 'ember-data'
-      });
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        assertDestroyingStore(this, 'hasRecordForId');
-      }
-      assert(`You need to pass a model name to the store's hasRecordForId method`, modelName);
-      assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-      const type = normalizeModelName$1(modelName);
-      const trueId = ensureStringId(id);
-      const resource = {
-        type,
-        id: trueId
-      };
-      const identifier = this.identifierCache.peekRecordIdentifier(resource);
-      return Boolean(identifier && this._instanceCache.recordIsLoaded(identifier));
-    }
-    assert(`store.hasRecordForId has been removed`);
-  }
-
   /**
     This method delegates a query to the adapter. This is the one place where
     adapter-level semantics are exposed to the application.
@@ -6329,7 +4661,7 @@ class Store {
     const promise = this.request({
       op: 'query',
       data: {
-        type: normalizeModelName$1(modelName),
+        type: normalizeModelName(modelName),
         query,
         options: options || {}
       },
@@ -6337,9 +4669,6 @@ class Store {
         [SkipCache]: true
       }
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(promise.then(document => document.content));
-    }
     return promise.then(document => document.content);
   }
 
@@ -6434,7 +4763,7 @@ class Store {
     const promise = this.request({
       op: 'queryRecord',
       data: {
-        type: normalizeModelName$1(modelName),
+        type: normalizeModelName(modelName),
         query,
         options: options || {}
       },
@@ -6442,9 +4771,6 @@ class Store {
         [SkipCache]: true
       }
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseObject(promise.then(document => document.content));
-    }
     return promise.then(document => document.content);
   }
 
@@ -6608,16 +4934,13 @@ class Store {
     const promise = this.request({
       op: 'findAll',
       data: {
-        type: normalizeModelName$1(modelName),
+        type: normalizeModelName(modelName),
         options: options || {}
       },
       cacheOptions: {
         [SkipCache]: true
       }
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(promise.then(document => document.content));
-    }
     return promise.then(document => document.content);
   }
 
@@ -6647,7 +4970,7 @@ class Store {
     }
     assert(`You need to pass a model name to the store's peekAll method`, modelName);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let type = normalizeModelName$1(modelName);
+    let type = normalizeModelName(modelName);
     return this.recordArrayManager.liveArrayFor(type);
   }
 
@@ -6684,7 +5007,7 @@ class Store {
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
-        let normalizedModelName = normalizeModelName$1(modelName);
+        let normalizedModelName = normalizeModelName(modelName);
         this._instanceCache.clear(normalizedModelName);
       }
     });
@@ -6863,15 +5186,9 @@ class Store {
     }
     let ret;
     this._join(() => {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-        ret = legacyCachePut(this, {
-          content: jsonApiDoc
-        });
-      } else {
-        ret = this.cache.put({
-          content: jsonApiDoc
-        });
-      }
+      ret = this.cache.put({
+        content: jsonApiDoc
+      });
     });
     this._enableAsyncFlush = null;
     return ret.data;
@@ -6934,7 +5251,7 @@ class Store {
     } else {
       payload = inputPayload;
       assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-      let normalizedModelName = normalizeModelName$1(modelName);
+      let normalizedModelName = normalizeModelName(modelName);
       serializer = this.serializerFor(normalizedModelName);
     }
     assert(`You must define a pushPayload method in your serializer in order to call store.pushPayload`, serializer.pushPayload);
@@ -6969,17 +5286,14 @@ class Store {
     }
     assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
     let identifier = recordIdentifierFor(record);
-    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
-      identifier,
-      bucket: 'resourceCache'
-    }) : this.cache);
-    if (!cache) {
+    const cache = this.cache;
+    if (!identifier) {
       // this commonly means we're disconnected
       // but just in case we reject here to prevent bad things.
       return Promise.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}`, cache && this._instanceCache.recordIsLoaded(identifier));
+    assert(`Cannot initiate a save request for an unloaded record: ${identifier}`, this._instanceCache.recordIsLoaded(identifier));
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
@@ -7044,26 +5358,12 @@ class Store {
     if (!cache) {
       cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
       if (macroCondition(getOwnConfig().env.DEBUG)) {
-        cache = new SingletonCacheManager(cache);
+        cache = new CacheManager(cache);
       }
     }
     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.
@@ -7088,7 +5388,7 @@ class Store {
     }
     assert(`You need to pass a model name to the store's normalize method`, modelName);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName$1(modelName);
+    let normalizedModelName = normalizeModelName(modelName);
     let serializer = this.serializerFor(normalizedModelName);
     let model = this.modelFor(normalizedModelName);
     assert(`You must define a normalize method in your serializer in order to call store.normalize`, serializer?.normalize);
@@ -7113,7 +5413,7 @@ class Store {
     }
     assert(`You need to pass a model name to the store's adapterFor method`, modelName);
     assert(`Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName$1(modelName);
+    let normalizedModelName = normalizeModelName(modelName);
     let {
       _adapterCache
     } = this;
@@ -7137,25 +5437,6 @@ class Store {
       _adapterCache.application = adapter;
       return adapter;
     }
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_JSON_API_FALLBACK)) {
-      // final fallback, no model specific adapter, no application adapter, no
-      // `adapter` property on store: use json-api adapter
-      adapter = _adapterCache['-json-api'] || owner.lookup('adapter:-json-api');
-      if (adapter !== undefined) {
-        deprecate(`Your application is utilizing a deprecated hidden fallback adapter (-json-api). Please implement an application adapter to function as your fallback.`, false, {
-          id: 'ember-data:deprecate-secret-adapter-fallback',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-        _adapterCache[normalizedModelName] = adapter;
-        _adapterCache['-json-api'] = adapter;
-        return adapter;
-      }
-    }
     assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`);
   }
 
@@ -7179,7 +5460,7 @@ class Store {
     }
     assert(`You need to pass a model name to the store's serializerFor method`, modelName);
     assert(`Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName$1(modelName);
+    let normalizedModelName = normalizeModelName(modelName);
     let {
       _serializerCache
     } = this;
@@ -7259,7 +5540,7 @@ function isDSModel(record) {
   }
   return !!record && 'constructor' in record && 'isModel' in record.constructor && record.constructor.isModel === true;
 }
-function normalizeProperties(store, identifier, properties, isForV1 = false) {
+function normalizeProperties(store, identifier, properties) {
   // assert here
   if (properties !== undefined) {
     if ('id' in properties) {
@@ -7285,9 +5566,9 @@ function normalizeProperties(store, identifier, properties, isForV1 = false) {
             if (macroCondition(getOwnConfig().env.DEBUG)) {
               assertRecordsPassedToHasMany(properties[prop]);
             }
-            relationshipValue = extractIdentifiersFromRecords(properties[prop], isForV1);
+            relationshipValue = extractIdentifiersFromRecords(properties[prop]);
           } else {
-            relationshipValue = extractIdentifierFromRecord(properties[prop], isForV1);
+            relationshipValue = extractIdentifierFromRecord(properties[prop]);
           }
           properties[prop] = relationshipValue;
         }
@@ -7309,53 +5590,19 @@ function assertRecordsPassedToHasMany(records) {
     });
   }());
 }
-function extractIdentifiersFromRecords(records, isForV1 = false) {
-  return records.map(record => extractIdentifierFromRecord(record, isForV1));
+function extractIdentifiersFromRecords(records) {
+  return records.map(record => extractIdentifierFromRecord(record));
 }
-function extractIdentifierFromRecord(recordOrPromiseRecord, isForV1 = false) {
+function extractIdentifierFromRecord(recordOrPromiseRecord) {
   if (!recordOrPromiseRecord) {
     return null;
   }
-  const extract = isForV1 ? peekCache : recordIdentifierFor;
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-    if (isPromiseRecord(recordOrPromiseRecord)) {
-      let content = recordOrPromiseRecord.content;
-      assert('You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.', content !== undefined);
-      deprecate(`You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`, false, {
-        id: 'ember-data:deprecate-promise-proxies',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return content ? extract(content) : null;
-    }
-  }
+  const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
-function isPromiseRecord(record) {
-  return !!record.then;
-}
 function secretInit(record, cache, identifier, store) {
   setRecordIdentifier(record, identifier);
   StoreMap.set(record, store);
   setCacheFor(record, cache);
 }
-function normalizeModelName(modelName) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
-    deprecate(`the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`, false, {
-      id: 'ember-data:deprecate-normalize-modelname-helper',
-      for: 'ember-data',
-      until: '5.0',
-      since: {
-        available: '4.7',
-        enabled: '4.7'
-      }
-    });
-    return normalizeModelName$1(modelName);
-  }
-  assert(`normalizeModelName support has been removed`);
-}
-export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, removeRecordDataFor as l, normalizeModelName as n, peekCache as p, recordIdentifierFor as r, storeFor as s };
+export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, IDENTIFIER_ARRAY_TAG as h, isStableIdentifier as i, fastPush as j, removeRecordDataFor as k, notifyArray as n, peekCache as p, recordIdentifierFor as r, storeFor as s };