@warp-drive/legacy 5.8.0-alpha.4 → 5.8.0-alpha.41

package/dist/{errors-8kD2mSe_.js → errors-Cz5KrzBk.js}

@@ -1,8 +1,9 @@
 import { Context } from '@warp-drive/core/reactive/-private';
-import { memoized, defineSignal, assertPrivateStore, defineNonEnumerableSignal, isResourceKey, recordIdentifierFor, isPrivateStore, storeFor, fastPush, createLegacyManyArray, notifyInternalSignal } from '@warp-drive/core/store/-private';
+import { memoized, defineSignal, defineNonEnumerableSignal, notifyInternalSignal } from '@warp-drive/core/signals/-leaked';
+import { assertPrivateStore, isResourceKey, recordIdentifierFor, isPrivateStore, storeFor, fastPush, createLegacyManyArray } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { EnableHydration } from '@warp-drive/core/types/request';
-import { u as upgradeStore } from "./-private-8UmnAf9J.js";
+import { u as upgradeStore } from "./-private-BG3bMiKp.js";
 import { computed, get } from '@ember/object';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
@@ -87,7 +88,6 @@ PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
   const comments = await post.comments;
   ```
 
-  @class PromiseManyArray
   @public
 */
 class PromiseManyArray {
@@ -99,7 +99,6 @@ class PromiseManyArray {
 
   /**
    * Retrieve the length of the content
-   * @property length
    * @public
    */
   get length() {
@@ -148,8 +147,6 @@ class PromiseManyArray {
   /**
    * Reload the relationship
    * @public
-   * @param options
-   * @return
    */
   reload(options) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -166,32 +163,24 @@ class PromiseManyArray {
   /**
    * Whether the loading promise is still pending
    *
-   * @property isPending
-   * @type {Boolean}
    * @public
    */
 
   /**
    * Whether the loading promise rejected
    *
-   * @property isRejected
-   * @type {Boolean}
    * @public
    */
 
   /**
    * Whether the loading promise succeeded
    *
-   * @property isFulfilled
-   * @type {Boolean}
    * @public
    */
 
   /**
    * Whether the loading promise completed (resolved or rejected)
    *
-   * @property isSettled
-   * @type {Boolean}
    * @public
    */
 
@@ -207,8 +196,6 @@ class PromiseManyArray {
   /**
    * catch errors thrown by this promise
    * @public
-   * @param callback
-   * @return {Promise}
    */
   catch(cb) {
     return this.promise.catch(cb);
@@ -218,8 +205,6 @@ class PromiseManyArray {
    * run cleanup after this promise completes
    *
    * @public
-   * @param callback
-   * @return {Promise}
    */
   finally(cb) {
     return this.promise.finally(cb);
@@ -237,7 +222,6 @@ class PromiseManyArray {
 
   /**
    * Retrieve the links for this relationship
-   * @property links
    * @public
    */
   get links() {
@@ -246,7 +230,6 @@ class PromiseManyArray {
 
   /**
    * Retrieve the meta for this relationship
-   * @property meta
    * @public
    */
   static {
@@ -344,11 +327,11 @@ function isResourceIdentiferWithRelatedLinks$1(value) {
  and manipulation of a hasMany relationship.
 
  It is especially useful when you're dealing with `async` relationships
- from `@ember-data/model` as it allows synchronous access to
+ from `@warp-drive/legacy/model` as it allows synchronous access to
  the relationship data if loaded, as well as APIs for loading, reloading
  the data or accessing available information without triggering a load.
 
- It may also be useful when using `sync` relationships with `@ember-data/model`
+ It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
  that need to be loaded/reloaded with more precise timing than marking the
  relationship as `async` and relying on autofetch would have allowed.
 
@@ -494,7 +477,7 @@ class HasManyReference {
    }
    ```
     @public
-   @return {String} The name of the remote type. This should either be `link` or `ids`
+   @return The name of the remote type. This should either be `link` or `ids`
    */
   remoteType() {
     const value = this._resource();
@@ -529,14 +512,14 @@ class HasManyReference {
     commentsRef.ids(); // ['1']
    ```
      @public
-   @return {Array} The ids in this has-many relationship
+   @return The ids in this has-many relationship
    */
   ids() {
     return this.identifiers.map(identifier => identifier.id);
   }
 
   /**
-   The link Ember Data will use to fetch or reload this belongs-to
+   The link WarpDrive will use to fetch or reload this belongs-to
    relationship. By default it uses only the "related" resource linkage.
     Example
     ```javascript
@@ -565,7 +548,7 @@ class HasManyReference {
     }
    ```
     @public
-   @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+   @return The link WarpDrive will use to fetch or reload this belongs-to relationship.
    */
   link() {
     const resource = this._resource();
@@ -620,7 +603,7 @@ class HasManyReference {
     usersRef.meta() // { lastUpdated: 1458014400000 }
    ```
    @public
-  @return {Object|null} The meta information for the belongs-to relationship.
+  @return The meta information for the belongs-to relationship.
   */
   meta() {
     let meta = null;
@@ -632,7 +615,7 @@ class HasManyReference {
   }
 
   /**
-   `push` can be used to update the data in the relationship and EmberData
+   `push` can be used to update the data in the relationship and WarpDrive
    will treat the new data as the canonical value of this relationship on
    the backend. An empty array will signify the canonical value should be
    empty.
@@ -706,9 +689,8 @@ class HasManyReference {
    particularly useful if you want to update the state of the relationship without
    forcing the load of all of the associated records.
     @public
-   @param {Array|Object} doc a JSONAPI document object describing the new value of this relationship.
-   @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-   @return {Promise<ManyArray | void>}
+   @param doc a JSONAPI document object describing the new value of this relationship.
+   @param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
   */
   async push(doc, skipFetch) {
     const {
@@ -800,7 +782,6 @@ class HasManyReference {
    })
    ```
      @public
-   @return {ManyArray}
    */
   value() {
     const support = LEGACY_SUPPORT.get(this.___identifier);
@@ -860,8 +841,8 @@ class HasManyReference {
    });
    ```
     @public
-   @param {Object} options the options to pass in.
-   @return {Promise} a promise that resolves with the ManyArray in
+   @param options the options to pass in.
+   @return a promise that resolves with the ManyArray in
    this has-many relationship.
    */
   async load(options) {
@@ -908,9 +889,9 @@ class HasManyReference {
     ```javascript
    commentsRef.reload({ adapterOptions: { isPrivate: true } })
    ```
-     @public
-   @param {Object} options the options to pass in.
-   @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
+    @public
+   @param options the options to pass in.
+   @return a promise that resolves with the ManyArray in this has-many relationship.
    */
   reload(options) {
     const support = LEGACY_SUPPORT.get(this.___identifier);
@@ -951,11 +932,11 @@ function isResourceIdentiferWithRelatedLinks(value) {
  and manipulation of a belongsTo relationship.
 
  It is especially useful when you're dealing with `async` relationships
- from `@ember-data/model` as it allows synchronous access to
+ from `@warp-drive/legacy/model` as it allows synchronous access to
  the relationship data if loaded, as well as APIs for loading, reloading
  the data or accessing available information without triggering a load.
 
- It may also be useful when using `sync` relationships with `@ember-data/model`
+ It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
  that need to be loaded/reloaded with more precise timing than marking the
  relationship as `async` and relying on autofetch would have allowed.
 
@@ -971,24 +952,17 @@ function isResourceIdentiferWithRelatedLinks(value) {
  References are "stable", meaning that multiple calls to retrieve the reference
   for a given relationship will always return the same HasManyReference.
 
- @class BelongsToReference
  @public
  */
 class BelongsToReference {
   /**
    * The field name on the parent record for this has-many relationship.
    *
-   * @property key
-   * @type {String}
-   * @public
    */
 
   /**
    * The type of resource this relationship will contain.
    *
-   * @property type
-   * @type {String}
-   * @public
    */
 
   // unsubscribe tokens given to us by the notification manager
@@ -1024,9 +998,6 @@ class BelongsToReference {
    * The identifier of the record that this reference refers to.
    * `null` if no related record is known.
    *
-   * @property identifier
-   * @type {ResourceKey | null}
-   * @public
    */
   get identifier() {
     if (this.___relatedToken) {
@@ -1077,7 +1048,7 @@ class BelongsToReference {
     }
    ```
     @public
-   @return {String} The id of the record in this belongsTo relationship.
+   @return The id of the record in this belongsTo relationship.
    */
   static {
     decorateMethodV2(this.prototype, "identifier", [memoized]);
@@ -1087,7 +1058,7 @@ class BelongsToReference {
   }
 
   /**
-   The link Ember Data will use to fetch or reload this belongs-to
+   The link WarpDrive will use to fetch or reload this belongs-to
    relationship. By default it uses only the "related" resource linkage.
     Example
     ```javascript
@@ -1116,7 +1087,7 @@ class BelongsToReference {
     }
    ```
     @public
-   @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+   @return The link WarpDrive will use to fetch or reload this belongs-to relationship.
    */
   link() {
     const resource = this._resource();
@@ -1171,7 +1142,7 @@ class BelongsToReference {
     userRef.meta() // { lastUpdated: 1458014400000 }
    ```
      @public
-   @return {Object} The meta information for the belongs-to relationship.
+   @return The meta information for the belongs-to relationship.
    */
   meta() {
     let meta = null;
@@ -1194,7 +1165,7 @@ class BelongsToReference {
    use the "link" otherwise it defaults to "id".
     Example
     ```js [app/models/post.js]
-   import Model, { hasMany } from '@ember-data/model';
+   import Model, { hasMany } from '@warp-drive/legacy/model';
     export default class PostModel extends Model {
      @hasMany('comment', { async: true, inverse: null }) comments;
    }
@@ -1220,7 +1191,7 @@ class BelongsToReference {
    }
    ```
     @public
-   @return {String} The name of the remote type. This should either be `link` or `id`
+   @return The name of the remote type. This should either be `link` or `id`
    */
   remoteType() {
     const value = this._resource();
@@ -1231,7 +1202,7 @@ class BelongsToReference {
   }
 
   /**
-   `push` can be used to update the data in the relationship and EmberData
+   `push` can be used to update the data in the relationship and WarpDrive
    will treat the new data as the canonical value of this relationship on
    the backend. A value of `null` (e.g. `{ data: null }`) can be passed to
    clear the relationship.
@@ -1303,9 +1274,9 @@ class BelongsToReference {
    particularly useful if you want to update the state of the relationship without
    forcing the load of all of the associated record.
     @public
-   @param {Object} doc a JSONAPI document object describing the new value of this relationship.
-   @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-   @return {Promise<OpaqueRecordInstance | null | void>}
+   @param doc a JSONAPI document object describing the new value of this relationship.
+   @param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+   @return a promise that resolves with the record in this belongs-to relationship after the push has completed.
   */
   async push(doc, skipFetch) {
     const {
@@ -1385,7 +1356,7 @@ class BelongsToReference {
     });
    ```
      @public
-   @return {Model} the record in this relationship
+   @return the record in this relationship
    */
   value() {
     const resource = this._resource();
@@ -1430,7 +1401,7 @@ class BelongsToReference {
    });
    ```
    ```js [app/adapters/user.js]
-   import Adapter from '@ember-data/adapter';
+   import Adapter from '@warp-drive/legacy/adapter';
     export default class UserAdapter extends Adapter {
      findRecord(store, type, id, snapshot) {
        // In the adapter you will have access to adapterOptions.
@@ -1439,8 +1410,8 @@ class BelongsToReference {
    });
    ```
      @public
-   @param {Object} options the options to pass in.
-   @return {Promise} a promise that resolves with the record in this belongs-to relationship.
+   @param options the options to pass in.
+   @return a promise that resolves with the record in this belongs-to relationship.
    */
   async load(options) {
     const support = LEGACY_SUPPORT.get(this.___identifier);
@@ -1453,7 +1424,7 @@ class BelongsToReference {
 
   /**
    Triggers a reload of the value in this relationship. If the
-   remoteType is `"link"` Ember Data will use the relationship link to
+   remoteType is `"link"` WarpDrive will use the relationship link to
    reload the relationship. Otherwise it will reload the record by its
    id.
     Example
@@ -1488,8 +1459,8 @@ class BelongsToReference {
    userRef.reload({ adapterOptions: { isPrivate: true } })
    ```
      @public
-   @param {Object} options the options to pass in.
-   @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
+   @param options the options to pass in.
+   @return a promise that resolves with the record in this belongs-to relationship after the reload has completed.
    */
   reload(options) {
     const support = LEGACY_SUPPORT.get(this.___identifier);
@@ -1581,28 +1552,31 @@ class LegacySupport {
     this.cache.mutate(mutation);
   }
   _findBelongsTo(key, resource, relationship, options) {
+    const name = getRealFieldName(this, key);
+
     // TODO @runspired follow up if parent isNew then we should not be attempting load here
     // TODO @runspired follow up on whether this should be in the relationship requests cache
-    return this._findBelongsToByJsonApiResource(resource, this.identifier, relationship, options).then(identifier => handleCompletedRelationshipRequest(this, key, relationship, identifier), e => handleCompletedRelationshipRequest(this, key, relationship, null, e));
+    return this._findBelongsToByJsonApiResource(resource, this.identifier, relationship, options).then(identifier => handleCompletedRelationshipRequest(this, name, relationship, identifier), e => handleCompletedRelationshipRequest(this, name, relationship, null, e));
   }
   reloadBelongsTo(key, options) {
     const loadingPromise = this._relationshipPromisesCache[key];
     if (loadingPromise) {
       return loadingPromise;
     }
-    const relationship = this.graph.get(this.identifier, key);
+    const name = getRealFieldName(this, key);
+    const resource = this.store.cache.getRelationship(this.identifier, name);
+    const relationship = this.graph.get(this.identifier, name);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Expected ${key} to be a belongs-to relationship`);
+        throw new Error(`Expected ${key === name ? name : `${key} (source: ${name})`} to be a belongs-to relationship`);
       }
     })(isBelongsTo(relationship)) : {};
-    const resource = this.cache.getRelationship(this.identifier, key);
     relationship.state.hasFailedLoadAttempt = false;
     relationship.state.shouldForceReload = true;
-    const promise = this._findBelongsTo(key, resource, relationship, options);
-    if (this._relationshipProxyCache[key]) {
+    const promise = this._findBelongsTo(name, resource, relationship, options);
+    if (this._relationshipProxyCache[name]) {
       // @ts-expect-error
-      return this._updatePromiseProxyFor('belongsTo', key, {
+      return this._updatePromiseProxyFor('belongsTo', name, {
         promise
       });
     }
@@ -1610,10 +1584,10 @@ class LegacySupport {
   }
   getBelongsTo(key, options) {
     const {
-      identifier,
-      cache
+      identifier
     } = this;
-    const resource = cache.getRelationship(this.identifier, key);
+    const name = getRealFieldName(this, key);
+    const resource = this.store.cache.getRelationship(this.identifier, name);
     const relatedIdentifier = resource && resource.data ? resource.data : null;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
@@ -1621,10 +1595,10 @@ class LegacySupport {
       }
     })(!relatedIdentifier || isResourceKey(relatedIdentifier)) : {};
     const store = this.store;
-    const relationship = this.graph.get(this.identifier, key);
+    const relationship = this.graph.get(this.identifier, name);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Expected ${key} to be a belongs-to relationship`);
+        throw new Error(`Expected ${key === name ? name : `${key} (source: ${name})`} to be a belongs-to relationship`);
       }
     })(isBelongsTo(relationship)) : {};
     const isAsync = relationship.definition.isAsync;
@@ -1636,11 +1610,11 @@ class LegacySupport {
     };
     if (isAsync) {
       if (relationship.state.hasFailedLoadAttempt) {
-        return this._relationshipProxyCache[key];
+        return this._relationshipProxyCache[name];
       }
-      const promise = this._findBelongsTo(key, resource, relationship, options);
+      const promise = this._findBelongsTo(name, resource, relationship, options);
       const isLoaded = relatedIdentifier && store._instanceCache.recordIsLoaded(relatedIdentifier);
-      return this._updatePromiseProxyFor('belongsTo', key, {
+      return this._updatePromiseProxyFor('belongsTo', name, {
         promise,
         content: isLoaded ? store._instanceCache.getRecord(relatedIdentifier) : null,
         _belongsToState
@@ -1651,7 +1625,7 @@ class LegacySupport {
       } else {
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
-            throw new Error(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`);
+            throw new Error(`You looked up the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`);
           }
         })(store._instanceCache.recordIsLoaded(relatedIdentifier, true)) : {};
         return store._instanceCache.getRecord(relatedIdentifier);
@@ -1659,10 +1633,11 @@ class LegacySupport {
     }
   }
   setDirtyBelongsTo(key, value) {
+    const name = getRealFieldName(this, key);
     return this.cache.mutate({
       op: 'replaceRelatedRecord',
       record: this.identifier,
-      field: key,
+      field: name,
       value: extractIdentifierFromRecord(value)
     },
     // @ts-expect-error
@@ -1688,13 +1663,15 @@ class LegacySupport {
     return [identifiers, jsonApi];
   }
   getManyArray(key, definition) {
+    const name = getRealFieldName(this, key);
     if (this.graph) {
-      let manyArray = this._manyArrayCache[key];
+      let manyArray = this._manyArrayCache[name];
       if (!definition) {
-        definition = this.graph.get(this.identifier, key).definition;
+        definition = this.graph.get(this.identifier, name).definition;
       }
       if (!manyArray) {
-        const [identifiers, doc] = this._getCurrentState(this.identifier, key);
+        const [identifiers, doc] = this._getCurrentState(this.identifier, name);
+        const field = getField(this, name);
         manyArray = createLegacyManyArray({
           store: this.store,
           // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
@@ -1705,60 +1682,62 @@ class LegacySupport {
           editable: true,
           isAsync: definition.isAsync,
           isPolymorphic: definition.isPolymorphic,
-          field: this.store.schema.fields(this.identifier).get(key),
+          field: field,
           identifier: this.identifier,
           links: doc.links || null,
           meta: doc.meta || null
         });
-        this._manyArrayCache[key] = manyArray;
+        this._manyArrayCache[name] = manyArray;
       }
       return manyArray;
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error('hasMany only works with the @ember-data/json-api package');
+        throw new Error('hasMany only works with the JSONAPICache');
       }
     })() : {};
   }
   fetchAsyncHasMany(key, relationship, manyArray, options) {
+    const name = getRealFieldName(this, key);
     if (this.graph) {
-      let loadingPromise = this._relationshipPromisesCache[key];
+      let loadingPromise = this._relationshipPromisesCache[name];
       if (loadingPromise) {
         return loadingPromise;
       }
-      const jsonApi = this.cache.getRelationship(this.identifier, key);
+      const jsonApi = this.cache.getRelationship(this.identifier, name);
       const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
       if (!promise) {
         manyArray.isLoaded = true;
         return Promise.resolve(manyArray);
       }
-      loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, key, relationship, manyArray), e => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e));
-      this._relationshipPromisesCache[key] = loadingPromise;
+      loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, name, relationship, manyArray), e => handleCompletedRelationshipRequest(this, name, relationship, manyArray, e));
+      this._relationshipPromisesCache[name] = loadingPromise;
       return loadingPromise;
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error('hasMany only works with the @ember-data/json-api package');
+        throw new Error('hasMany only works with the JSONAPICache');
       }
     })() : {};
   }
   reloadHasMany(key, options) {
+    const name = getRealFieldName(this, key);
     if (this.graph) {
-      const loadingPromise = this._relationshipPromisesCache[key];
+      const loadingPromise = this._relationshipPromisesCache[name];
       if (loadingPromise) {
         return loadingPromise;
       }
-      const relationship = this.graph.get(this.identifier, key);
+      const relationship = this.graph.get(this.identifier, name);
       const {
         definition,
         state
       } = relationship;
       state.hasFailedLoadAttempt = false;
       state.shouldForceReload = true;
-      const manyArray = this.getManyArray(key, definition);
-      const promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);
-      if (this._relationshipProxyCache[key]) {
-        return this._updatePromiseProxyFor('hasMany', key, {
+      const manyArray = this.getManyArray(name, definition);
+      const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
+      if (this._relationshipProxyCache[name]) {
+        return this._updatePromiseProxyFor('hasMany', name, {
           promise
         });
       }
@@ -1766,31 +1745,32 @@ class LegacySupport {
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+        throw new Error(`hasMany only works with the JSONAPICache`);
       }
     })() : {};
   }
   getHasMany(key, options) {
+    const name = getRealFieldName(this, key);
     if (this.graph) {
-      const relationship = this.graph.get(this.identifier, key);
+      const relationship = this.graph.get(this.identifier, name);
       const {
         definition,
         state
       } = relationship;
-      const manyArray = this.getManyArray(key, definition);
+      const manyArray = this.getManyArray(name, definition);
       if (definition.isAsync) {
         if (state.hasFailedLoadAttempt) {
-          return this._relationshipProxyCache[key];
+          return this._relationshipProxyCache[name];
         }
-        const promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);
-        return this._updatePromiseProxyFor('hasMany', key, {
+        const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
+        return this._updatePromiseProxyFor('hasMany', name, {
           promise,
           content: manyArray
         });
       } else {
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
-            throw new Error(`You looked up the '${key}' relationship on a '${this.identifier.type}' with id ${this.identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany(<type>, { async: true, inverse: <inverse> })')`);
+            throw new Error(`You looked up the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${this.identifier.type}' with id ${this.identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany(<type>, { async: true, inverse: <inverse> })')`);
           }
         })(!anyUnloaded(this.store, relationship)) : {};
         return manyArray;
@@ -1798,7 +1778,7 @@ class LegacySupport {
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+        throw new Error(`hasMany only works with the JSONAPICache`);
       }
     })() : {};
   }
@@ -1841,7 +1821,8 @@ class LegacySupport {
     }
     return promiseProxy;
   }
-  referenceFor(kind, name) {
+  referenceFor(kind, key) {
+    const name = getRealFieldName(this, key);
     let reference = this.references[name];
     if (!reference) {
       if (!this.graph) {
@@ -1850,7 +1831,7 @@ class LegacySupport {
         // because of the intimate API access involved. This is something we will need to redesign.
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           {
-            throw new Error(`snapshot.belongsTo only supported for @ember-data/json-api`);
+            throw new Error(`snapshot.belongsTo only supported when using the JSONAPICache`);
           }
         })() : {};
       }
@@ -1865,16 +1846,16 @@ class LegacySupport {
           const actualRelationshipKind = relationship.definition.kind;
           macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
             if (!test) {
-              throw new Error(`You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`);
+              throw new Error(`You tried to get the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${modelName}' via record.${kind}('${key}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${key}') instead.`);
             }
           })(actualRelationshipKind === kind) : {};
         }
       }
       const relationshipKind = relationship.definition.kind;
       if (relationshipKind === 'belongsTo') {
-        reference = new BelongsToReference(this.store, graph, identifier, relationship, name);
+        reference = new BelongsToReference(this.store, graph, identifier, relationship, key);
       } else if (relationshipKind === 'hasMany') {
-        reference = new HasManyReference(this.store, graph, identifier, relationship, name);
+        reference = new HasManyReference(this.store, graph, identifier, relationship, key);
       }
       this.references[name] = reference;
     }
@@ -1982,7 +1963,7 @@ class LegacySupport {
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+        throw new Error(`hasMany only works with the JSONAPICache`);
       }
     })() : {};
   }
@@ -1991,12 +1972,13 @@ class LegacySupport {
       return Promise.resolve(null);
     }
     const key = relationship.definition.key;
+    const name = getRealFieldName(this, key);
 
     // interleaved promises mean that we MUST cache this here
     // in order to prevent infinite re-render if the request
     // fails.
-    if (this._pending[key]) {
-      return this._pending[key];
+    if (this._pending[name]) {
+      return this._pending[name];
     }
     const identifier = resource.data ? resource.data : null;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -2046,10 +2028,10 @@ class LegacySupport {
         }
       };
       const future = this.store.request(req);
-      this._pending[key] = future.then(doc => field.options.linksMode ? doc.content.data : doc.content).finally(() => {
-        this._pending[key] = undefined;
+      this._pending[name] = future.then(doc => field.options.linksMode ? doc.content.data : doc.content).finally(() => {
+        this._pending[name] = undefined;
       });
-      return this._pending[key];
+      return this._pending[name];
     }
     const preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
     const hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
@@ -2076,7 +2058,7 @@ class LegacySupport {
         }
       })(identifier) : {};
       options.reload = options.reload || !attemptLocalCache || undefined;
-      this._pending[key] = this.store.request({
+      this._pending[name] = this.store.request({
         op: 'findBelongsTo',
         records: [identifier],
         data: request,
@@ -2084,9 +2066,9 @@ class LegacySupport {
           [Symbol.for('wd:skip-cache')]: true
         }
       }).then(doc => doc.content).finally(() => {
-        this._pending[key] = undefined;
+        this._pending[name] = undefined;
       });
-      return this._pending[key];
+      return this._pending[name];
     }
 
     // we were explicitly told we have no data and no links.
@@ -2213,6 +2195,17 @@ function areAllInverseRecordsLoaded(store, resource) {
 function isBelongsTo(relationship) {
   return relationship.definition.kind === 'belongsTo';
 }
+function getField(context, key) {
+  const {
+    identifier,
+    store
+  } = context;
+  return store.schema.fields(identifier).get(key) ?? store.schema.cacheFields?.(identifier).get(key);
+}
+function getRealFieldName(context, key) {
+  const field = getField(context, key);
+  return field ? field.sourceKey ?? field.name : key;
+}
 
 // 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