@ember-data/model 4.8.0-alpha.3 → 4.8.0-alpha.6

package/addon/-private/model.js

@@ -7,7 +7,6 @@ import EmberError from '@ember/error';
 import EmberObject from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
-import { inject as service } from '@ember/service';
 import { isNone } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
@@ -19,11 +18,13 @@ import { HAS_DEBUG_PACKAGE } from '@ember-data/private-build-infra';
 import {
   DEPRECATE_EARLY_STATIC,
   DEPRECATE_MODEL_REOPEN,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
   DEPRECATE_SAVE_PROMISE_ACCESS,
 } from '@ember-data/private-build-infra/deprecations';
 import { recordIdentifierFor, storeFor } from '@ember-data/store';
-import { coerceId, deprecatedPromiseObject, recordDataFor, WeakCache } from '@ember-data/store/-private';
+import { coerceId, recordDataFor } from '@ember-data/store/-private';
 
+import { deprecatedPromiseObject } from './deprecated-promise-proxy';
 import Errors from './errors';
 import { LegacySupport } from './legacy-relationships-support';
 import notifyChanges from './notify-changes';
@@ -31,18 +32,21 @@ import RecordState, { peekTag, tagged } from './record-state';
 import { relationshipFromMeta } from './relationship-meta';
 
 const { changeProperties } = Ember;
-export const LEGACY_SUPPORT = new WeakCache(DEBUG ? 'legacy-relationships' : '');
-LEGACY_SUPPORT._generator = (record) => {
+export const LEGACY_SUPPORT = new Map();
+
+export function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
   let support = LEGACY_SUPPORT.get(identifier);
 
   if (!support) {
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
+    LEGACY_SUPPORT.set(record, support);
   }
 
   return support;
-};
+}
+
 function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let possibleRelationships = relationshipsSoFar || [];
 
@@ -118,8 +122,7 @@ function computeOnce(target, key, desc) {
   @extends Ember.EmberObject
 */
 class Model extends EmberObject {
-  @service store;
-  #notifications;
+  ___private_notifications;
 
   init(options = {}) {
     if (DEBUG && !options._secretInit && !options._createProps) {
@@ -129,37 +132,46 @@ class Model extends EmberObject {
     }
     const createProps = options._createProps;
     const _secretInit = options._secretInit;
-    delete options._createProps;
-    delete options._secretInit;
+    options._createProps = null;
+    options._secretInit = null;
+
+    let store = (this.store = _secretInit.store);
     super.init(options);
 
-    _secretInit(this);
+    let identity = _secretInit.identifier;
+    _secretInit.cb(this, _secretInit.recordData, identity, _secretInit.store);
+
     this.___recordState = DEBUG ? new RecordState(this) : null;
 
     this.setProperties(createProps);
 
-    let store = storeFor(this);
     let notifications = store._notificationManager;
-    let identity = recordIdentifierFor(this);
-
-    this.#notifications = notifications.subscribe(identity, (identifier, type, key) => {
+    this.___private_notifications = notifications.subscribe(identity, (identifier, type, key) => {
       notifyChanges(identifier, type, key, this, store);
     });
   }
 
   destroy() {
-    LEGACY_SUPPORT.get(this)?.destroy();
+    const identifier = recordIdentifierFor(this);
     this.___recordState?.destroy();
     const store = storeFor(this);
-    const identifier = recordIdentifierFor(this);
-    store._notificationManager.unsubscribe(this.#notifications);
+    store._notificationManager.unsubscribe(this.___private_notifications);
     // Legacy behavior is to notify the relationships on destroy
     // such that they "clear". It's uncertain this behavior would
     // be good for a new model paradigm, likely cheaper and safer
     // to simply not notify, for this reason the store does not itself
     // notify individual changes once the delete has been signaled,
     // this decision is left to model instances.
-    notifyChanges(identifier, 'relationships', undefined, this, store);
+
+    this.eachRelationship((key, meta) => {
+      if (meta.kind === 'belongsTo') {
+        this.notifyPropertyChange(key);
+      }
+    });
+    LEGACY_SUPPORT.get(this)?.destroy();
+    LEGACY_SUPPORT.delete(this);
+    LEGACY_SUPPORT.delete(identifier);
+
     super.destroy();
   }
 
@@ -487,14 +499,13 @@ class Model extends EmberObject {
     );
 
     if (normalizedId !== null && didChange) {
-      this.store._instanceCache.setRecordId(identifier.type, normalizedId, identifier.lid);
+      this.store._instanceCache.setRecordId(identifier, normalizedId);
       this.store._notificationManager.notify(identifier, 'identity');
     }
   }
 
-  // TODO just write a nice toString
-  toStringExtension() {
-    return this.id;
+  toString() {
+    return `<model::${this.constructor.modelName}:${this.id}>`;
   }
 
   /**
@@ -813,7 +824,7 @@ class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return recordDataFor(this).changedAttributes();
+    return recordDataFor(this).changedAttrs(recordIdentifierFor(this));
   }
 
   /**
@@ -837,12 +848,15 @@ class Model extends EmberObject {
   rollbackAttributes() {
     const { currentState } = this;
     const { isNew } = currentState;
-    recordDataFor(this).rollbackAttributes();
-    this.errors.clear();
-    currentState.cleanErrorRequests();
-    if (isNew) {
-      this.unloadRecord();
-    }
+
+    storeFor(this)._join(() => {
+      recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
+      this.errors.clear();
+      currentState.cleanErrorRequests();
+      if (isNew) {
+        this.unloadRecord();
+      }
+    });
   }
 
   /**
@@ -980,7 +994,7 @@ class Model extends EmberObject {
     import Model, { belongsTo } from '@ember-data/model';
 
     export default class BlogModel extends Model {
-      @belongsTo({ async: true }) user;
+      @belongsTo('user', { async: true, inverse: null }) user;
     }
     ```
 
@@ -1036,7 +1050,7 @@ class Model extends EmberObject {
     @return {BelongsToReference} reference for this relationship
   */
   belongsTo(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('belongsTo', name);
+    return lookupLegacySupport(this).referenceFor('belongsTo', name);
   }
 
   /**
@@ -1048,7 +1062,7 @@ class Model extends EmberObject {
     import Model, { hasMany } from '@ember-data/model';
 
     export default class BlogModel extends Model {
-      @hasMany({ async: true }) comments;
+      @hasMany('comment', { async: true, inverse: null }) comments;
     }
 
     let blog = store.push({
@@ -1099,7 +1113,7 @@ class Model extends EmberObject {
     @return {HasManyReference} reference for this relationship
   */
   hasMany(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('hasMany', name);
+    return lookupLegacySupport(this).referenceFor('hasMany', name);
   }
 
   /**
@@ -1141,7 +1155,7 @@ class Model extends EmberObject {
       record.eachRelationship(function(name, descriptor) {
         if (descriptor.kind === 'hasMany') {
           let serializedHasManyName = name.toUpperCase() + '_IDS';
-          json[serializedHasManyName] = record.get(name).mapBy('id');
+          json[serializedHasManyName] = record.get(name).map(r => r.id);
         }
       });
 
@@ -1201,7 +1215,7 @@ class Model extends EmberObject {
 
    ```javascript
    import RESTSerializer from '@ember-data/serializer/rest';
-   import { underscore } from '@ember/string';
+   import { underscore } from '<app-name>/utils/string-utils';
 
    export default const PostSerializer = RESTSerializer.extend({
      payloadKeyFromModelName(modelName) {
@@ -1795,7 +1809,7 @@ class Model extends EmberObject {
         meta.key = name;
         meta.name = name;
         meta.parentModelName = modelName;
-        relationships[name] = relationshipFromMeta(meta);
+        relationships[name] = DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE ? relationshipFromMeta(meta) : meta;
       }
     });
     return relationships;
@@ -1865,6 +1879,7 @@ class Model extends EmberObject {
     let map = new Map();
 
     this.eachComputedProperty((name, meta) => {
+      // TODO end reliance on these booleans and stop leaking them in the spec
       if (meta.isRelationship) {
         map.set(name, meta.kind);
       } else if (meta.isAttribute) {
@@ -2411,7 +2426,7 @@ if (DEBUG) {
         until: '5.0',
         since: { available: '4.8', enabled: '4.8' },
       });
-      return originalReopen.call(this, arguments);
+      return originalReopen.call(this, ...arguments);
     };
 
     Model.reopenClass = function deprecatedReopenClass() {
@@ -2425,7 +2440,7 @@ if (DEBUG) {
           since: { available: '4.8', enabled: '4.8' },
         }
       );
-      return originalReopenClass.call(this, arguments);
+      return originalReopenClass.call(this, ...arguments);
     };
   }
 }

package/addon/-private/notify-changes.ts

@@ -66,7 +66,7 @@ function notifyRelationship(identifier: StableRecordIdentifier, key: string, rec
 function notifyAttribute(store: Store, identifier: StableRecordIdentifier, key: string, record: Model) {
   let currentValue = cacheFor(record, key);
 
-  if (currentValue !== store._instanceCache.getRecordData(identifier).getAttr(key)) {
+  if (currentValue !== store._instanceCache.getRecordData(identifier).getAttr(identifier, key)) {
     record.notifyPropertyChange(key);
   }
 }

package/addon/-private/promise-belongs-to.ts

@@ -4,11 +4,11 @@ import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import type ObjectProxy from '@ember/object/proxy';
 
 import type Store from '@ember-data/store';
-import { PromiseObject } from '@ember-data/store/-private';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import type { Dict } from '@ember-data/types/q/utils';
 
 import { LegacySupport } from './legacy-relationships-support';
+import { PromiseObject } from './promise-proxy-base';
 
 export interface BelongsToProxyMeta {
   key: string;

package/addon/-private/promise-many-array.ts

@@ -2,18 +2,23 @@ import ArrayMixin, { NativeArray } from '@ember/array';
 import type ArrayProxy from '@ember/array/proxy';
 import { assert, deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
+import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
 import Ember from 'ember';
 
 import { resolve } from 'rsvp';
 
-import type { ManyArray } from 'ember-data/-private';
-
-import { DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS } from '@ember-data/private-build-infra/deprecations';
+import {
+  DEPRECATE_A_USAGE,
+  DEPRECATE_COMPUTED_CHAINS,
+  DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS,
+} from '@ember-data/private-build-infra/deprecations';
 import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import { FindOptions } from '@ember-data/types/q/store';
 
+import type ManyArray from './many-array';
+
 export interface HasManyProxyCreateArgs {
   promise: Promise<ManyArray>;
   content?: ManyArray;
@@ -53,13 +58,27 @@ export default class PromiseManyArray {
     this.isDestroyed = false;
     this.isDestroying = false;
 
-    const meta = Ember.meta(this);
-    meta.hasMixin = (mixin: Object) => {
-      if (mixin === NativeArray || mixin === ArrayMixin) {
-        return true;
-      }
-      return false;
-    };
+    if (DEPRECATE_A_USAGE) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        deprecate(`Do not use A() on an EmberData PromiseManyArray`, false, {
+          id: 'ember-data:no-a-with-array-like',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        });
+        // @ts-expect-error ArrayMixin is more than a type
+        if (mixin === NativeArray || mixin === ArrayMixin) {
+          return true;
+        }
+        return false;
+      };
+    } else if (DEBUG) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        assert(`Do not use A() on an EmberData PromiseManyArray`);
+      };
+    }
   }
 
   //---- Methods/Properties on ArrayProxy that we will keep as our API
@@ -75,7 +94,9 @@ export default class PromiseManyArray {
   get length(): number {
     // shouldn't be needed, but ends up being needed
     // for computed chains even in 4.x
-    this['[]'];
+    if (DEPRECATE_COMPUTED_CHAINS) {
+      this['[]'];
+    }
     return this.content ? this.content.length : 0;
   }
 
@@ -85,7 +106,9 @@ export default class PromiseManyArray {
   // to recompute. We entangle the '[]' tag from
   @dependentKeyCompat
   get '[]'() {
-    return this.content ? this.content['[]'] : this.content;
+    if (DEPRECATE_COMPUTED_CHAINS) {
+      return this.content?.length && this.content;
+    }
   }
 
   /**
@@ -99,7 +122,6 @@ export default class PromiseManyArray {
    * @private
    */
   forEach(cb) {
-    this['[]']; // needed for < 3.23 support e.g. 3.20 lts
     if (this.content && this.length) {
       this.content.forEach(cb);
     }

package/addon/-private/promise-proxy-base.js

@@ -0,0 +1,4 @@
+import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import ObjectProxy from '@ember/object/proxy';
+
+export const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);

package/addon/-private/record-state.ts

@@ -105,7 +105,7 @@ export function tagged(_target, key, desc) {
 
 /**
 Historically EmberData managed a state machine
-for each record, the currentState for which
+for each record, the localState for which
 was reflected onto Model.
 
 This implements the flags and stateName for backwards compat
@@ -247,10 +247,6 @@ export default class RecordState {
             this.notify('isEmpty');
             this.notify('isDirty');
             break;
-          case 'unload':
-            this.notify('isNew');
-            this.notify('isDeleted');
-            break;
           case 'errors':
             this.updateInvalidErrors(this.record.errors);
             this.notify('isValid');
@@ -326,7 +322,7 @@ export default class RecordState {
     let rd = this.recordData;
     if (this.isDeleted) {
       assert(`Expected RecordData to implement isDeletionCommitted()`, rd.isDeletionCommitted);
-      return rd.isDeletionCommitted();
+      return rd.isDeletionCommitted(this.identifier);
     }
     if (this.isNew || this.isEmpty || !this.isValid || this.isDirty || this.isLoading) {
       return false;
@@ -340,21 +336,21 @@ export default class RecordState {
     // TODO this is not actually an RFC'd concept. Determine the
     // correct heuristic to replace this with.
     assert(`Expected RecordData to implement isEmpty()`, rd.isEmpty);
-    return !this.isNew && rd.isEmpty();
+    return !this.isNew && rd.isEmpty(this.identifier);
   }
 
   @tagged
   get isNew() {
     let rd = this.recordData;
     assert(`Expected RecordData to implement isNew()`, rd.isNew);
-    return rd.isNew();
+    return rd.isNew(this.identifier);
   }
 
   @tagged
   get isDeleted() {
     let rd = this.recordData;
     assert(`Expected RecordData to implement isDeleted()`, rd.isDeleted);
-    return rd.isDeleted();
+    return rd.isDeleted(this.identifier);
   }
 
   @tagged
@@ -365,12 +361,10 @@ export default class RecordState {
   @tagged
   get isDirty() {
     let rd = this.recordData;
-    assert(`Expected RecordData to implement hasChangedAttributes()`, rd.hasChangedAttributes);
-    assert(`Expected RecordData to implement isDeletionCommitted()`, rd.isDeletionCommitted);
-    if (rd.isDeletionCommitted() || (this.isDeleted && this.isNew)) {
+    if (rd.isDeletionCommitted(this.identifier) || (this.isDeleted && this.isNew)) {
       return false;
     }
-    return this.isNew || rd.hasChangedAttributes();
+    return this.isNew || rd.hasChangedAttrs(this.identifier);
   }
 
   @tagged

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

@@ -1,15 +1,17 @@
+import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { cached, tracked } from '@glimmer/tracking';
 
 import type { Object as JSONObject, Value as JSONValue } from 'json-typescript';
 import { resolve } from 'rsvp';
 
-import type { BelongsToRelationship } from '@ember-data/record-data/-private';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph';
+import type BelongsToRelationship from '@ember-data/record-data/-private/relationships/state/belongs-to';
 import type Store from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 import { recordIdentifierFor } from '@ember-data/store/-private';
 import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/utils/weak-cache';
 import type {
   LinkObject,
   Links,
@@ -52,31 +54,34 @@ export default class BelongsToReference {
   declare key: string;
   declare belongsToRelationship: BelongsToRelationship;
   declare type: string;
-  #identifier: StableRecordIdentifier;
+  ___identifier: StableRecordIdentifier;
   declare store: Store;
+  declare graph: Graph;
 
   // unsubscribe tokens given to us by the notification manager
-  #token!: Object;
-  #relatedToken: Object | null = null;
+  ___token!: object;
+  ___relatedToken: object | null = null;
 
   @tracked _ref = 0;
 
   constructor(
     store: Store,
+    graph: Graph,
     parentIdentifier: StableRecordIdentifier,
     belongsToRelationship: BelongsToRelationship,
     key: string
   ) {
+    this.graph = graph;
     this.key = key;
     this.belongsToRelationship = belongsToRelationship;
     this.type = belongsToRelationship.definition.type;
     this.store = store;
-    this.#identifier = parentIdentifier;
+    this.___identifier = parentIdentifier;
 
-    this.#token = store._notificationManager.subscribe(
+    this.___token = store._notificationManager.subscribe(
       parentIdentifier,
       (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+        if (bucket === 'relationships' && notifiedKey === key) {
           this._ref++;
         }
       }
@@ -88,9 +93,11 @@ export default class BelongsToReference {
   destroy() {
     // TODO @feature we need the notification manager often enough
     // we should potentially just expose it fully public
-    this.store._notificationManager.unsubscribe(this.#token);
-    if (this.#relatedToken) {
-      this.store._notificationManager.unsubscribe(this.#relatedToken);
+    this.store._notificationManager.unsubscribe(this.___token);
+    this.___token = null as unknown as object;
+    if (this.___relatedToken) {
+      this.store._notificationManager.unsubscribe(this.___relatedToken);
+      this.___relatedToken = null;
     }
   }
 
@@ -98,17 +105,18 @@ export default class BelongsToReference {
   @dependentKeyCompat
   get _relatedIdentifier(): StableRecordIdentifier | null {
     this._ref; // consume the tracked prop
-    if (this.#relatedToken) {
-      this.store._notificationManager.unsubscribe(this.#relatedToken);
+    if (this.___relatedToken) {
+      this.store._notificationManager.unsubscribe(this.___relatedToken);
+      this.___relatedToken = null;
     }
 
     let resource = this._resource();
     if (resource && resource.data) {
       const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
-      this.#relatedToken = this.store._notificationManager.subscribe(
+      this.___relatedToken = this.store._notificationManager.subscribe(
         identifier,
         (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+          if (bucket === 'identity' || (bucket === 'attributes' && notifiedKey === 'id')) {
             this._ref++;
           }
         }
@@ -134,7 +142,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-    @belongsTo({ async: true }) user;
+    @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -174,7 +182,7 @@ export default class BelongsToReference {
    // models/blog.js
    import Model, { belongsTo } from '@ember-data/model';
    export default Model.extend({
-      user: belongsTo({ async: true })
+      user: belongsTo('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -236,7 +244,7 @@ export default class BelongsToReference {
    // models/blog.js
    import Model, { belongsTo } from '@ember-data/model';
    export default Model.extend({
-      user: belongsTo({ async: true })
+      user: belongsTo('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -277,7 +285,9 @@ export default class BelongsToReference {
   }
 
   _resource() {
-    return this.store._instanceCache.getRecordData(this.#identifier).getBelongsTo(this.key);
+    return this.store._instanceCache
+      .getRecordData(this.___identifier)
+      .getRelationship(this.___identifier, this.key) as SingleResourceRelationship;
   }
 
   /**
@@ -291,7 +301,7 @@ export default class BelongsToReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -341,7 +351,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-      @belongsTo({ async: true }) user;
+      @belongsTo('user', { async: true, inverse: null }) user;
     }
 
    let blog = store.push({
@@ -377,8 +387,25 @@ export default class BelongsToReference {
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
   async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<RecordInstance> {
-    // TODO @deprecate pushing unresolved payloads
-    const jsonApiDoc = await resolve(data);
+    let jsonApiDoc: SingleResourceDocument = data as SingleResourceDocument;
+    if (DEPRECATE_PROMISE_PROXIES && (data as { then: unknown }).then) {
+      jsonApiDoc = await resolve(data);
+      if (jsonApiDoc !== data) {
+        deprecate(
+          `You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            since: {
+              enabled: '4.8',
+              available: '4.8',
+            },
+            for: 'ember-data',
+          }
+        );
+      }
+    }
     let record = this.store.push(jsonApiDoc);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -389,9 +416,9 @@ export default class BelongsToReference {
       this.store
     );
 
-    const { graph, identifier } = this.belongsToRelationship;
-    this.store._backburner.join(() => {
-      graph.push({
+    const { identifier } = this.belongsToRelationship;
+    this.store._join(() => {
+      this.graph.push({
         op: 'replaceRelatedRecord',
         record: identifier,
         field: this.key,
@@ -416,7 +443,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -469,7 +496,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -520,9 +547,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship.
    */
   load(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.getBelongsTo(this.key, options);
   }
 
@@ -539,7 +566,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -577,9 +604,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
    */
   reload(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.reloadBelongsTo(this.key, options).then(() => this.value());
   }
 }