@ember-data/store 3.28.8 → 3.28.11

package/addon/-private/system/core-store.ts

@@ -2500,6 +2500,7 @@ abstract class CoreStore extends Service {
     const factory = internalModelFactoryFor(this);
 
     if (modelName === undefined) {
+      this._notificationManager.destroy();
       factory.clear();
     } else {
       let normalizedModelName = normalizeModelName(modelName);

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

@@ -28,6 +28,8 @@ import Snapshot from '../snapshot';
 import { internalModelFactoryFor, setRecordIdentifier } from '../store/internal-model-factory';
 import RootState from './states';
 
+type DSModel = import('../../ts-interfaces/ds-model').DSModel;
+
 type BelongsToRelationship = import('@ember-data/record-data/-private').BelongsToRelationship;
 type ManyRelationship = import('@ember-data/record-data/-private').ManyRelationship;
 
@@ -130,7 +132,7 @@ export default class InternalModel {
   declare _deferredTriggers: any;
   declare __recordArrays: any;
   declare references: any;
-  declare _recordReference: any;
+  declare _recordReference: RecordReference;
   declare _manyArrayCache: ConfidentDict<ManyArray>;
 
   declare _relationshipPromisesCache: ConfidentDict<RSVP.Promise<any>>;
@@ -202,7 +204,7 @@ export default class InternalModel {
     }
   }
 
-  get recordReference() {
+  get recordReference(): RecordReference {
     if (this._recordReference === null) {
       this._recordReference = new RecordReference(this.store, this.identifier);
     }
@@ -294,7 +296,7 @@ export default class InternalModel {
     }
   }
 
-  getRecord(properties?) {
+  getRecord(properties?): Object {
     if (!this._record && !this._isDematerializing) {
       let { store } = this;
 
@@ -616,7 +618,7 @@ export default class InternalModel {
             "' with id " +
             parentInternalModel.id +
             ' but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`belongsTo({ async: true })`)',
-          toReturn === null || !toReturn.get('isEmpty')
+          toReturn === null || !(toReturn as DSModel).isEmpty
         );
         return toReturn;
       }
@@ -675,7 +677,7 @@ export default class InternalModel {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  getHasMany(key: string, options) {
+  getHasMany(key: string, options?) {
     if (HAS_RECORD_DATA_PACKAGE) {
       const graphFor = require('@ember-data/record-data/-private').graphFor;
       const relationship = graphFor(this.store).get(this.identifier, key);
@@ -793,11 +795,22 @@ export default class InternalModel {
       !this._record || this._record.get('isDestroyed') || this._record.get('isDestroying')
     );
     this.isDestroying = true;
+    if (this._recordReference) {
+      this._recordReference.destroy();
+    }
+    this._recordReference = null;
     let cache = this._manyArrayCache;
     Object.keys(cache).forEach((key) => {
       cache[key].destroy();
       delete cache[key];
     });
+    if (this.references) {
+      cache = this.references;
+      Object.keys(cache).forEach((key) => {
+        cache[key].destroy();
+        delete cache[key];
+      });
+    }
 
     internalModelFactoryFor(this.store).remove(this);
     this._isDestroyed = true;
@@ -806,6 +819,7 @@ export default class InternalModel {
   setupData(data) {
     let changedKeys = this._recordData.pushData(data, this.hasRecord);
     if (this.hasRecord) {
+      // TODO @runspired should this be going through the notification manager?
       this._record._notifyProperties(changedKeys);
     }
     this.send('pushedData');
@@ -966,10 +980,10 @@ export default class InternalModel {
         this.store._notificationManager.notify(this.identifier, 'state');
       } else {
         if (!key || key === 'isNew') {
-          this.getRecord().notifyPropertyChange('isNew');
+          (this.getRecord() as DSModel).notifyPropertyChange('isNew');
         }
         if (!key || key === 'isDeleted') {
-          this.getRecord().notifyPropertyChange('isDeleted');
+          (this.getRecord() as DSModel).notifyPropertyChange('isDeleted');
         }
       }
     }
@@ -1273,12 +1287,12 @@ export default class InternalModel {
       if (this._recordData.getErrors) {
         return this._recordData.getErrors(this.identifier).length > 0;
       } else {
-        let errors = get(this.getRecord(), 'errors');
-        return errors.get('length') > 0;
+        let errors = (this.getRecord() as DSModel).errors;
+        return errors.length > 0;
       }
     } else {
-      let errors = get(this.getRecord(), 'errors');
-      return errors.get('length') > 0;
+      let errors = (this.getRecord() as DSModel).errors;
+      return errors.length > 0;
     }
   }
 
@@ -1293,7 +1307,7 @@ export default class InternalModel {
         if (!this._recordData.getErrors) {
           for (attribute in parsedErrors) {
             if (hasOwnProperty.call(parsedErrors, attribute)) {
-              this.getRecord().errors._add(attribute, parsedErrors[attribute]);
+              (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
             }
           }
         }
@@ -1313,7 +1327,7 @@ export default class InternalModel {
 
       for (attribute in parsedErrors) {
         if (hasOwnProperty.call(parsedErrors, attribute)) {
-          this.getRecord().errors._add(attribute, parsedErrors[attribute]);
+          (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
         }
       }
 

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

@@ -3,7 +3,7 @@
 */
 import { assert } from '@ember/debug';
 
-import { REQUEST_SERVICE } from '@ember-data/canary-features';
+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.
@@ -431,6 +431,12 @@ 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.transitionTo('loaded.updated.uncommitted');
   internalModel.triggerLater('didLoad');
 };

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

@@ -27,7 +27,7 @@ export function recordArraysForIdentifier(identifierOrInternalModel) {
   return RecordArraysCache.get(identifierOrInternalModel);
 }
 
-const pendingForIdentifier = new Set([]);
+const pendingForIdentifier = new Set();
 const IMDematerializing = new WeakMap();
 
 const getIdentifier = function getIdentifier(identifierOrInternalModel) {

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

@@ -1,13 +1,16 @@
-import { identifierCacheFor } from '../identifiers/cache';
+import { assert } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+import isStableIdentifier from '../identifiers/is-stable-identifier';
 
 type CoreStore = import('./core-store').default;
-type RecordIdentifier = import('../ts-interfaces/identifier').RecordIdentifier;
 type StableRecordIdentifier = import('../ts-interfaces/identifier').StableRecordIdentifier;
 
-type UnsubscribeToken = Object;
+type UnsubscribeToken = object;
+let tokenId = 0;
 
-const Cache = new WeakMap<StableRecordIdentifier, NotificationCallback>();
-const Tokens = new WeakMap<UnsubscribeToken, StableRecordIdentifier>();
+const Cache = new Map<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>();
+const Tokens = new Map<UnsubscribeToken, StableRecordIdentifier>();
 
 export type NotificationType =
   | 'attributes'
@@ -20,42 +23,73 @@ export type NotificationType =
   | 'property'; // 'property' is an internal EmberData only transition period concept.
 
 export interface NotificationCallback {
-  (identifier: RecordIdentifier, notificationType: 'attributes' | 'relationships' | 'property', key?: string): void;
-  (identifier: RecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): void;
+  (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
+  (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
 }
 
+// TODO this isn't importable anyway, remove and use a map on the manager?
 export function unsubscribe(token: UnsubscribeToken) {
   let identifier = Tokens.get(token);
-  if (!identifier) {
-    throw new Error('Passed unknown unsubscribe token to unsubscribe');
+
+  if (identifier) {
+    Tokens.delete(token);
+    const map = Cache.get(identifier);
+    map?.delete(token);
   }
-  Tokens.delete(token);
-  Cache.delete(identifier);
 }
 /*
   Currently only support a single callback per identifier
 */
 export default class NotificationManager {
-  constructor(private store: CoreStore) {}
+  declare store: CoreStore;
+  constructor(store: CoreStore) {
+    this.store = store;
+  }
+
+  subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
+    assert(`Expected to receive a stable Identifier to subscribe to`, isStableIdentifier(identifier));
+    let map = Cache.get(identifier);
 
-  subscribe(identifier: RecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
-    let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
-    Cache.set(stableIdentifier, callback);
-    let unsubToken = {};
-    Tokens.set(unsubToken, stableIdentifier);
+    if (!map) {
+      map = new Map();
+      Cache.set(identifier, map);
+    }
+
+    let unsubToken = DEBUG ? { _tokenRef: tokenId++ } : {};
+    map.set(unsubToken, callback);
+    Tokens.set(unsubToken, identifier);
     return unsubToken;
   }
 
-  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 callback = Cache.get(stableIdentifier);
-    if (!callback) {
+  unsubscribe(token: UnsubscribeToken) {
+    unsubscribe(token);
+  }
+
+  // deactivated type signature overloads because pass-through was failing to match any. Bring back if possible.
+  // notify(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships', key?: string): boolean;
+  // notify(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'state'): boolean;
+  notify(identifier: StableRecordIdentifier, value: NotificationType, key?: string): boolean {
+    assert(
+      `Notify does not accept a key argument for the namespace '${value}'. Received key '${key}'.`,
+      !key || value === 'attributes' || value === 'relationships'
+    );
+    if (!isStableIdentifier(identifier)) {
+      return false;
+    }
+
+    let callbackMap = Cache.get(identifier);
+    if (!callbackMap || !callbackMap.size) {
       return false;
     }
-    callback(stableIdentifier, value, key);
+    callbackMap.forEach((cb) => {
+      cb(identifier, value, key);
+    });
     return true;
   }
+
+  destroy() {
+    Tokens.clear();
+    Cache.clear();
+  }
 }

package/addon/-private/system/references/{belongs-to.js → belongs-to.ts}

@@ -1,13 +1,24 @@
 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 { assertPolymorphicType } from '@ember-data/store/-debug';
 
+import { unsubscribe } from '../record-notification-manager';
 import { internalModelFactoryFor, peekRecordIdentifier, recordIdentifierFor } from '../store/internal-model-factory';
 import Reference from './reference';
 
+type RecordReference = import('./record').default;
+type NotificationType = import('../record-notification-manager').NotificationType;
+type CoreStore = import('../core-store').default;
+type StableRecordIdentifier = import('../../ts-interfaces/identifier').StableRecordIdentifier;
+type SingleResourceDocument = import('../../ts-interfaces/ember-data-json-api').SingleResourceDocument;
+
+type BelongsToRelationship = import('@ember-data/record-data/-private').BelongsToRelationship;
 /**
   @module @ember-data/store
 */
@@ -22,17 +33,84 @@ import Reference from './reference';
  @extends Reference
  */
 export default class BelongsToReference extends Reference {
-  constructor(store, parentIMOrIdentifier, belongsToRelationship, key) {
-    super(store, parentIMOrIdentifier);
+  declare key: string;
+  declare belongsToRelationship: BelongsToRelationship;
+  declare type: string;
+  declare parent: RecordReference;
+  declare parentIdentifier: StableRecordIdentifier;
+
+  // unsubscribe tokens given to us by the notification manager
+  #token!: object;
+  #relatedToken: object | null = null;
+
+  @tracked _ref = 0;
+
+  constructor(
+    store: CoreStore,
+    parentIdentifier: StableRecordIdentifier,
+    belongsToRelationship: BelongsToRelationship,
+    key: string
+  ) {
+    super(store, parentIdentifier);
     this.key = key;
     this.belongsToRelationship = belongsToRelationship;
     this.type = belongsToRelationship.definition.type;
-    this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference;
-    this.parentIdentifier = parentIMOrIdentifier;
+    const parent = internalModelFactoryFor(store).peek(parentIdentifier);
+    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++;
+          }
+        }
+      );
+    }
 
     // TODO inverse
   }
 
+  destroy() {
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+      this.#token = null as unknown as object;
+      if (this.#relatedToken) {
+        unsubscribe(this.#relatedToken);
+        this.#relatedToken = null;
+      }
+    }
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifier(): StableRecordIdentifier | null {
+    this._ref; // consume the tracked prop
+    if (this.#relatedToken) {
+      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(
+        identifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+            this._ref++;
+          }
+        }
+      );
+
+      return identifier;
+    }
+
+    return null;
+  }
+
   /**
    The `id` of the record that this reference refers to. Together, the
    `type()` and `id()` methods form a composite key for the identity
@@ -73,13 +151,18 @@ export default class BelongsToReference extends Reference {
     @public
    @return {String} The id of the record in this belongsTo relationship.
    */
-  id() {
-    let id = null;
+  id(): string | null {
+    if (CUSTOM_MODEL_CLASS) {
+      return this._relatedIdentifier?.id || null;
+    }
     let resource = this._resource();
     if (resource && resource.data) {
-      id = resource.data.id;
+      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
+
+      return identifier.id;
     }
-    return id;
+
+    return null;
   }
 
   _resource() {
@@ -132,10 +215,10 @@ 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.
    */
-  push(objectOrPromise) {
+  async push(objectOrPromise: Object | SingleResourceDocument): Promise<Object> {
     // TODO deprecate thenable support
     return resolve(objectOrPromise).then((data) => {
-      let record;
+      let record: Object;
 
       if (DEPRECATE_BELONGS_TO_REFERENCE_PUSH && peekRecordIdentifier(data)) {
         deprecate('Pushing a record into a BelongsToReference is deprecated', false, {
@@ -147,15 +230,16 @@ export default class BelongsToReference extends Reference {
             enabled: '3.16',
           },
         });
-        record = data;
+        record = data as Object;
       } else {
-        record = this.store.push(data);
+        record = this.store.push(data as SingleResourceDocument);
       }
 
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       assertPolymorphicType(
         this.belongsToRelationship.identifier,
         this.belongsToRelationship.definition,
-        record._internalModel.identifier,
+        recordIdentifierFor(record),
         this.store
       );
 
@@ -223,7 +307,7 @@ export default class BelongsToReference extends Reference {
     @public
    @return {Model} the record in this relationship
    */
-  value() {
+  value(): Object | null {
     let resource = this._resource();
     if (resource && resource.data) {
       let inverseInternalModel = this.store._internalModelForResource(resource.data);
@@ -299,7 +383,7 @@ export default class BelongsToReference extends Reference {
    */
   load(options) {
     let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);
-    return parentInternalModel.getBelongsTo(this.key, options);
+    return parentInternalModel!.getBelongsTo(this.key, options);
   }
 
   /**
@@ -354,7 +438,7 @@ export default class BelongsToReference extends Reference {
    */
   reload(options) {
     let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);
-    return parentInternalModel.reloadBelongsTo(this.key, options).then((internalModel) => {
+    return parentInternalModel!.reloadBelongsTo(this.key, options).then((internalModel) => {
       return this.value();
     });
   }

package/addon/-private/system/references/{has-many.js → has-many.ts}

@@ -1,12 +1,26 @@
+import { dependentKeyCompat } from '@ember/object/compat';
 import { DEBUG } from '@glimmer/env';
+import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
+import { unsubscribe } from '../record-notification-manager';
 import { internalModelFactoryFor, recordIdentifierFor } from '../store/internal-model-factory';
 import Reference, { internalModelForReference } from './reference';
 
+type RecordReference = import('./record').default;
+type NotificationType = import('../record-notification-manager').NotificationType;
+type CoreStore = import('../core-store').default;
+type StableRecordIdentifier = import('../../ts-interfaces/identifier').StableRecordIdentifier;
+type CollectionResourceDocument = import('../../ts-interfaces/ember-data-json-api').CollectionResourceDocument;
+type ExistingResourceObject = import('../../ts-interfaces/ember-data-json-api').ExistingResourceObject;
+type SingleResourceDocument = import('../../ts-interfaces/ember-data-json-api').SingleResourceDocument;
+
+type ManyRelationship = import('@ember-data/record-data/-private').ManyRelationship;
+
 /**
   @module @ember-data/store
 */
@@ -20,17 +34,102 @@ import Reference, { internalModelForReference } from './reference';
  @extends Reference
  */
 export default class HasManyReference extends Reference {
-  constructor(store, parentIMOrIdentifier, hasManyRelationship, key) {
-    super(store, parentIMOrIdentifier);
+  declare key: string;
+  declare hasManyRelationship: ManyRelationship;
+  declare type: string;
+  declare parent: RecordReference;
+  declare parentIdentifier: StableRecordIdentifier;
+
+  // unsubscribe tokens given to us by the notification manager
+  #token!: Object;
+  #relatedTokenMap!: Map<StableRecordIdentifier, Object>;
+
+  @tracked _ref = 0;
+
+  constructor(
+    store: CoreStore,
+    parentIdentifier: StableRecordIdentifier,
+    hasManyRelationship: ManyRelationship,
+    key: string
+  ) {
+    super(store, parentIdentifier);
     this.key = key;
     this.hasManyRelationship = hasManyRelationship;
     this.type = hasManyRelationship.definition.type;
 
-    this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference;
+    this.parent = internalModelFactoryFor(store).peek(parentIdentifier)!.recordReference;
 
+    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.#relatedTokenMap = new Map();
+    }
     // TODO inverse
   }
 
+  destroy() {
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+      this.#token = null as unknown as object;
+      this.#relatedTokenMap.forEach((token) => {
+        unsubscribe(token);
+      });
+      this.#relatedTokenMap.clear();
+    }
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifiers(): StableRecordIdentifier[] {
+    this._ref; // consume the tracked prop
+
+    let resource = this._resource();
+
+    let map = this.#relatedTokenMap;
+    this.#relatedTokenMap = new Map();
+
+    if (resource && resource.data) {
+      return resource.data.map((resourceIdentifier) => {
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+
+        let token = map.get(identifier);
+
+        if (token) {
+          map.delete(identifier);
+        } else {
+          token = this.store._notificationManager.subscribe(
+            identifier,
+            (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+              if (
+                bucket === 'identity' ||
+                ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')
+              ) {
+                this._ref++;
+              }
+            }
+          );
+        }
+
+        this.#relatedTokenMap.set(identifier, token);
+
+        return identifier;
+      });
+    }
+
+    map.forEach((token) => {
+      this.store._notificationManager.unsubscribe(token);
+    });
+    map.clear();
+
+    return [];
+  }
+
   _resource() {
     return this.recordData.getHasMany(this.key);
   }
@@ -77,7 +176,7 @@ export default class HasManyReference extends Reference {
    @public
    @return {String} The name of the remote type. This should either be `link` or `ids`
    */
-  remoteType() {
+  remoteType(): 'link' | 'ids' {
     let value = this._resource();
     if (value && value.links && value.links.related) {
       return 'link';
@@ -121,15 +220,22 @@ export default class HasManyReference extends Reference {
     @public
    @return {Array} The ids in this has-many relationship
    */
-  ids() {
+  ids(): Array<string | null> {
+    if (CUSTOM_MODEL_CLASS) {
+      return this._relatedIdentifiers.map((identifier) => identifier.id);
+    }
+
     let resource = this._resource();
 
-    let ids = [];
-    if (resource.data) {
-      ids = resource.data.map((data) => data.id);
+    if (resource && resource.data) {
+      return resource.data.map((resourceIdentifier) => {
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+
+        return identifier.id;
+      });
     }
 
-    return ids;
+    return [];
   }
 
   /**
@@ -177,45 +283,50 @@ export default class HasManyReference extends Reference {
    @param {Array|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
    @return {ManyArray}
    */
-  push(objectOrPromise) {
-    return resolve(objectOrPromise).then((payload) => {
-      let array = payload;
-
-      if (typeof payload === 'object' && payload.data) {
-        array = payload.data;
-      }
+  async push(
+    objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
+  ): Promise<any> {
+    const payload = await resolve(objectOrPromise);
+    let array: Array<ExistingResourceObject | SingleResourceDocument>;
+
+    if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {
+      array = payload.data;
+    } else {
+      array = payload as ExistingResourceObject[];
+    }
 
-      let internalModel = internalModelForReference(this);
+    const internalModel = internalModelForReference(this)!;
+    const { store } = this;
 
-      let identifiers = array.map((obj) => {
-        let record = this.store.push(obj);
+    let identifiers = array.map((obj) => {
+      let record;
+      if ('data' in obj) {
+        // TODO deprecate pushing non-valid JSON:API here
+        record = store.push(obj);
+      } else {
+        record = store.push({ data: obj });
+      }
 
-        if (DEBUG) {
-          let relationshipMeta = this.hasManyRelationship.definition;
-          assertPolymorphicType(
-            internalModel.identifier,
-            relationshipMeta,
-            record._internalModel.identifier,
-            this.store
-          );
-        }
-        return recordIdentifierFor(record);
-      });
+      if (DEBUG) {
+        let relationshipMeta = this.hasManyRelationship.definition;
+        let identifier = this.hasManyRelationship.identifier;
+        assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor(record), store);
+      }
+      return recordIdentifierFor(record);
+    });
 
-      const { graph, identifier } = this.hasManyRelationship;
-      this.store._backburner.join(() => {
-        graph.push({
-          op: 'replaceRelatedRecords',
-          record: identifier,
-          field: this.key,
-          value: identifiers,
-        });
+    const { graph, identifier } = this.hasManyRelationship;
+    store._backburner.join(() => {
+      graph.push({
+        op: 'replaceRelatedRecords',
+        record: identifier,
+        field: this.key,
+        value: identifiers,
       });
-
-      return internalModel.getHasMany(this.key);
-      // TODO IGOR it seems wrong that we were returning the many array here
-      //return this.hasManyRelationship.manyArray;
     });
+
+    // TODO IGOR it seems wrong that we were returning the many array here
+    return internalModel.getHasMany(this.key);
   }
 
   _isLoaded() {
@@ -275,7 +386,7 @@ export default class HasManyReference extends Reference {
    @return {ManyArray}
    */
   value() {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     if (this._isLoaded()) {
       return internalModel.getManyArray(this.key);
     }
@@ -348,7 +459,7 @@ export default class HasManyReference extends Reference {
    this has-many relationship.
    */
   load(options) {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     return internalModel.getHasMany(this.key, options);
   }
 
@@ -403,7 +514,7 @@ export default class HasManyReference extends Reference {
    @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
    */
   reload(options) {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     return internalModel.reloadHasMany(this.key, options);
   }
 }

package/addon/-private/system/references/record.ts

@@ -1,7 +1,16 @@
+import { dependentKeyCompat } from '@ember/object/compat';
+import { cached, tracked } from '@glimmer/tracking';
+
 import RSVP, { resolve } from 'rsvp';
 
+import { CUSTOM_MODEL_CLASS } from '@ember-data/canary-features';
+
+import { unsubscribe } from '../record-notification-manager';
 import Reference, { internalModelForReference, REFERENCE_CACHE } from './reference';
 
+type NotificationType = import('../record-notification-manager').NotificationType;
+
+type CoreStore = import('../core-store').default;
 type SingleResourceDocument = import('../../ts-interfaces/ember-data-json-api').SingleResourceDocument;
 type RecordInstance = import('../../ts-interfaces/record-instance').RecordInstance;
 type StableRecordIdentifier = import('../../ts-interfaces/identifier').StableRecordIdentifier;
@@ -19,11 +28,39 @@ type StableRecordIdentifier = import('../../ts-interfaces/identifier').StableRec
    @extends Reference
 */
 export default class RecordReference extends Reference {
+  // unsubscribe token given to us by the notification manager
+  #token!: Object;
+
+  @tracked _ref = 0;
+
+  constructor(public store: CoreStore, identifier: StableRecordIdentifier) {
+    super(store, identifier);
+    if (CUSTOM_MODEL_CLASS) {
+      this.#token = store._notificationManager.subscribe(
+        identifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+            this._ref++;
+          }
+        }
+      );
+    }
+  }
+
+  destroy() {
+    if (CUSTOM_MODEL_CLASS) {
+      unsubscribe(this.#token);
+    }
+  }
+
   public get type(): string {
     return this.identifier().type;
   }
 
+  @cached
+  @dependentKeyCompat
   private get _id(): string | null {
+    this._ref; // consume the tracked prop
     let identifier = this.identifier();
     if (identifier) {
       return identifier.id;
@@ -51,7 +88,15 @@ export default class RecordReference extends Reference {
      @return {String} The id of the record.
   */
   id() {
-    return this._id;
+    if (CUSTOM_MODEL_CLASS) {
+      return this._id;
+    }
+    let identifier = this.identifier();
+    if (identifier) {
+      return identifier.id;
+    }
+
+    return null;
   }
 
   /**
@@ -93,7 +138,7 @@ export default class RecordReference extends Reference {
      @public
      @return {String} 'identity'
   */
-  remoteType(): 'link' | 'id' | 'identity' {
+  remoteType(): 'identity' {
     return 'identity';
   }
 
@@ -160,7 +205,7 @@ export default class RecordReference extends Reference {
      @return {Model} the record for this RecordReference
   */
   value(): RecordInstance | null {
-    if (this._id !== null) {
+    if (this.id() !== null) {
       let internalModel = internalModelForReference(this);
       if (internalModel && internalModel.currentState.isLoaded) {
         return internalModel.getRecord();
@@ -187,8 +232,9 @@ export default class RecordReference extends Reference {
      @return {Promise<record>} the record for this RecordReference
   */
   load() {
-    if (this._id !== null) {
-      return this.store.findRecord(this.type, this._id);
+    const id = this.id();
+    if (id !== null) {
+      return this.store.findRecord(this.type, id);
     }
     throw new Error(`Unable to fetch record of type ${this.type} without an id`);
   }
@@ -211,8 +257,9 @@ export default class RecordReference extends Reference {
      @return {Promise<record>} the record for this RecordReference
   */
   reload() {
-    if (this._id !== null) {
-      return this.store.findRecord(this.type, this._id, { reload: true });
+    const id = this.id();
+    if (id !== null) {
+      return this.store.findRecord(this.type, id, { reload: true });
     }
     throw new Error(`Unable to fetch record of type ${this.type} without an id`);
   }

package/addon/-private/system/references/reference.ts

@@ -100,7 +100,7 @@ abstract class Reference {
    @public
    @return {String} The name of the remote type. This should either be "link" or "ids"
    */
-  remoteType(): 'link' | 'id' | 'identity' {
+  remoteType(): 'link' | 'id' | 'ids' | 'identity' {
     let value = this._resource();
     if (isResourceIdentiferWithRelatedLinks(value)) {
       return 'link';

package/addon/-private/ts-interfaces/ds-model.ts

@@ -19,6 +19,7 @@ export interface DSModel extends RecordInstance, EmberObject {
   isDeleted: boolean;
   deleteRecord(): void;
   unloadRecord(): void;
+  errors: any;
 }
 
 // Implemented by both ShimModelClass and DSModel

package/index.js

@@ -10,6 +10,8 @@ module.exports = Object.assign({}, addonBaseConfig, {
   shouldRollupPrivate: true,
   externalDependenciesForPrivateModule() {
     return [
+      'ember-cached-decorator-polyfill',
+
       '@ember-data/canary-features',
       '@ember-data/store/-debug',
 
@@ -23,6 +25,7 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember/object/evented',
       '@ember/object/internals',
       '@ember/object/mixin',
+      '@ember/object/compat',
       '@ember/object/promise-proxy-mixin',
       '@ember/object/proxy',
       '@ember/polyfills',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "3.28.8",
+  "version": "3.28.11",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -17,16 +17,17 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "3.28.8",
-    "@ember-data/private-build-infra": "3.28.8",
+    "@ember-data/canary-features": "3.28.11",
+    "@ember-data/private-build-infra": "3.28.11",
     "@ember/string": "^3.0.0",
     "@glimmer/tracking": "^1.0.4",
+    "ember-cached-decorator-polyfill": "^0.1.4",
     "ember-cli-babel": "^7.26.6",
     "ember-cli-path-utils": "^1.0.0",
     "ember-cli-typescript": "^4.1.0"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "3.28.8",
+    "@ember-data/unpublished-test-infra": "3.28.11",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "^2.2.5",
     "@types/ember": "^3.16.5",