@warp-drive/legacy 5.8.0-alpha.3 → 5.8.0-alpha.30

package/dist/compat/utils.js

@@ -33,7 +33,7 @@ let NormalizedType = str => {
  * changes during normalization. This is useful for instrumenting
  * to discover places where usage in the app is not consistent.
  *
- * @param method a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+ * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
  * @public
  */
 function configureMismatchReporter(fn) {
@@ -45,7 +45,7 @@ function configureMismatchReporter(fn) {
  * fails validation. This is useful for instrumenting
  * to discover places where usage in the app is not consistent.
  *
- * @param method a function which takes a message and a condition
+ * @param fn - a function which takes a message and a condition
  * @public
  */
 function configureAssertFn(fn) {
@@ -62,7 +62,7 @@ function configureAssertFn(fn) {
  * the configured mismatch reporter and assert functions will
  * be called.
  *
- * @param method a function which takes a string and returns a string
+ * @param fn - a function which takes a string and returns a string
  * @public
  */
 function configureTypeNormalization(fn) {
@@ -72,7 +72,7 @@ const NORMALIZED_TYPES = new Map();
 
 /**
  * Converts a potentially unnormalized type into the format expected
- * by our EmberData Cache. Currently this is singular-dasherized.
+ * by our WarpDrive Cache. Currently this is singular-dasherized.
  *
  * you should not rely on this function to give you an exact format
  * for display purposes. Formatting for display should be handled
@@ -95,8 +95,8 @@ const NORMALIZED_TYPES = new Map();
  * formattedType('PostComment'); // => 'post-comment'
  * ```
  *
- * @param {String} type the potentially un-normalized type
- * @return {String} the normalized type
+ * @param type the potentially un-normalized type
+ * @return the normalized type
  * @public
  */
 function formattedType(type) {
@@ -116,7 +116,7 @@ function formattedType(type) {
 }
 
 /**
- * Format an id to the format expected by the EmberData Cache.
+ * Format an id to the format expected by the WarpDrive Cache.
  * Currently this means that id should be `string | null`.
  *
  * Asserts invalid IDs (undefined, '', 0, '0') in dev.
@@ -131,8 +131,8 @@ function formattedType(type) {
  * formattedId(null); // => null
  *	```
  *
- * @param {String | Number | null} id the potentially un-normalized id
- * @return {String | null} the normalized id
+ * @param id the potentially un-normalized id
+ * @return the normalized id
  * @public
  */
 
@@ -154,7 +154,7 @@ function expectId(id) {
 
 /**
  * Compares two types for strict equality, converting them to
- * the format expected by the EmberData Cache to ensure
+ * the format expected by the WarpDrive Cache to ensure
  * differences in format are accounted for in the comparison.
  *
  * Asserts when expected or actual are invalid types in dev.
@@ -172,9 +172,9 @@ function expectId(id) {
  * isEquivType('posts', null); // false
  * ```
  *
- * @param {String} expected a potentially unnormalized type to match against
- * @param {String} actual a potentially unnormalized type to match against
- * @return {Boolean} true if the types are equivalent
+ * @param expected a potentially unnormalized type to match against
+ * @param actual a potentially unnormalized type to match against
+ * @return true if the types are equivalent
  * @public
  */
 function isEquivType(expected, actual) {
@@ -191,7 +191,7 @@ function isEquivType(expected, actual) {
 
 /**
  * Compares two IDs for strict equality, converting them to
- * the format expected by the EmberData Cache to ensure
+ * the format expected by the WarpDrive Cache to ensure
  * differences in format are accounted for in the comparison.
  *
  * Asserts when expected or actual are invalid IDs in dev.
@@ -205,9 +205,9 @@ function isEquivType(expected, actual) {
  * isEquivId(1, null); // false
  * ```
  *
- * @param {string | number} expected a potentially un-normalized id to match against
- * @param {string | number} actual a potentially un-normalized id to match against
- * @return {Boolean} true if the ids are equivalent
+ * @param expected a potentially un-normalized id to match against
+ * @param actual a potentially un-normalized id to match against
+ * @return true if the ids are equivalent
  * @public
  */
 function isEquivId(expected, actual) {

package/dist/compat.js

@@ -2,7 +2,7 @@ import { getOwner } from '@ember/application';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { assertPrivateStore, waitFor, _deprecatingNormalize } from '@warp-drive/core/store/-private';
 import '@warp-drive/core/reactive/-private';
-import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-8UmnAf9J.js";
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-B1pSSN52.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 function _findHasMany(adapter, store, identifier, link, relationship, options) {
   const promise = Promise.resolve().then(() => {
@@ -737,18 +737,30 @@ function queryRecord(context) {
 }
 
 /**
-    Returns an instance of the adapter for a given type. For
-    example, `adapterFor('person')` will return an instance of
-    the adapter located at `app/adapters/person.js`
+ * Extends the signature of {@link Store} with additional
+ * methods available when using the legacy network layer.
+ *
+ * @public
+ * @noInheritDoc
+ * @legacy
+ */
 
-    If no `person` adapter is found, this method will look
-    for an `application` adapter (the default adapter for
-    your entire application).
+/**
+ * @deprecated - use {@link LegacyStoreCompat} instead
+ */
 
-    @public
-    @param {String} modelName
-    @return {Adapter}
-  */
+/**
+  Returns an instance of the adapter for a given type. For
+  example, `adapterFor('person')` will return an instance of
+  the adapter located at `app/adapters/person.js`
+
+  If no `person` adapter is found, this method will look
+  for an `application` adapter (the default adapter for
+  your entire application).
+
+  @public
+  @param modelName
+*/
 
 function adapterFor(modelName, _allowMissing) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -799,20 +811,19 @@ function adapterFor(modelName, _allowMissing) {
 }
 
 /**
-    Returns an instance of the serializer for a given type. For
-    example, `serializerFor('person')` will return an instance of
-    `App.PersonSerializer`.
+  Returns an instance of the serializer for a given type. For
+  example, `serializerFor('person')` will return an instance of
+  `App.PersonSerializer`.
 
-    If no `App.PersonSerializer` is found, this method will look
-    for an `App.ApplicationSerializer` (the default serializer for
-    your entire application).
+  If no `App.PersonSerializer` is found, this method will look
+  for an `App.ApplicationSerializer` (the default serializer for
+  your entire application).
 
-    If a serializer cannot be found on the adapter, it will fall back
-    to an instance of `JSONSerializer`.
+  If a serializer cannot be found on the adapter, it will fall back
+  to an instance of `JSONSerializer`.
 
-    @public
-    @param {String} modelName the record to serialize
-    @return {Serializer}
+  @public
+  @param modelName the record to serialize
   */
 function serializerFor(modelName) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -859,23 +870,29 @@ function serializerFor(modelName) {
 }
 
 /**
-    `normalize` converts a json payload into the normalized form that
-    [push](../methods/push?anchor=push) expects.
+  `normalize` converts a json payload into the normalized form expected by
+  {@link Store.push | push} using the serializer specified by `modelName`
 
-    Example
+  :::warning
+  Generally it would be better to invoke the serializer yourself directly,
+  or write a more specialized normalization utility.
+  :::
 
-    ```js
-    socket.on('message', function(message) {
-      let modelName = message.model;
-      let data = message.data;
-      store.push(store.normalize(modelName, data));
-    });
-    ```
+  Example
 
-    @public
-    @param modelName The name of the model type for this payload
-    @return The normalized payload
-  */
+  ```js
+  socket.on('message', function(message) {
+    let modelName = message.model;
+    let data = message.data;
+    store.push(store.normalize(modelName, data));
+  });
+  ```
+
+  @legacy
+  @public
+  @param modelName The name of the model type for this payload
+  @return The normalized payload
+*/
 // TODO @runspired @deprecate users should call normalize on the associated serializer directly
 function normalize(modelName, payload) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -956,8 +973,8 @@ function normalize(modelName, payload) {
     ```
 
     @public
-    @param {String} modelName Optionally, a model type used to determine which serializer will be used
-    @param {Object} inputPayload
+    @param modelName Optionally, a model type used to determine which serializer will be used
+    @param inputPayload
   */
 // TODO @runspired @deprecate pushPayload in favor of looking up the serializer
 function pushPayload(modelName, inputPayload) {

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

@@ -2,7 +2,7 @@ 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 { 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-B1pSSN52.js";
 import { computed, get } from '@ember/object';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
@@ -632,7 +632,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.
@@ -1231,7 +1231,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.
@@ -1581,28 +1581,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 +1613,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 +1624,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 +1639,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 +1654,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 +1662,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 +1692,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,12 +1711,12 @@ 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;
     }
@@ -1721,19 +1727,20 @@ class LegacySupport {
     })() : {};
   }
   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 => {
@@ -1743,22 +1750,23 @@ class LegacySupport {
     })() : {};
   }
   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
         });
       }
@@ -1771,26 +1779,27 @@ class LegacySupport {
     })() : {};
   }
   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;
@@ -1841,7 +1850,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) {
@@ -1865,16 +1875,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;
     }
@@ -1991,12 +2001,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 +2057,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 +2087,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 +2095,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 +2224,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

package/dist/hooks-CQXyievu.js

@@ -0,0 +1,74 @@
+import { setOwner, getOwner } from '@ember/application';
+import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
+import { g as getModelFactory } from "./schema-provider-BnVr_CnJ.js";
+import { n as normalizeModelName } from "./util-Dul6TZts.js";
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+function instantiateRecord(identifier, createRecordArgs) {
+  const type = identifier.type;
+
+  // TODO deprecate allowing unknown args setting
+  const createOptions = {
+    _createProps: createRecordArgs ?? {},
+    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+    _secretInit: {
+      identifier,
+      store: this,
+      cb: secretInit
+    }
+  };
+
+  // ensure that `getOwner(this)` works inside a model instance
+  setOwner(createOptions, getOwner(this));
+  const factory = getModelFactory(this, type);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No model was found for '${type}'`);
+    }
+  })(factory) : {};
+  return factory.class.create(createOptions);
+}
+function teardownRecord(record) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`expected to receive an instance of Model from @ember-data/model. If using a custom model make sure you implement teardownRecord`);
+    }
+  })('destroy' in record) : {};
+  record.destroy();
+}
+function modelFor(modelName) {
+  assertPrivateStore(this);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
+    }
+  })(!this.isDestroyed && !this.isDestroying) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the store's modelFor method`);
+    }
+  })(modelName) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Please pass a proper model name to the store's modelFor method`);
+    }
+  })(typeof modelName === 'string' && modelName.length) : {};
+  const type = normalizeModelName(modelName);
+  const maybeFactory = getModelFactory(this, type);
+  const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;
+  const ignoreType = !klass || !klass.isModel || this._forceShim;
+  if (!ignoreType) {
+    return klass;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No model was found for '${type}' and no schema handles the type`);
+    }
+  })(this.schema.hasResource({
+    type
+  })) : {};
+}
+function secretInit(record, identifier, store) {
+  setRecordIdentifier(record, identifier);
+  StoreMap.set(record, store);
+}
+export { instantiateRecord as i, modelFor as m, teardownRecord as t };