@ember-data/store 4.8.0-alpha.2 → 4.8.0-alpha.3

package/addon/-private/{record-data-for.ts → caches/record-data-for.ts}

@@ -5,7 +5,7 @@ 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 WeakCache from './weak-cache';
+import WeakCache from '../utils/weak-cache';
 
 /*
  * Returns the RecordData instance associated with a given
@@ -24,7 +24,7 @@ export function setRecordDataFor(identifier: StableRecordIdentifier | RecordInst
   RecordDataForIdentifierCache.set(identifier, recordData);
 }
 
-export function removeRecordDataFor(identifier: StableRecordIdentifier): void {
+export function removeRecordDataFor(identifier: StableRecordIdentifier | RecordInstance): void {
   RecordDataForIdentifierCache.delete(identifier);
 }
 

package/addon/-private/index.ts

@@ -6,19 +6,19 @@ import { assert, deprecate } from '@ember/debug';
 
 import { DEPRECATE_HELPERS } from '@ember-data/private-build-infra/deprecations';
 
-import _normalize from './normalize-model-name';
+import _normalize from './utils/normalize-model-name';
 
-export { default as Store, storeFor } from './core-store';
+export { default as Store, storeFor } from './store-service';
 
-export { recordIdentifierFor } from './internal-model-factory';
+export { recordIdentifierFor } from './caches/instance-cache';
 
-export { default as Snapshot } from './snapshot';
+export { default as Snapshot } from './network/snapshot';
 export {
   setIdentifierGenerationMethod,
   setIdentifierUpdateMethod,
   setIdentifierForgetMethod,
   setIdentifierResetMethod,
-} from './identifier-cache';
+} from './caches/identifier-cache';
 
 export function normalizeModelName(modelName: string) {
   if (DEPRECATE_HELPERS) {
@@ -37,23 +37,20 @@ export function normalizeModelName(modelName: string) {
   assert(`normalizeModelName support has been removed`);
 }
 
-export { default as coerceId } from './coerce-id';
+export { default as coerceId } from './utils/coerce-id';
 
-// `ember-data-model-fragments` relies on `InternalModel`
-export { default as InternalModel } from './model/internal-model';
-
-export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './promise-proxies';
+export { PromiseArray, PromiseObject, deprecatedPromiseObject } from './proxies/promise-proxies';
 
 export { default as RecordArray } from './record-arrays/record-array';
 export { default as AdapterPopulatedRecordArray } from './record-arrays/adapter-populated-record-array';
 
-export { default as RecordArrayManager } from './record-array-manager';
+export { default as RecordArrayManager } from './managers/record-array-manager';
 
 // // Used by tests
-export { default as SnapshotRecordArray } from './snapshot-record-array';
+export { default as SnapshotRecordArray } from './network/snapshot-record-array';
 
 // New
-export { default as recordDataFor, removeRecordDataFor } from './record-data-for';
-export { default as RecordDataStoreWrapper } from './record-data-store-wrapper';
+export { default as recordDataFor, removeRecordDataFor } from './caches/record-data-for';
+export { default as RecordDataStoreWrapper } from './managers/record-data-store-wrapper';
 
-export { default as WeakCache } from './weak-cache';
+export { default as WeakCache } from './utils/weak-cache';

package/addon/-private/{model → legacy-model-support}/record-reference.ts

@@ -10,9 +10,9 @@ import type { SingleResourceDocument } from '@ember-data/types/q/ember-data-json
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 
-import type Store from '../core-store';
-import type { NotificationType } from '../record-notification-manager';
-import { unsubscribe } from '../record-notification-manager';
+import type { NotificationType } from '../managers/record-notification-manager';
+import { unsubscribe } from '../managers/record-notification-manager';
+import type Store from '../store-service';
 
 /**
   @module @ember-data/store

package/addon/-private/{schema-definition-service.ts → legacy-model-support/schema-definition-service.ts}

@@ -1,6 +1,5 @@
 import { getOwner } from '@ember/application';
 import { deprecate } from '@ember/debug';
-import { get } from '@ember/object';
 
 import { importSync } from '@embroider/macros';
 
@@ -10,8 +9,8 @@ import { DEPRECATE_STRING_ARG_SCHEMAS } from '@ember-data/private-build-infra/de
 import type { RecordIdentifier } from '@ember-data/types/q/identifier';
 import type { AttributesSchema, RelationshipsSchema } from '@ember-data/types/q/record-data-schemas';
 
-import type Store from './core-store';
-import normalizeModelName from './normalize-model-name';
+import type Store from '../store-service';
+import normalizeModelName from '../utils/normalize-model-name';
 
 type ModelForMixin = (store: Store, normalizedModelName: string) => Model | null;
 
@@ -55,7 +54,7 @@ export class DSModelSchemaDefinitionService {
 
     if (attributes === undefined) {
       let modelClass = this.store.modelFor(modelName);
-      let attributeMap = get(modelClass, 'attributes');
+      let attributeMap = modelClass.attributes;
 
       attributes = Object.create(null);
       attributeMap.forEach((meta, name) => (attributes[name] = meta));
@@ -88,7 +87,7 @@ export class DSModelSchemaDefinitionService {
 
     if (relationships === undefined) {
       let modelClass = this.store.modelFor(modelName);
-      relationships = get(modelClass, 'relationshipsObject') || null;
+      relationships = modelClass.relationshipsObject || null;
       this._relationshipsDefCache[modelName] = relationships;
     }
 

package/addon/-private/{model → legacy-model-support}/shim-model-class.ts

@@ -4,8 +4,8 @@ import type { ModelSchema } from '@ember-data/types/q/ds-model';
 import type { AttributeSchema, RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import type Store from '../core-store';
-import WeakCache from '../weak-cache';
+import type Store from '../store-service';
+import WeakCache from '../utils/weak-cache';
 
 const AvailableShims = new WeakCache<Store, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
 AvailableShims._generator = () => {

package/addon/-private/{record-array-manager.ts → managers/record-array-manager.ts}

@@ -4,20 +4,17 @@
 
 import { A } from '@ember/array';
 import { assert } from '@ember/debug';
-import { set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-// import isStableIdentifier from '../identifiers/is-stable-identifier';
 import type { CollectionResourceDocument, Meta } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import type Store from './core-store';
-import { internalModelFactoryFor } from './internal-model-factory';
-import AdapterPopulatedRecordArray from './record-arrays/adapter-populated-record-array';
-import RecordArray from './record-arrays/record-array';
-import WeakCache from './weak-cache';
+import AdapterPopulatedRecordArray from '../record-arrays/adapter-populated-record-array';
+import RecordArray from '../record-arrays/record-array';
+import type Store from '../store-service';
+import WeakCache from '../utils/weak-cache';
 
 const RecordArraysCache = new WeakCache<StableRecordIdentifier, Set<RecordArray>>(DEBUG ? 'record-arrays' : '');
 RecordArraysCache._generator = () => new Set();
@@ -27,27 +24,6 @@ export function recordArraysForIdentifier(identifier: StableRecordIdentifier): S
 
 const pendingForIdentifier: Set<StableRecordIdentifier> = new Set([]);
 
-function getIdentifier(identifier: StableRecordIdentifier): StableRecordIdentifier {
-  // during dematerialization we will get an identifier that
-  // has already been removed from the identifiers cache
-  // so it will not behave as if stable. This is a bug we should fix.
-  // if (!isStableIdentifier(identifierOrInternalModel)) {
-  //   console.log({ unstable: i });
-  // }
-
-  return identifier;
-}
-
-function shouldIncludeInRecordArrays(store: Store, identifier: StableRecordIdentifier): boolean {
-  const cache = internalModelFactoryFor(store);
-  const internalModel = cache.peek(identifier);
-
-  if (internalModel === null) {
-    return false;
-  }
-  return !internalModel.isHiddenFromRecordArrays();
-}
-
 /**
   @class RecordArrayManager
   @internal
@@ -84,6 +60,7 @@ class RecordArrayManager {
       return;
     }
     let identifiersToRemove: StableRecordIdentifier[] = [];
+    let cache = this.store._instanceCache;
 
     for (let j = 0; j < identifiers.length; j++) {
       let i = identifiers[j];
@@ -91,8 +68,7 @@ class RecordArrayManager {
       // recordArrayManager
       pendingForIdentifier.delete(i);
       // build up a set of models to ensure we have purged correctly;
-      let isIncluded = shouldIncludeInRecordArrays(this.store, i);
-      if (!isIncluded) {
+      if (!cache.recordIsLoaded(i, true)) {
         identifiersToRemove.push(i);
       }
     }
@@ -130,8 +106,8 @@ class RecordArrayManager {
       return;
     }
     let hasNoPotentialDeletions = pending.length === 0;
-    let map = internalModelFactoryFor(this.store).modelMapFor(modelName);
-    let hasNoInsertionsOrRemovals = map.length === array.length;
+    let listSize = this.store._instanceCache.peekList[modelName]?.size;
+    let hasNoInsertionsOrRemovals = listSize === array.length;
 
     /*
       Ideally the recordArrayManager has knowledge of the changes to be applied to
@@ -165,7 +141,7 @@ class RecordArrayManager {
   _didUpdateAll(modelName: string): void {
     let recordArray = this._liveRecordArrays[modelName];
     if (recordArray) {
-      set(recordArray, 'isUpdating', false);
+      recordArray.isUpdating = false;
       // TODO potentially we should sync here, currently
       // this occurs as a side-effect of individual records updating
       // this._syncLiveRecordArray(recordArray, modelName);
@@ -204,13 +180,14 @@ class RecordArrayManager {
   }
 
   _visibleIdentifiersByType(modelName: string) {
-    let all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;
+    const cache = this.store._instanceCache;
+    const list = cache.peekList[modelName];
+    let all = list ? [...list.values()] : [];
     let visible: StableRecordIdentifier[] = [];
     for (let i = 0; i < all.length; i++) {
       let identifier = all[i];
-      let shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);
 
-      if (shouldInclude) {
+      if (cache.recordIsLoaded(identifier, true)) {
         visible.push(identifier);
       }
     }
@@ -335,7 +312,6 @@ class RecordArrayManager {
   _associateWithRecordArray(identifiers: StableRecordIdentifier[], array: RecordArray): void {
     for (let i = 0, l = identifiers.length; i < l; i++) {
       let identifier = identifiers[i];
-      identifier = getIdentifier(identifier);
       let recordArrays = this.getRecordArraysForIdentifier(identifier);
       recordArrays.add(array);
     }
@@ -350,7 +326,6 @@ class RecordArrayManager {
       return;
     }
     let modelName = identifier.type;
-    identifier = getIdentifier(identifier);
 
     if (pendingForIdentifier.has(identifier)) {
       return;
@@ -397,20 +372,18 @@ function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
 function updateLiveRecordArray(store: Store, recordArray: RecordArray, identifiers: StableRecordIdentifier[]): void {
   let identifiersToAdd: StableRecordIdentifier[] = [];
   let identifiersToRemove: StableRecordIdentifier[] = [];
+  const cache = store._instanceCache;
 
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
-    let shouldInclude = shouldIncludeInRecordArrays(store, identifier);
     let recordArrays = recordArraysForIdentifier(identifier);
 
-    if (shouldInclude) {
+    if (cache.recordIsLoaded(identifier, true)) {
       if (!recordArrays.has(recordArray)) {
         identifiersToAdd.push(identifier);
         recordArrays.add(recordArray);
       }
-    }
-
-    if (!shouldInclude) {
+    } else {
       identifiersToRemove.push(identifier);
       recordArrays.delete(recordArray);
     }
@@ -431,7 +404,6 @@ function removeFromAdapterPopulatedRecordArrays(store: Store, identifiers: Stabl
 }
 
 function removeFromAll(store: Store, identifier: StableRecordIdentifier): void {
-  identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);
 
   recordArrays.forEach(function (recordArray) {

package/addon/-private/{record-data-store-wrapper.ts → managers/record-data-store-wrapper.ts}

@@ -1,7 +1,4 @@
-import { importSync } from '@embroider/macros';
-
 import type { RelationshipDefinition } from '@ember-data/model/-private/relationship-meta';
-import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 import type {
@@ -11,10 +8,9 @@ import type {
 } from '@ember-data/types/q/record-data-schemas';
 import type { RecordDataStoreWrapper as StoreWrapper } from '@ember-data/types/q/record-data-store-wrapper';
 
-import type Store from './core-store';
-import type { IdentifierCache } from './identifier-cache';
-import { internalModelFactoryFor } from './internal-model-factory';
-import constructResource from './utils/construct-resource';
+import type { IdentifierCache } from '../caches/identifier-cache';
+import type Store from '../store-service';
+import constructResource from '../utils/construct-resource';
 
 /**
   @module @ember-data/store
@@ -24,17 +20,6 @@ function metaIsRelationshipDefinition(meta: RelationshipSchema): meta is Relatio
   return typeof (meta as RelationshipDefinition)._inverseKey === 'function';
 }
 
-let peekGraph;
-if (HAS_RECORD_DATA_PACKAGE) {
-  let _peekGraph;
-  peekGraph = (wrapper) => {
-    _peekGraph =
-      _peekGraph ||
-      (importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')).peekGraph;
-    return _peekGraph(wrapper);
-  };
-}
-
 export default class RecordDataStoreWrapper implements StoreWrapper {
   declare _willNotify: boolean;
   declare _pendingNotifies: Map<StableRecordIdentifier, Map<string, string>>;
@@ -86,19 +71,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
     let pending = this._pendingNotifies;
     this._pendingNotifies = new Map();
     this._willNotify = false;
-    const factory = internalModelFactoryFor(this._store);
 
     pending.forEach((map, identifier) => {
-      const internalModel = factory.peek(identifier);
-      if (internalModel) {
-        map.forEach((kind, key) => {
-          if (kind === 'belongsTo') {
-            internalModel.notifyBelongsToChange(key);
-          } else {
-            internalModel.notifyHasManyChange(key);
-          }
-        });
-      }
+      map.forEach((kind, key) => {
+        this._store._notificationManager.notify(identifier, 'relationships', key);
+      });
     });
   }
 
@@ -152,11 +129,8 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   notifyPropertyChange(type: string, id: string | null, lid: string | null | undefined, key?: string): void {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
-    if (internalModel) {
-      internalModel.notifyAttributes(key ? [key] : []);
-    }
+    this._store._notificationManager.notify(identifier, 'attributes', key);
   }
 
   notifyHasManyChange(type: string, id: string | null, lid: string, key: string): void;
@@ -181,10 +155,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   notifyStateChange(type: string, id: string | null, lid: string | null, key?: string): void {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
 
-    if (internalModel) {
-      internalModel.notifyStateChange(key);
+    this._store._notificationManager.notify(identifier, 'state');
+
+    if (!key || key === 'isDeletionCommitted') {
+      this._store.recordArrayManager.recordDidChange(identifier);
     }
   }
 
@@ -192,17 +167,25 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   recordDataFor(type: string, id: string | null, lid: string): RecordData;
   recordDataFor(type: string): RecordData;
   recordDataFor(type: string, id?: string | null, lid?: string | null): RecordData {
-    let identifier: StableRecordIdentifier | { type: string };
-    let isCreate: boolean = false;
+    // TODO @deprecate create capability. This is problematic because there's
+    // no outside association between this RecordData and an Identifier. It's
+    // likely a mistake but we said in an RFC we'd allow this. We should RFC
+    // enforcing someone to use the record-data and identifier-cache APIs to
+    // create a new identifier and then call clientDidCreate on the RecordData
+    // instead.
+    const identifier =
+      !id && !lid
+        ? this.identifierCache.createIdentifierForNewRecord({ type: type })
+        : this.identifierCache.getOrCreateRecordIdentifier(constructResource(type, id, lid));
+
+    const recordData = this._store._instanceCache.getRecordData(identifier);
+
     if (!id && !lid) {
-      isCreate = true;
-      identifier = { type };
-    } else {
-      const resource = constructResource(type, id, lid);
-      identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
+      recordData.clientDidCreate();
+      this._store.recordArrayManager.recordDidChange(identifier);
     }
 
-    return this._store._instanceCache.recordDataFor(identifier, isCreate);
+    return recordData;
   }
 
   setRecordId(type: string, id: string, lid: string) {
@@ -213,9 +196,9 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   isRecordInUse(type: string, id: string, lid?: string | null): boolean;
   isRecordInUse(type: string, id: string | null, lid?: string | null): boolean {
     const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
+    const identifier = this.identifierCache.peekRecordIdentifier(resource);
 
-    const record = this._store._instanceCache.peek({ identifier, bucket: 'record' });
+    const record = identifier && this._store._instanceCache.peek({ identifier, bucket: 'record' });
 
     return record ? !(record.isDestroyed || record.isDestroying) : false;
   }
@@ -224,16 +207,11 @@ export default class RecordDataStoreWrapper implements StoreWrapper {
   disconnectRecord(type: string, id: string, lid?: string | null): void;
   disconnectRecord(type: string, id: string | null, lid?: string | null): void {
     const resource = constructResource(type, id, lid);
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    if (HAS_RECORD_DATA_PACKAGE) {
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.remove(identifier);
-      }
-    }
-    let internalModel = internalModelFactoryFor(this._store).peek(identifier);
-    if (internalModel) {
-      internalModel.destroyFromRecordData();
+    const identifier = this.identifierCache.peekRecordIdentifier(resource);
+
+    if (identifier) {
+      this._store._instanceCache.disconnect(identifier);
+      this._pendingNotifies.delete(identifier);
     }
   }
 }

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

@@ -0,0 +1,96 @@
+import { assert } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+import { LOG_NOTIFICATIONS } from '@ember-data/private-build-infra/debugging';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+
+import { isStableIdentifier } from '../caches/identifier-cache';
+import type Store from '../store-service';
+import WeakCache from '../utils/weak-cache';
+
+type UnsubscribeToken = object;
+
+const Cache = new WeakCache<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>(
+  DEBUG ? 'subscribers' : ''
+);
+Cache._generator = () => new Map();
+const Tokens = new WeakCache<UnsubscribeToken, StableRecordIdentifier>(DEBUG ? 'identifier' : '');
+
+export type NotificationType =
+  | 'attributes'
+  | 'relationships'
+  | 'identity'
+  | 'errors'
+  | 'meta'
+  | 'unload'
+  | 'state'
+  | 'property'; // 'property' is an internal EmberData only transition period concept.
+
+export interface NotificationCallback {
+  (
+    identifier: StableRecordIdentifier,
+    notificationType: 'attributes' | 'relationships' | 'property',
+    key?: string
+  ): void;
+  (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): void;
+  (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
+}
+
+export function unsubscribe(token: UnsubscribeToken) {
+  let identifier = Tokens.get(token);
+  if (!identifier) {
+    throw new Error('Passed unknown unsubscribe token to unsubscribe');
+  }
+  Tokens.delete(token);
+  const map = Cache.get(identifier);
+  map?.delete(token);
+}
+/*
+  Currently only support a single callback per identifier
+*/
+export default class NotificationManager {
+  constructor(private store: Store) {}
+
+  subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
+    assert(`Expected to receive a stable Identifier to subscribe to`, isStableIdentifier(identifier));
+    let map = Cache.lookup(identifier);
+    let unsubToken = {};
+    map.set(unsubToken, callback);
+    Tokens.set(unsubToken, identifier);
+    return unsubToken;
+  }
+
+  unsubscribe(token: UnsubscribeToken) {
+    unsubscribe(token);
+  }
+
+  notify(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships' | 'property', key?: string): boolean;
+  notify(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): boolean;
+  notify(identifier: StableRecordIdentifier, value: NotificationType, key?: string): boolean {
+    if (!isStableIdentifier(identifier)) {
+      if (LOG_NOTIFICATIONS) {
+        // eslint-disable-next-line no-console
+        console.log(
+          `Notifying: Expected to receive a stable Identifier to notify '${value}' '${key}' with, but ${String(
+            identifier
+          )} is not in the cache`,
+          identifier
+        );
+      }
+      return false;
+    }
+
+    if (LOG_NOTIFICATIONS) {
+      // eslint-disable-next-line no-console
+      console.log(`Notifying: ${String(identifier)}\t${value}\t${key}`);
+    }
+    let callbackMap = Cache.get(identifier);
+    if (!callbackMap || !callbackMap.size) {
+      return false;
+    }
+    callbackMap.forEach((cb) => {
+      cb(identifier, value, key);
+    });
+    return true;
+  }
+}

package/addon/-private/{fetch-manager.ts → network/fetch-manager.ts}

@@ -19,14 +19,14 @@ import type { MinimumSerializerInterface } from '@ember-data/types/q/minimum-ser
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import coerceId from './coerce-id';
-import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from './common';
-import type Store from './core-store';
-import ShimModelClass from './model/shim-model-class';
+import ShimModelClass from '../legacy-model-support/shim-model-class';
+import type Store from '../store-service';
+import coerceId from '../utils/coerce-id';
+import { _bind, _guard, _objectIsAlive, guardDestroyedStore } from '../utils/common';
+import { normalizeResponseHelper } from '../utils/serializer-response';
+import WeakCache from '../utils/weak-cache';
 import RequestCache from './request-cache';
-import { normalizeResponseHelper } from './serializer-response';
 import Snapshot from './snapshot';
-import WeakCache from './weak-cache';
 
 function payloadIsNotBlank(adapterPayload): boolean {
   if (Array.isArray(adapterPayload)) {
@@ -84,6 +84,10 @@ export default class FetchManager {
     this.isDestroyed = false;
   }
 
+  clearEntries(identifier: StableRecordIdentifier) {
+    delete this.requestCache._done[identifier.lid];
+  }
+
   /**
     This method is called by `record.save`, and gets passed a
     resolver for the promise that `record.save` returns.
@@ -126,10 +130,10 @@ export default class FetchManager {
     let adapter = this._store.adapterFor(identifier.type);
     let operation = options[SaveOp];
 
-    let internalModel = snapshot._internalModel;
     let modelName = snapshot.modelName;
     let store = this._store;
     let modelClass = store.modelFor(modelName);
+    const record = store._instanceCache.getRecord(identifier);
 
     assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter);
     assert(
@@ -139,16 +143,16 @@ export default class FetchManager {
 
     let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
     let serializer: SerializerWithParseErrors | null = store.serializerFor(modelName);
-    let label = `DS: Extract and notify about ${operation} completion of ${internalModel}`;
+    let label = `DS: Extract and notify about ${operation} completion of ${identifier}`;
 
     assert(
       `Your adapter's '${operation}' method must return a value, but it returned 'undefined'`,
       promise !== undefined
     );
 
-    promise = _guard(guardDestroyedStore(promise, store, label), _bind(_objectIsAlive, internalModel)).then(
+    promise = _guard(guardDestroyedStore(promise, store, label), _bind(_objectIsAlive, record)).then(
       (adapterPayload) => {
-        if (!_objectIsAlive(internalModel)) {
+        if (!_objectIsAlive(record)) {
           if (DEPRECATE_RSVP_PROMISE) {
             deprecate(
               `A Promise while saving ${modelName} did not resolve by the time your model was destroyed. This will error in a future release.`,
@@ -239,11 +243,8 @@ export default class FetchManager {
     }
 
     let resolverPromise = resolver.promise;
-
-    // TODO replace with some form of record state cache
     const store = this._store;
-    const internalModel = store._instanceCache.getInternalModel(identifier);
-    const isLoading = !internalModel.isLoaded; // we don't use isLoading directly because we are the request
+    const isLoading = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
 
     const promise = resolverPromise.then(
       (payload) => {
@@ -262,8 +263,9 @@ export default class FetchManager {
         return identifier;
       },
       (error) => {
-        if (internalModel.isEmpty || isLoading) {
-          internalModel.unloadRecord();
+        const recordData = store._instanceCache.peek({ identifier, bucket: 'recordData' });
+        if (!recordData || recordData.isEmpty?.() || isLoading) {
+          store._instanceCache.unloadRecord(identifier);
         }
         throw error;
       }