@ember-data/model 4.12.0-alpha.2 → 4.12.0-alpha.20

package/addon/{has-many-26353d30.js → has-many-465843f4.js}

@@ -1,8 +1,8 @@
-import { macroCondition, isDevelopingApp, getOwnConfig, importSync, dependencySatisfies } from '@embroider/macros';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { assert, deprecate, warn, inspect } from '@ember/debug';
 import EmberObject, { computed, get } from '@ember/object';
-import { recordIdentifierFor, storeFor } from '@ember-data/store';
-import { recordDataFor, RecordArray, MUTATE, SOURCE, recordIdentifierFor as recordIdentifierFor$1, IDENTIFIER_ARRAY_TAG, notifyArray, isStableIdentifier, storeFor as storeFor$1, fastPush, coerceId } from '@ember-data/store/-private';
+import { recordIdentifierFor, storeFor as storeFor$1 } from '@ember-data/store';
+import { peekCache, RecordArray, MUTATE, SOURCE, recordIdentifierFor as recordIdentifierFor$1, IDENTIFIER_ARRAY_TAG, notifyArray, isStableIdentifier, storeFor, fastPush, coerceId } from '@ember-data/store/-private';
 import { dasherize } from '@ember/string';
 import ArrayMixin, { A, NativeArray } from '@ember/array';
 import { singularize } from 'ember-inflector';
@@ -10,7 +10,6 @@ import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
 import { cached, tracked } from '@glimmer/tracking';
 import Ember from 'ember';
-import { resolve, all } from 'rsvp';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
 import ArrayProxy from '@ember/array/proxy';
@@ -103,9 +102,7 @@ function computedMacroWithOptionalParams(fn) {
   ```
 
   ```app/transforms/text.js
-  import Transform from '@ember-data/serializer/transform';
-
-  export default class TextTransform extends Transform {
+  export default class TextTransform {
     serialize(value, options) {
       if (options.uppercase) {
         return value.toUpperCase();
@@ -117,6 +114,10 @@ function computedMacroWithOptionalParams(fn) {
     deserialize(value) {
       return value;
     }
+
+    static create() {
+      return new this();
+    }
   }
   ```
 
@@ -142,7 +143,7 @@ function attr(type, options) {
   };
   return computed({
     get(key) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
         }
@@ -150,20 +151,20 @@ function attr(type, options) {
       if (this.isDestroyed || this.isDestroying) {
         return;
       }
-      return recordDataFor(this).getAttr(recordIdentifierFor(this), key);
+      return peekCache(this).getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
         }
       }
       assert(`Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`, !this.currentState.isDeleted);
       const identifier = recordIdentifierFor(this);
-      const recordData = storeFor(this)._instanceCache.getRecordData(identifier);
-      let currentValue = recordData.getAttr(identifier, key);
+      const cache = peekCache(this);
+      let currentValue = cache.getAttr(identifier, key);
       if (currentValue !== value) {
-        recordData.setAttr(identifier, key, value);
+        cache.setAttr(identifier, key, value);
         if (!this.isValid) {
           const {
             errors
@@ -214,7 +215,7 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
 const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
 function promiseObject(promise) {
   return PromiseObject.create({
-    promise: resolve(promise)
+    promise
   });
 }
 
@@ -225,7 +226,7 @@ const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected',
 const ProxySymbolString = String(Symbol.for('PROXY_CONTENT'));
 function deprecatedPromiseObject(promise) {
   const promiseObjectProxy = promiseObject(promise);
-  if (macroCondition(!isDevelopingApp())) {
+  if (macroCondition(!getOwnConfig().env.DEBUG)) {
     return promiseObjectProxy;
   }
   const handler = {
@@ -268,6 +269,11 @@ function deprecatedPromiseObject(promise) {
   return new Proxy(promiseObjectProxy, handler);
 }
 var _dec$1, _dec2, _dec3, _dec4, _class$6, _descriptor$5, _descriptor2$2;
+
+/**
+  @module @ember-data/model
+*/
+
 // we force the type here to our own construct because mixin and extend patterns
 // lose generic signatures. We also do this because we need to Omit `clear` from
 // the type of ArrayProxy as we override it's signature.
@@ -632,384 +638,6 @@ let Errors = (_dec$1 = computed(), _dec2 = mapBy('content', 'message'), _dec3 =
   writable: true,
   initializer: null
 })), _class$6));
-function iterateData(data, fn) {
-  if (Array.isArray(data)) {
-    return data.map(fn);
-  } else {
-    return fn(data);
-  }
-}
-function assertIdentifierHasId(identifier) {
-  assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
-}
-function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
-  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
-  validateDocumentStructure(normalizedResponse);
-  return normalizedResponse;
-}
-function validateDocumentStructure(doc) {
-  if (macroCondition(isDevelopingApp())) {
-    let errors = [];
-    if (!doc || typeof doc !== 'object') {
-      errors.push('Top level of a JSON API document must be an object');
-    } else {
-      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
-        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
-      } else {
-        if ('data' in doc && 'errors' in doc) {
-          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
-        }
-      }
-      if ('data' in doc) {
-        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
-          errors.push('data must be null, an object, or an array');
-        }
-      }
-      if ('meta' in doc) {
-        if (typeof doc.meta !== 'object') {
-          errors.push('meta must be an object');
-        }
-      }
-      if ('errors' in doc) {
-        if (!Array.isArray(doc.errors)) {
-          errors.push('errors must be an array');
-        }
-      }
-      if ('links' in doc) {
-        if (typeof doc.links !== 'object') {
-          errors.push('links must be an object');
-        }
-      }
-      if ('jsonapi' in doc) {
-        if (typeof doc.jsonapi !== 'object') {
-          errors.push('jsonapi must be an object');
-        }
-      }
-      if ('included' in doc) {
-        if (typeof doc.included !== 'object') {
-          errors.push('included must be an array');
-        }
-      }
-    }
-    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
-  }
-}
-function _findHasMany(adapter, store, identifier, link, relationship, options) {
-  const record = store._instanceCache.getRecord(identifier);
-  const snapshot = store._instanceCache.createSnapshot(identifier, options);
-  let modelClass = store.modelFor(relationship.type);
-  let useLink = !link || typeof link === 'string';
-  let relatedLink = useLink ? link : link.href;
-  let promise = adapter.findHasMany(store, snapshot, relatedLink, relationship);
-  let label = `DS: Handle Adapter#findHasMany of '${identifier.type}' : '${relationship.type}'`;
-  promise = guardDestroyedStore(promise, store, label);
-  promise = promise.then(adapterPayload => {
-    if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    assert(`You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.key}' relationship, using link '${link}' , but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
-    let serializer = store.serializerFor(relationship.type);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');
-    assert(`fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: [] }`, 'data' in payload && Array.isArray(payload.data));
-    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
-    return store._push(payload);
-  }, null, `DS: Extract payload of '${identifier.type}' : hasMany '${relationship.type}'`);
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-    promise = _guard(promise, _bind(_objectIsAlive, record));
-  }
-  return promise;
-}
-function _findBelongsTo(store, identifier, link, relationship, options) {
-  const record = store._instanceCache.getRecord(identifier);
-  let adapter = store.adapterFor(identifier.type);
-  assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);
-  assert(`You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`, typeof adapter.findBelongsTo === 'function');
-  let snapshot = store._instanceCache.createSnapshot(identifier, options);
-  let modelClass = store.modelFor(relationship.type);
-  let useLink = !link || typeof link === 'string';
-  let relatedLink = useLink ? link : link.href;
-  let promise = adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
-  let label = `DS: Handle Adapter#findBelongsTo of ${identifier.type} : ${relationship.type}`;
-  promise = guardDestroyedStore(promise, store, label);
-  promise = _guard(promise, _bind(_objectIsAlive, record));
-  promise = promise.then(adapterPayload => {
-    if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    let serializer = store.serializerFor(relationship.type);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');
-    assert(`fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: null }`, 'data' in payload && (payload.data === null || typeof payload.data === 'object' && !Array.isArray(payload.data)));
-    if (!payload.data && !payload.links && !payload.meta) {
-      return null;
-    }
-    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
-    return store._push(payload);
-  }, null, `DS: Extract payload of ${identifier.type} : ${relationship.type}`);
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-    promise = _guard(promise, _bind(_objectIsAlive, record));
-  }
-  return promise;
-}
-
-// sync
-// iterate over records in payload.data
-// for each record
-//   assert that record.relationships[inverse] is either undefined (so we can fix it)
-//     or provide a data: {id, type} that matches the record that requested it
-//   return the relationship data for the parent
-function syncRelationshipDataFromLink(store, payload, parentIdentifier, relationship) {
-  // ensure the right hand side (incoming payload) points to the parent record that
-  // requested this relationship
-  let relationshipData = payload.data ? iterateData(payload.data, (data, index) => {
-    const {
-      id,
-      type
-    } = data;
-    ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);
-    return {
-      id,
-      type
-    };
-  }) : null;
-  const relatedDataHash = {};
-  if ('meta' in payload) {
-    relatedDataHash.meta = payload.meta;
-  }
-  if ('links' in payload) {
-    relatedDataHash.links = payload.links;
-  }
-  if ('data' in payload) {
-    relatedDataHash.data = relationshipData;
-  }
-
-  // now, push the left hand side (the parent record) to ensure things are in sync, since
-  // the payload will be pushed with store._push
-  const parentPayload = {
-    id: parentIdentifier.id,
-    type: parentIdentifier.type,
-    relationships: {
-      [relationship.key]: relatedDataHash
-    }
-  };
-  if (!Array.isArray(payload.included)) {
-    payload.included = [];
-  }
-  payload.included.push(parentPayload);
-  return payload;
-}
-function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
-  let {
-    id,
-    type
-  } = payload;
-  if (!payload.relationships) {
-    payload.relationships = {};
-  }
-  let {
-    relationships
-  } = payload;
-  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
-  if (inverse) {
-    let {
-      inverseKey,
-      kind
-    } = inverse;
-    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
-    if (macroCondition(isDevelopingApp())) {
-      if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
-        let inspect = function inspect(thing) {
-          return `'${JSON.stringify(thing)}'`;
-        };
-        let quotedType = inspect(type);
-        let quotedInverse = inspect(inverseKey);
-        let expected = inspect({
-          id: parentIdentifier.id,
-          type: parentIdentifier.type
-        });
-        let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
-        let got = inspect(relationshipData);
-        let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
-        let path = `${prefix}.relationships.${inverseKey}.data`;
-        let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
-        let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
-        let includedRecord = `<${type}:${id}>`;
-        let message = [`Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`, `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`, `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`, `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`, `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`].join('\n');
-        assert(message);
-      }
-    }
-    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
-      relationships[inverseKey] = relationships[inverseKey] || {};
-      relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentIdentifier);
-    }
-  }
-}
-function metaIsRelationshipDefinition(meta) {
-  return typeof meta._inverseKey === 'function';
-}
-function inverseForRelationship(store, identifier, key) {
-  const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
-  if (!definition) {
-    return null;
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE)) {
-    if (metaIsRelationshipDefinition(definition)) {
-      const modelClass = store.modelFor(identifier.type);
-      return definition._inverseKey(store, modelClass);
-    }
-  }
-  assert(`Expected the relationship defintion to specify the inverse type or null.`, definition.options?.inverse === null || typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0);
-  return definition.options.inverse;
-}
-function getInverse(store, parentIdentifier, parentRelationship, type) {
-  let {
-    name: lhs_relationshipName
-  } = parentRelationship;
-  let {
-    type: parentType
-  } = parentIdentifier;
-  let inverseKey = inverseForRelationship(store, {
-    type: parentType
-  }, lhs_relationshipName);
-  if (inverseKey) {
-    const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type
-    });
-    let {
-      kind
-    } = definition[inverseKey];
-    return {
-      inverseKey,
-      kind
-    };
-  }
-}
-function relationshipDataPointsToParent(relationshipData, identifier) {
-  if (relationshipData === null) {
-    return false;
-  }
-  if (Array.isArray(relationshipData)) {
-    if (relationshipData.length === 0) {
-      return false;
-    }
-    for (let i = 0; i < relationshipData.length; i++) {
-      let entry = relationshipData[i];
-      if (validateRelationshipEntry(entry, identifier)) {
-        return true;
-      }
-    }
-  } else {
-    return validateRelationshipEntry(relationshipData, identifier);
-  }
-  return false;
-}
-function fixRelationshipData(relationshipData, relationshipKind, {
-  id,
-  type
-}) {
-  let parentRelationshipData = {
-    id,
-    type
-  };
-  let payload;
-  if (relationshipKind === 'hasMany') {
-    payload = relationshipData || [];
-    if (relationshipData) {
-      // these arrays could be massive so this is better than filter
-      // Note: this is potentially problematic if type/id are not in the
-      // same state of normalization.
-      let found = relationshipData.find(v => {
-        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
-      });
-      if (!found) {
-        payload.push(parentRelationshipData);
-      }
-    } else {
-      payload.push(parentRelationshipData);
-    }
-  } else {
-    payload = relationshipData || {};
-    Object.assign(payload, parentRelationshipData);
-  }
-  return payload;
-}
-function validateRelationshipEntry({
-  id
-}, {
-  id: parentModelID
-}) {
-  return id && id.toString() === parentModelID;
-}
-function _bind(fn, ...args) {
-  return function () {
-    return fn.apply(undefined, args);
-  };
-}
-function _guard(promise, test) {
-  let guarded = promise.finally(() => {
-    if (!test()) {
-      guarded._subscribers.length = 0;
-    }
-  });
-  return guarded;
-}
-function _objectIsAlive(object) {
-  return !(object.isDestroyed || object.isDestroying);
-}
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length;
-  }
-}
-function guardDestroyedStore(promise, store, label) {
-  let token;
-  if (macroCondition(isDevelopingApp())) {
-    token = store._trackAsyncRequestStart(label);
-  }
-  let wrapperPromise = resolve(promise, label).then(_v => {
-    if (!_objectIsAlive(store)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    return promise;
-  });
-  return _guard(wrapperPromise, () => {
-    if (macroCondition(isDevelopingApp())) {
-      store._trackAsyncRequestEnd(token);
-    }
-    return _objectIsAlive(store);
-  });
-}
 
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
@@ -1118,7 +746,7 @@ class RelatedCollection extends RecordArray {
     switch (prop) {
       case 'length 0':
         {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'replaceRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1129,7 +757,7 @@ class RelatedCollection extends RecordArray {
       case 'replace cell':
         {
           const [index, prior, value] = args;
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'replaceRelatedRecord',
             record: this.identifier,
             field: this.key,
@@ -1140,7 +768,7 @@ class RelatedCollection extends RecordArray {
           break;
         }
       case 'push':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'addToRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1149,7 +777,7 @@ class RelatedCollection extends RecordArray {
         break;
       case 'pop':
         if (result) {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1158,7 +786,7 @@ class RelatedCollection extends RecordArray {
         }
         break;
       case 'unshift':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'addToRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1168,7 +796,7 @@ class RelatedCollection extends RecordArray {
         break;
       case 'shift':
         if (result) {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1178,7 +806,7 @@ class RelatedCollection extends RecordArray {
         }
         break;
       case 'sort':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'sortRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1190,7 +818,7 @@ class RelatedCollection extends RecordArray {
           const [start, removeCount, ...adds] = args;
           // detect a full replace
           if (removeCount > 0 && adds.length === this[SOURCE].length) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'replaceRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1199,7 +827,7 @@ class RelatedCollection extends RecordArray {
             return;
           }
           if (removeCount > 0) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'removeFromRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1208,7 +836,7 @@ class RelatedCollection extends RecordArray {
             });
           }
           if (adds?.length) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'addToRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1278,6 +906,7 @@ class RelatedCollection extends RecordArray {
     const {
       store
     } = this;
+    assert(`Expected modelName to be set`, this.modelName);
     const record = store.createRecord(this.modelName, hash);
     this.push(record);
     return record;
@@ -1286,7 +915,7 @@ class RelatedCollection extends RecordArray {
 RelatedCollection.prototype.isAsync = false;
 RelatedCollection.prototype.isPolymorphic = false;
 RelatedCollection.prototype.identifier = null;
-RelatedCollection.prototype.recordData = null;
+RelatedCollection.prototype.cache = null;
 RelatedCollection.prototype._inverseIsAsync = false;
 RelatedCollection.prototype.key = '';
 RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
@@ -1328,6 +957,9 @@ function isPromiseRecord$1(record) {
   return !!record.then;
 }
 var _dec, _class$5;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 const Extended = PromiseObject;
 
 /**
@@ -1374,6 +1006,26 @@ let PromiseBelongsTo = (_dec = computed(), (_class$5 = class PromiseBelongsTo ex
   }
 }, (_applyDecoratedDescriptor(_class$5.prototype, "id", [cached], Object.getOwnPropertyDescriptor(_class$5.prototype, "id"), _class$5.prototype), _applyDecoratedDescriptor(_class$5.prototype, "meta", [_dec], Object.getOwnPropertyDescriptor(_class$5.prototype, "meta"), _class$5.prototype)), _class$5));
 var _class$4, _descriptor$4, _descriptor2$1, _descriptor3, _descriptor4, _descriptor5;
+
+/**
+ @module @ember-data/model
+ */
+/**
+  This class is returned as the result of accessing an async hasMany relationship
+  on an instance of a Model extending from `@ember-data/model`.
+
+  A PromiseManyArray is an iterable proxy that allows templates to consume related
+  ManyArrays and update once their contents are no longer pending.
+
+  In your JS code you should resolve the promise first.
+
+  ```js
+  const comments = await post.comments;
+  ```
+
+  @class PromiseManyArray
+  @public
+*/
 let PromiseManyArray = (_class$4 = class PromiseManyArray {
   // @deprecated (isDestroyed is not deprecated)
 
@@ -1430,7 +1082,7 @@ let PromiseManyArray = (_class$4 = class PromiseManyArray {
         }
         return false;
       };
-    } else if (macroCondition(isDevelopingApp())) {
+    } else if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not use A() on an EmberData PromiseManyArray`);
@@ -1652,7 +1304,7 @@ function tapPromise(proxy, promise) {
   proxy.isSettled = false;
   proxy.isFulfilled = false;
   proxy.isRejected = false;
-  return resolve(promise).then(content => {
+  return Promise.resolve(promise).then(content => {
     proxy.isPending = false;
     proxy.isFulfilled = true;
     proxy.isSettled = true;
@@ -1715,7 +1367,7 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHA
   `record.relationshipFor(key)`.
 */
 let assertPolymorphicType;
-if (macroCondition(isDevelopingApp())) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {
     if (modelClass.__isMixin) {
       return modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||
@@ -1967,7 +1619,8 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
   }
   _resource() {
     this._ref; // subscribe
-    return this.store._instanceCache.getRecordData(this.___identifier).getRelationship(this.___identifier, this.key);
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.store._instanceCache.getResourceCache(this.___identifier) : this.store.cache;
+    return cache.getRelationship(this.___identifier, this.key);
   }
 
   /**
@@ -2057,7 +1710,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
     let jsonApiDoc = data;
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
       if (data.then) {
-        jsonApiDoc = await resolve(data);
+        jsonApiDoc = await data;
         if (jsonApiDoc !== data) {
           deprecate(`You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`, false, {
             id: 'ember-data:deprecate-promise-proxies',
@@ -2072,7 +1725,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
       }
     }
     let record = this.store.push(jsonApiDoc);
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       assertPolymorphicType(this.belongsToRelationship.identifier, this.belongsToRelationship.definition, recordIdentifierFor$1(record), this.store);
     }
@@ -2332,7 +1985,8 @@ let HasManyReference = (_class$2 = class HasManyReference {
     return [];
   }
   _resource() {
-    return this.store._instanceCache.getRecordData(this.___identifier).getRelationship(this.___identifier, this.key);
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.store._instanceCache.getResourceCache(this.___identifier) : this.store.cache;
+    return cache.getRelationship(this.___identifier, this.key);
   }
 
   /**
@@ -2549,7 +2203,7 @@ let HasManyReference = (_class$2 = class HasManyReference {
     let payload = objectOrPromise;
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
       if (objectOrPromise.then) {
-        payload = await resolve(objectOrPromise);
+        payload = await objectOrPromise;
         if (payload !== objectOrPromise) {
           deprecate(`You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`, false, {
             id: 'ember-data:deprecate-promise-proxies',
@@ -2582,7 +2236,7 @@ let HasManyReference = (_class$2 = class HasManyReference {
           data: obj
         });
       }
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let relationshipMeta = this.hasManyRelationship.definition;
         let identifier = this.hasManyRelationship.identifier;
 
@@ -2775,9 +2429,9 @@ let HasManyReference = (_class$2 = class HasManyReference {
 class LegacySupport {
   constructor(record) {
     this.record = record;
-    this.store = storeFor$1(record);
+    this.store = storeFor(record);
     this.identifier = recordIdentifierFor$1(record);
-    this.recordData = this.store._instanceCache.getRecordData(this.identifier);
+    this.cache = peekCache(record);
     this._manyArrayCache = Object.create(null);
     this._relationshipPromisesCache = Object.create(null);
     this._relationshipProxyCache = Object.create(null);
@@ -2800,8 +2454,8 @@ class LegacySupport {
     currentState.length = 0;
     fastPush(currentState, identifiers);
   }
-  updateCache(operation) {
-    this.recordData.update(operation);
+  mutate(mutation) {
+    this.cache.mutate(mutation);
   }
   _findBelongsTo(key, resource, relationship, options) {
     // TODO @runspired follow up if parent isNew then we should not be attempting load here
@@ -2816,7 +2470,7 @@ class LegacySupport {
     const graphFor = importSync('@ember-data/graph/-private').graphFor;
     const relationship = graphFor(this.store).get(this.identifier, key);
     assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
-    let resource = this.recordData.getRelationship(this.identifier, key);
+    let resource = this.cache.getRelationship(this.identifier, key);
     relationship.state.hasFailedLoadAttempt = false;
     relationship.state.shouldForceReload = true;
     let promise = this._findBelongsTo(key, resource, relationship, options);
@@ -2830,9 +2484,9 @@ class LegacySupport {
   getBelongsTo(key, options) {
     const {
       identifier,
-      recordData
+      cache
     } = this;
-    let resource = recordData.getRelationship(this.identifier, key);
+    let resource = cache.getRelationship(this.identifier, key);
     let relatedIdentifier = resource && resource.data ? resource.data : null;
     assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
     const store = this.store;
@@ -2868,7 +2522,7 @@ class LegacySupport {
     }
   }
   setDirtyBelongsTo(key, value) {
-    return this.recordData.update({
+    return this.cache.mutate({
       op: 'replaceRelatedRecord',
       record: this.identifier,
       field: key,
@@ -2878,7 +2532,7 @@ class LegacySupport {
     true);
   }
   _getCurrentState(identifier, field) {
-    let jsonApi = this.recordData.getRelationship(identifier, field, true);
+    let jsonApi = this.cache.getRelationship(identifier, field, true);
     const cache = this.store._instanceCache;
     let identifiers = [];
     if (jsonApi.data) {
@@ -2893,7 +2547,7 @@ class LegacySupport {
     return [identifiers, jsonApi];
   }
   getManyArray(key, definition) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let manyArray = this._manyArrayCache[key];
       if (!definition) {
         const graphFor = importSync('@ember-data/graph/-private').graphFor;
@@ -2905,7 +2559,7 @@ class LegacySupport {
           store: this.store,
           type: definition.type,
           identifier: this.identifier,
-          recordData: this.recordData,
+          cache: this.cache,
           identifiers,
           key,
           meta: doc.meta || null,
@@ -2924,16 +2578,16 @@ class LegacySupport {
     assert('hasMany only works with the @ember-data/json-api package');
   }
   fetchAsyncHasMany(key, relationship, manyArray, options) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
       }
-      const jsonApi = this.recordData.getRelationship(this.identifier, key);
+      const jsonApi = this.cache.getRelationship(this.identifier, key);
       const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
       if (!promise) {
         manyArray.isLoaded = true;
-        return resolve(manyArray);
+        return Promise.resolve(manyArray);
       }
       loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, key, relationship, manyArray), e => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e));
       this._relationshipPromisesCache[key] = loadingPromise;
@@ -2942,7 +2596,7 @@ class LegacySupport {
     assert('hasMany only works with the @ember-data/json-api package');
   }
   reloadHasMany(key, options) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
@@ -2967,7 +2621,7 @@ class LegacySupport {
     assert(`hasMany only works with the @ember-data/json-api package`);
   }
   getHasMany(key, options) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       const relationship = graphFor(this.store).get(this.identifier, key);
       const {
@@ -3025,7 +2679,7 @@ class LegacySupport {
   referenceFor(kind, name) {
     let reference = this.references[name];
     if (!reference) {
-      if (macroCondition(!dependencySatisfies("@ember-data/json-api", "*"))) {
+      if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
         // TODO @runspired while this feels odd, it is not a regression in capability because we do
         // not today support references pulling from RecordDatas other than our own
         // because of the intimate API access involved. This is something we will need to redesign.
@@ -3034,7 +2688,7 @@ class LegacySupport {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       const graph = graphFor(this.store);
       const relationship = graph.get(this.identifier, name);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (kind) {
           let modelName = this.identifier.type;
           let actualRelationshipKind = relationship.definition.kind;
@@ -3052,7 +2706,7 @@ class LegacySupport {
     return reference;
   }
   _findHasManyByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       if (!resource) {
         return;
       }
@@ -3069,66 +2723,52 @@ class LegacySupport {
         shouldForceReload
       } = state;
       const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-      const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+      const identifiers = resource.data;
+      const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof identifiers === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor({
+        type: definition.inverseType
+      })[definition.key];
+      const request = {
+        useLink: shouldFindViaLink,
+        field: relationshipMeta,
+        links: resource.links,
+        meta: resource.meta,
+        options,
+        record: parentIdentifier
+      };
 
       // fetch via link
       if (shouldFindViaLink) {
-        // findHasMany, although not public, does not need to care about our upgrade relationship definitions
-        // and can stick with the public definition API for now.
-        const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor({
-          type: definition.inverseType
-        })[definition.key];
-        let adapter = this.store.adapterFor(parentIdentifier.type);
-
-        /*
-          If a relationship was originally populated by the adapter as a link
-          (as opposed to a list of IDs), this method is called when the
-          relationship is fetched.
-           The link (which is usually a URL) is passed through unchanged, so the
-          adapter can make whatever request it wants.
-           The usual use-case is for the server to register a URL as a link, and
-          then use that URL in the future to make a request for the relationship.
-        */
-        assert(`You tried to load a hasMany relationship but you have no adapter (for ${parentIdentifier.type})`, adapter);
-        assert(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`, typeof adapter.findHasMany === 'function');
-        return _findHasMany(adapter, this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+        assert(`Expected collection to be an array`, !identifiers || Array.isArray(identifiers));
+        assert(`Expected stable identifiers`, !identifiers || identifiers.every(isStableIdentifier));
+        return this.store.request({
+          op: 'findHasMany',
+          records: identifiers || [],
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
+        });
       }
       const preferLocalCache = hasReceivedData && !isEmpty;
-      const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(resource.data) && resource.data.length > 0;
-
-      // fetch using data, pulling from local cache if possible
-      if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
-        if (allInverseRecordsAreLoaded) {
-          return;
-        }
-        assert(`Expected collection to be an array`, Array.isArray(resource.data));
-        if (allInverseRecordsAreLoaded) {
-          return;
-        }
-        let finds = new Array(resource.data.length);
-        let cache = this.store._instanceCache;
-        for (let i = 0; i < resource.data.length; i++) {
-          const identifier = resource.data[i];
-          assert(`expected a stable identifier`, isStableIdentifier(identifier));
-          finds[i] = cache._fetchDataIfNeededForIdentifier(identifier, options);
-        }
-        return all(finds);
+      const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(identifiers) && identifiers.length > 0;
+      const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
+      if (attemptLocalCache && allInverseRecordsAreLoaded) {
+        return;
       }
-      let hasData = hasReceivedData && !isEmpty;
-
-      // fetch by data
-      if (hasData || hasLocalPartialData) {
-        const identifiers = resource.data;
+      const hasData = hasReceivedData && !isEmpty;
+      if (attemptLocalCache || hasData || hasLocalPartialData) {
         assert(`Expected collection to be an array`, Array.isArray(identifiers));
         assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
-        let fetches = new Array(identifiers.length);
-        const manager = this.store._fetchManager;
-        for (let i = 0; i < identifiers.length; i++) {
-          let identifier = identifiers[i];
-          assertIdentifierHasId(identifier);
-          fetches[i] = manager.scheduleFetch(identifier, options);
-        }
-        return all(fetches);
+        options.reload = options.reload || !attemptLocalCache || undefined;
+        return this.store.request({
+          op: 'findHasMany',
+          records: identifiers,
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
+        });
       }
 
       // we were explicitly told we have no data and no links.
@@ -3139,7 +2779,14 @@ class LegacySupport {
   }
   _findBelongsToByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
     if (!resource) {
-      return resolve(null);
+      return Promise.resolve(null);
+    }
+
+    // interleaved promises mean that we MUST cache this here
+    // in order to prevent infinite re-render if the request
+    // fails.
+    if (this._pending) {
+      return this._pending;
     }
     const identifier = resource.data ? resource.data : null;
     assert(`Expected a stable identifier`, !identifier || isStableIdentifier(identifier));
@@ -3150,53 +2797,71 @@ class LegacySupport {
       isEmpty,
       shouldForceReload
     } = relationship.state;
-
-    // short circuit if we are already loading
-    let pendingRequest = identifier && this.store._fetchManager.getPendingFetch(identifier, options);
-    if (pendingRequest) {
-      return pendingRequest;
-    }
     const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
     const shouldFindViaLink = resource.links?.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+    const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[relationship.definition.key];
+    assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
+    const request = {
+      useLink: shouldFindViaLink,
+      field: relationshipMeta,
+      links: resource.links,
+      meta: resource.meta,
+      options,
+      record: parentIdentifier
+    };
 
     // fetch via link
     if (shouldFindViaLink) {
-      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[relationship.definition.key];
-      assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
-      return _findBelongsTo(this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+      const future = this.store.request({
+        op: 'findBelongsTo',
+        records: identifier ? [identifier] : [],
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
+      });
+      this._pending = future.then(doc => doc.content).finally(() => {
+        this._pending = null;
+      });
+      return this._pending;
     }
-    let preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
-    let hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
+    const preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
+    const hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
     // null is explicit empty, undefined is "we don't know anything"
-    const localDataIsEmpty = resource.data === undefined || resource.data === null;
-
-    // fetch using data, pulling from local cache if possible
-    if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
-      /*
-        We have canonical data, but our local state is empty
-       */
-      if (localDataIsEmpty) {
-        return resolve(null);
-      }
-      if (!identifier) {
-        assert(`No Information found for ${resource.data.lid}`, identifier);
-      }
-      return this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
-    }
-    let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
-    if (identifier && resourceIsLocal) {
-      return resolve(identifier);
-    }
-
-    // fetch by data
-    if (identifier && !localDataIsEmpty) {
-      assertIdentifierHasId(identifier);
-      return this.store._fetchManager.scheduleFetch(identifier, options);
+    const localDataIsEmpty = !identifier;
+    const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
+
+    // we dont need to fetch and are empty
+    if (attemptLocalCache && localDataIsEmpty) {
+      return Promise.resolve(null);
+    }
+
+    // we dont need to fetch because we are local state
+    const resourceIsLocal = identifier?.id === null;
+    if (attemptLocalCache && allInverseRecordsAreLoaded || resourceIsLocal) {
+      return Promise.resolve(identifier);
+    }
+
+    // we may need to fetch
+    if (identifier) {
+      assert(`Cannot fetch belongs-to relationship with no information`, identifier);
+      options.reload = options.reload || !attemptLocalCache || undefined;
+      this._pending = this.store.request({
+        op: 'findBelongsTo',
+        records: [identifier],
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
+      }).then(doc => doc.content).finally(() => {
+        this._pending = null;
+      });
+      return this._pending;
     }
 
     // we were explicitly told we have no data and no links.
     //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-    return resolve(null);
+    return Promise.resolve(null);
   }
   destroy() {
     this.isDestroying = true;
@@ -3245,11 +2910,14 @@ function handleCompletedRelationshipRequest(recordExt, key, relationship, value,
       if (proxy.content && proxy.content.isDestroying) {
         proxy.set('content', null);
       }
+      recordExt.store.notifications._flush();
     }
     throw error;
   }
   if (isHasMany) {
     value.isLoaded = true;
+  } else {
+    recordExt.store.notifications._flush();
   }
   relationship.state.hasFailedLoadAttempt = false;
   // only set to not stale if no error is thrown
@@ -3356,7 +3024,8 @@ function notifyRelationship(identifier, key, record, meta) {
 }
 function notifyAttribute(store, identifier, key, record) {
   let currentValue = cacheFor(record, key);
-  if (currentValue !== store._instanceCache.getRecordData(identifier).getAttr(identifier, key)) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? peekCache(record) : store.cache;
+  if (currentValue !== cache.getAttr(identifier, key)) {
     record.notifyPropertyChange(key);
   }
 }
@@ -3491,11 +3160,11 @@ root
 let RecordState = (_class3 = class RecordState {
   constructor(record) {
     _initializerDefineProperty(this, "isSaving", _descriptor2, this);
-    const store = storeFor(record);
+    const store = storeFor$1(record);
     const identity = recordIdentifierFor$1(record);
     this.identifier = identity;
     this.record = record;
-    this.cache = store._instanceCache.getRecordData(identity);
+    this.cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? peekCache(record) : store.cache;
     this.pendingCount = 0;
     this.fulfilledCount = 0;
     this.rejectedCount = 0;
@@ -3555,7 +3224,7 @@ let RecordState = (_class3 = class RecordState {
 
     // we instantiate lazily
     // so we grab anything we don't have yet
-    if (macroCondition(!isDevelopingApp())) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       const lastRequest = requests.getLastRequestForRecord(identity);
       if (lastRequest) {
         handleRequest(lastRequest);
@@ -3580,7 +3249,7 @@ let RecordState = (_class3 = class RecordState {
     });
   }
   destroy() {
-    storeFor(this.record).notifications.unsubscribe(this.handler);
+    storeFor$1(this.record).notifications.unsubscribe(this.handler);
   }
   notify(key) {
     getTag(this, key).notify();
@@ -3814,7 +3483,7 @@ class RelationshipDefinition {
       inverse = modelClass.inverseFor(this.key, store);
     }
     // TODO make this error again for the non-polymorphic case
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (!this.options.polymorphic) {
         modelClass.typeForRelationship(this.key, store);
       }
@@ -3839,6 +3508,7 @@ function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
   let support = LEGACY_SUPPORT.get(identifier);
   if (!support) {
+    assert(`Memory Leak Detected`, !record.isDestroyed && !record.isDestroying);
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
     LEGACY_SUPPORT.set(record, support);
@@ -3897,7 +3567,7 @@ function computeOnce(target, key, desc) {
 }
 
 /**
-  Base class from which Models can be define.
+  Base class from which Models can be defined.
 
   ```js
   import Model, { attr } from '@ember-data/model';
@@ -3931,7 +3601,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     _initializerDefineProperty(this, "isReloading", _descriptor, this);
   }
   init(options = {}) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (!options._secretInit && !options._createProps) {
         throw new Error('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');
       }
@@ -3943,8 +3613,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     let store = this.store = _secretInit.store;
     super.init(options);
     let identity = _secretInit.identifier;
-    _secretInit.cb(this, _secretInit.recordData, identity, _secretInit.store);
-    this.___recordState = macroCondition(isDevelopingApp()) ? new RecordState(this) : null;
+    _secretInit.cb(this, _secretInit.cache, identity, _secretInit.store);
+    this.___recordState = macroCondition(getOwnConfig().env.DEBUG) ? new RecordState(this) : null;
     this.setProperties(createProps);
     let notifications = store.notifications;
     this.___private_notifications = notifications.subscribe(identity, (identifier, type, key) => {
@@ -3954,7 +3624,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   destroy() {
     const identifier = recordIdentifierFor(this);
     this.___recordState?.destroy();
-    const store = storeFor(this);
+    const store = storeFor$1(this);
     store.notifications.unsubscribe(this.___private_notifications);
     // Legacy behavior is to notify the relationships on destroy
     // such that they "clear". It's uncertain this behavior would
@@ -4189,7 +3859,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     return this.currentState.isError;
   }
   set isError(v) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       throw new Error(`isError is not directly settable`);
     }
   }
@@ -4214,7 +3884,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // this guard exists, because some dev-only deprecation code
     // (addListener via validatePropertyInjections) invokes toString before the
     // object is real.
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       try {
         return recordIdentifierFor(this).id;
       } catch {
@@ -4249,7 +3919,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // when using legacy/classic ember classes. Basically: lazy in prod and eager in dev.
     // so we do this to try to steer folks to the nicer "dont user currentState"
     // error.
-    if (macroCondition(!isDevelopingApp())) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       if (!this.___recordState) {
         this.___recordState = new RecordState(this);
       }
@@ -4345,7 +4015,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @return {Object} an object whose values are primitive JSON values only
   */
   serialize(options) {
-    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this)).serialize(options);
+    return storeFor$1(this).serializeRecord(this, options);
   }
 
   /*
@@ -4394,7 +4064,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   deleteRecord() {
     // ensure we've populated currentState prior to deleting a new record
     if (this.currentState) {
-      storeFor(this).deleteRecord(this);
+      storeFor$1(this).deleteRecord(this);
     }
   }
 
@@ -4441,7 +4111,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     } = this.currentState;
     this.deleteRecord();
     if (isNew) {
-      return resolve(this);
+      return Promise.resolve(this);
     }
     return this.save(options).then(_ => {
       run(() => {
@@ -4461,7 +4131,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     if (this.currentState.isNew && (this.isDestroyed || this.isDestroying)) {
       return;
     }
-    storeFor(this).unloadRecord(this);
+    storeFor$1(this).unloadRecord(this);
   }
 
   /**
@@ -4517,7 +4187,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return recordDataFor(this).changedAttrs(recordIdentifierFor(this));
+    return peekCache(this).changedAttrs(recordIdentifierFor(this));
   }
 
   /**
@@ -4542,8 +4212,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     const {
       isNew
     } = currentState;
-    storeFor(this)._join(() => {
-      recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
+    storeFor$1(this)._join(() => {
+      peekCache(this).rollbackAttrs(recordIdentifierFor(this));
       this.errors.clear();
       currentState.cleanErrorRequests();
       if (isNew) {
@@ -4558,7 +4228,12 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   */
   // TODO @deprecate in favor of a public API or examples of how to test successfully
   _createSnapshot() {
-    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this));
+    const store = storeFor$1(this);
+    if (!store._fetchManager) {
+      const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
+      store._fetchManager = new FetchManager(store);
+    }
+    return store._fetchManager.createSnapshot(recordIdentifierFor(this));
   }
 
   /**
@@ -4598,9 +4273,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   save(options) {
     let promise;
     if (this.currentState.isNew && this.currentState.isDeleted) {
-      promise = resolve(this);
+      promise = Promise.resolve(this);
     } else {
-      promise = storeFor(this).saveRecord(this, options);
+      promise = storeFor$1(this).saveRecord(this, options);
     }
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
       return deprecatedPromiseObject(promise);
@@ -4631,16 +4306,22 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     adapter returns successfully or rejected if the adapter returns
     with an error.
   */
-  reload(_options) {
-    let options = {};
-    if (typeof _options === 'object' && _options !== null && _options.adapterOptions) {
-      options.adapterOptions = _options.adapterOptions;
-    }
+  reload(options = {}) {
     options.isReloading = true;
-    let identifier = recordIdentifierFor(this);
+    options.reload = true;
+    const identifier = recordIdentifierFor(this);
     assert(`You cannot reload a record without an ID`, identifier.id);
     this.isReloading = true;
-    const promise = storeFor(this)._fetchManager.scheduleFetch(identifier, options).then(() => this).finally(() => {
+    const promise = storeFor$1(this).request({
+      op: 'findRecord',
+      data: {
+        options,
+        record: identifier
+      },
+      cacheOptions: {
+        [Symbol.for('ember-data:skip-cache')]: true
+      }
+    }).then(() => this).finally(() => {
       this.isReloading = false;
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
@@ -4808,11 +4489,46 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     return this.constructor.relationshipsByName.get(name);
   }
   inverseFor(key) {
-    return this.constructor.inverseFor(key, storeFor(this));
+    return this.constructor.inverseFor(key, storeFor$1(this));
   }
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
+
+  /**
+    Create should only ever be called by the store. To create an instance of a
+    `Model` in a dirty state use `store.createRecord`.
+    To create instances of `Model` in a clean state, use `store.push`
+     @method create
+    @private
+    @static
+  */
+  /**
+   Represents the model's class name as a string. This can be used to look up the model's class name through
+   `Store`'s modelFor method.
+    `modelName` is generated for you by Ember Data. It will be a lowercased, dasherized string.
+   For example:
+    ```javascript
+   store.modelFor('post').modelName; // 'post'
+   store.modelFor('blog-post').modelName; // 'blog-post'
+   ```
+    The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
+   keys to underscore (instead of dasherized), you might use the following code:
+    ```javascript
+   import RESTSerializer from '@ember-data/serializer/rest';
+   import { underscore } from '<app-name>/utils/string-utils';
+    export default const PostSerializer = RESTSerializer.extend({
+     payloadKeyFromModelName(modelName) {
+       return underscore(modelName);
+     }
+   });
+   ```
+   @property modelName
+    @public
+   @type String
+   @readonly
+   @static
+  */
   /*
    These class methods below provide relationship
    introspection abilities about relationships.
@@ -4826,7 +4542,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    do it before using your model with the store, which uses these properties
    extensively.
    */
-
   /**
    For a given relationship name, returns the model type of the relationship.
     For example, if you define a model like this:
@@ -4980,7 +4695,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       if (possibleRelationships.length === 0) {
         return null;
       }
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let filteredRelationships = possibleRelationships.filter(possibleRelationship => {
           let optionsForRelationship = possibleRelationship.options;
           return name === optionsForRelationship.inverse;
@@ -4998,7 +4713,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
 
     // ensure inverse is properly configured
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (isPolymorphic) {
         if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
           if (!inverseOptions.as) {
@@ -5020,7 +4735,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
 
     // ensure we are properly configured
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (inverseOptions.polymorphic) {
         if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
           if (!options.as) {
@@ -5186,7 +4901,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    import { get } from '@ember/object';
    import Blog from 'app/models/blog';
     let relatedTypes = Blog.relatedTypes');
-   //=> [ User, Post ]
+   //=> ['user', 'post']
    ```
     @property relatedTypes
     @public
@@ -5274,7 +4989,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     for (let i = 0; i < relationships.length; i++) {
       let key = relationships[i];
       let value = rels[key];
-      map.set(value.key, value);
+      map.set(value.name || value.key, value);
     }
     return map;
   }
@@ -5721,16 +5436,21 @@ if (macroCondition(getOwnConfig().includeDataAdapter)) {
    @private
    */
   Model.prototype._debugInfo = function () {
-    let attributes = ['id'];
     let relationships = {};
     let expensiveProperties = [];
-    this.eachAttribute((name, meta) => attributes.push(name));
+    const identifier = recordIdentifierFor(this);
+    const schema = this.store.getSchemaDefinitionService();
+    const attrDefs = schema.attributesDefinitionFor(identifier);
+    const relDefs = schema.relationshipsDefinitionFor(identifier);
+    const attributes = Object.keys(attrDefs);
+    attributes.unshift('id');
     let groups = [{
       name: 'Attributes',
       properties: attributes,
       expand: true
     }];
-    this.eachRelationship((name, relationship) => {
+    Object.keys(relDefs).forEach(name => {
+      const relationship = relDefs[name];
       let properties = relationships[relationship.kind];
       if (properties === undefined) {
         properties = relationships[relationship.kind] = [];
@@ -5758,7 +5478,7 @@ if (macroCondition(getOwnConfig().includeDataAdapter)) {
     };
   };
 }
-if (macroCondition(isDevelopingApp())) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   let lookupDescriptor = function lookupDescriptor(obj, keyName) {
     let current = obj;
     do {
@@ -5861,6 +5581,7 @@ function normalizeType$1(type) {
   ```
 
   #### One-To-Many
+
   To declare a one-to-many relationship between two models, use
   `belongsTo` in combination with `hasMany`, like this:
 
@@ -5868,7 +5589,7 @@ function normalizeType$1(type) {
   import Model, { hasMany } from '@ember-data/model';
 
   export default class PostModel extends Model {
-    @hasMany('comment') comments;
+    @hasMany('comment', { async: false, inverse: 'post' }) comments;
   }
   ```
 
@@ -5876,23 +5597,10 @@ function normalizeType$1(type) {
   import Model, { belongsTo } from '@ember-data/model';
 
   export default class CommentModel extends Model {
-    @belongsTo('post') post;
-  }
-  ```
-
-  You can avoid passing a string as the first parameter. In that case Ember Data
-  will infer the type from the key name.
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo post;
+    @belongsTo('post', { async: false, inverse: 'comments' }) post;
   }
   ```
 
-  will lookup for a Post type.
-
   #### Sync relationships
 
   Ember Data resolves sync relationships with the related resources
@@ -5904,7 +5612,8 @@ function normalizeType$1(type) {
 
   export default class CommentModel extends Model {
     @belongsTo('post', {
-      async: false
+      async: false,
+      inverse: null
     })
     post;
   }
@@ -6007,7 +5716,7 @@ function belongsTo(modelName, options) {
         return null;
       }
       const support = lookupLegacySupport(this);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
         }
@@ -6026,7 +5735,7 @@ function belongsTo(modelName, options) {
     },
     set(key, value) {
       const support = lookupLegacySupport(this);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
         }
@@ -6257,7 +5966,7 @@ function hasMany(type, options) {
   };
   return computed({
     get(key) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
         }
@@ -6268,7 +5977,7 @@ function hasMany(type, options) {
       return lookupLegacySupport(this).getHasMany(key);
     },
     set(key, records) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
         }