@ember-data/store 4.2.0-alpha.0 → 4.2.0-alpha.1

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

@@ -30,7 +30,6 @@ import {
 } from '@ember-data/private-build-infra';
 import {
   DEPRECATE_DEFAULT_ADAPTER,
-  DEPRECATE_DEFAULT_SERIALIZER,
   DEPRECATE_LEGACY_TEST_REGISTRATIONS,
 } from '@ember-data/private-build-infra/deprecations';
 import type {
@@ -1248,7 +1247,7 @@ abstract class CoreStore extends Service {
     return Promise.resolve(internalModel);
   }
 
-  _findByInternalModel(internalModel, options: { preload?: any } = {}) {
+  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}) {
     if (options.preload) {
       this._backburner.join(() => {
         internalModel.preloadData(options.preload);
@@ -1263,7 +1262,7 @@ abstract class CoreStore extends Service {
     );
   }
 
-  _findEmptyInternalModel(internalModel, options) {
+  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions) {
     if (internalModel.currentState.isEmpty) {
       return this._scheduleFetch(internalModel, options);
     }
@@ -1275,9 +1274,9 @@ abstract class CoreStore extends Service {
       }
     } else {
       if (internalModel.currentState.isLoading) {
-        let pending = this._fetchManager.getPendingFetch(internalModel.identifier);
-        if (pending) {
-          return pending.then(() => Promise.resolve(internalModel));
+        let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
+        if (pendingRequest) {
+          return pendingRequest.then(() => Promise.resolve(internalModel));
         }
         return this._scheduleFetch(internalModel, options);
       }
@@ -1729,7 +1728,7 @@ abstract class CoreStore extends Service {
     if (arguments.length === 1 && isMaybeIdentifier(identifier)) {
       let stableIdentifier = identifierCacheFor(this).peekRecordIdentifier(identifier);
       if (stableIdentifier) {
-        return internalModelFactoryFor(this).peek(stableIdentifier)?.getRecord();
+        return internalModelFactoryFor(this).peek(stableIdentifier)?.getRecord() || null;
       }
       return null;
     }
@@ -2019,7 +2018,7 @@ abstract class CoreStore extends Service {
     if (internalModel) {
       // short circuit if we are already loading
       if (REQUEST_SERVICE) {
-        let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier);
+        let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
         if (pendingRequest) {
           return pendingRequest.then(() => internalModel.getRecord());
         }
@@ -2051,6 +2050,10 @@ abstract class CoreStore extends Service {
         return resolve(null);
       }
 
+      if (!internalModel) {
+        assert(`No InternalModel found for ${resource.lid}`, internalModel);
+      }
+
       return this._findByInternalModel(internalModel, options);
     }
 
@@ -3601,10 +3604,6 @@ abstract class CoreStore extends Service {
     for an `App.ApplicationSerializer` (the default serializer for
     your entire application).
 
-    if no `App.ApplicationSerializer` is found, it will attempt
-    to get the `defaultSerializer` from the `PersonAdapter`
-    (`adapterFor('person')`).
-
     If a serializer cannot be found on the adapter, it will fall back
     to an instance of `JSONSerializer`.
 
@@ -3672,31 +3671,6 @@ abstract class CoreStore extends Service {
     }
 
     let serializerName;
-    if (DEPRECATE_DEFAULT_SERIALIZER) {
-      // no model specific serializer or application serializer, check for the `defaultSerializer`
-      // property defined on the adapter
-      let adapter = this.adapterFor(modelName);
-      serializerName = get(adapter, 'defaultSerializer');
-
-      deprecate(
-        `store.serializerFor("${modelName}") resolved the "${serializerName}" serializer via the deprecated \`adapter.defaultSerializer\` property.\n\n\tPreviously, if no application or type-specific serializer was specified, the store would attempt to lookup a serializer via the \`defaultSerializer\` property on the type's adapter. This behavior is deprecated in favor of explicitly defining a type-specific serializer or application serializer`,
-        !serializerName,
-        {
-          id: 'ember-data:default-serializer',
-          until: '4.0',
-          url: 'https://deprecations.emberjs.com/ember-data/v3.x/#toc_ember-data-default-serializers',
-          for: '@ember-data/store',
-          since: {
-            available: '3.15',
-            enabled: '3.15',
-          },
-        }
-      );
-
-      serializer = serializerName
-        ? _serializerCache[serializerName] || owner.lookup(`serializer:${serializerName}`)
-        : undefined;
-    }
 
     if (DEPRECATE_LEGACY_TEST_REGISTRATIONS) {
       // in production this is handled by the re-export
@@ -3727,49 +3701,10 @@ abstract class CoreStore extends Service {
       }
     }
 
-    if (DEPRECATE_DEFAULT_SERIALIZER) {
-      // final fallback, no model specific serializer, no application serializer, no
-      // `serializer` property on store: use the convenience JSONSerializer
-      serializer = _serializerCache['-default'] || owner.lookup('serializer:-default');
-      if (DEBUG && HAS_EMBER_DATA_PACKAGE && HAS_SERIALIZER_PACKAGE && serializer === undefined) {
-        const JSONSerializer = require('@ember-data/serializer/json').default;
-        owner.register('serializer:-default', JSONSerializer);
-        serializer = owner.lookup('serializer:-default');
-
-        serializer && deprecateTestRegistration('serializer', '-default');
-      }
-
-      deprecate(
-        `store.serializerFor("${modelName}") resolved the "-default" serializer via the deprecated "-default" lookup fallback.\n\n\tPreviously, when no type-specific serializer, application serializer, or adapter.defaultSerializer had been defined by the app, the "-default" serializer would be used which defaulted to the \`JSONSerializer\`. This behavior is deprecated in favor of explicitly defining an application or type-specific serializer`,
-        !serializer,
-        {
-          id: 'ember-data:default-serializer',
-          until: '4.0',
-          url: 'https://deprecations.emberjs.com/ember-data/v3.x/#toc_ember-data-default-serializers',
-          for: '@ember-data/store',
-          since: {
-            available: '3.15',
-            enabled: '3.15',
-          },
-        }
-      );
-
-      assert(
-        `No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`,
-        serializer !== undefined
-      );
-
-      set(serializer, 'store', this);
-      _serializerCache[normalizedModelName] = serializer;
-      _serializerCache['-default'] = serializer;
-
-      return serializer;
-    } else {
-      assert(
-        `No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`,
-        serializer !== undefined
-      );
-    }
+    assert(
+      `No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`,
+      serializer !== undefined
+    );
   }
 
   destroy() {

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

@@ -37,9 +37,10 @@ class Store extends CoreStore {
     let createOptions: any = {
       store: this,
       _internalModel: internalModel,
+      // TODO deprecate allowing unknown args setting
+      _createProps: createRecordArgs,
       container: null,
     };
-    Object.assign(createOptions, createRecordArgs);
 
     // ensure that `getOwner(this)` works inside a model instance
     setOwner(createOptions, getOwner(this));

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

@@ -501,10 +501,10 @@ export default class FetchManager {
     }
   }
 
-  getPendingFetch(identifier: StableRecordIdentifier) {
-    let pendingRequests = this.requestCache
-      .getPendingRequestsForRecord(identifier)
-      .filter((req) => req.type === 'query');
+  getPendingFetch(identifier: StableRecordIdentifier, options) {
+    let pendingRequests = this.requestCache.getPendingRequestsForRecord(identifier).filter((req) => {
+      return req.type === 'query' && isSameRequest(options, req.request.data[0].options);
+    });
 
     if (pendingRequests.length > 0) {
       return pendingRequests[0][RequestPromise];
@@ -532,3 +532,8 @@ function assertIsString(id: string | null): asserts id is string {
     }
   }
 }
+
+// this function helps resolve whether we have a pending request that we should use instead
+function isSameRequest(options: Dict<unknown> = {}, reqOptions: Dict<unknown> = {}) {
+  return options.include === reqOptions.include;
+}

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

@@ -24,6 +24,7 @@ import type {
 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';
 import type { JsonApiResource, JsonApiValidationError } from '../../ts-interfaces/record-data-json-api';
@@ -127,7 +128,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>>;
@@ -199,7 +200,7 @@ export default class InternalModel {
     }
   }
 
-  get recordReference() {
+  get recordReference(): RecordReference {
     if (this._recordReference === null) {
       this._recordReference = new RecordReference(this.store, this.identifier);
     }
@@ -291,7 +292,7 @@ export default class InternalModel {
     }
   }
 
-  getRecord(properties?) {
+  getRecord(properties?): Object {
     if (!this._record && !this._isDematerializing) {
       let { store } = this;
 
@@ -613,7 +614,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;
       }
@@ -672,7 +673,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);
@@ -790,11 +791,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;
@@ -803,6 +815,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');
@@ -902,11 +915,18 @@ export default class InternalModel {
 
   notifyHasManyChange(key: string) {
     if (this.hasRecord) {
+      let manyArray = this._manyArrayCache[key];
+      let hasPromise = !!this._relationshipPromisesCache[key];
+
+      if (manyArray && hasPromise) {
+        // do nothing, we will notify the ManyArray directly
+        // once the fetch has completed.
+        return;
+      }
+
       if (CUSTOM_MODEL_CLASS) {
         this.store._notificationManager.notify(this.identifier, 'relationships', key);
       } else {
-        let manyArray = this._manyArrayCache[key];
-
         if (manyArray) {
           manyArray.notify();
 
@@ -956,10 +976,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');
         }
       }
     }
@@ -1263,12 +1283,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;
     }
   }
 
@@ -1283,7 +1303,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]);
             }
           }
         }
@@ -1303,7 +1323,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-notification-manager.ts

@@ -4,7 +4,7 @@ import type CoreStore from './core-store';
 
 type UnsubscribeToken = Object;
 
-const Cache = new WeakMap<StableRecordIdentifier, NotificationCallback>();
+const Cache = new WeakMap<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>();
 const Tokens = new WeakMap<UnsubscribeToken, StableRecordIdentifier>();
 
 export type NotificationType =
@@ -29,7 +29,8 @@ export function unsubscribe(token: UnsubscribeToken) {
     throw new Error('Passed unknown unsubscribe token to unsubscribe');
   }
   Tokens.delete(token);
-  Cache.delete(identifier);
+  const map = Cache.get(identifier);
+  map?.delete(token);
 }
 /*
   Currently only support a single callback per identifier
@@ -39,8 +40,13 @@ export default class NotificationManager {
 
   subscribe(identifier: RecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
     let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
-    Cache.set(stableIdentifier, callback);
+    let map = Cache.get(stableIdentifier);
+    if (map === undefined) {
+      map = new Map();
+      Cache.set(stableIdentifier, map);
+    }
     let unsubToken = {};
+    map.set(unsubToken, callback);
     Tokens.set(unsubToken, stableIdentifier);
     return unsubToken;
   }
@@ -49,11 +55,13 @@ export default class NotificationManager {
   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) {
+    let callbackMap = Cache.get(stableIdentifier);
+    if (!callbackMap || !callbackMap.size) {
       return false;
     }
-    callback(stableIdentifier, value, key);
+    callbackMap.forEach((cb) => {
+      cb(stableIdentifier, value, key);
+    });
     return true;
   }
 }

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

@@ -1,11 +1,20 @@
 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';
 
+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 RecordReference from './record';
 import Reference from './reference';
 
 /**
@@ -22,17 +31,81 @@ 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);
+      if (this.#relatedToken) {
+        unsubscribe(this.#relatedToken);
+      }
+    }
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifier(): StableRecordIdentifier | null {
+    this._ref; // consume the tracked prop
+    if (this.#relatedToken) {
+      unsubscribe(this.#relatedToken);
+    }
+
+    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 +146,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 +210,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 +225,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 +302,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 +378,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 +433,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,10 +1,23 @@
+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 type { ManyRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
+import {
+  CollectionResourceDocument,
+  ExistingResourceObject,
+  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, recordIdentifierFor } from '../store/internal-model-factory';
+import RecordReference from './record';
 import Reference, { internalModelForReference } from './reference';
 
 /**
@@ -20,17 +33,88 @@ 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.#relatedTokenMap.forEach((token) => {
+        unsubscribe(token);
+      });
+      this.#relatedTokenMap.clear();
+    }
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifiers(): StableRecordIdentifier[] {
+    this._ref; // consume the tracked prop
+
+    let resource = this._resource();
+
+    this.#relatedTokenMap.forEach((token) => {
+      unsubscribe(token);
+    });
+    this.#relatedTokenMap.clear();
+
+    if (resource && resource.data) {
+      return resource.data.map((resourceIdentifier) => {
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+        const 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;
+      });
+    }
+
+    return [];
+  }
+
   _resource() {
     return this.recordData.getHasMany(this.key);
   }
@@ -77,7 +161,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 +205,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 +268,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 +371,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 +444,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 +499,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,8 +1,15 @@
+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 type { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api';
 import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
 import type { RecordInstance } from '../../ts-interfaces/record-instance';
+import type CoreStore from '../core-store';
+import { NotificationType, unsubscribe } from '../record-notification-manager';
 import Reference, { internalModelForReference, REFERENCE_CACHE } from './reference';
 
 /**
@@ -18,11 +25,39 @@ import Reference, { internalModelForReference, REFERENCE_CACHE } from './referen
    @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;
@@ -50,7 +85,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;
   }
 
   /**
@@ -92,7 +135,7 @@ export default class RecordReference extends Reference {
      @public
      @return {String} 'identity'
   */
-  remoteType(): 'link' | 'id' | 'identity' {
+  remoteType(): 'identity' {
     return 'identity';
   }
 
@@ -159,7 +202,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();
@@ -186,8 +229,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`);
   }
@@ -210,8 +254,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

@@ -94,7 +94,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

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

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

@@ -1,7 +1,11 @@
+import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
+
 import type { RecordIdentifier } from './identifier';
 
 export interface Operation {
   op: string;
+  options: Dict<unknown> | undefined;
+  recordIdentifier: RecordIdentifier;
 }
 
 export interface FindRecordQuery extends Operation {

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": "4.2.0-alpha.0",
+  "version": "4.2.0-alpha.1",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -17,17 +17,18 @@
     "start": "ember serve"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.2.0-alpha.0",
-    "@ember-data/private-build-infra": "4.2.0-alpha.0",
+    "@ember-data/canary-features": "4.2.0-alpha.1",
+    "@ember-data/private-build-infra": "4.2.0-alpha.1",
     "@ember/string": "^3.0.0",
     "@glimmer/tracking": "^1.0.4",
     "ember-auto-import": "^2.2.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": "4.2.0-alpha.0",
+    "@ember-data/unpublished-test-infra": "4.2.0-alpha.1",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "^2.6.0",
     "@types/ember": "^3.16.5",
@@ -44,8 +45,8 @@
     "ember-load-initializers": "^2.1.1",
     "ember-maybe-import-regenerator": "^0.1.6",
     "ember-qunit": "^5.1.5",
-    "ember-resolver": "^8.0.0",
-    "ember-source": "~3.28.6",
+    "ember-resolver": "^8.0.3",
+    "ember-source": "~4.0.0",
     "ember-source-channel-url": "^3.0.0",
     "ember-try": "^1.4.0",
     "loader.js": "^4.7.0",