@ember-data/model 4.8.0-alpha.2 → 4.8.0-alpha.5

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

@@ -5,25 +5,23 @@ 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 { UpgradedMeta } from '@ember-data/record-data/-private/graph/-edge-definition';
-import type { RelationshipState } from '@ember-data/record-data/-private/graph/-state';
+import type { ImplicitRelationship } from '@ember-data/record-data/-private/graph/index';
+import type BelongsToRelationship from '@ember-data/record-data/-private/relationships/state/belongs-to';
+import type ManyRelationship from '@ember-data/record-data/-private/relationships/state/has-many';
 import type Store from '@ember-data/store';
-import type { InternalModel } from '@ember-data/store/-private';
-import { recordDataFor, recordIdentifierFor, storeFor } from '@ember-data/store/-private';
-import type { IdentifierCache } from '@ember-data/store/-private/identifier-cache';
+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 type { 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';
 
@@ -44,7 +42,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>;
@@ -58,7 +56,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>>;
@@ -68,16 +66,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)
     );
   }
 
@@ -87,15 +85,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 });
     }
@@ -104,28 +103,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,
@@ -140,8 +142,8 @@ 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 })\`)`,
-          toReturn === null || !store._instanceCache.getInternalModel(relatedIdentifier).isEmpty
+          } 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;
       }
@@ -149,7 +151,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 {
@@ -166,6 +168,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,
@@ -192,7 +195,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),
@@ -251,7 +254,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)
         );
 
@@ -263,7 +266,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;
@@ -318,7 +321,8 @@ export class LegacySupport {
       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, name);
+      const graph = graphFor(this.store);
+      const relationship = graph.get(this.identifier, name);
 
       if (DEBUG && kind) {
         let modelName = this.identifier.type;
@@ -332,9 +336,15 @@ export class LegacySupport {
       let relationshipKind = relationship.definition.kind;
 
       if (relationshipKind === 'belongsTo') {
-        reference = new BelongsToReference(this.store, this.identifier, relationship as BelongsToRelationship, name);
+        reference = new BelongsToReference(
+          this.store,
+          graph,
+          this.identifier,
+          relationship as BelongsToRelationship,
+          name
+        );
       } else if (relationshipKind === 'hasMany') {
-        reference = new HasManyReference(this.store, this.identifier, relationship as ManyRelationship, name);
+        reference = new HasManyReference(this.store, graph, this.identifier, relationship as ManyRelationship, name);
       }
 
       this.references[name] = reference;
@@ -344,7 +354,7 @@ export class LegacySupport {
   }
 
   _findHasManyByJsonApiResource(
-    resource,
+    resource: CollectionResourceRelationship,
     parentIdentifier: StableRecordIdentifier,
     relationship: ManyRelationship,
     options: FindOptions = {}
@@ -354,12 +364,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') &&
@@ -369,9 +377,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);
 
         /*
@@ -394,16 +402,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]);
@@ -417,6 +425,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;
@@ -438,43 +447,44 @@ export class LegacySupport {
   }
 
   _findBelongsToByJsonApiResource(
-    resource,
+    resource: SingleResourceRelationship,
     parentIdentifier: StableRecordIdentifier,
-    relationshipMeta,
+    relationship: BelongsToRelationship,
     options: FindOptions = {}
   ): Promise<StableRecordIdentifier | null> {
     if (!resource) {
       return resolve(null);
     }
 
-    const internalModel = resource.data ? this.store._instanceCache._internalModelForResource(resource.data) : null;
+    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 { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = relationship.state;
 
-    let shouldFindViaLink =
-      resource.links &&
-      resource.links.related &&
-      (shouldForceReload || hasDematerializedInverse || isStale || (!allInverseRecordsAreLoaded && !isEmpty));
-
-    if (internalModel) {
-      // short circuit if we are already loading
-      let pendingRequest = this.store._fetchManager.getPendingFetch(internalModel.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,22 +495,21 @@ export class LegacySupport {
         return resolve(null);
       }
 
-      if (!internalModel) {
-        assert(`No InternalModel found for ${resource.lid}`, internalModel);
+      if (!identifier) {
+        assert(`No Information found for ${resource.data!.lid}`, identifier);
       }
 
-      return this.store._instanceCache._fetchDataIfNeededForIdentifier(internalModel.identifier, options);
+      return this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
     }
 
-    let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
+    let resourceIsLocal = !localDataIsEmpty && resource.data!.id === null;
 
-    if (internalModel && resourceIsLocal) {
-      return resolve(internalModel.identifier);
+    if (identifier && resourceIsLocal) {
+      return resolve(identifier);
     }
 
     // fetch by data
-    if (internalModel && !localDataIsEmpty) {
-      let identifier = internalModel.identifier;
+    if (identifier && !localDataIsEmpty) {
       assertIdentifierHasId(identifier);
 
       return this.store._fetchManager.scheduleFetch(identifier, options);
@@ -512,32 +521,28 @@ export class LegacySupport {
   }
 
   destroy() {
-    assert(
-      'Cannot destroy an internalModel while its record is materialized',
-      !this.record || this.record.isDestroyed || this.record.isDestroying
-    );
     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;
   }
 }
@@ -625,32 +630,39 @@ function assertRecordsPassedToHasMany(records: RecordInstance[]) {
       .map((r) => `${typeof r}`)
       .join(', ')}`,
     (function () {
-      return records.every((record) => Object.prototype.hasOwnProperty.call(record, '_internalModel') === true);
+      return records.every((record) => {
+        try {
+          recordIdentifierFor(record);
+          return true;
+        } catch {
+          return false;
+        }
+      });
     })()
   );
 }
 
-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; get(str: '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;
   }
 
   if (isPromiseRecord(recordOrPromiseRecord)) {
-    let content = recordOrPromiseRecord.get && recordOrPromiseRecord.get('content');
+    let content = recordOrPromiseRecord.content;
     assert(
       '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 {
@@ -658,25 +670,16 @@ function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is
 }
 
 function anyUnloaded(store: Store, relationship: ManyRelationship) {
-  let state = relationship.currentState;
+  let state = relationship.localState;
+  const cache = store._instanceCache;
   const unloaded = state.find((s) => {
-    let im = store._instanceCache.getInternalModel(s);
-    return im._isDematerializing || !im.isLoaded;
+    let isLoaded = cache.recordIsLoaded(s, true);
+    return !isLoaded;
   });
 
   return unloaded || false;
 }
 
-/**
- * Flag indicating whether all inverse records are available
- *
- * true if the inverse exists and is loaded (not empty)
- * true if there is no inverse
- * false if the inverse exists and is not loaded (empty)
- *
- * @internal
- * @return {boolean}
- */
 function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship): boolean {
   const cache = store.identifierCache;
 
@@ -684,7 +687,7 @@ function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship)
     // treat as collection
     // check for unloaded records
     let hasEmptyRecords = resource.data.reduce((hasEmptyModel, resourceIdentifier) => {
-      return hasEmptyModel || internalModelForRelatedResource(store, cache, resourceIdentifier).isEmpty;
+      return hasEmptyModel || isEmpty(store, cache, resourceIdentifier);
     }, false);
 
     return !hasEmptyRecords;
@@ -693,17 +696,19 @@ function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship)
     if (!resource.data) {
       return true;
     } else {
-      const internalModel = internalModelForRelatedResource(store, cache, resource.data);
-      return !internalModel.isEmpty;
+      return !isEmpty(store, cache, resource.data);
     }
   }
 }
 
-function internalModelForRelatedResource(
-  store: Store,
-  cache: IdentifierCache,
-  resource: ResourceIdentifierObject
-): InternalModel {
+function isEmpty(store: Store, cache: IdentifierCache, resource: ResourceIdentifierObject): boolean {
   const identifier = cache.getOrCreateRecordIdentifier(resource);
-  return store._instanceCache._internalModelForResource(identifier);
+  const recordData = store._instanceCache.__instances.recordData.get(identifier);
+  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 type { CreateRecordProperties } from '@ember-data/store/-private/core-store';
-import type ShimModelClass from '@ember-data/store/-private/model/shim-model-class';
+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;
-    store._backburner.join(() => {
+    assert(
+      'The third argument to replace needs to be an array.',
+      !objects || Array.isArray(objects) || EmberArray.detect(objects)
+    );
+    const { store, identifier } = this;
+    store._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,17 +305,23 @@ 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;
 
     let identifiers: StableRecordIdentifier[] = [];
     if (jsonApi.data) {
       for (let i = 0; i < jsonApi.data.length; i++) {
-        // TODO figure out where this state comes from
-        let im = this.store._instanceCache._internalModelForResource(jsonApi.data[i]);
-        let shouldRemove = im._isDematerializing || im.isEmpty || !im.isLoaded;
+        const identifier = idCache.getOrCreateRecordIdentifier(jsonApi.data[i]);
 
-        if (!shouldRemove) {
-          identifiers.push(im.identifier);
+        if (cache.recordIsLoaded(identifier, true)) {
+          identifiers.push(identifier);
         }
       }
     }
@@ -348,6 +354,12 @@ export default class ManyArray extends MutableArrayWithObject<StableRecordIdenti
     this._isUpdating = false;
   }
 
+  destroy() {
+    this._length = 0;
+    this.currentState = [];
+    return super.destroy();
+  }
+
   /**
     Reloads all of the records in the manyArray. If the manyArray
     holds a relationship that was originally fetched using a links url