@ember-data/store 4.2.0-beta.0 → 4.3.0

package/addon/-private/system/model/shim-model-class.ts

@@ -1,18 +1,17 @@
+import { DEBUG } from '@glimmer/env';
+
 import { ModelSchema } from '../../ts-interfaces/ds-model';
 import type { AttributeSchema, RelationshipSchema } from '../../ts-interfaces/record-data-schemas';
 import type { Dict } from '../../ts-interfaces/utils';
 import type CoreStore from '../core-store';
+import WeakCache from '../weak-cache';
 
-const AvailableShims = new WeakMap<CoreStore, Dict<ShimModelClass>>();
-
+const AvailableShims = new WeakCache<CoreStore, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
+AvailableShims._generator = () => {
+  return Object.create(null) as Dict<ShimModelClass>;
+};
 export function getShimClass(store: CoreStore, modelName: string): ShimModelClass {
-  let shims = AvailableShims.get(store);
-
-  if (shims === undefined) {
-    shims = Object.create(null) as Dict<ShimModelClass>;
-    AvailableShims.set(store, shims);
-  }
-
+  let shims = AvailableShims.lookup(store);
   let shim = shims[modelName];
   if (shim === undefined) {
     shim = shims[modelName] = new ShimModelClass(store, modelName);
@@ -37,8 +36,8 @@ export default class ShimModelClass implements ModelSchema {
   constructor(private __store: CoreStore, public modelName: string) {}
 
   get fields(): Map<string, 'attribute' | 'belongsTo' | 'hasMany'> {
-    let attrs = this.__store._attributesDefinitionFor(this.modelName);
-    let relationships = this.__store._relationshipsDefinitionFor(this.modelName);
+    let attrs = this.__store._attributesDefinitionFor({ type: this.modelName });
+    let relationships = this.__store._relationshipsDefinitionFor({ type: this.modelName });
     let fields = new Map<string, 'attribute' | 'belongsTo' | 'hasMany'>();
     Object.keys(attrs).forEach((key) => fields.set(key, 'attribute'));
     Object.keys(relationships).forEach((key) => fields.set(key, relationships[key]!.kind));
@@ -46,17 +45,17 @@ export default class ShimModelClass implements ModelSchema {
   }
 
   get attributes(): Map<string, AttributeSchema> {
-    let attrs = this.__store._attributesDefinitionFor(this.modelName);
+    let attrs = this.__store._attributesDefinitionFor({ type: this.modelName });
     return mapFromHash(attrs);
   }
 
   get relationshipsByName(): Map<string, RelationshipSchema> {
-    let relationships = this.__store._relationshipsDefinitionFor(this.modelName);
+    let relationships = this.__store._relationshipsDefinitionFor({ type: this.modelName });
     return mapFromHash(relationships);
   }
 
   eachAttribute<T>(callback: (this: T | undefined, key: string, attribute: AttributeSchema) => void, binding?: T) {
-    let attrDefs = this.__store._attributesDefinitionFor(this.modelName);
+    let attrDefs = this.__store._attributesDefinitionFor({ type: this.modelName });
     Object.keys(attrDefs).forEach((key) => {
       callback.call(binding, key, attrDefs[key] as AttributeSchema);
     });
@@ -66,7 +65,7 @@ export default class ShimModelClass implements ModelSchema {
     callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
     binding?: T
   ) {
-    let relationshipDefs = this.__store._relationshipsDefinitionFor(this.modelName);
+    let relationshipDefs = this.__store._relationshipsDefinitionFor({ type: this.modelName });
     Object.keys(relationshipDefs).forEach((key) => {
       callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);
     });
@@ -76,7 +75,7 @@ export default class ShimModelClass implements ModelSchema {
     callback: (this: T | undefined, key: string, relationship: RelationshipSchema) => void,
     binding?: T
   ) {
-    let relationshipDefs = this.__store._relationshipsDefinitionFor(this.modelName);
+    let relationshipDefs = this.__store._relationshipsDefinitionFor({ type: this.modelName });
     Object.keys(relationshipDefs).forEach((key) => {
       if (relationshipDefs[key]!.type) {
         callback.call(binding, key, relationshipDefs[key] as RelationshipSchema);

package/addon/-private/system/model/states.js

@@ -3,7 +3,6 @@
 */
 import { assert } from '@ember/debug';
 
-import { CUSTOM_MODEL_CLASS, REQUEST_SERVICE } from '@ember-data/canary-features';
 /*
   This file encapsulates the various states that a record can transition
   through during its lifecycle.
@@ -432,11 +431,7 @@ createdState.uncommitted.rollback = function (internalModel) {
 
 createdState.uncommitted.pushedData = function (internalModel) {
   // TODO @runspired consider where to do this once we kill off state machine
-  if (CUSTOM_MODEL_CLASS) {
-    internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');
-  } else {
-    internalModel.notifyPropertyChange('id');
-  }
+  internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');
   internalModel.transitionTo('loaded.updated.uncommitted');
   internalModel.triggerLater('didLoad');
 };
@@ -500,9 +495,6 @@ const RootState = {
 
     // EVENTS
     loadingData(internalModel, promise) {
-      if (!REQUEST_SERVICE) {
-        internalModel._promiseProxy = promise;
-      }
       internalModel.transitionTo('loading');
     },
 
@@ -593,11 +585,7 @@ const RootState = {
         internalModel.transitionTo('updated.inFlight');
       },
 
-      reloadRecord(internalModel, { resolve, options }) {
-        if (!REQUEST_SERVICE) {
-          resolve(internalModel.store._reloadRecord(internalModel, options));
-        }
-      },
+      reloadRecord() {},
 
       deleteRecord(internalModel) {
         internalModel.transitionTo('deleted.uncommitted');

package/addon/-private/system/record-array-manager.js

@@ -6,32 +6,24 @@ import { A } from '@ember/array';
 import { assert } from '@ember/debug';
 import { get, set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
-
-import { REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT } from '@ember-data/canary-features';
+import { DEBUG } from '@glimmer/env';
 
 import isStableIdentifier from '../identifiers/is-stable-identifier';
 import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { internalModelFactoryFor } from './store/internal-model-factory';
+import WeakCache from './weak-cache';
 
-const RecordArraysCache = new WeakMap();
-
+const RecordArraysCache = new WeakCache(DEBUG ? 'record-arrays' : '');
+RecordArraysCache._generator = () => new Set();
 export function recordArraysForIdentifier(identifierOrInternalModel) {
-  if (RecordArraysCache.has(identifierOrInternalModel)) {
-    // return existing Set if exists
-    return RecordArraysCache.get(identifierOrInternalModel);
-  }
-
-  // returns workable Set instance
-  RecordArraysCache.set(identifierOrInternalModel, new Set());
-  return RecordArraysCache.get(identifierOrInternalModel);
+  return RecordArraysCache.lookup(identifierOrInternalModel);
 }
 
 const pendingForIdentifier = new Set([]);
-const IMDematerializing = new WeakMap();
 
-const getIdentifier = function getIdentifier(identifierOrInternalModel) {
+function getIdentifier(identifierOrInternalModel) {
   let i = identifierOrInternalModel;
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !isStableIdentifier(identifierOrInternalModel)) {
+  if (!isStableIdentifier(identifierOrInternalModel)) {
     // identifier may actually be an internalModel
     // but during materialization we will get an identifier that
     // has already been removed from the identifiers cache yet
@@ -40,24 +32,9 @@ const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   }
 
   return i;
-};
-
-// REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT only
-const peekIMCache = function peekIMCache(cache, identifier) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
-    let im = IMDematerializing.get(identifier);
-    if (im === undefined) {
-      // if not im._isDematerializing
-      im = cache.peek(identifier);
-    }
-
-    return im;
-  }
-
-  return cache.peek(identifier);
-};
+}
 
-const shouldIncludeInRecordArrays = function shouldIncludeInRecordArrays(store, identifier) {
+function shouldIncludeInRecordArrays(store, identifier) {
   const cache = internalModelFactoryFor(store);
   const internalModel = cache.peek(identifier);
 
@@ -65,7 +42,7 @@ const shouldIncludeInRecordArrays = function shouldIncludeInRecordArrays(store,
     return false;
   }
   return !internalModel.isHiddenFromRecordArrays();
-};
+}
 
 /**
   @class RecordArrayManager
@@ -351,14 +328,6 @@ class RecordArrayManager {
     let modelName = identifier.type;
     identifier = getIdentifier(identifier);
 
-    if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
-      const cache = internalModelFactoryFor(this.store);
-      const im = peekIMCache(cache, identifier);
-      if (im && im._isDematerializing) {
-        IMDematerializing.set(identifier, im);
-      }
-    }
-
     if (pendingForIdentifier.has(identifier)) {
       return;
     }
@@ -386,7 +355,7 @@ class RecordArrayManager {
   }
 }
 
-const removeFromArray = function removeFromArray(array, item) {
+function removeFromArray(array, item) {
   let index = array.indexOf(item);
 
   if (index !== -1) {
@@ -395,9 +364,9 @@ const removeFromArray = function removeFromArray(array, item) {
   }
 
   return false;
-};
+}
 
-const updateLiveRecordArray = function updateLiveRecordArray(store, recordArray, identifiers) {
+function updateLiveRecordArray(store, recordArray, identifiers) {
   let identifiersToAdd = [];
   let identifiersToRemove = [];
 
@@ -420,46 +389,28 @@ const updateLiveRecordArray = function updateLiveRecordArray(store, recordArray,
   }
 
   if (identifiersToAdd.length > 0) {
-    pushIdentifiers(recordArray, identifiersToAdd, internalModelFactoryFor(store));
+    recordArray._pushIdentifiers(identifiersToAdd);
   }
   if (identifiersToRemove.length > 0) {
-    removeIdentifiers(recordArray, identifiersToRemove, internalModelFactoryFor(store));
-  }
-};
-
-const pushIdentifiers = function pushIdentifiers(recordArray, identifiers, cache) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._pushIdentifiers) {
-    // deprecate('not allowed to use this intimate api any more');
-    recordArray._pushInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
-  } else {
-    recordArray._pushIdentifiers(identifiers);
+    recordArray._removeIdentifiers(identifiersToRemove);
   }
-};
-const removeIdentifiers = function removeIdentifiers(recordArray, identifiers, cache) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._removeIdentifiers) {
-    // deprecate('not allowed to use this intimate api any more');
-    recordArray._removeInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
-  } else {
-    recordArray._removeIdentifiers(identifiers);
-  }
-};
+}
 
-const removeFromAdapterPopulatedRecordArrays = function removeFromAdapterPopulatedRecordArrays(store, identifiers) {
+function removeFromAdapterPopulatedRecordArrays(store, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
     removeFromAll(store, identifiers[i]);
   }
-};
+}
 
-const removeFromAll = function removeFromAll(store, identifier) {
+function removeFromAll(store, identifier) {
   identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);
-  const cache = internalModelFactoryFor(store);
 
   recordArrays.forEach(function (recordArray) {
-    removeIdentifiers(recordArray, [identifier], cache);
+    recordArray._removeIdentifiers([identifier]);
   });
 
   recordArrays.clear();
-};
+}
 
 export default RecordArrayManager;

package/addon/-private/system/record-arrays/adapter-populated-record-array.js

@@ -1,9 +1,5 @@
 import { A } from '@ember/array';
 import { get } from '@ember/object';
-import { once } from '@ember/runloop';
-import { DEBUG } from '@glimmer/env';
-
-import { DEPRECATE_EVENTED_API_USAGE } from '@ember-data/private-build-infra/deprecations';
 
 import RecordArray from './record-array';
 
@@ -51,18 +47,13 @@ import RecordArray from './record-array';
   @public
   @extends RecordArray
 */
-let AdapterPopulatedRecordArray = RecordArray.extend({
+export default RecordArray.extend({
   init() {
     this.set('content', this.get('content') || A());
 
     this._super(...arguments);
     this.query = this.query || null;
     this.links = this.links || null;
-
-    if (DEBUG) {
-      this._getDeprecatedEventedInfo = () =>
-        `AdapterPopulatedRecordArray containing ${this.modelName} for query: ${this.query}`;
-    }
   },
 
   replace() {
@@ -90,14 +81,6 @@ let AdapterPopulatedRecordArray = RecordArray.extend({
     });
 
     this.manager._associateWithRecordArray(identifiersOrInternalModels, this);
-
-    if (DEPRECATE_EVENTED_API_USAGE) {
-      let _hasDidLoad = DEBUG ? this._has('didLoad') : this.has('didLoad');
-      if (_hasDidLoad) {
-        // TODO: should triggering didLoad event be the last action of the runLoop?
-        once(this, 'trigger', 'didLoad');
-      }
-    }
   },
 
   /**
@@ -110,5 +93,3 @@ let AdapterPopulatedRecordArray = RecordArray.extend({
     this._setObjects(identifiers, payload);
   },
 });
-
-export default AdapterPopulatedRecordArray;

package/addon/-private/system/record-arrays/record-array.js

@@ -3,11 +3,9 @@
 */
 import ArrayProxy from '@ember/array/proxy';
 import { computed, get, set } from '@ember/object';
-import { DEBUG } from '@glimmer/env';
 
 import { Promise } from 'rsvp';
 
-import DeprecatedEvented from '../deprecated-evented';
 import { PromiseArray } from '../promise-proxies';
 import SnapshotRecordArray from '../snapshot-record-array';
 import { internalModelFactoryFor } from '../store/internal-model-factory';
@@ -28,17 +26,12 @@ function recordForIdentifier(store, identifier) {
   @class RecordArray
   @public
   @extends Ember.ArrayProxy
-  @uses Ember.Evented
 */
 
-let RecordArray = ArrayProxy.extend(DeprecatedEvented, {
+let RecordArray = ArrayProxy.extend({
   init(args) {
     this._super(args);
 
-    if (DEBUG) {
-      this._getDeprecatedEventedInfo = () => `RecordArray containing ${this.modelName}`;
-    }
-
     /**
       The array of client ids backing the record array. When a
       record is requested from the record array, the record

package/addon/-private/system/record-data-for.ts

@@ -1,7 +1,9 @@
 import { assert } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
 
 import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
 import type { RecordData } from '../ts-interfaces/record-data';
+import WeakCache from './weak-cache';
 
 /*
  * Returns the RecordData instance associated with a given
@@ -25,23 +27,23 @@ type Reference = { internalModel: InternalModel };
 
 type Instance = StableRecordIdentifier | InternalModel | RecordData | DSModelOrSnapshot | Reference;
 
-const IdentifierCache = new WeakMap<StableRecordIdentifier, RecordData>();
+const RecordDataForIdentifierCache = new WeakCache<StableRecordIdentifier, RecordData>(DEBUG ? 'recordData' : '');
 
-export function setRecordDataFor(identifier: StableRecordIdentifier, recordData: RecordData) {
-  assert(`Illegal set of identifier`, !IdentifierCache.has(identifier));
-  IdentifierCache.set(identifier, recordData);
+export function setRecordDataFor(identifier: StableRecordIdentifier, recordData: RecordData): void {
+  assert(`Illegal set of identifier`, !RecordDataForIdentifierCache.has(identifier));
+  RecordDataForIdentifierCache.set(identifier, recordData);
 }
 
-export function removeRecordDataFor(identifier) {
-  IdentifierCache.delete(identifier);
+export function removeRecordDataFor(identifier: StableRecordIdentifier): void {
+  RecordDataForIdentifierCache.delete(identifier);
 }
 
 export default function recordDataFor(instance: StableRecordIdentifier): RecordData | null;
 export default function recordDataFor(instance: Instance): RecordData;
 export default function recordDataFor(instance: object): null;
 export default function recordDataFor(instance: Instance | object): RecordData | null {
-  if (IdentifierCache.has(instance as StableRecordIdentifier)) {
-    return IdentifierCache.get(instance as StableRecordIdentifier) as RecordData;
+  if (RecordDataForIdentifierCache.has(instance as StableRecordIdentifier)) {
+    return RecordDataForIdentifierCache.get(instance as StableRecordIdentifier) as RecordData;
   }
   let internalModel =
     (instance as DSModelOrSnapshot)._internalModel || (instance as Reference).internalModel || instance;

package/addon/-private/system/record-notification-manager.ts

@@ -1,11 +1,16 @@
-import { identifierCacheFor } from '../identifiers/cache';
+import { DEBUG } from '@glimmer/env';
+
 import type { RecordIdentifier, StableRecordIdentifier } from '../ts-interfaces/identifier';
 import type CoreStore from './core-store';
+import WeakCache from './weak-cache';
 
 type UnsubscribeToken = Object;
 
-const Cache = new WeakMap<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>();
-const Tokens = new WeakMap<UnsubscribeToken, StableRecordIdentifier>();
+const Cache = new WeakCache<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>(
+  DEBUG ? 'subscribers' : ''
+);
+Cache._generator = () => new Map();
+const Tokens = new WeakCache<UnsubscribeToken, StableRecordIdentifier>(DEBUG ? 'identifier' : '');
 
 export type NotificationType =
   | 'attributes'
@@ -39,12 +44,8 @@ export default class NotificationManager {
   constructor(private store: CoreStore) {}
 
   subscribe(identifier: RecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
-    let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
-    let map = Cache.get(stableIdentifier);
-    if (map === undefined) {
-      map = new Map();
-      Cache.set(stableIdentifier, map);
-    }
+    let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);
+    let map = Cache.lookup(stableIdentifier);
     let unsubToken = {};
     map.set(unsubToken, callback);
     Tokens.set(unsubToken, stableIdentifier);
@@ -54,7 +55,7 @@ export default class NotificationManager {
   notify(identifier: RecordIdentifier, value: 'attributes' | 'relationships' | 'property', key?: string): boolean;
   notify(identifier: RecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): boolean;
   notify(identifier: RecordIdentifier, value: NotificationType, key?: string): boolean {
-    let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
+    let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);
     let callbackMap = Cache.get(stableIdentifier);
     if (!callbackMap || !callbackMap.size) {
       return false;

package/addon/-private/system/references/belongs-to.ts

@@ -1,11 +1,8 @@
-import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
-import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
-import { DEPRECATE_BELONGS_TO_REFERENCE_PUSH } from '@ember-data/private-build-infra/deprecations';
 import type { BelongsToRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
@@ -13,7 +10,7 @@ import { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api'
 import { StableRecordIdentifier } from '../../ts-interfaces/identifier';
 import CoreStore from '../core-store';
 import { NotificationType, unsubscribe } from '../record-notification-manager';
-import { internalModelFactoryFor, peekRecordIdentifier, recordIdentifierFor } from '../store/internal-model-factory';
+import { internalModelFactoryFor, recordIdentifierFor } from '../store/internal-model-factory';
 import RecordReference from './record';
 import Reference from './reference';
 
@@ -57,26 +54,22 @@ export default class BelongsToReference extends Reference {
     this.parent = parent!.recordReference;
     this.parentIdentifier = parentIdentifier;
 
-    if (CUSTOM_MODEL_CLASS) {
-      this.#token = store._notificationManager.subscribe(
-        parentIdentifier,
-        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-          if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
-            this._ref++;
-          }
+    this.#token = store._notificationManager.subscribe(
+      parentIdentifier,
+      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+          this._ref++;
         }
-      );
-    }
+      }
+    );
 
     // TODO inverse
   }
 
   destroy() {
-    if (CUSTOM_MODEL_CLASS) {
-      unsubscribe(this.#token);
-      if (this.#relatedToken) {
-        unsubscribe(this.#relatedToken);
-      }
+    unsubscribe(this.#token);
+    if (this.#relatedToken) {
+      unsubscribe(this.#relatedToken);
     }
   }
 
@@ -147,17 +140,7 @@ export default class BelongsToReference extends Reference {
    @return {String} The id of the record in this belongsTo relationship.
    */
   id(): string | null {
-    if (CUSTOM_MODEL_CLASS) {
-      return this._relatedIdentifier?.id || null;
-    }
-    let resource = this._resource();
-    if (resource && resource.data) {
-      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
-
-      return identifier.id;
-    }
-
-    return null;
+    return this._relatedIdentifier?.id || null;
   }
 
   _resource() {
@@ -210,46 +193,28 @@ export default class BelongsToReference extends Reference {
    @param {Object|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
-  async push(objectOrPromise: Object | SingleResourceDocument): Promise<Object> {
-    // TODO deprecate thenable support
-    return resolve(objectOrPromise).then((data) => {
-      let record: Object;
-
-      if (DEPRECATE_BELONGS_TO_REFERENCE_PUSH && peekRecordIdentifier(data)) {
-        deprecate('Pushing a record into a BelongsToReference is deprecated', false, {
-          id: 'ember-data:belongs-to-reference-push-record',
-          until: '4.0',
-          for: '@ember-data/store',
-          since: {
-            available: '3.16',
-            enabled: '3.16',
-          },
-        });
-        record = data as Object;
-      } else {
-        record = this.store.push(data as SingleResourceDocument);
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-      assertPolymorphicType(
-        this.belongsToRelationship.identifier,
-        this.belongsToRelationship.definition,
-        recordIdentifierFor(record),
-        this.store
-      );
-
-      const { graph, identifier } = this.belongsToRelationship;
-      this.store._backburner.join(() => {
-        graph.push({
-          op: 'replaceRelatedRecord',
-          record: identifier,
-          field: this.key,
-          value: recordIdentifierFor(record),
-        });
+  async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<Object> {
+    const jsonApiDoc = await resolve(data);
+    let record = this.store.push(jsonApiDoc);
+
+    assertPolymorphicType(
+      this.belongsToRelationship.identifier,
+      this.belongsToRelationship.definition,
+      recordIdentifierFor(record),
+      this.store
+    );
+
+    const { graph, identifier } = this.belongsToRelationship;
+    this.store._backburner.join(() => {
+      graph.push({
+        op: 'replaceRelatedRecord',
+        record: identifier,
+        field: this.key,
+        value: recordIdentifierFor(record),
       });
-
-      return record;
     });
+
+    return record;
   }
 
   /**