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

package/addon/-private/system/ds-model-store.ts

@@ -1,5 +1,5 @@
 import { getOwner, setOwner } from '@ember/application';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import EmberError from '@ember/error';
 import { isPresent } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
@@ -7,7 +7,7 @@ import { DEBUG } from '@glimmer/env';
 import type DSModelClass from '@ember-data/model';
 
 import type { DSModel } from '../ts-interfaces/ds-model';
-import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
+import type { RecordIdentifier, StableRecordIdentifier } from '../ts-interfaces/identifier';
 import type { RecordDataRecordWrapper } from '../ts-interfaces/record-data-record-wrapper';
 import type { RelationshipsSchema } from '../ts-interfaces/record-data-schemas';
 import type { SchemaDefinitionService } from '../ts-interfaces/schema-definition-service';
@@ -105,23 +105,15 @@ class Store extends CoreStore {
   }
 
   _relationshipMetaFor(modelName: string, id: string | null, key: string) {
-    return this._relationshipsDefinitionFor(modelName)[key];
+    return this._relationshipsDefinitionFor({ type: modelName })[key];
   }
 
-  _attributesDefinitionFor(modelName: string, identifier?: StableRecordIdentifier) {
-    if (identifier) {
-      return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
-    } else {
-      return this.getSchemaDefinitionService().attributesDefinitionFor(modelName);
-    }
+  _attributesDefinitionFor(identifier: RecordIdentifier | { type: string }) {
+    return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
   }
 
-  _relationshipsDefinitionFor(modelName: string, identifier?: StableRecordIdentifier): RelationshipsSchema {
-    if (identifier) {
-      return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
-    } else {
-      return this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);
-    }
+  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+    return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
   }
 
   getSchemaDefinitionService(): SchemaDefinitionService {
@@ -137,48 +129,16 @@ let assertDestroyedStoreOnly: Function;
 
 if (DEBUG) {
   assertDestroyingStore = function assertDestroyedStore(store, method) {
-    if (!store.shouldAssertMethodCallsOnDestroyedStore) {
-      deprecate(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !(store.isDestroying || store.isDestroyed),
-        {
-          id: 'ember-data:method-calls-on-destroyed-store',
-          until: '3.8',
-          for: '@ember-data/store',
-          since: {
-            available: '3.8',
-            enabled: '3.8',
-          },
-        }
-      );
-    } else {
-      assert(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !(store.isDestroying || store.isDestroyed)
-      );
-    }
+    assert(
+      `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
+      !(store.isDestroying || store.isDestroyed)
+    );
   };
   assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
-    if (!store.shouldAssertMethodCallsOnDestroyedStore) {
-      deprecate(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !store.isDestroyed,
-        {
-          id: 'ember-data:method-calls-on-destroyed-store',
-          until: '3.8',
-          for: '@ember-data/store',
-          since: {
-            available: '3.8',
-            enabled: '3.8',
-          },
-        }
-      );
-    } else {
-      assert(
-        `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
-        !store.isDestroyed
-      );
-    }
+    assert(
+      `Attempted to call store.${method}(), but the store instance has already been destroyed.`,
+      !store.isDestroyed
+    );
   };
 }
 

package/addon/-private/system/fetch-manager.ts

@@ -20,6 +20,7 @@ import type { PrivateSnapshot } from './snapshot';
 import Snapshot from './snapshot';
 import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './store/common';
 import { normalizeResponseHelper } from './store/serializer-response';
+import WeakCache from './weak-cache';
 
 function payloadIsNotBlank(adapterPayload): boolean {
   if (Array.isArray(adapterPayload)) {
@@ -455,7 +456,7 @@ export default class FetchManager {
     let identifiers = new Array(totalItems);
     let seeking: { [id: string]: PendingFetchItem } = Object.create(null);
 
-    let optionsMap = new WeakMap<RecordIdentifier, Dict<unknown>>();
+    let optionsMap = new WeakCache<RecordIdentifier, Dict<unknown>>(DEBUG ? 'fetch-options' : '');
 
     for (let i = 0; i < totalItems; i++) {
       let pendingItem = pendingFetchItems[i];

package/addon/-private/system/model/internal-model.ts

@@ -15,7 +15,6 @@ import type {
 } from '@ember-data/record-data/-private';
 import type { UpgradedMeta } from '@ember-data/record-data/-private/graph/-edge-definition';
 
-import { identifierCacheFor } from '../../identifiers/cache';
 import { DSModel } from '../../ts-interfaces/ds-model';
 import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
 import type { RecordData } from '../../ts-interfaces/record-data';
@@ -174,7 +173,7 @@ export default class InternalModel {
   set id(value: string | null) {
     if (value !== this._id) {
       let newIdentifier = { type: this.identifier.type, lid: this.identifier.lid, id: value };
-      identifierCacheFor(this.store).updateRecordIdentifier(this.identifier, newIdentifier);
+      this.store.identifierCache.updateRecordIdentifier(this.identifier, newIdentifier);
       this.notifyPropertyChange('id');
     }
   }
@@ -437,7 +436,7 @@ export default class InternalModel {
   getBelongsTo(key, options) {
     let resource = (this._recordData as DefaultRecordData).getBelongsTo(key);
     let identifier =
-      resource && resource.data ? identifierCacheFor(this.store).getOrCreateRecordIdentifier(resource.data) : null;
+      resource && resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
     let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);
     if (!relationshipMeta) return;
 

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/record-array-manager.js

@@ -6,27 +6,22 @@ import { A } from '@ember/array';
 import { assert } from '@ember/debug';
 import { get, set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
+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 getIdentifier = function getIdentifier(identifierOrInternalModel) {
+function getIdentifier(identifierOrInternalModel) {
   let i = identifierOrInternalModel;
   if (!isStableIdentifier(identifierOrInternalModel)) {
     // identifier may actually be an internalModel
@@ -37,13 +32,9 @@ const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   }
 
   return i;
-};
-
-const peekIMCache = function peekIMCache(cache, identifier) {
-  return cache.peek(identifier);
-};
+}
 
-const shouldIncludeInRecordArrays = function shouldIncludeInRecordArrays(store, identifier) {
+function shouldIncludeInRecordArrays(store, identifier) {
   const cache = internalModelFactoryFor(store);
   const internalModel = cache.peek(identifier);
 
@@ -51,7 +42,7 @@ const shouldIncludeInRecordArrays = function shouldIncludeInRecordArrays(store,
     return false;
   }
   return !internalModel.isHiddenFromRecordArrays();
-};
+}
 
 /**
   @class RecordArrayManager
@@ -364,7 +355,7 @@ class RecordArrayManager {
   }
 }
 
-const removeFromArray = function removeFromArray(array, item) {
+function removeFromArray(array, item) {
   let index = array.indexOf(item);
 
   if (index !== -1) {
@@ -373,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 = [];
 
@@ -398,41 +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) {
-  recordArray._pushIdentifiers(identifiers);
-};
-const removeIdentifiers = function removeIdentifiers(recordArray, identifiers, cache) {
-  if (!recordArray._removeIdentifiers) {
-    // deprecate('not allowed to use this intimate api any more');
-    recordArray._removeInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
-  } else {
-    recordArray._removeIdentifiers(identifiers);
+    recordArray._removeIdentifiers(identifiersToRemove);
   }
-};
+}
 
-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,10 +1,8 @@
-import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
-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';
 
@@ -12,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';
 
@@ -195,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
-      );
+  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),
-        });
+    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;
   }
 
   /**