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

package/addon/-private/legacy-relationships-support.ts

@@ -5,24 +5,22 @@ import { importSync } from '@embroider/macros';
 import { all, resolve } from 'rsvp';
 
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
-import type {
-  BelongsToRelationship,
-  ManyRelationship,
-  RecordData as DefaultRecordData,
-} from '@ember-data/record-data/-private';
+import type { BelongsToRelationship, ManyRelationship } from '@ember-data/record-data/-private';
 import type { UpgradedMeta } from '@ember-data/record-data/-private/graph/-edge-definition';
-import type { RelationshipState } from '@ember-data/record-data/-private/graph/-state';
+import ImplicitRelationship from '@ember-data/record-data/-private/relationships/state/implicit';
 import type Store from '@ember-data/store';
-import { recordDataFor, recordIdentifierFor, storeFor } from '@ember-data/store/-private';
+import { recordIdentifierFor, storeFor } from '@ember-data/store/-private';
 import { IdentifierCache } from '@ember-data/store/-private/caches/identifier-cache';
 import type { DSModel } from '@ember-data/types/q/ds-model';
-import { ResourceIdentifierObject } from '@ember-data/types/q/ember-data-json-api';
+import {
+  CollectionResourceRelationship,
+  ResourceIdentifierObject,
+  SingleResourceRelationship,
+} from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 import type { JsonApiRelationship } from '@ember-data/types/q/record-data-json-api';
-import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
-import type { DefaultSingleResourceRelationship } from '@ember-data/types/q/relationship-record-data';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
@@ -43,7 +41,7 @@ type PromiseBelongsToFactory = { create(args: BelongsToProxyCreateArgs): Promise
 export class LegacySupport {
   declare record: DSModel;
   declare store: Store;
-  declare recordData: DefaultRecordData;
+  declare recordData: RecordData;
   declare references: Dict<BelongsToReference | HasManyReference>;
   declare identifier: StableRecordIdentifier;
   declare _manyArrayCache: Dict<ManyArray>;
@@ -57,7 +55,7 @@ export class LegacySupport {
     this.record = record;
     this.store = storeFor(record)!;
     this.identifier = recordIdentifierFor(record);
-    this.recordData = this.store._instanceCache.getRecordData(this.identifier) as DefaultRecordData;
+    this.recordData = this.store._instanceCache.getRecordData(this.identifier);
 
     this._manyArrayCache = Object.create(null) as Dict<ManyArray>;
     this._relationshipPromisesCache = Object.create(null) as Dict<Promise<ManyArray | RecordInstance>>;
@@ -67,16 +65,16 @@ export class LegacySupport {
 
   _findBelongsTo(
     key: string,
-    resource: DefaultSingleResourceRelationship,
-    relationshipMeta: RelationshipSchema,
+    resource: SingleResourceRelationship,
+    relationship: BelongsToRelationship,
     options?: FindOptions
   ): Promise<RecordInstance | null> {
     // TODO @runspired follow up if parent isNew then we should not be attempting load here
     // TODO @runspired follow up on whether this should be in the relationship requests cache
-    return this._findBelongsToByJsonApiResource(resource, this.identifier, relationshipMeta, options).then(
+    return this._findBelongsToByJsonApiResource(resource, this.identifier, relationship, options).then(
       (identifier: StableRecordIdentifier | null) =>
-        handleCompletedRelationshipRequest(this, key, resource._relationship, identifier),
-      (e: Error) => handleCompletedRelationshipRequest(this, key, resource._relationship, null, e)
+        handleCompletedRelationshipRequest(this, key, relationship, identifier),
+      (e: Error) => handleCompletedRelationshipRequest(this, key, relationship, null, e)
     );
   }
 
@@ -86,15 +84,16 @@ export class LegacySupport {
       return loadingPromise;
     }
 
-    let resource = this.recordData.getBelongsTo(key);
-    // TODO move this to a public api
-    if (resource._relationship) {
-      resource._relationship.state.hasFailedLoadAttempt = false;
-      resource._relationship.state.shouldForceReload = true;
-    }
-    let relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[key];
-    assert(`Attempted to reload a belongsTo relationship but no definition exists for it`, relationshipMeta);
-    let promise = this._findBelongsTo(key, resource, relationshipMeta, options);
+    const graphFor = (
+      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+    ).graphFor;
+    const relationship = graphFor(this.store).get(this.identifier, key);
+    assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
+
+    let resource = this.recordData.getRelationship(this.identifier, key) as SingleResourceRelationship;
+    relationship.state.hasFailedLoadAttempt = false;
+    relationship.state.shouldForceReload = true;
+    let promise = this._findBelongsTo(key, resource, relationship, options);
     if (this._relationshipProxyCache[key]) {
       return this._updatePromiseProxyFor('belongsTo', key, { promise });
     }
@@ -103,28 +102,31 @@ export class LegacySupport {
 
   getBelongsTo(key: string, options?: FindOptions): PromiseBelongsTo | RecordInstance | null {
     const { identifier, recordData } = this;
-    let resource = recordData.getBelongsTo(key);
+    let resource = recordData.getRelationship(this.identifier, key) as SingleResourceRelationship;
     let relatedIdentifier =
       resource && resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
-    let relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
-    assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
 
-    let store = this.store;
-    let async = relationshipMeta.options.async;
-    let isAsync = typeof async === 'undefined' ? true : async;
+    const store = this.store;
+    const graphFor = (
+      importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+    ).graphFor;
+    const relationship = graphFor(store).get(this.identifier, key);
+    assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
+
+    let isAsync = relationship.definition.isAsync;
     let _belongsToState: BelongsToProxyMeta = {
       key,
       store,
       legacySupport: this,
-      modelName: relationshipMeta.type,
+      modelName: relationship.definition.type,
     };
 
     if (isAsync) {
-      if (resource._relationship.state.hasFailedLoadAttempt) {
+      if (relationship.state.hasFailedLoadAttempt) {
         return this._relationshipProxyCache[key] as PromiseBelongsTo;
       }
 
-      let promise = this._findBelongsTo(key, resource, relationshipMeta, options);
+      let promise = this._findBelongsTo(key, resource, relationship, options);
 
       return this._updatePromiseProxyFor('belongsTo', key, {
         promise,
@@ -139,7 +141,7 @@ export class LegacySupport {
         assert(
           `You looked up the '${key}' relationship on a '${identifier.type}' with id ${
             identifier.id || 'null'
-          } 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 })\`)`,
+          } 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(<type>, { async: true, inverse: <inverse> })\`)`,
           toReturn === null || store._instanceCache.recordIsLoaded(relatedIdentifier, true)
         );
         return toReturn;
@@ -148,7 +150,7 @@ export class LegacySupport {
   }
 
   setDirtyBelongsTo(key: string, value: RecordInstance | null) {
-    return this.recordData.setDirtyBelongsTo(key, extractRecordDataFromRecord(value));
+    return this.recordData.setBelongsTo(this.identifier, key, extractIdentifierFromRecord(value));
   }
 
   getManyArray(key: string, definition?: UpgradedMeta): ManyArray {
@@ -165,6 +167,7 @@ export class LegacySupport {
       manyArray = (ManyArray as unknown as ManyArrayFactory).create({
         store: this.store,
         type: this.store.modelFor(definition.type),
+        identifier: this.identifier,
         recordData: this.recordData,
         key,
         isPolymorphic: definition.isPolymorphic,
@@ -191,7 +194,7 @@ export class LegacySupport {
         return loadingPromise;
       }
 
-      const jsonApi = this.recordData.getHasMany(key);
+      const jsonApi = this.recordData.getRelationship(this.identifier, key) as CollectionResourceRelationship;
 
       loadingPromise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options).then(
         () => handleCompletedRelationshipRequest(this, key, relationship, manyArray),
@@ -250,7 +253,7 @@ export class LegacySupport {
         assert(
           `You looked up the '${key}' relationship on a '${this.identifier.type}' with id ${
             this.identifier.id || 'null'
-          } 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 ('hasMany({ async: true })')`,
+          } 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 ('hasMany(<type>, { async: true, inverse: <inverse> })')`,
           !anyUnloaded(this.store, relationship)
         );
 
@@ -262,7 +265,7 @@ export class LegacySupport {
 
   setDirtyHasMany(key: string, records: RecordInstance[]) {
     assertRecordsPassedToHasMany(records);
-    return this.recordData.setDirtyHasMany(key, extractRecordDatasFromRecords(records));
+    return this.recordData.setHasMany(this.identifier, key, extractIdentifiersFromRecords(records));
   }
 
   _updatePromiseProxyFor(kind: 'hasMany', key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
@@ -343,7 +346,7 @@ export class LegacySupport {
   }
 
   _findHasManyByJsonApiResource(
-    resource,
+    resource: CollectionResourceRelationship,
     parentIdentifier: StableRecordIdentifier,
     relationship: ManyRelationship,
     options: FindOptions = {}
@@ -353,12 +356,10 @@ export class LegacySupport {
         return resolve();
       }
       const { definition, state } = relationship;
-      let adapter = this.store.adapterFor(definition.type);
-
-      let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
+      const adapter = this.store.adapterFor(definition.type);
+      const { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
       const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-
-      let shouldFindViaLink =
+      const shouldFindViaLink =
         resource.links &&
         resource.links.related &&
         (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') &&
@@ -368,9 +369,9 @@ export class LegacySupport {
       if (shouldFindViaLink) {
         // findHasMany, although not public, does not need to care about our upgrade relationship definitions
         // and can stick with the public definition API for now.
-        const relationshipMeta = this.store._instanceCache._storeWrapper.relationshipsDefinitionFor(
-          definition.inverseType
-        )[definition.key];
+        const relationshipMeta = this.store
+          .getSchemaDefinitionService()
+          .relationshipsDefinitionFor({ type: definition.inverseType })[definition.key];
         let adapter = this.store.adapterFor(parentIdentifier.type);
 
         /*
@@ -393,16 +394,16 @@ export class LegacySupport {
           typeof adapter.findHasMany === 'function'
         );
 
-        return _findHasMany(adapter, this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+        return _findHasMany(adapter, this.store, parentIdentifier, resource.links!.related, relationshipMeta, options);
       }
 
-      let preferLocalCache = hasReceivedData && !isEmpty;
-
-      let hasLocalPartialData =
+      const preferLocalCache = hasReceivedData && !isEmpty;
+      const hasLocalPartialData =
         hasDematerializedInverse || (isEmpty && Array.isArray(resource.data) && resource.data.length > 0);
 
       // fetch using data, pulling from local cache if possible
       if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
+        assert(`Expected collection to be an array`, Array.isArray(resource.data));
         let finds = new Array(resource.data.length);
         for (let i = 0; i < resource.data.length; i++) {
           let identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data[i]);
@@ -416,6 +417,7 @@ export class LegacySupport {
 
       // fetch by data
       if (hasData || hasLocalPartialData) {
+        assert(`Expected collection to be an array`, Array.isArray(resource.data));
         let identifiers = resource.data.map((json) => this.store.identifierCache.getOrCreateRecordIdentifier(json));
         let fetches = new Array(identifiers.length);
         const manager = this.store._fetchManager;
@@ -437,9 +439,9 @@ export class LegacySupport {
   }
 
   _findBelongsToByJsonApiResource(
-    resource,
+    resource: SingleResourceRelationship,
     parentIdentifier: StableRecordIdentifier,
-    relationshipMeta,
+    relationship: BelongsToRelationship,
     options: FindOptions = {}
   ): Promise<StableRecordIdentifier | null> {
     if (!resource) {
@@ -448,32 +450,33 @@ export class LegacySupport {
 
     const identifier = resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
 
-    let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = resource._relationship
-      .state as RelationshipState;
-    const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-
-    let shouldFindViaLink =
-      resource.links &&
-      resource.links.related &&
-      (shouldForceReload || hasDematerializedInverse || isStale || (!allInverseRecordsAreLoaded && !isEmpty));
+    let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = relationship.state;
 
-    if (identifier) {
-      // short circuit if we are already loading
-      let pendingRequest = this.store._fetchManager.getPendingFetch(identifier, options);
-      if (pendingRequest) {
-        return pendingRequest;
-      }
+    // short circuit if we are already loading
+    let pendingRequest = identifier && this.store._fetchManager.getPendingFetch(identifier, options);
+    if (pendingRequest) {
+      return pendingRequest;
     }
 
+    const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
+    const shouldFindViaLink =
+      resource.links?.related &&
+      (shouldForceReload || hasDematerializedInverse || isStale || (!allInverseRecordsAreLoaded && !isEmpty));
+
     // fetch via link
     if (shouldFindViaLink) {
-      return _findBelongsTo(this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[
+        relationship.definition.key
+      ];
+      assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
+
+      return _findBelongsTo(this.store, parentIdentifier, resource.links!.related, relationshipMeta, options);
     }
 
     let preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
     let hasLocalPartialData = hasDematerializedInverse || (isEmpty && resource.data);
     // null is explicit empty, undefined is "we don't know anything"
-    let localDataIsEmpty = resource.data === undefined || resource.data === null;
+    const localDataIsEmpty = resource.data === undefined || resource.data === null;
 
     // fetch using data, pulling from local cache if possible
     if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
@@ -485,13 +488,13 @@ export class LegacySupport {
       }
 
       if (!identifier) {
-        assert(`No Information found for ${resource.lid}`, identifier);
+        assert(`No Information found for ${resource.data!.lid}`, identifier);
       }
 
       return this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
     }
 
-    let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
+    let resourceIsLocal = !localDataIsEmpty && resource.data!.id === null;
 
     if (identifier && resourceIsLocal) {
       return resolve(identifier);
@@ -512,26 +515,26 @@ export class LegacySupport {
   destroy() {
     this.isDestroying = true;
 
-    const cache = this._manyArrayCache;
+    let cache: Dict<{ destroy(): void }> = this._manyArrayCache;
+    this._manyArrayCache = Object.create(null);
     Object.keys(cache).forEach((key) => {
       cache[key]!.destroy();
-      delete cache[key];
     });
-    const keys = Object.keys(this._relationshipProxyCache);
-    keys.forEach((key) => {
-      const proxy = this._relationshipProxyCache[key]!;
+
+    cache = this._relationshipProxyCache;
+    this._relationshipProxyCache = Object.create(null);
+    Object.keys(cache).forEach((key) => {
+      const proxy = cache[key]!;
       if (proxy.destroy) {
         proxy.destroy();
       }
-      delete this._relationshipProxyCache[key];
     });
-    if (this.references) {
-      const refs = this.references;
-      Object.keys(refs).forEach((key) => {
-        refs[key]!.destroy();
-        delete refs[key];
-      });
-    }
+
+    cache = this.references;
+    this.references = Object.create(null);
+    Object.keys(cache).forEach((key) => {
+      cache[key]!.destroy();
+    });
     this.isDestroyed = true;
   }
 }
@@ -631,16 +634,13 @@ function assertRecordsPassedToHasMany(records: RecordInstance[]) {
   );
 }
 
-function extractRecordDatasFromRecords(records: RecordInstance[]): RecordData[] {
-  return records.map(extractRecordDataFromRecord) as RecordData[];
+function extractIdentifiersFromRecords(records: RecordInstance[]): StableRecordIdentifier[] {
+  return records.map(extractIdentifierFromRecord) as StableRecordIdentifier[];
 }
 
-type PromiseProxyRecord = {
-  then(): void;
-  content: RecordInstance | null | undefined;
-};
+type PromiseProxyRecord = { then(): void; content: RecordInstance | null | undefined };
 
-function extractRecordDataFromRecord(recordOrPromiseRecord: PromiseProxyRecord | RecordInstance | null) {
+function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord | RecordInstance | null) {
   if (!recordOrPromiseRecord) {
     return null;
   }
@@ -651,10 +651,10 @@ function extractRecordDataFromRecord(recordOrPromiseRecord: PromiseProxyRecord |
       'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
       content !== undefined
     );
-    return content ? recordDataFor(content) : null;
+    return content ? recordIdentifierFor(content) : null;
   }
 
-  return recordDataFor(recordOrPromiseRecord);
+  return recordIdentifierFor(recordOrPromiseRecord);
 }
 
 function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is PromiseProxyRecord {
@@ -696,5 +696,11 @@ function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship)
 function isEmpty(store: Store, cache: IdentifierCache, resource: ResourceIdentifierObject): boolean {
   const identifier = cache.getOrCreateRecordIdentifier(resource);
   const recordData = store._instanceCache.peek({ identifier, bucket: 'recordData' });
-  return !recordData || !!recordData.isEmpty?.();
+  return !recordData || !!recordData.isEmpty?.(identifier);
+}
+
+function isBelongsTo(
+  relationship: BelongsToRelationship | ImplicitRelationship | ManyRelationship
+): relationship is BelongsToRelationship {
+  return relationship.definition.kind === 'belongsTo';
 }

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

@@ -9,14 +9,15 @@ import EmberObject, { get } from '@ember/object';
 import { all } from 'rsvp';
 
 import type Store from '@ember-data/store';
-import { PromiseArray, recordDataFor } from '@ember-data/store/-private';
+import { PromiseArray, recordIdentifierFor } from '@ember-data/store/-private';
 import type ShimModelClass from '@ember-data/store/-private/legacy-model-support/shim-model-class';
+import type { NonSingletonRecordDataManager } from '@ember-data/store/-private/managers/record-data-manager';
 import type { CreateRecordProperties } from '@ember-data/store/-private/store-service';
 import type { DSModelSchema } from '@ember-data/types/q/ds-model';
-import type { Links, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
+import type { CollectionResourceRelationship, Links, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordData } from '@ember-data/types/q/record-data';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
-import type { RelationshipRecordData } from '@ember-data/types/q/relationship-record-data';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
@@ -32,7 +33,8 @@ const MutableArrayWithObject = EmberObject.extend(MutableArray) as unknown as ne
 export interface ManyArrayCreateArgs {
   store: Store;
   type: ShimModelClass;
-  recordData: RelationshipRecordData;
+  identifier: StableRecordIdentifier;
+  recordData: RecordData;
   key: string;
   isPolymorphic: boolean;
   isAsync: boolean;
@@ -98,7 +100,8 @@ export default class ManyArray extends MutableArrayWithObject<StableRecordIdenti
   declare _meta: Dict<unknown> | null;
   declare _links: Links | PaginationLinks | null;
   declare currentState: StableRecordIdentifier[];
-  declare recordData: RelationshipRecordData;
+  declare identifier: StableRecordIdentifier;
+  declare recordData: RecordData;
   declare legacySupport: LegacySupport;
   declare store: Store;
   declare key: string;
@@ -272,25 +275,22 @@ export default class ManyArray extends MutableArrayWithObject<StableRecordIdenti
 
   replace(idx: number, amt: number, objects?: RecordInstance[]) {
     assert(`Cannot push mutations to the cache while updating the relationship from cache`, !this._isUpdating);
-    const { store } = this;
+    assert(
+      'The third argument to replace needs to be an array.',
+      !objects || Array.isArray(objects) || EmberArray.detect(objects)
+    );
+    const { store, identifier } = this;
     store._backburner.join(() => {
       let identifiers: StableRecordIdentifier[];
       if (amt > 0) {
         identifiers = this.currentState.slice(idx, idx + amt);
-        this.recordData.removeFromHasMany(
-          this.key,
-          // TODO RecordData V2: recordData should take identifiers not RecordDatas
-          identifiers.map((identifier) => store._instanceCache.getRecordData(identifier))
-        );
+        this.recordData.removeFromHasMany(identifier, this.key, identifiers);
       }
-      if (objects) {
-        assert(
-          'The third argument to replace needs to be an array.',
-          Array.isArray(objects) || EmberArray.detect(objects)
-        );
+      if (objects && objects.length > 0) {
         this.recordData.addToHasMany(
+          identifier,
           this.key,
-          objects.map((obj: RecordInstance) => recordDataFor(obj)),
+          objects.map((obj: RecordInstance) => recordIdentifierFor(obj)),
           idx
         );
       }
@@ -305,7 +305,13 @@ export default class ManyArray extends MutableArrayWithObject<StableRecordIdenti
     }
     this._isDirty = false;
     this._isUpdating = true;
-    let jsonApi = this.recordData.getHasMany(this.key);
+    const identifier = this.identifier;
+
+    let jsonApi = (this.recordData as NonSingletonRecordDataManager).getRelationship(
+      identifier,
+      this.key,
+      true
+    ) as CollectionResourceRelationship;
     const cache = this.store._instanceCache;
     const idCache = this.store.identifierCache;
 

package/addon/-private/model.js

@@ -19,6 +19,7 @@ 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';
@@ -119,7 +120,7 @@ function computeOnce(target, key, desc) {
 */
 class Model extends EmberObject {
   @service store;
-  #notifications;
+  ___private_notifications;
 
   init(options = {}) {
     if (DEBUG && !options._secretInit && !options._createProps) {
@@ -142,7 +143,7 @@ class Model extends EmberObject {
     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);
     });
   }
@@ -152,7 +153,7 @@ class Model extends EmberObject {
     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
@@ -487,7 +488,7 @@ 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');
     }
   }
@@ -813,7 +814,7 @@ class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return recordDataFor(this).changedAttributes();
+    return recordDataFor(this).changedAttrs(recordIdentifierFor(this));
   }
 
   /**
@@ -837,7 +838,7 @@ class Model extends EmberObject {
   rollbackAttributes() {
     const { currentState } = this;
     const { isNew } = currentState;
-    recordDataFor(this).rollbackAttributes();
+    recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
     this.errors.clear();
     currentState.cleanErrorRequests();
     if (isNew) {
@@ -980,7 +981,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;
     }
     ```
 
@@ -1048,7 +1049,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({
@@ -1201,7 +1202,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 +1796,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 +1866,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 +2413,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 +2427,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);
   }
 }