@ember-data/model 4.7.0-beta.0 → 4.7.1

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

@@ -1,36 +1,31 @@
-import { assert } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 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 { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
 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 { LocalRelationshipOperation } from '@ember-data/record-data/-private/graph/-operations';
+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 { fastPush, isStableIdentifier, recordIdentifierFor, SOURCE, storeFor } from '@ember-data/store/-private';
+import type { NonSingletonRecordDataManager } from '@ember-data/store/-private/managers/record-data-manager';
 import type { DSModel } from '@ember-data/types/q/ds-model';
-import type { ResourceIdentifierObject } from '@ember-data/types/q/ember-data-json-api';
+import { CollectionResourceRelationship, 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';
 
 import { _findBelongsTo, _findHasMany } from './legacy-data-fetch';
 import { assertIdentifierHasId } from './legacy-data-utils';
-import type { ManyArrayCreateArgs } from './many-array';
-import ManyArray from './many-array';
+import RelatedCollection from './many-array';
 import type { BelongsToProxyCreateArgs, BelongsToProxyMeta } from './promise-belongs-to';
 import PromiseBelongsTo from './promise-belongs-to';
 import type { HasManyProxyCreateArgs } from './promise-many-array';
@@ -38,17 +33,16 @@ import PromiseManyArray from './promise-many-array';
 import BelongsToReference from './references/belongs-to';
 import HasManyReference from './references/has-many';
 
-type ManyArrayFactory = { create(args: ManyArrayCreateArgs): ManyArray };
 type PromiseBelongsToFactory = { create(args: BelongsToProxyCreateArgs): PromiseBelongsTo };
 
 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>;
-  declare _relationshipPromisesCache: Dict<Promise<ManyArray | RecordInstance>>;
+  declare _manyArrayCache: Dict<RelatedCollection>;
+  declare _relationshipPromisesCache: Dict<Promise<RelatedCollection | RecordInstance>>;
   declare _relationshipProxyCache: Dict<PromiseManyArray | PromiseBelongsTo>;
 
   declare isDestroying: boolean;
@@ -58,26 +52,52 @@ 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>>;
+    this._manyArrayCache = Object.create(null) as Dict<RelatedCollection>;
+    this._relationshipPromisesCache = Object.create(null) as Dict<Promise<RelatedCollection | RecordInstance>>;
     this._relationshipProxyCache = Object.create(null) as Dict<PromiseManyArray | PromiseBelongsTo>;
     this.references = Object.create(null) as Dict<BelongsToReference>;
   }
 
+  _syncArray(array: RelatedCollection) {
+    // It’s possible the parent side of the relationship may have been destroyed by this point
+    if (this.isDestroyed || this.isDestroying) {
+      return;
+    }
+    const currentState = array[SOURCE];
+    const identifier = this.identifier;
+
+    let [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
+
+    if (jsonApi.meta) {
+      array.meta = jsonApi.meta;
+    }
+
+    if (jsonApi.links) {
+      array.links = jsonApi.links;
+    }
+
+    currentState.length = 0;
+    fastPush(currentState, identifiers);
+  }
+
+  updateCache(operation: LocalRelationshipOperation): void {
+    this.recordData.update(operation);
+  }
+
   _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 +107,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,32 +125,36 @@ export class LegacySupport {
 
   getBelongsTo(key: string, options?: FindOptions): PromiseBelongsTo | RecordInstance | null {
     const { identifier, recordData } = this;
-    let resource = recordData.getBelongsTo(key);
-    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;
+    let resource = recordData.getRelationship(this.identifier, key) as SingleResourceRelationship;
+    let relatedIdentifier = resource && resource.data ? resource.data : null;
+    assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
+
+    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);
+      const isLoaded = relatedIdentifier && store._instanceCache.recordIsLoaded(relatedIdentifier);
 
       return this._updatePromiseProxyFor('belongsTo', key, {
         promise,
-        content: relatedIdentifier ? store._instanceCache.getRecord(relatedIdentifier) : null,
+        content: isLoaded ? store._instanceCache.getRecord(relatedIdentifier!) : null,
         _belongsToState,
       });
     } else {
@@ -140,8 +165,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,52 +174,100 @@ export class LegacySupport {
   }
 
   setDirtyBelongsTo(key: string, value: RecordInstance | null) {
-    return this.recordData.setDirtyBelongsTo(key, extractRecordDataFromRecord(value));
+    return this.recordData.update(
+      {
+        op: 'replaceRelatedRecord',
+        record: this.identifier,
+        field: key,
+        value: extractIdentifierFromRecord(value),
+      },
+      // @ts-expect-error
+      true
+    );
   }
 
-  getManyArray(key: string, definition?: UpgradedMeta): ManyArray {
-    assert('hasMany only works with the @ember-data/record-data package', HAS_RECORD_DATA_PACKAGE);
-    let manyArray: ManyArray | undefined = this._manyArrayCache[key];
-    if (!definition) {
-      const graphFor = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).graphFor;
-      definition = graphFor(this.store).get(this.identifier, key).definition;
+  _getCurrentState(
+    identifier: StableRecordIdentifier,
+    field: string
+  ): [StableRecordIdentifier[], CollectionResourceRelationship] {
+    let jsonApi = (this.recordData as NonSingletonRecordDataManager).getRelationship(
+      identifier,
+      field,
+      true
+    ) as CollectionResourceRelationship;
+    const cache = this.store._instanceCache;
+    let identifiers: StableRecordIdentifier[] = [];
+    if (jsonApi.data) {
+      for (let i = 0; i < jsonApi.data.length; i++) {
+        const identifier = jsonApi.data[i];
+        assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+        if (cache.recordIsLoaded(identifier, true)) {
+          identifiers.push(identifier);
+        }
+      }
     }
 
-    if (!manyArray) {
-      manyArray = (ManyArray as unknown as ManyArrayFactory).create({
-        store: this.store,
-        type: this.store.modelFor(definition.type),
-        recordData: this.recordData,
-        key,
-        isPolymorphic: definition.isPolymorphic,
-        isAsync: definition.isAsync,
-        _inverseIsAsync: definition.inverseIsAsync,
-        legacySupport: this,
-        isLoaded: !definition.isAsync,
-      });
-      this._manyArrayCache[key] = manyArray;
-    }
+    return [identifiers, jsonApi];
+  }
 
-    return manyArray;
+  getManyArray(key: string, definition?: UpgradedMeta): RelatedCollection {
+    if (HAS_RECORD_DATA_PACKAGE) {
+      let manyArray: RelatedCollection | undefined = this._manyArrayCache[key];
+      if (!definition) {
+        const graphFor = (
+          importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+        ).graphFor;
+        definition = graphFor(this.store).get(this.identifier, key).definition;
+      }
+
+      if (!manyArray) {
+        const [identifiers, doc] = this._getCurrentState(this.identifier, key);
+
+        manyArray = new RelatedCollection({
+          store: this.store,
+          type: definition.type,
+          identifier: this.identifier,
+          recordData: this.recordData,
+          identifiers,
+          key,
+          meta: doc.meta || null,
+          links: doc.links || null,
+          isPolymorphic: definition.isPolymorphic,
+          isAsync: definition.isAsync,
+          _inverseIsAsync: definition.inverseIsAsync,
+          manager: this,
+          isLoaded: !definition.isAsync,
+          allowMutation: true,
+        });
+        this._manyArrayCache[key] = manyArray;
+      }
+
+      return manyArray;
+    }
+    assert('hasMany only works with the @ember-data/record-data package');
   }
 
   fetchAsyncHasMany(
     key: string,
     relationship: ManyRelationship,
-    manyArray: ManyArray,
+    manyArray: RelatedCollection,
     options?: FindOptions
-  ): Promise<ManyArray> {
+  ): Promise<RelatedCollection> {
     if (HAS_RECORD_DATA_PACKAGE) {
-      let loadingPromise = this._relationshipPromisesCache[key] as Promise<ManyArray> | undefined;
+      let loadingPromise = this._relationshipPromisesCache[key] as Promise<RelatedCollection> | undefined;
       if (loadingPromise) {
         return loadingPromise;
       }
 
-      const jsonApi = this.recordData.getHasMany(key);
+      const jsonApi = this.recordData.getRelationship(this.identifier, key) as CollectionResourceRelationship;
+      const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
+
+      if (!promise) {
+        manyArray.isLoaded = true;
+        return resolve(manyArray);
+      }
 
-      loadingPromise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options).then(
+      loadingPromise = promise.then(
         () => handleCompletedRelationshipRequest(this, key, relationship, manyArray),
         (e: Error) => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e)
       );
@@ -230,7 +303,7 @@ export class LegacySupport {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  getHasMany(key: string, options?: FindOptions): PromiseManyArray | ManyArray {
+  getHasMany(key: string, options?: FindOptions): PromiseManyArray | RelatedCollection {
     if (HAS_RECORD_DATA_PACKAGE) {
       const graphFor = (
         importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
@@ -251,7 +324,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)
         );
 
@@ -261,11 +334,6 @@ export class LegacySupport {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  setDirtyHasMany(key: string, records: RecordInstance[]) {
-    assertRecordsPassedToHasMany(records);
-    return this.recordData.setDirtyHasMany(key, extractRecordDatasFromRecords(records));
-  }
-
   _updatePromiseProxyFor(kind: 'hasMany', key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
   _updatePromiseProxyFor(kind: 'belongsTo', key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
   _updatePromiseProxyFor(
@@ -318,7 +386,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 +401,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,22 +419,20 @@ export class LegacySupport {
   }
 
   _findHasManyByJsonApiResource(
-    resource,
+    resource: CollectionResourceRelationship,
     parentIdentifier: StableRecordIdentifier,
     relationship: ManyRelationship,
     options: FindOptions = {}
-  ): Promise<void | unknown[]> {
+  ): Promise<void | unknown[]> | void {
     if (HAS_RECORD_DATA_PACKAGE) {
       if (!resource) {
-        return resolve();
+        return;
       }
       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 +442,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,20 +467,28 @@ 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)) {
+        if (allInverseRecordsAreLoaded) {
+          return;
+        }
+        assert(`Expected collection to be an array`, Array.isArray(resource.data));
+        if (allInverseRecordsAreLoaded) {
+          return;
+        }
         let finds = new Array(resource.data.length);
+        let cache = this.store._instanceCache;
         for (let i = 0; i < resource.data.length; i++) {
-          let identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data[i]);
-          finds[i] = this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
+          const identifier = resource.data[i];
+          assert(`expected a stable identifier`, isStableIdentifier(identifier));
+          finds[i] = cache._fetchDataIfNeededForIdentifier(identifier, options);
         }
 
         return all(finds);
@@ -417,7 +498,9 @@ export class LegacySupport {
 
       // fetch by data
       if (hasData || hasLocalPartialData) {
-        let identifiers = resource.data.map((json) => this.store.identifierCache.getOrCreateRecordIdentifier(json));
+        const identifiers = resource.data;
+        assert(`Expected collection to be an array`, Array.isArray(identifiers));
+        assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
         let fetches = new Array(identifiers.length);
         const manager = this.store._fetchManager;
 
@@ -432,49 +515,51 @@ export class LegacySupport {
 
       // we were explicitly told we have no data and no links.
       //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-      return resolve();
+      return;
     }
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
   _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 ? resource.data : null;
+    assert(`Expected a stable identifier`, !identifier || isStableIdentifier(identifier));
 
-    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 (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 +570,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 +596,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;
   }
 }
@@ -552,8 +632,8 @@ function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: ManyRelationship,
-  value: ManyArray
-): ManyArray;
+  value: RelatedCollection
+): RelatedCollection;
 function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
@@ -565,16 +645,16 @@ function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: ManyRelationship,
-  value: ManyArray,
+  value: RelatedCollection,
   error: Error
 ): never;
 function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: BelongsToRelationship | ManyRelationship,
-  value: ManyArray | StableRecordIdentifier | null,
+  value: RelatedCollection | StableRecordIdentifier | null,
   error?: Error
-): ManyArray | RecordInstance | null {
+): RelatedCollection | RecordInstance | null {
   delete recordExt._relationshipPromisesCache[key];
   relationship.state.shouldForceReload = false;
   const isHasMany = relationship.definition.kind === 'hasMany';
@@ -582,7 +662,7 @@ function handleCompletedRelationshipRequest(
   if (isHasMany) {
     // we don't notify the record property here to avoid refetch
     // only the many array
-    (value as ManyArray).notify();
+    (value as RelatedCollection).notify();
   }
 
   if (error) {
@@ -606,7 +686,7 @@ function handleCompletedRelationshipRequest(
   }
 
   if (isHasMany) {
-    (value as ManyArray).set('isLoaded', true);
+    (value as RelatedCollection).isLoaded = true;
   }
 
   relationship.state.hasFailedLoadAttempt = false;
@@ -614,43 +694,40 @@ function handleCompletedRelationshipRequest(
   relationship.state.isStale = false;
 
   return isHasMany || !value
-    ? (value as ManyArray | null)
+    ? (value as RelatedCollection | null)
     : recordExt.store.peekRecord(value as StableRecordIdentifier);
 }
 
-function assertRecordsPassedToHasMany(records: RecordInstance[]) {
-  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
-  assert(
-    `All elements of a hasMany relationship must be instances of Model, you passed ${records
-      .map((r) => `${typeof r}`)
-      .join(', ')}`,
-    (function () {
-      return records.every((record) => Object.prototype.hasOwnProperty.call(record, '_internalModel') === true);
-    })()
-  );
-}
-
-function extractRecordDatasFromRecords(records: RecordInstance[]): RecordData[] {
-  return records.map(extractRecordDataFromRecord) as RecordData[];
-}
-
-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');
+  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
+    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;
+    deprecate(
+      `You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`,
+      false,
+      {
+        id: 'ember-data:deprecate-promise-proxies',
+        until: '5.0',
+        since: {
+          enabled: '4.8',
+          available: '4.8',
+        },
+        for: 'ember-data',
+      }
+    );
+    return content ? recordIdentifierFor(content) : null;
   }
 
-  return recordDataFor(recordOrPromiseRecord);
+  return recordIdentifierFor(recordOrPromiseRecord);
 }
 
 function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is PromiseProxyRecord {
@@ -658,52 +735,36 @@ 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;
+  const instanceCache = store._instanceCache;
+  const identifiers = resource.data;
 
-  if (Array.isArray(resource.data)) {
+  if (Array.isArray(identifiers)) {
+    assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
     // treat as collection
     // check for unloaded records
-    let hasEmptyRecords = resource.data.reduce((hasEmptyModel, resourceIdentifier) => {
-      return hasEmptyModel || internalModelForRelatedResource(store, cache, resourceIdentifier).isEmpty;
-    }, false);
-
-    return !hasEmptyRecords;
-  } else {
-    // treat as single resource
-    if (!resource.data) {
-      return true;
-    } else {
-      const internalModel = internalModelForRelatedResource(store, cache, resource.data);
-      return !internalModel.isEmpty;
-    }
+    return identifiers.every((identifier: StableRecordIdentifier) => instanceCache.recordIsLoaded(identifier));
   }
+
+  // treat as single resource
+  if (!identifiers) return true;
+
+  assert(`Expected stable identifiers`, isStableIdentifier(identifiers));
+  return instanceCache.recordIsLoaded(identifiers);
 }
 
-function internalModelForRelatedResource(
-  store: Store,
-  cache: IdentifierCache,
-  resource: ResourceIdentifierObject
-): InternalModel {
-  const identifier = cache.getOrCreateRecordIdentifier(resource);
-  return store._instanceCache._internalModelForResource(identifier);
+function isBelongsTo(
+  relationship: BelongsToRelationship | ImplicitRelationship | ManyRelationship
+): relationship is BelongsToRelationship {
+  return relationship.definition.kind === 'belongsTo';
 }