@warp-drive/legacy 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/{json-ChdEfB0X.js → json-DU8m1pGf.js}

@@ -15,6 +15,78 @@ function coerceId(id) {
   }
 }
 
+/**
+  Given the name of a relationship on a resource `type`, determines the
+  inverse relationship field (if any) using only the schema service.
+
+  Unlike `Model.inverseFor`, this does not require `type` to be backed by
+  a `Model` class, so it works for both `Model`-based and schema-only
+  (e.g. `withDefaults` migration-support) resources.
+
+  @private
+*/
+function inverseForRelationship(store, type, name) {
+  const relationship = store.schema.fields({
+    type
+  }).get(name);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No relationship named '${name}' on '${type}' exists.`);
+    }
+  })(relationship) : {};
+  const {
+    options
+  } = relationship;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected the relationship ${name} on ${type} to define an inverse.`);
+    }
+  })(options.inverse === null || typeof options.inverse === 'string' && options.inverse.length > 0) : {};
+  if (options.inverse === null) {
+    return null;
+  }
+  const schemaExists = store.schema.hasResource(relationship);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No associated schema found for '${relationship.type}' while calculating the inverse of ${name} on ${type}`);
+    }
+  })(schemaExists) : {};
+  if (!schemaExists) {
+    return null;
+  }
+  const inverseField = store.schema.fields(relationship).get(options.inverse);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`No inverse relationship found for '${name}' on '${type}'`);
+    }
+  })(inverseField && (inverseField.kind === 'belongsTo' || inverseField.kind === 'hasMany')) : {};
+  return inverseField ?? null;
+}
+
+/**
+  Given a relationship field on a resource `type`, determines the
+  cardinality of the relationship using only the schema service.
+
+  Unlike `Model.determineRelationshipType`, this does not require `type`
+  to be backed by a `Model` class, so it works for both `Model`-based and
+  schema-only (e.g. `withDefaults` migration-support) resources.
+
+  @private
+*/
+function determineRelationshipType(store, type, knownSide) {
+  const knownKind = knownSide.kind;
+  const inverse = inverseForRelationship(store, type, knownSide.name);
+  if (!inverse) {
+    return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';
+  }
+  const otherKind = inverse.kind;
+  if (otherKind === 'belongsTo') {
+    return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';
+  } else {
+    return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';
+  }
+}
+
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
@@ -744,9 +816,7 @@ const JSONSerializer = Serializer.extend({
   */
   shouldSerializeHasMany(snapshot, key, relationship) {
     // @ts-expect-error store is dynamically injected
-    const schema = this.store.modelFor(snapshot.modelName);
-    // @ts-expect-error store is dynamically injected
-    const relationshipType = schema.determineRelationshipType(relationship, this.store);
+    const relationshipType = determineRelationshipType(this.store, snapshot.modelName, relationship);
     if (this._mustSerialize(key)) {
       return true;
     }
@@ -785,8 +855,15 @@ const JSONSerializer = Serializer.extend({
      `serialize` takes an options hash with a single option:
     `includeId`. If this option is `true`, `serialize` will,
     by default include the ID in the JSON object it builds.
-     The adapter passes in `includeId: true` when serializing
-    a record for `createRecord`, but not for `updateRecord`.
+     Whether `includeId` is `true` or `false` depends on the
+    adapter and the operation being performed, since it is the
+    adapter that invokes `serialize` and decides which options
+    to pass. For instance, `RESTAdapter` passes `includeId: true`
+    when serializing a record for `createRecord`, but not for
+    `updateRecord`, while `JSONAPIAdapter` passes `includeId: true`
+    for both `createRecord` and `updateRecord`. Refer to the
+    documentation for the adapter and serializer pairing you are
+    using for specifics.
      ## Customization
      Your server may expect a different JSON format than the
     built-in serialization format.
@@ -1256,4 +1333,4 @@ const JSONSerializer = Serializer.extend({
     return transform;
   }
 });
-export { JSONSerializer as J, coerceId as c };
+export { JSONSerializer as J, coerceId as c, inverseForRelationship as i };

package/dist/model/-private.js

@@ -1 +1 @@
-export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-Cz5KrzBk.js";
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-DZKA206g.js";

package/dist/model/migration-support.js

@@ -5,8 +5,8 @@ import { notifyInternalSignal } from '@warp-drive/core/signals/-leaked';
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, E as Errors } from "../errors-Cz5KrzBk.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, i as deleteRecord, R as RecordState, j as changedAttributes, k as belongsTo, l as createSnapshot } from "../schema-provider-DJCV_6AF.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-DZKA206g.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, i as deleteRecord, R as RecordState, j as changedAttributes, k as belongsTo, l as createSnapshot } from "../schema-provider-DtPOp0d7.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
@@ -28,6 +28,11 @@ import { macroCondition, getGlobalConfig } from '@embroider/macros';
  *
  * @module
  */
+/**
+ * Adds the `Model`-style `belongsTo`/`hasMany` reference methods to a
+ * {@link TypedRecordInstance}, for use when migrating a resource from
+ * `Model` to a schema-based record while preserving these APIs.
+ */
 // 'isDestroying', 'isDestroyed'
 const LegacyFields = ['_createSnapshot', 'adapterError', 'belongsTo', 'changedAttributes', 'constructor', 'currentState', 'deleteRecord', 'destroyRecord', 'dirtyType', 'errors', 'hasDirtyAttributes', 'hasMany', 'isDeleted', 'isEmpty', 'isError', 'isLoaded', 'isLoading', 'isNew', 'isSaving', 'isValid', 'reload', 'rollbackAttributes', 'save', 'serialize', 'unloadRecord'];
 
@@ -434,6 +439,9 @@ function registerDerivations(schema) {
  * @public
  */
 
+/**
+ * See the {@link DelegatingSchemaService | class documentation above} for usage.
+ */
 class DelegatingSchemaService {
   /** @internal */
   _preferred;
@@ -443,6 +451,11 @@ class DelegatingSchemaService {
     this._preferred = schema;
     this._secondary = buildSchema(store);
   }
+
+  /**
+   * Whether the given resource's schema is being served by the fallback
+   * (legacy Model-derived) schema service rather than the primary one.
+   */
   isDelegated(resource) {
     return !this._preferred.hasResource(resource) && this._secondary.hasResource(resource);
   }

package/dist/{unpkg/dev-deprecated/model-for-CqXsIKws.js → model-for-CXkJw59V.js}

@@ -1,6 +1,11 @@
 import { tracked, cached } from '@glimmer/tracking';
 import { Context } from '@warp-drive/core/reactive/-private';
 import { a as decorateFieldV2, i as initializeDeferredDecorator, d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+
+/**
+ * The features added to an object resource by {@link FragmentExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment API for migrated resources.
+ */
 class Fragment {
   static {
     decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
@@ -8,12 +13,21 @@ class Fragment {
     });
   }
   #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  /**
+   * Whether this fragment is in the process of being destroyed.
+   */
   static {
     decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
       return false;
     });
   }
   #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  /**
+   * Whether this fragment has been destroyed.
+   */
+  /**
+   * Whether this fragment (or the attribute it is rooted at) has uncommitted changes.
+   */
   get hasDirtyAttributes() {
     const {
       path,
@@ -27,18 +41,30 @@ class Fragment {
     }
     return false;
   }
+
+  /**
+   * Always `true`. Used to distinguish fragments from other resources.
+   */
   static {
     decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
   }
   get isFragment() {
     return true;
   }
+
+  /**
+   * The resource type of this fragment, if known.
+   */
   get $type() {
     const {
       field
     } = this[Context];
     return field?.type;
   }
+
+  /**
+   * Reverts this fragment's attribute back to its last known remote value.
+   */
   rollbackAttributes() {
     const {
       path,
@@ -51,11 +77,21 @@ class Fragment {
     }
   }
 }
+
+/**
+ * A schema extension that adds the {@link Fragment} API to migrated
+ * `ModelFragments` object resources.
+ */
 const FragmentExtension = {
   kind: 'object',
   name: 'fragment',
   features: Fragment
 };
+
+/**
+ * The features added to an array resource by {@link FragmentArrayExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment-array API for migrated resources.
+ */
 class FragmentArray {
   static {
     decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
@@ -63,18 +99,29 @@ class FragmentArray {
     });
   }
   #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  /**
+   * Whether this fragment array is in the process of being destroyed.
+   */
   static {
     decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
       return false;
     });
   }
   #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  /**
+   * Whether this fragment array has been destroyed.
+   */
+  /**
+   * Whether this fragment array (or any of its members) has uncommitted changes.
+   */
   get hasDirtyAttributes() {
+    const array = this;
+    const context = array[Context];
     const {
       path,
       resourceKey,
       store
-    } = this[Context];
+    } = context;
     const record = store.peekRecord(resourceKey);
     if (record.hasDirtyAttributes && path) {
       const root = path.at(0);
@@ -82,6 +129,10 @@ class FragmentArray {
     }
     return false;
   }
+
+  /**
+   * Adds an existing fragment to this array, if one was given.
+   */
   static {
     decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
   }
@@ -91,12 +142,20 @@ class FragmentArray {
     }
     return this.addObject(fragment);
   }
+
+  /**
+   * Appends a new fragment to the end of this array, if one was given.
+   */
   createFragment(fragment) {
     if (!fragment) {
       return;
     }
     return this.pushObject(fragment);
   }
+
+  /**
+   * Removes the given fragment from this array, if present.
+   */
   removeFragment(fragment) {
     if (!fragment) {
       return;
@@ -106,6 +165,10 @@ class FragmentArray {
       this.splice(index, 1);
     }
   }
+
+  /**
+   * Reverts each member fragment's attribute back to its last known remote value.
+   */
   rollbackAttributes() {
     for (const fragment of this) {
       // @ts-expect-error TODO: fix these types
@@ -113,6 +176,11 @@ class FragmentArray {
     }
   }
 }
+
+/**
+ * A schema extension that adds the {@link FragmentArray} API to migrated
+ * `ModelFragments` array resources.
+ */
 const FragmentArrayExtension = {
   kind: 'array',
   name: 'fragment-array',
@@ -217,5 +285,13 @@ class ShimModelClass {
 function fragmentsModelFor(modelName) {
   return getShimClass(this, modelName);
 }
+
+/**
+ * The `modelFor` fallback used to construct a `ShimModelClass` schema for a
+ * type when ModelFragments support is enabled and no real `Model` subclass
+ * is registered for that type.
+ *
+ * @public
+ */
 const modelFor = fragmentsModelFor;
 export { FragmentExtension as F, FragmentArrayExtension as a, FragmentArray as b, Fragment as c, fragmentsModelFor as f, modelFor as m };

package/dist/model-fragments.js

@@ -1,7 +1,7 @@
 import { pluralize, singularize } from '@warp-drive/utilities/string';
 import { withDefaults } from './model/migration-support.js';
-import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CqXsIKws.js";
-export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CqXsIKws.js";
+import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CXkJw59V.js";
+export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CXkJw59V.js";
 
 /**
  * Used as a helper to setup the relevant parts of an array
@@ -62,6 +62,15 @@ function withFragmentArrayDefaults(fragmentArrayType, fragmentArrayName) {
     }
   };
 }
+
+/**
+ * Used as a helper to setup the relevant parts of a legacy resource schema
+ * migrated from `Model`, applying the `ember-object` and `fragment` object
+ * extensions and a default `@id` identity field.
+ *
+ * @param schema the partial legacy resource schema to complete
+ * @returns the completed resource schema
+ */
 function withLegacy(schema) {
   return withDefaults({
     ...schema,
@@ -72,6 +81,13 @@ function withLegacy(schema) {
     objectExtensions: ['ember-object', 'fragment']
   });
 }
+
+/**
+ * Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema
+ * extensions on the given `SchemaService`, enabling ModelFragments migration support.
+ *
+ * @public
+ */
 function registerFragmentExtensions(schema) {
   schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
   schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);

package/dist/model.js

@@ -5,10 +5,10 @@ import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZ
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-Cz5KrzBk.js";
+import { l as lookupLegacySupport } from "./errors-DZKA206g.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DJCV_6AF.js";
-export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-D6diaM34.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DtPOp0d7.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-BvOqJBei.js";
 function _attr(type, options) {
   if (typeof type === 'object') {
     options = type;
@@ -21,6 +21,7 @@ function _attr(type, options) {
     kind: 'attribute',
     isAttribute: true,
     options: options,
+    sourceKey: options.sourceKey,
     key: null
   };
   return computed({
@@ -34,7 +35,7 @@ function _attr(type, options) {
         return;
       }
       const cache = this[RecordStore].cache;
-      return cache.getAttr(recordIdentifierFor(this), key);
+      return cache.getAttr(recordIdentifierFor(this), meta.sourceKey ?? key);
     },
     set(key, value) {
       if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
@@ -49,9 +50,10 @@ function _attr(type, options) {
         }
       })(!this.currentState.isDeleted) : {};
       const cache = this[RecordStore].cache;
-      const currentValue = cache.getAttr(identifier, key);
+      const cacheKey = meta.sourceKey ?? key;
+      const currentValue = cache.getAttr(identifier, cacheKey);
       if (currentValue !== value) {
-        cache.setAttr(identifier, key, value);
+        cache.setAttr(identifier, cacheKey, value);
         if (!this.isValid) {
           const {
             errors
@@ -202,7 +204,8 @@ function _belongsTo(type, options) {
     type: normalizeModelName(type),
     options: options,
     kind: 'belongsTo',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {
@@ -456,7 +459,8 @@ function _hasMany(type, options) {
     type: normalizeType(type),
     options,
     kind: 'hasMany',
-    name: '<Unknown BelongsTo>'
+    name: '<Unknown BelongsTo>',
+    sourceKey: options.sourceKey
   };
   return computed({
     get(key) {

package/dist/{schema-provider-DJCV_6AF.js → schema-provider-DtPOp0d7.js}

@@ -5,7 +5,7 @@ import { recordIdentifierFor, storeFor } from '@warp-drive/core';
 import { notifyInternalSignal, peekInternalSignal, withSignalStore, gate, memoized, defineSignal, entangleSignal, defineGate } from '@warp-drive/core/signals/-leaked';
 import { assertPrivateStore, recordIdentifierFor as recordIdentifierFor$1, coerceId } from '@warp-drive/core/store/-private';
 import { RecordStore } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-Cz5KrzBk.js";
+import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-DZKA206g.js";
 import { u as upgradeStore, F as FetchManager } from "./-private-BG3bMiKp.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { cacheFor } from '@ember/object/internals';
@@ -44,11 +44,13 @@ function hasMany(prop) {
 }
 function reload(options = {}) {
   if (macroCondition(!getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUEST_METHODS)) {
+    const message = `You cannot use reload() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`You cannot use reload() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`);
+        throw new Error(message);
       }
     })() : {};
+    return Promise.reject(new Error(message));
   } else {
     deprecate(`record.reload is deprecated, please use store.request to initiate a request instead.`, false, {
       id: 'warp-drive:deprecate-legacy-request-methods',
@@ -102,11 +104,13 @@ function deleteRecord() {
 }
 function save(options) {
   if (macroCondition(!getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUEST_METHODS)) {
+    const message = `You cannot use save() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`You cannot use save() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`);
+        throw new Error(message);
       }
     })() : {};
+    return Promise.reject(new Error(message));
   } else {
     deprecate(`record.save is deprecated, please use store.request to initiate a request instead.`, false, {
       id: 'warp-drive:deprecate-legacy-request-methods',
@@ -133,11 +137,13 @@ function _save(options) {
 }
 function destroyRecord(options) {
   if (macroCondition(!getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUEST_METHODS)) {
+    const message = `You cannot use destroyRecord() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       {
-        throw new Error(`You cannot use destroyRecord() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`);
+        throw new Error(message);
       }
     })() : {};
+    return Promise.reject(new Error(message));
   } else {
     deprecate(`record.destroyRecord is deprecated, please use store.request to initiate a request instead.`, false, {
       id: 'warp-drive:deprecate-legacy-request-methods',
@@ -977,6 +983,9 @@ class Model extends EmberObject {
   get isError() {
     return this.currentState.isError;
   }
+  /**
+   * `isError` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "isError", [memoized]);
   }
@@ -1024,6 +1033,10 @@ class Model extends EmberObject {
     }
     return recordIdentifierFor(this).id;
   }
+  /**
+   * Assigns the resource's primary key. Typically only used internally
+   * when a client-created record is assigned an id upon being saved.
+   */
   static {
     decorateMethodV2(this.prototype, "id", [gate]);
   }
@@ -1063,6 +1076,9 @@ class Model extends EmberObject {
     }
     return this.___recordState;
   }
+  /**
+   * `currentState` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "currentState", [gate]);
   }
@@ -1136,6 +1152,9 @@ class Model extends EmberObject {
   get adapterError() {
     return this.currentState.adapterError;
   }
+  /**
+   * `adapterError` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "adapterError", [memoized]);
   }
@@ -1209,12 +1228,29 @@ class Model extends EmberObject {
   eachRelationship(callback, binding) {
     this.constructor.eachRelationship(callback, binding);
   }
+
+  /**
+   * Returns the relationship schema for the given relationship name, if any.
+   */
   relationshipFor(name) {
     return this.constructor.relationshipsByName.get(name);
   }
+
+  /**
+   * Returns the inverse relationship schema for the given relationship
+   * name, if one exists. See {@link Model.inverseFor | the static inverseFor}.
+   */
   inverseFor(name) {
     return this.constructor.inverseFor(name, storeFor(this, false));
   }
+
+  /**
+   * Iterates over the attributes defined on this record's class, calling
+   * `callback` for each one. See {@link Model.eachAttribute | the static eachAttribute}.
+   *
+   * @param callback the callback to invoke
+   * @param binding the value to which the callback's `this` should be bound
+   */
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
@@ -1286,6 +1322,11 @@ class Model extends EmberObject {
     const relationship = this.relationshipsByName.get(name);
     return relationship && store.modelFor(relationship.type);
   }
+
+  /**
+   * A cache of resolved inverse relationships by name, populated lazily by
+   * {@link Model.inverseFor | inverseFor}.
+   */
   static get inverseMap() {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
@@ -1338,6 +1379,9 @@ class Model extends EmberObject {
     }
   }
 
+  /**
+   * @private
+   */
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1568,6 +1612,12 @@ class Model extends EmberObject {
     }
     return map;
   }
+
+  /**
+   * A hash of the model's relationship schemas keyed by relationship name.
+   * See also {@link Model.relationshipsByName | relationshipsByName}, which
+   * provides the same information as a `Map`.
+   */
   static {
     decorateMethodV2(this, "relationshipsByName", [computeOnce]);
   }
@@ -1954,6 +2004,13 @@ defineGate(Model.prototype, 'isReloading', {
   // @ts-expect-error specially handled prop
   isLocal: true
 });
+
+/**
+ * Restores the pre-`RequestManager` implementations of `save`,
+ * `destroyRecord`, and `reload` onto the given `Model` subclass, for
+ * apps that have not yet migrated off of the deprecated
+ * `ENABLE_LEGACY_REQUEST_METHODS` behaviors.
+ */
 function restoreDeprecatedModelRequestBehaviors(ModelKlass) {
   // @ts-expect-error TS doesn't know how to do `this` function overloads
   ModelKlass.prototype.save = _save;
@@ -2147,7 +2204,11 @@ class ModelSchemaProvider {
   }
   /** @internal */
   _loadModelSchema(type) {
-    const modelClass = this.store.modelFor(type);
+    const factory = getModelFactory(this.store, type);
+    if (!factory) {
+      throw new Error(`No model was found for '${type}'`);
+    }
+    const modelClass = factory.class;
     const attributeMap = modelClass.attributes;
     const attributes = Object.create(null);
     attributeMap.forEach((meta, name) => attributes[name] = meta);
@@ -2168,11 +2229,22 @@ class ModelSchemaProvider {
       type,
       fields: Array.from(fields.values())
     };
+    const cacheFields = new Map();
+    for (const field of fields.values()) {
+      const cacheKey = field.sourceKey ?? field.name;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`The sourceKey '${field.sourceKey}' for the field '${field.name}' on '${type}' is invalid because it matches the name of an existing field`);
+        }
+      })(!field.sourceKey || field.sourceKey === field.name || !fields.has(field.sourceKey)) : {};
+      cacheFields.set(cacheKey, field);
+    }
     const internalSchema = {
       schema,
       attributes,
       relationships,
-      fields
+      fields,
+      cacheFields
     };
     this._schemas.set(type, internalSchema);
     return internalSchema;
@@ -2184,6 +2256,13 @@ class ModelSchemaProvider {
     }
     return this._schemas.get(type).fields;
   }
+  cacheFields(resource) {
+    const type = normalizeModelName(resource.type);
+    if (!this._schemas.has(type)) {
+      this._loadModelSchema(type);
+    }
+    return this._schemas.get(type).cacheFields;
+  }
   hasResource(resource) {
     const type = normalizeModelName(resource.type);
     if (this._schemas.has(type)) {
@@ -2259,6 +2338,14 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return this._schemas.get(type).relationships;
   };
 }
+
+/**
+ * The `createSchemaService` implementation for use with `Model`. Pass
+ * the result of this to your store's `createSchemaService` method when
+ * configuring the store to use `Model` for schema information.
+ *
+ * @public
+ */
 function buildSchema(store) {
   return new ModelSchemaProvider(store);
 }