@ember-data/model 4.12.0-alpha.11 → 4.12.0-alpha.13

package/addon/{has-many-27395cb2.js → has-many-f4cb2303.js}

@@ -1,4 +1,4 @@
-import { isDevelopingApp, macroCondition, getOwnConfig, importSync } 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 as storeFor$1 } from '@ember-data/store';
@@ -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';
@@ -144,7 +143,7 @@ function attr(type, options) {
   };
   return computed({
     get(key) {
-      if (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()}`);
         }
@@ -155,7 +154,7 @@ function attr(type, options) {
       return peekCache(this).getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
-      if (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()}`);
         }
@@ -216,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
   });
 }
 
@@ -227,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 (!isDevelopingApp()) {
+  if (macroCondition(!getOwnConfig().env.DEBUG)) {
     return promiseObjectProxy;
   }
   const handler = {
@@ -634,384 +633,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 (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 (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 (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 (isDevelopingApp()) {
-      store._trackAsyncRequestEnd(token);
-    }
-    return _objectIsAlive(store);
-  });
-}
 
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
@@ -1433,7 +1054,7 @@ let PromiseManyArray = (_class$4 = class PromiseManyArray {
         }
         return false;
       };
-    } else if (isDevelopingApp()) {
+    } else if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not use A() on an EmberData PromiseManyArray`);
@@ -1655,7 +1276,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;
@@ -1718,7 +1339,7 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHA
   `record.relationshipFor(key)`.
 */
 let assertPolymorphicType;
-if (isDevelopingApp()) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {
     if (modelClass.__isMixin) {
       return modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||
@@ -2061,7 +1682,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',
@@ -2076,7 +1697,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
       }
     }
     let record = this.store.push(jsonApiDoc);
-    if (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);
     }
@@ -2554,7 +2175,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',
@@ -2587,7 +2208,7 @@ let HasManyReference = (_class$2 = class HasManyReference {
           data: obj
         });
       }
-      if (isDevelopingApp()) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let relationshipMeta = this.hasManyRelationship.definition;
         let identifier = this.hasManyRelationship.identifier;
 
@@ -2938,7 +2559,7 @@ class LegacySupport {
       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;
@@ -3039,7 +2660,7 @@ class LegacySupport {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       const graph = graphFor(this.store);
       const relationship = graph.get(this.identifier, name);
-      if (isDevelopingApp()) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (kind) {
           let modelName = this.identifier.type;
           let actualRelationshipKind = relationship.definition.kind;
@@ -3074,66 +2695,46 @@ 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
+        });
       }
       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._fetchManager;
-        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
+        });
       }
 
       // we were explicitly told we have no data and no links.
@@ -3144,7 +2745,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));
@@ -3155,53 +2763,65 @@ 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
+      });
+      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._fetchManager.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
+      }).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;
@@ -3250,11 +2870,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
@@ -3561,7 +3184,7 @@ let RecordState = (_class3 = class RecordState {
 
     // we instantiate lazily
     // so we grab anything we don't have yet
-    if (!isDevelopingApp()) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       const lastRequest = requests.getLastRequestForRecord(identity);
       if (lastRequest) {
         handleRequest(lastRequest);
@@ -3820,7 +3443,7 @@ class RelationshipDefinition {
       inverse = modelClass.inverseFor(this.key, store);
     }
     // TODO make this error again for the non-polymorphic case
-    if (isDevelopingApp()) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (!this.options.polymorphic) {
         modelClass.typeForRelationship(this.key, store);
       }
@@ -3938,7 +3561,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     _initializerDefineProperty(this, "isReloading", _descriptor, this);
   }
   init(options = {}) {
-    if (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.');
       }
@@ -3951,7 +3574,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     super.init(options);
     let identity = _secretInit.identifier;
     _secretInit.cb(this, _secretInit.cache, identity, _secretInit.store);
-    this.___recordState = isDevelopingApp() ? new RecordState(this) : null;
+    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) => {
@@ -4196,7 +3819,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     return this.currentState.isError;
   }
   set isError(v) {
-    if (isDevelopingApp()) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       throw new Error(`isError is not directly settable`);
     }
   }
@@ -4221,7 +3844,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 (isDevelopingApp()) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       try {
         return recordIdentifierFor(this).id;
       } catch {
@@ -4256,7 +3879,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 (!isDevelopingApp()) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       if (!this.___recordState) {
         this.___recordState = new RecordState(this);
       }
@@ -4352,7 +3975,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @return {Object} an object whose values are primitive JSON values only
   */
   serialize(options) {
-    return storeFor$1(this)._instanceCache.createSnapshot(recordIdentifierFor(this)).serialize(options);
+    return storeFor$1(this).serializeRecord(this, options);
   }
 
   /*
@@ -4448,7 +4071,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(() => {
@@ -4565,7 +4188,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$1(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));
   }
 
   /**
@@ -4605,7 +4233,7 @@ 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$1(this).saveRecord(this, options);
     }
@@ -4638,16 +4266,19 @@ 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$1(this)._fetchManager.scheduleFetch(identifier, options).then(() => this).finally(() => {
+    const promise = storeFor$1(this).request({
+      op: 'findRecord',
+      data: {
+        options,
+        record: identifier
+      }
+    }).then(() => this).finally(() => {
       this.isReloading = false;
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
@@ -4987,7 +4618,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       if (possibleRelationships.length === 0) {
         return null;
       }
-      if (isDevelopingApp()) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let filteredRelationships = possibleRelationships.filter(possibleRelationship => {
           let optionsForRelationship = possibleRelationship.options;
           return name === optionsForRelationship.inverse;
@@ -5005,7 +4636,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
 
     // ensure inverse is properly configured
-    if (isDevelopingApp()) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (isPolymorphic) {
         if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
           if (!inverseOptions.as) {
@@ -5027,7 +4658,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
 
     // ensure we are properly configured
-    if (isDevelopingApp()) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (inverseOptions.polymorphic) {
         if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
           if (!options.as) {
@@ -5281,7 +4912,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;
   }
@@ -5728,16 +5359,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] = [];
@@ -5765,7 +5401,7 @@ if (macroCondition(getOwnConfig().includeDataAdapter)) {
     };
   };
 }
-if (isDevelopingApp()) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   let lookupDescriptor = function lookupDescriptor(obj, keyName) {
     let current = obj;
     do {
@@ -6014,7 +5650,7 @@ function belongsTo(modelName, options) {
         return null;
       }
       const support = lookupLegacySupport(this);
-      if (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()}`);
         }
@@ -6033,7 +5669,7 @@ function belongsTo(modelName, options) {
     },
     set(key, value) {
       const support = lookupLegacySupport(this);
-      if (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()}`);
         }
@@ -6264,7 +5900,7 @@ function hasMany(type, options) {
   };
   return computed({
     get(key) {
-      if (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()}`);
         }
@@ -6275,7 +5911,7 @@ function hasMany(type, options) {
       return lookupLegacySupport(this).getHasMany(key);
     },
     set(key, records) {
-      if (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()}`);
         }