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

package/dist/unpkg/dev/model/-private.js

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

package/dist/unpkg/dev/model/migration-support.js

@@ -4,8 +4,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-DmGGJr3T.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-DDVYxmUV.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-DngRU-If.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-0D7f-QOn.js";
 
 /**
  * This module provides support for migrating away from @warp-drive/legacy/model
@@ -27,6 +27,12 @@ import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as s
  * @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'];
 
@@ -423,6 +429,9 @@ function registerDerivations(schema) {
  * @public
  */
 
+/**
+ * See the {@link DelegatingSchemaService | class documentation above} for usage.
+ */
 class DelegatingSchemaService {
   /** @internal */
   _preferred;
@@ -432,6 +441,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/{prod-deprecated/model-for-CqXsIKws.js → dev/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/unpkg/dev/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/unpkg/dev/model.js

@@ -3,10 +3,10 @@ import { recordIdentifierFor } from '@warp-drive/core';
 import { RecordStore } from '@warp-drive/core/types/symbols';
 import { i as isElementDescriptor, n as normalizeModelName } from "./util-DvanW33H.js";
 import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { l as lookupLegacySupport } from "./errors-DmGGJr3T.js";
+import { l as lookupLegacySupport } from "./errors-DngRU-If.js";
 import '@warp-drive/utilities/string';
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DDVYxmUV.js";
-export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-CkYiE6Ud.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-0D7f-QOn.js";
+export { i as instantiateRecord, m as modelFor, t as teardownRecord } from "./hooks-UuiLxWxS.js";
 
 /**
  * Options provided to the attr decorator are
@@ -44,6 +44,7 @@ function _attr(type, options) {
     kind: 'attribute',
     isAttribute: true,
     options: options,
+    sourceKey: options.sourceKey,
     key: null
   };
   return computed({
@@ -57,7 +58,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) {
       {
@@ -72,9 +73,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
@@ -226,7 +228,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) {
@@ -467,7 +470,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/unpkg/dev/{schema-provider-DDVYxmUV.js → schema-provider-0D7f-QOn.js}

@@ -4,7 +4,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-DmGGJr3T.js";
+import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-DngRU-If.js";
 import { u as upgradeStore, F as FetchManager } from "./-private-DtjBbEgy.js";
 import { cacheFor } from '@ember/object/internals';
 import { Context } from '@warp-drive/core/reactive/-private';
@@ -42,11 +42,13 @@ function hasMany(prop) {
 }
 function reload(options = {}) {
   {
+    const message = `You cannot use reload() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     (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));
   }
 }
 function _reload(options = {}) {
@@ -88,11 +90,13 @@ function deleteRecord() {
 }
 function save(options) {
   {
+    const message = `You cannot use save() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     (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));
   }
 }
 function _save(options) {
@@ -107,11 +111,13 @@ function _save(options) {
 }
 function destroyRecord(options) {
   {
+    const message = `You cannot use destroyRecord() on a record when ENABLE_LEGACY_REQUEST_METHODS is false.`;
     (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));
   }
 }
 function _destroyRecord(options) {
@@ -939,6 +945,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]);
   }
@@ -986,6 +995,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]);
   }
@@ -1021,6 +1034,9 @@ class Model extends EmberObject {
 
     return this.___recordState;
   }
+  /**
+   * `currentState` is read-only and cannot be set directly.
+   */
   static {
     decorateMethodV2(this.prototype, "currentState", [gate]);
   }
@@ -1094,6 +1110,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]);
   }
@@ -1167,12 +1186,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);
   }
@@ -1244,6 +1280,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() {
     (test => {
       if (!test) {
@@ -1296,6 +1337,9 @@ class Model extends EmberObject {
     }
   }
 
+  /**
+   * @private
+   */
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
     (test => {
@@ -1526,6 +1570,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]);
   }
@@ -1903,6 +1953,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;
@@ -2096,7 +2153,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);
@@ -2117,11 +2178,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;
+      (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;
@@ -2133,6 +2205,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)) {
@@ -2150,6 +2229,13 @@ class ModelSchemaProvider {
     return true;
   }
 }
+/**
+ * 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);
 }

package/dist/unpkg/dev/serializer/json-api.js

@@ -1,5 +1,5 @@
 import { dasherize, pluralize, singularize } from '@warp-drive/utilities/string';
-import { J as JSONSerializer } from "../json-Cu1LNgmQ.js";
+import { J as JSONSerializer } from "../json-K2Y9z6MN.js";
 
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
@@ -102,7 +102,7 @@ import { J as JSONSerializer } from "../json-Cu1LNgmQ.js";
   `extractRelationship`.
 
   ```js [app/serializers/application.js]
-  import JSONAPISerializer from '@warp-drive/legacy/serializer/json-api';
+  import { JSONAPISerializer } from '@warp-drive/legacy/serializer/json-api';
 
   export default class ApplicationSerializer extends JSONAPISerializer {
     normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
@@ -136,10 +136,15 @@ const JSONAPISerializer = JSONSerializer.extend({
   */
   _normalizeDocumentHelper(documentHash) {
     if (Array.isArray(documentHash.data)) {
-      const ret = new Array(documentHash.data.length);
+      const ret = [];
       for (let i = 0; i < documentHash.data.length; i++) {
         const data = documentHash.data[i];
-        ret[i] = this._normalizeResourceHelper(data);
+        const normalized = this._normalizeResourceHelper(data);
+        if (normalized !== null) {
+          // @ts-expect-error untyped
+          // can be null when unknown type is encountered
+          ret.push(normalized);
+        }
       }
       documentHash.data = ret;
     } else if (documentHash.data && typeof documentHash.data === 'object') {

package/dist/unpkg/dev/serializer/json.js

@@ -1,4 +1,4 @@
 import '@ember/application';
 import '@warp-drive/utilities/string';
 import '../serializer.js';
-export { J as JSONSerializer } from "../json-Cu1LNgmQ.js";
+export { J as JSONSerializer } from "../json-K2Y9z6MN.js";

package/dist/unpkg/dev/serializer/rest.js

@@ -1,5 +1,5 @@
 import { camelize, dasherize, singularize } from '@warp-drive/utilities/string';
-import { J as JSONSerializer, c as coerceId } from "../json-Cu1LNgmQ.js";
+import { i as inverseForRelationship, J as JSONSerializer, c as coerceId } from "../json-K2Y9z6MN.js";
 import Mixin from '@ember/object/mixin';
 
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
@@ -420,8 +420,7 @@ const EmbeddedRecordsMixin = Mixin.create({
   */
   removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json) {
     if (relationship.kind === 'belongsTo') {
-      const schema = this.store.modelFor(snapshot.modelName);
-      const parentRecord = schema.inverseFor(relationship.name, this.store);
+      const parentRecord = inverseForRelationship(this.store, snapshot.modelName, relationship.name);
       if (parentRecord) {
         const name = parentRecord.name;
         const embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);
@@ -1024,7 +1023,7 @@ const RESTSerializer = JSONSerializer.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
+     The RESTAdapter passes in `includeId: true` when serializing
     a record for `createRecord`, but not for `updateRecord`.
      ## Customization
      Your server may expect a different JSON format than the