@ember-data/store 4.5.0-beta.0 → 4.5.0

package/addon/-private/{system/core-store.ts → core-store.ts}

@@ -1,90 +1,79 @@
 /**
   @module @ember-data/store
  */
-import { getOwner } from '@ember/application';
-import { A } from '@ember/array';
-import { assert, inspect, warn } from '@ember/debug';
-import { set } from '@ember/object';
+import { getOwner, setOwner } from '@ember/application';
+import { assert, deprecate } from '@ember/debug';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import type { Backburner } from '@ember/runloop/-private/backburner';
 import Service from '@ember/service';
 import { registerWaiter, unregisterWaiter } from '@ember/test';
-import { isNone, isPresent, typeOf } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
-import Ember from 'ember';
 
 import { importSync } from '@embroider/macros';
-import { all, default as RSVP, resolve } from 'rsvp';
+import { reject, resolve } from 'rsvp';
 
-import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
-import type { ManyRelationship, RecordData as RecordDataClass } from '@ember-data/record-data/-private';
-import type { RelationshipState } from '@ember-data/record-data/-private/graph/-state';
-
-import { IdentifierCache } from '../identifiers/cache';
+import type DSModelClass from '@ember-data/model';
+import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
+import {
+  DEPRECATE_HAS_RECORD,
+  DEPRECATE_JSON_API_FALLBACK,
+  DEPRECATE_RECORD_WAS_INVALID,
+  DEPRECATE_STORE_FIND,
+} from '@ember-data/private-build-infra/deprecations';
+import type { RecordData as RecordDataClass } from '@ember-data/record-data/-private';
+import type { DSModel } from '@ember-data/types/q/ds-model';
 import type {
   CollectionResourceDocument,
   EmptyResourceDocument,
-  ExistingResourceObject,
   JsonApiDocument,
   ResourceIdentifierObject,
   SingleResourceDocument,
-} from '../ts-interfaces/ember-data-json-api';
-import type {
-  RecordIdentifier,
-  StableExistingRecordIdentifier,
-  StableRecordIdentifier,
-} from '../ts-interfaces/identifier';
-import { MinimumAdapterInterface } from '../ts-interfaces/minimum-adapter-interface';
-import type { MinimumSerializerInterface } from '../ts-interfaces/minimum-serializer-interface';
-import type { RecordData } from '../ts-interfaces/record-data';
-import type { JsonApiRelationship } from '../ts-interfaces/record-data-json-api';
-import type { RecordDataRecordWrapper } from '../ts-interfaces/record-data-record-wrapper';
-import type { AttributesSchema, RelationshipsSchema } from '../ts-interfaces/record-data-schemas';
-import type { RecordInstance } from '../ts-interfaces/record-instance';
-import type { SchemaDefinitionService } from '../ts-interfaces/schema-definition-service';
-import type { FindOptions } from '../ts-interfaces/store';
-import type { Dict } from '../ts-interfaces/utils';
-import constructResource from '../utils/construct-resource';
-import promiseRecord from '../utils/promise-record';
+} from '@ember-data/types/q/ember-data-json-api';
+import type { StableExistingRecordIdentifier, StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { MinimumAdapterInterface } from '@ember-data/types/q/minimum-adapter-interface';
+import type { MinimumSerializerInterface } from '@ember-data/types/q/minimum-serializer-interface';
+import type { RecordData } from '@ember-data/types/q/record-data';
+import type { RecordDataRecordWrapper } from '@ember-data/types/q/record-data-record-wrapper';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
+import type { SchemaDefinitionService } from '@ember-data/types/q/schema-definition-service';
+import type { FindOptions } from '@ember-data/types/q/store';
+import type { Dict } from '@ember-data/types/q/utils';
+
 import edBackburner from './backburner';
 import coerceId, { ensureStringId } from './coerce-id';
 import FetchManager, { SaveOp } from './fetch-manager';
-import type InternalModel from './model/internal-model';
+import { _findAll, _query, _queryRecord } from './finders';
+import { IdentifierCache } from './identifier-cache';
+import { InstanceCache, storeFor, StoreMap } from './instance-cache';
 import {
-  assertRecordsPassedToHasMany,
-  extractRecordDataFromRecord,
-  extractRecordDatasFromRecords,
-} from './model/internal-model';
+  internalModelFactoryFor,
+  peekRecordIdentifier,
+  recordIdentifierFor,
+  setRecordIdentifier,
+} from './internal-model-factory';
+import RecordReference from './model/record-reference';
 import type ShimModelClass from './model/shim-model-class';
 import { getShimClass } from './model/shim-model-class';
 import normalizeModelName from './normalize-model-name';
-import type { PromiseArray, PromiseObject } from './promise-proxies';
-import { promiseArray, promiseObject } from './promise-proxies';
+import { PromiseArray, promiseArray, PromiseObject, promiseObject } from './promise-proxies';
 import RecordArrayManager from './record-array-manager';
-import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
+import AdapterPopulatedRecordArray from './record-arrays/adapter-populated-record-array';
+import RecordArray from './record-arrays/record-array';
 import { setRecordDataFor } from './record-data-for';
+import RecordDataStoreWrapper from './record-data-store-wrapper';
 import NotificationManager from './record-notification-manager';
-import type { BelongsToReference, HasManyReference } from './references';
-import { RecordReference } from './references';
 import type RequestCache from './request-cache';
-import { _findAll, _findBelongsTo, _findHasMany, _query, _queryRecord } from './store/finders';
-import {
-  internalModelFactoryFor,
-  peekRecordIdentifier,
-  recordIdentifierFor,
-  setRecordIdentifier,
-} from './store/internal-model-factory';
-import RecordDataStoreWrapper from './store/record-data-store-wrapper';
-import WeakCache from './weak-cache';
+import { DSModelSchemaDefinitionService, getModelFactory } from './schema-definition-service';
+import constructResource from './utils/construct-resource';
+import promiseRecord from './utils/promise-record';
+
+export { storeFor };
 
 type RecordDataConstruct = typeof RecordDataClass;
 let _RecordData: RecordDataConstruct | undefined;
 
-const { ENV } = Ember;
 type AsyncTrackingToken = Readonly<{ label: string; trace: Error | string }>;
 
-const RECORD_REFERENCES = new WeakCache<StableRecordIdentifier, RecordReference>(DEBUG ? 'reference' : '');
-
 function freeze<T>(obj: T): T {
   if (typeof Object.freeze === 'function') {
     return Object.freeze(obj);
@@ -172,7 +161,7 @@ export interface CreateRecordProperties {
   @extends Ember.Service
 */
 
-abstract class CoreStore extends Service {
+class Store extends Service {
   /**
    * Ember Data uses several specialized micro-queues for organizing
     and coalescing similar async work.
@@ -189,79 +178,26 @@ abstract class CoreStore extends Service {
 
   declare _notificationManager: NotificationManager;
   declare identifierCache: IdentifierCache;
-  declare _adapterCache: Dict<MinimumAdapterInterface & { store: CoreStore }>;
-  declare _serializerCache: Dict<MinimumSerializerInterface & { store: CoreStore }>;
-  declare _storeWrapper: RecordDataStoreWrapper;
+  declare _adapterCache: Dict<MinimumAdapterInterface & { store: Store }>;
+  declare _serializerCache: Dict<MinimumSerializerInterface & { store: Store }>;
+  declare _modelFactoryCache: Dict<unknown>;
   declare _fetchManager: FetchManager;
   declare _schemaDefinitionService: SchemaDefinitionService;
+  declare _instanceCache: InstanceCache;
 
   // DEBUG-only properties
   declare _trackedAsyncRequests: AsyncTrackingToken[];
-  declare shouldTrackAsyncRequests: boolean;
   declare generateStackTracesForTrackedRequests: boolean;
   declare _trackAsyncRequestStart: (str: string) => void;
   declare _trackAsyncRequestEnd: (token: AsyncTrackingToken) => void;
   declare __asyncWaiter: () => boolean;
 
-  /**
-    The default adapter to use to communicate to a backend server or
-    other persistence layer. This will be overridden by an application
-    adapter if present.
-
-    If you want to specify `app/adapters/custom.js` as a string, do:
-
-    ```js
-    import Store from '@ember-data/store';
-
-    export default Store.extend({
-      constructor() {
-        super(...arguments);
-        this.adapter = 'custom';
-      }
-    }
-    ```
-
-    @property adapter
-    @public
-    @default '-json-api'
-    @type {String}
-  */
-
-  /**
-  This property returns the adapter, after resolving a possible
-  string key.
-
-  If the supplied `adapter` was a class, or a String property
-  path resolved to a class, this property will instantiate the
-  class.
-
-  This property is cacheable, so the same instance of a specified
-  adapter class should be used for the lifetime of the store.
-
-  @property defaultAdapter
-  @private
-  @return Adapter
-*/
-
   /**
     @method init
     @private
   */
   constructor() {
     super(...arguments);
-    this._adapterCache = Object.create(null);
-    this._serializerCache = Object.create(null);
-    this._storeWrapper = new RecordDataStoreWrapper(this);
-    this._backburner = edBackburner;
-    this.recordArrayManager = new RecordArrayManager({ store: this });
-
-    RECORD_REFERENCES._generator = (identifier) => {
-      return new RecordReference(this, identifier);
-    };
-
-    this._fetchManager = new FetchManager(this);
-    this._notificationManager = new NotificationManager(this);
-    this.__recordDataFor = this.__recordDataFor.bind(this);
 
     /**
      * Provides access to the IdentifierCache instance
@@ -275,10 +211,24 @@ abstract class CoreStore extends Service {
      */
     this.identifierCache = new IdentifierCache();
 
+    // private but maybe useful to be here, somewhat intimate
+    this.recordArrayManager = new RecordArrayManager({ store: this });
+
+    // private, TODO consider taking public as the instance is public to instantiateRecord anyway
+    this._notificationManager = new NotificationManager(this);
+
+    // private
+    this._fetchManager = new FetchManager(this);
+    this._instanceCache = new InstanceCache(this);
+    this._adapterCache = Object.create(null);
+    this._serializerCache = Object.create(null);
+    this._modelFactoryCache = Object.create(null);
+
+    // private
+    // TODO we should find a path to something simpler than backburner
+    this._backburner = edBackburner;
+
     if (DEBUG) {
-      if (this.shouldTrackAsyncRequests === undefined) {
-        this.shouldTrackAsyncRequests = false;
-      }
       if (this.generateStackTracesForTrackedRequests === undefined) {
         this.generateStackTracesForTrackedRequests = false;
       }
@@ -317,11 +267,8 @@ abstract class CoreStore extends Service {
       };
 
       this.__asyncWaiter = () => {
-        let shouldTrack = this.shouldTrackAsyncRequests;
         let tracked = this._trackedAsyncRequests;
-        let isSettled = tracked.length === 0;
-
-        return shouldTrack !== true || isSettled;
+        return tracked.length === 0;
       };
 
       registerWaiter(this.__asyncWaiter);
@@ -332,85 +279,66 @@ abstract class CoreStore extends Service {
     return this._fetchManager.requestCache;
   }
 
-  _instantiateRecord(
-    internalModel: InternalModel,
-    modelName: string,
-    recordData: RecordData,
+  instantiateRecord(
     identifier: StableRecordIdentifier,
-    properties?: { [key: string]: any }
-  ) {
-    // assert here
-    if (properties !== undefined) {
-      assert(
-        `You passed '${properties}' as properties for record creation instead of an object.`,
-        typeof properties === 'object' && properties !== null
-      );
-
-      if ('id' in properties) {
-        internalModel.setId(properties.id);
-      }
-
-      // convert relationship Records to RecordDatas before passing to RecordData
-      let defs = this._relationshipsDefinitionFor({ type: modelName });
-
-      if (defs !== null) {
-        let keys = Object.keys(properties);
-        let relationshipValue;
-
-        for (let i = 0; i < keys.length; i++) {
-          let prop = keys[i];
-          let def = defs[prop];
-
-          if (def !== undefined) {
-            if (def.kind === 'hasMany') {
-              if (DEBUG) {
-                assertRecordsPassedToHasMany(properties[prop]);
-              }
-              relationshipValue = extractRecordDatasFromRecords(properties[prop]);
-            } else {
-              relationshipValue = extractRecordDataFromRecord(properties[prop]);
-            }
+    createRecordArgs: { [key: string]: unknown },
+    recordDataFor: (identifier: StableRecordIdentifier) => RecordDataRecordWrapper,
+    notificationManager: NotificationManager
+  ): DSModel | RecordInstance {
+    if (HAS_MODEL_PACKAGE) {
+      let modelName = identifier.type;
+      let store = this;
+
+      let internalModel = this._instanceCache._internalModelForResource(identifier);
+      let createOptions: any = {
+        _internalModel: internalModel,
+        // TODO deprecate allowing unknown args setting
+        _createProps: createRecordArgs,
+        // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+        _secretInit: (record: RecordInstance): void => {
+          setRecordIdentifier(record, identifier);
+          StoreMap.set(record, store);
+          setRecordDataFor(record, internalModel._recordData);
+        },
+        container: null, // necessary hack for setOwner?
+      };
 
-            properties[prop] = relationshipValue;
-          }
-        }
-      }
+      // ensure that `getOwner(this)` works inside a model instance
+      setOwner(createOptions, getOwner(this));
+      delete createOptions.container;
+      // TODO this needs to not use the private property here to get modelFactoryCache so as to not break interop
+      return getModelFactory(this, this._modelFactoryCache, modelName).create(createOptions);
     }
-
-    // TODO guard against initRecordOptions no being there
-    let createOptions = recordData._initRecordCreateOptions(properties);
-    //TODO Igor pass a wrapper instead of RD
-    let record = this.instantiateRecord(identifier, createOptions, this.__recordDataFor, this._notificationManager);
-    setRecordIdentifier(record, identifier);
-    //recordToInternalModelMap.set(record, internalModel);
-    return record;
+    assert(`You must implement the store's instantiateRecord hook for your custom model class.`);
   }
 
-  abstract instantiateRecord(
-    identifier: StableRecordIdentifier,
-    createRecordArgs: { [key: string]: unknown }, // args passed in to store.createRecord() and processed by recordData to be set on creation
-    recordDataFor: (identifier: RecordIdentifier) => RecordDataRecordWrapper,
-    notificationManager: NotificationManager
-  ): RecordInstance;
-  abstract teardownRecord(record: RecordInstance): void;
-  abstract getSchemaDefinitionService(): SchemaDefinitionService;
-
-  _attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
-    return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
+  teardownRecord(record: DSModel | RecordInstance): void {
+    if (HAS_MODEL_PACKAGE) {
+      assert(
+        `expected to receive an instance of DSModel. If using a custom model make sure you implement teardownRecord`,
+        'destroy' in record
+      );
+      (record as DSModel).destroy();
+    } else {
+      assert(`You must implement the store's teardownRecord hook for your custom models`);
+    }
   }
 
-  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
-    return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
+  getSchemaDefinitionService(): SchemaDefinitionService {
+    if (HAS_MODEL_PACKAGE && !this._schemaDefinitionService) {
+      this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
+    }
+    assert(
+      `You must registerSchemaDefinitionService with the store to use custom model classes`,
+      this._schemaDefinitionService
+    );
+    return this._schemaDefinitionService;
   }
 
   registerSchemaDefinitionService(schema: SchemaDefinitionService) {
     this._schemaDefinitionService = schema;
   }
 
-  _relationshipMetaFor(modelName: string, id: string | null, key: string) {
-    return this._relationshipsDefinitionFor({ type: modelName })[key];
-  }
-
   /**
     Returns the schema for a particular `modelName`.
 
@@ -427,41 +355,46 @@ abstract class CoreStore extends Service {
     @param {String} modelName
     @return {subclass of Model | ShimModelClass}
     */
-  modelFor(modelName: string): ShimModelClass {
+  // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
+  modelFor(modelName: string): ShimModelClass | DSModelClass {
     if (DEBUG) {
       assertDestroyedStoreOnly(this, 'modelFor');
     }
-
-    return getShimClass(this, modelName);
-  }
-
-  // Feature Flagged in DSModelStore
-  /**
-    Returns whether a ModelClass exists for a given modelName
-    This exists for legacy support for the RESTSerializer,
-    which due to how it must guess whether a key is a model
-    must query for whether a match exists.
-
-    We should investigate an RFC to make this public or removing
-    this requirement.
-
-    @method _hasModelFor
-    @private
-  */
-  _hasModelFor(modelName: string): boolean {
-    assert(`You need to pass a model name to the store's hasModelFor method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's modelFor method`, modelName);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
     );
+    if (HAS_MODEL_PACKAGE) {
+      let normalizedModelName = normalizeModelName(modelName);
+      // TODO this is safe only because
+      // apps would be horribly broken if the schema service were using DS_MODEL but not using DS_MODEL's schema service.
+      // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
+      // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
+      let maybeFactory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
+
+      // for factorFor factory/class split
+      let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;
+      if (!klass || !klass.isModel) {
+        assert(
+          `No model was found for '${modelName}' and no schema handles the type`,
+          this.getSchemaDefinitionService().doesTypeExist(modelName)
+        );
+
+        return getShimClass(this, modelName);
+      } else {
+        // TODO @deprecate ever returning the klass, always return the shim
+        return klass;
+      }
+    }
 
-    return this.getSchemaDefinitionService().doesTypeExist(modelName);
+    assert(
+      `No model was found for '${modelName}' and no schema handles the type`,
+      this.getSchemaDefinitionService().doesTypeExist(modelName)
+    );
+    return getShimClass(this, modelName);
   }
 
-  // .....................
-  // . CREATE NEW RECORD .
-  // .....................
-
   /**
     Create a new record in the current store. The properties passed
     to this method are set on the newly created record.
@@ -495,7 +428,7 @@ abstract class CoreStore extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'createRecord');
     }
-    assert(`You need to pass a model name to the store's createRecord method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's createRecord method`, modelName);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
@@ -516,8 +449,14 @@ abstract class CoreStore extends Service {
         // client-side ID generators will use something like uuid.js
         // to avoid conflicts.
 
-        if (isNone(properties.id)) {
-          properties.id = this._generateId(normalizedModelName, properties);
+        if (properties.id === null || properties.id === undefined) {
+          let adapter = this.adapterFor(modelName);
+
+          if (adapter && adapter.generateIdForRecord) {
+            properties.id = adapter.generateIdForRecord(this, modelName, properties);
+          } else {
+            properties.id = null;
+          }
         }
 
         // Coerce ID to a string
@@ -525,40 +464,16 @@ abstract class CoreStore extends Service {
 
         const factory = internalModelFactoryFor(this);
         const internalModel = factory.build({ type: normalizedModelName, id: properties.id });
+        const { identifier } = internalModel;
 
-        internalModel.send('loadedData');
-        // TODO this exists just to proxy `isNew` to RecordData which is weird
-        internalModel.didCreateRecord();
+        this._instanceCache.getRecordData(identifier).clientDidCreate();
+        this.recordArrayManager.recordDidChange(identifier);
 
-        return internalModel.getRecord(properties);
+        return this._instanceCache.getRecord(identifier, properties);
       });
     });
   }
 
-  /**
-    If possible, this method asks the adapter to generate an ID for
-    a newly created record.
-
-    @method _generateId
-    @private
-    @param {String} modelName
-    @param {Object} properties from the new record
-    @return {String} if the adapter can generate one, an ID
-  */
-  _generateId(modelName: string, properties: CreateRecordProperties): string | null {
-    let adapter = this.adapterFor(modelName);
-
-    if (adapter && adapter.generateIdForRecord) {
-      return adapter.generateIdForRecord(this, modelName, properties);
-    }
-
-    return null;
-  }
-
-  // .................
-  // . DELETE RECORD .
-  // .................
-
   /**
     For symmetry, a record can be deleted via the store.
 
@@ -620,16 +535,13 @@ abstract class CoreStore extends Service {
     }
   }
 
-  // ................
-  // . FIND RECORDS .
-  // ................
-
   /**
     @method find
     @param {String} modelName
     @param {String|Integer} id
     @param {Object} options
     @return {Promise} promise
+    @deprecated
     @private
   */
   find(modelName: string, id: string | number, options?): PromiseObject<RecordInstance> {
@@ -661,7 +573,20 @@ abstract class CoreStore extends Service {
       typeof modelName === 'string'
     );
 
-    return this.findRecord(modelName, id);
+    if (DEPRECATE_STORE_FIND) {
+      deprecate(
+        `Using store.find is deprecated, use store.findRecord instead. Likely this means you are relying on the implicit store fetching behavior of routes unknowingly.`,
+        false,
+        {
+          id: 'ember-data:deprecate-store-find',
+          since: { available: '4.5', enabled: '4.5' },
+          for: 'ember-data',
+          until: '5.0',
+        }
+      );
+      return this.findRecord(modelName, id);
+    }
+    assert(`store.find has been removed. Use store.findRecord instead.`);
   }
 
   /**
@@ -1044,7 +969,7 @@ abstract class CoreStore extends Service {
 
     assert(
       `You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`,
-      isPresent(resource)
+      resource
     );
     if (isMaybeIdentifier(resource)) {
       options = id as FindOptions | undefined;
@@ -1059,155 +984,48 @@ abstract class CoreStore extends Service {
     }
 
     const internalModel = internalModelFactoryFor(this).lookup(resource);
+    const { identifier } = internalModel;
+    let promise;
     options = options || {};
 
-    if (!internalModel.currentState.isLoaded) {
-      return promiseRecord(
-        this._findByInternalModel(internalModel, options),
-        `DS: Store#findRecord ${internalModel.identifier}`
-      );
-    }
-
-    let fetchedInternalModel = this._findRecord(internalModel, options);
-
-    return promiseRecord(fetchedInternalModel, `DS: Store#findRecord ${internalModel.identifier}`);
-  }
-
-  _findRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
-    // Refetch if the reload option is passed
-    if (options.reload) {
-      return this._scheduleFetch(internalModel, options);
-    }
-
-    let snapshot = internalModel.createSnapshot(options);
-    let adapter = this.adapterFor(internalModel.modelName);
-
-    // Refetch the record if the adapter thinks the record is stale
-    if (
-      typeof options.reload === 'undefined' &&
-      adapter.shouldReloadRecord &&
-      adapter.shouldReloadRecord(this, snapshot)
-    ) {
-      return this._scheduleFetch(internalModel, options);
-    }
-
-    if (options.backgroundReload === false) {
-      return resolve(internalModel);
-    }
-
-    // Trigger the background refetch if backgroundReload option is passed
-    if (
-      options.backgroundReload ||
-      !adapter.shouldBackgroundReloadRecord ||
-      adapter.shouldBackgroundReloadRecord(this, snapshot)
-    ) {
-      this._scheduleFetch(internalModel, options);
-    }
-
-    // Return the cached record
-    return resolve(internalModel);
-  }
-
-  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}): Promise<InternalModel> {
-    if (options.preload) {
-      this._backburner.join(() => {
-        internalModel.preloadData(options.preload);
-      });
-    }
+    // if not loaded start loading
+    if (!internalModel.isLoaded) {
+      promise = this._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
 
-    return this._findEmptyInternalModel(internalModel, options);
-  }
+      // Refetch if the reload option is passed
+    } else if (options.reload) {
+      assertIdentifierHasId(identifier);
+      promise = this._fetchManager.scheduleFetch(identifier, options);
+    } else {
+      let snapshot = this._instanceCache.createSnapshot(identifier, options);
+      let adapter = this.adapterFor(identifier.type);
 
-  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
-    if (internalModel.currentState.isEmpty) {
-      return this._scheduleFetch(internalModel, options);
-    }
+      // Refetch the record if the adapter thinks the record is stale
+      if (
+        typeof options.reload === 'undefined' &&
+        adapter.shouldReloadRecord &&
+        adapter.shouldReloadRecord(this, snapshot)
+      ) {
+        assertIdentifierHasId(identifier);
+        promise = this._fetchManager.scheduleFetch(identifier, options);
+      } else {
+        // Trigger the background refetch if backgroundReload option is passed
+        if (
+          options.backgroundReload !== false &&
+          (options.backgroundReload ||
+            !adapter.shouldBackgroundReloadRecord ||
+            adapter.shouldBackgroundReloadRecord(this, snapshot))
+        ) {
+          assertIdentifierHasId(identifier);
+          this._fetchManager.scheduleFetch(identifier, options);
+        }
 
-    if (internalModel.currentState.isLoading) {
-      let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
-      if (pendingRequest) {
-        return pendingRequest.then(() => resolve(internalModel));
+        // Return the cached record
+        promise = resolve(identifier);
       }
-      return this._scheduleFetch(internalModel, options);
-    }
-
-    return resolve(internalModel);
-  }
-
-  /**
-    This method makes a series of requests to the adapter's `find` method
-    and returns a promise that resolves once they are all loaded.
-
-    @private
-    @method findByIds
-    @param {String} modelName
-    @param {Array} ids
-    @return {Promise} promise
-  */
-  findByIds(modelName, ids) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'findByIds');
-    }
-    assert(`You need to pass a model name to the store's findByIds method`, isPresent(modelName));
-    assert(
-      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
-      typeof modelName === 'string'
-    );
-
-    let promises = new Array(ids.length);
-
-    let normalizedModelName = normalizeModelName(modelName);
-
-    for (let i = 0; i < ids.length; i++) {
-      promises[i] = this.findRecord(normalizedModelName, ids[i]);
-    }
-
-    return promiseArray(all(promises).then(A, null, `DS: Store#findByIds of ${normalizedModelName} complete`));
-  }
-
-  _scheduleFetchMany(internalModels, options) {
-    let fetches = new Array(internalModels.length);
-
-    for (let i = 0; i < internalModels.length; i++) {
-      fetches[i] = this._scheduleFetch(internalModels[i], options);
     }
 
-    return all(fetches);
-  }
-
-  _scheduleFetch(internalModel: InternalModel, options = {}): Promise<InternalModel> {
-    let generateStackTrace = this.generateStackTracesForTrackedRequests;
-    // TODO  remove this once we don't rely on state machine
-    internalModel.send('loadingData');
-    let identifier = internalModel.identifier;
-
-    assertIdentifierHasId(identifier);
-
-    let promise = this._fetchManager.scheduleFetch(identifier, options, generateStackTrace);
-    return promise.then(
-      (payload) => {
-        // ensure that regardless of id returned we assign to the correct record
-        if (payload.data && !Array.isArray(payload.data)) {
-          payload.data.lid = identifier.lid;
-        }
-
-        // Returning this._push here, breaks typing but not any tests, investigate potential missing tests
-        let potentiallyNewIm = this._push(payload);
-        if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
-          return potentiallyNewIm;
-        } else {
-          return internalModel;
-        }
-      },
-      (error) => {
-        // TODO  remove this once we don't rely on state machine
-        internalModel.send('notFound');
-        if (internalModel.currentState.isEmpty) {
-          internalModel.unloadRecord();
-        }
-        throw error;
-      }
-    );
+    return promiseRecord(this, promise, `DS: Store#findRecord ${identifier}`);
   }
 
   /**
@@ -1248,6 +1066,7 @@ abstract class CoreStore extends Service {
     @since 2.5.0
     @return {RecordReference}
   */
+  // TODO @deprecate getReference (and references generally)
   getReference(resource: string | ResourceIdentifierObject, id: string | number): RecordReference {
     if (DEBUG) {
       assertDestroyingStore(this, 'getReference');
@@ -1268,9 +1087,8 @@ abstract class CoreStore extends Service {
     );
 
     let identifier: StableRecordIdentifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
-    if (identifier) {
-      return RECORD_REFERENCES.lookup(identifier);
-    }
+
+    return this._instanceCache.getReference(identifier);
   }
 
   /**
@@ -1325,18 +1143,18 @@ abstract class CoreStore extends Service {
   peekRecord(identifier: ResourceIdentifierObject): RecordInstance | null;
   peekRecord(identifier: ResourceIdentifierObject | string, id?: string | number): RecordInstance | null {
     if (arguments.length === 1 && isMaybeIdentifier(identifier)) {
-      let stableIdentifier = this.identifierCache.peekRecordIdentifier(identifier);
-      if (stableIdentifier) {
-        return internalModelFactoryFor(this).peek(stableIdentifier)?.getRecord() || null;
-      }
-      return null;
+      const stableIdentifier = this.identifierCache.peekRecordIdentifier(identifier);
+      const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
+      // TODO come up with a better mechanism for determining if we have data and could peek.
+      // this is basically an "are we not empty" query.
+      return internalModel && internalModel.isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
 
     if (DEBUG) {
       assertDestroyingStore(this, 'peekRecord');
     }
 
-    assert(`You need to pass a model name to the store's peekRecord method`, isPresent(identifier));
+    assert(`You need to pass a model name to the store's peekRecord method`, identifier);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${identifier}`,
       typeof identifier === 'string'
@@ -1344,41 +1162,11 @@ abstract class CoreStore extends Service {
 
     const type = normalizeModelName(identifier);
     const normalizedId = ensureStringId(id);
+    const resource = { type, id: normalizedId };
+    const stableIdentifier = this.identifierCache.peekRecordIdentifier(resource);
+    const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
 
-    if (this.hasRecordForId(type, normalizedId)) {
-      const resource = constructResource(type, normalizedId);
-      return internalModelFactoryFor(this).lookup(resource).getRecord();
-    } else {
-      return null;
-    }
-  }
-
-  /**
-    This method is called by the record's `reload` method.
-
-    This method calls the adapter's `find` method, which returns a promise. When
-    **that** promise resolves, `_reloadRecord` will resolve the promise returned
-    by the record's `reload`.
-
-    @method _reloadRecord
-    @private
-    @param {Model} internalModel
-    @param options optional to include adapterOptions
-    @return {Promise} promise
-  */
-  _reloadRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
-    options.isReloading = true;
-    let { id, modelName } = internalModel;
-    let adapter = this.adapterFor(modelName);
-
-    assert(`You cannot reload a record without an ID`, id);
-    assert(`You tried to reload a record but you have no adapter (for ${modelName})`, adapter);
-    assert(
-      `You tried to reload a record but your adapter does not implement 'findRecord'`,
-      typeof adapter.findRecord === 'function'
-    );
-
-    return this._scheduleFetch(internalModel, options);
+    return internalModel && internalModel.isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
   }
 
   /**
@@ -1402,299 +1190,61 @@ abstract class CoreStore extends Service {
     @return {Boolean}
   */
   hasRecordForId(modelName: string, id: string | number): boolean {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'hasRecordForId');
-    }
-    assert(`You need to pass a model name to the store's hasRecordForId method`, isPresent(modelName));
-    assert(
-      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
-      typeof modelName === 'string'
-    );
+    if (DEPRECATE_HAS_RECORD) {
+      deprecate(`store.hasRecordForId has been deprecated in favor of store.peekRecord`, false, {
+        id: 'ember-data:deprecate-has-record-for-id',
+        since: { available: '4.5', enabled: '4.5' },
+        until: '5.0',
+        for: 'ember-data',
+      });
+      if (DEBUG) {
+        assertDestroyingStore(this, 'hasRecordForId');
+      }
+      assert(`You need to pass a model name to the store's hasRecordForId method`, modelName);
+      assert(
+        `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
+        typeof modelName === 'string'
+      );
 
-    const type = normalizeModelName(modelName);
-    const trueId = ensureStringId(id);
-    const resource = { type, id: trueId };
+      const type = normalizeModelName(modelName);
+      const trueId = ensureStringId(id);
+      const resource = { type, id: trueId };
 
-    const identifier = this.identifierCache.peekRecordIdentifier(resource);
-    const internalModel = identifier && internalModelFactoryFor(this).peek(identifier);
+      const identifier = this.identifierCache.peekRecordIdentifier(resource);
+      const internalModel = identifier && internalModelFactoryFor(this).peek(identifier);
 
-    return !!internalModel && internalModel.currentState.isLoaded;
+      return !!internalModel && internalModel.isLoaded;
+    }
+    assert(`store.hasRecordForId has been removed`);
   }
 
   /**
-    Returns id record for a given type and ID. If one isn't already loaded,
-    it builds a new record and leaves it in the `empty` state.
+    This method delegates a query to the adapter. This is the one place where
+    adapter-level semantics are exposed to the application.
 
-    @method recordForId
-    @private
-    @param {String} modelName
-    @param {(String|Integer)} id
-    @return {Model} record
-  */
-  recordForId(modelName: string, id: string | number): RecordInstance {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'recordForId');
-    }
-    assert(`You need to pass a model name to the store's recordForId method`, isPresent(modelName));
-    assert(
-      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
-      typeof modelName === 'string'
-    );
+    Each time this method is called a new request is made through the adapter.
 
-    const resource = constructResource(modelName, ensureStringId(id));
+    Exposing queries this way seems preferable to creating an abstract query
+    language for all server-side queries, and then require all adapters to
+    implement them.
 
-    return internalModelFactoryFor(this).lookup(resource).getRecord();
-  }
+    ---
 
-  /**
-    @method findMany
-    @private
-    @param {Array} internalModels
-    @return {Promise} promise
-  */
-  findMany(internalModels, options) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'findMany');
-    }
-    let finds = new Array(internalModels.length);
+    If you do something like this:
 
-    for (let i = 0; i < internalModels.length; i++) {
-      finds[i] = this._findEmptyInternalModel(internalModels[i], options);
-    }
+    ```javascript
+    store.query('person', { page: 1 });
+    ```
 
-    return all(finds);
-  }
+    The request made to the server will look something like this:
 
-  /**
-    If a relationship was originally populated by the adapter as a link
-    (as opposed to a list of IDs), this method is called when the
-    relationship is fetched.
+    ```
+    GET "/api/v1/person?page=1"
+    ```
 
-    The link (which is usually a URL) is passed through unchanged, so the
-    adapter can make whatever request it wants.
+    ---
 
-    The usual use-case is for the server to register a URL as a link, and
-    then use that URL in the future to make a request for the relationship.
-
-    @method findHasMany
-    @private
-    @param {InternalModel} internalModel
-    @param {any} link
-    @param {(Relationship)} relationship
-    @return {Promise} promise
-  */
-  findHasMany(internalModel, link, relationship, options) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'findHasMany');
-    }
-    let adapter = this.adapterFor(internalModel.modelName);
-
-    assert(
-      `You tried to load a hasMany relationship but you have no adapter (for ${internalModel.modelName})`,
-      adapter
-    );
-    assert(
-      `You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`,
-      typeof adapter.findHasMany === 'function'
-    );
-
-    return _findHasMany(adapter, this, internalModel, link, relationship, options);
-  }
-
-  _findHasManyByJsonApiResource(
-    resource,
-    parentInternalModel: InternalModel,
-    relationship: ManyRelationship,
-    options?: Dict<unknown>
-  ): Promise<void | unknown[]> {
-    if (HAS_RECORD_DATA_PACKAGE) {
-      if (!resource) {
-        return resolve();
-      }
-      const { definition, state } = relationship;
-      let adapter = this.adapterFor(definition.type);
-
-      let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
-      const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);
-
-      let shouldFindViaLink =
-        resource.links &&
-        resource.links.related &&
-        (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') &&
-        (shouldForceReload || hasDematerializedInverse || isStale || (!allInverseRecordsAreLoaded && !isEmpty));
-
-      // fetch via link
-      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._storeWrapper.relationshipsDefinitionFor(definition.inverseType)[definition.key];
-        return this.findHasMany(parentInternalModel, resource.links.related, relationshipMeta, options);
-      }
-
-      let preferLocalCache = hasReceivedData && !isEmpty;
-
-      let 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)) {
-        let internalModels = resource.data.map((json) => this._internalModelForResource(json));
-
-        return this.findMany(internalModels, options);
-      }
-
-      let hasData = hasReceivedData && !isEmpty;
-
-      // fetch by data
-      if (hasData || hasLocalPartialData) {
-        let internalModels = resource.data.map((json) => this._internalModelForResource(json));
-
-        return this._scheduleFetchMany(internalModels, options);
-      }
-
-      // we were explicitly told we have no data and no links.
-      //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-      return resolve();
-    }
-    assert(`hasMany only works with the @ember-data/record-data package`);
-  }
-
-  /**
-    @method findBelongsTo
-    @private
-    @param {InternalModel} internalModel
-    @param {any} link
-    @param {Relationship} relationship
-    @return {Promise} promise
-  */
-  findBelongsTo(internalModel, link, relationship, options): Promise<InternalModel> {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'findBelongsTo');
-    }
-    let adapter = this.adapterFor(internalModel.modelName);
-
-    assert(
-      `You tried to load a belongsTo relationship but you have no adapter (for ${internalModel.modelName})`,
-      adapter
-    );
-    assert(
-      `You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`,
-      typeof adapter.findBelongsTo === 'function'
-    );
-
-    return _findBelongsTo(adapter, this, internalModel, link, relationship, options);
-  }
-
-  _fetchBelongsToLinkFromResource(
-    resource,
-    parentInternalModel: InternalModel,
-    relationshipMeta,
-    options
-  ): Promise<InternalModel | null> {
-    if (!resource || !resource.links || !resource.links.related) {
-      // should we warn here, not sure cause its an internal method
-      return resolve(null);
-    }
-    return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options);
-  }
-
-  _findBelongsToByJsonApiResource(
-    resource,
-    parentInternalModel: InternalModel,
-    relationshipMeta,
-    options
-  ): Promise<InternalModel | null> {
-    if (!resource) {
-      return resolve(null);
-    }
-
-    const internalModel = resource.data ? this._internalModelForResource(resource.data) : null;
-    let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = resource._relationship
-      .state as RelationshipState;
-    const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);
-
-    let shouldFindViaLink =
-      resource.links &&
-      resource.links.related &&
-      (shouldForceReload || hasDematerializedInverse || isStale || (!allInverseRecordsAreLoaded && !isEmpty));
-
-    if (internalModel) {
-      // short circuit if we are already loading
-      let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
-      if (pendingRequest) {
-        return pendingRequest.then(() => internalModel);
-      }
-    }
-
-    // fetch via link
-    if (shouldFindViaLink) {
-      return this._fetchBelongsToLinkFromResource(resource, parentInternalModel, 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;
-
-    // fetch using data, pulling from local cache if possible
-    if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
-      /*
-        We have canonical data, but our local state is empty
-       */
-      if (localDataIsEmpty) {
-        return resolve(null);
-      }
-
-      if (!internalModel) {
-        assert(`No InternalModel found for ${resource.lid}`, internalModel);
-      }
-
-      return this._findByInternalModel(internalModel, options);
-    }
-
-    let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
-
-    if (internalModel && resourceIsLocal) {
-      return resolve(internalModel);
-    }
-
-    // fetch by data
-    if (internalModel && !localDataIsEmpty) {
-      return this._scheduleFetch(internalModel, options);
-    }
-
-    // we were explicitly told we have no data and no links.
-    //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-    return resolve(null);
-  }
-
-  /**
-    This method delegates a query to the adapter. This is the one place where
-    adapter-level semantics are exposed to the application.
-
-    Each time this method is called a new request is made through the adapter.
-
-    Exposing queries this way seems preferable to creating an abstract query
-    language for all server-side queries, and then require all adapters to
-    implement them.
-
-    ---
-
-    If you do something like this:
-
-    ```javascript
-    store.query('person', { page: 1 });
-    ```
-
-    The request made to the server will look something like this:
-
-    ```
-    GET "/api/v1/person?page=1"
-    ```
-
-    ---
-
-    If you do something like this:
+    If you do something like this:
 
     ```javascript
     store.query('person', { ids: [1, 2, 3] });
@@ -1723,7 +1273,7 @@ abstract class CoreStore extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'query');
     }
-    assert(`You need to pass a model name to the store's query method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's query method`, modelName);
     assert(`You need to pass a query hash to the store's query method`, query);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
@@ -1735,20 +1285,10 @@ abstract class CoreStore extends Service {
     if (options && options.adapterOptions) {
       adapterOptionsWrapper.adapterOptions = options.adapterOptions;
     }
+    let recordArray = options?._recordArray || null;
 
     let normalizedModelName = normalizeModelName(modelName);
-    return promiseArray(this._query(normalizedModelName, query, null, adapterOptionsWrapper));
-  }
-
-  _query(modelName: string, query, array, options): Promise<AdapterPopulatedRecordArray> {
-    assert(`You need to pass a model name to the store's query method`, isPresent(modelName));
-    assert(`You need to pass a query hash to the store's query method`, query);
-    assert(
-      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
-      typeof modelName === 'string'
-    );
-
-    let adapter = this.adapterFor(modelName);
+    let adapter = this.adapterFor(normalizedModelName);
 
     assert(`You tried to load a query but you have no adapter (for ${modelName})`, adapter);
     assert(
@@ -1756,7 +1296,16 @@ abstract class CoreStore extends Service {
       typeof adapter.query === 'function'
     );
 
-    return _query(adapter, this, modelName, query, array, options) as unknown as Promise<AdapterPopulatedRecordArray>;
+    let queryPromise = _query(
+      adapter,
+      this,
+      normalizedModelName,
+      query,
+      recordArray,
+      adapterOptionsWrapper
+    ) as unknown as Promise<AdapterPopulatedRecordArray>;
+
+    return promiseArray(queryPromise);
   }
 
   /**
@@ -1857,11 +1406,11 @@ abstract class CoreStore extends Service {
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
     @return {Promise} promise which resolves with the found record or `null`
   */
-  queryRecord(modelName: string, query, options): PromiseObject<RecordInstance | null> {
+  queryRecord(modelName: string, query, options?): PromiseObject<RecordInstance | null> {
     if (DEBUG) {
       assertDestroyingStore(this, 'queryRecord');
     }
-    assert(`You need to pass a model name to the store's queryRecord method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's queryRecord method`, modelName);
     assert(`You need to pass a query hash to the store's queryRecord method`, query);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
@@ -1882,19 +1431,15 @@ abstract class CoreStore extends Service {
       typeof adapter.queryRecord === 'function'
     );
 
-    const promise: Promise<InternalModel | null> = _queryRecord(
+    const promise: Promise<StableRecordIdentifier | null> = _queryRecord(
       adapter,
       this,
       normalizedModelName,
       query,
       adapterOptionsWrapper
-    ) as Promise<InternalModel | null>;
+    ) as Promise<StableRecordIdentifier | null>;
 
-    return promiseObject(
-      promise.then((internalModel: InternalModel | null) => {
-        return internalModel ? internalModel.getRecord() : null;
-      })
-    );
+    return promiseObject(promise.then((identifier) => identifier && this.peekRecord(identifier)));
   }
 
   /**
@@ -2092,78 +1637,57 @@ abstract class CoreStore extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
-    assert(`You need to pass a model name to the store's findAll method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's findAll method`, modelName);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
     );
 
     let normalizedModelName = normalizeModelName(modelName);
-    let fetch = this._fetchAll(normalizedModelName, this.peekAll(normalizedModelName), options);
-
-    return promiseArray(fetch);
-  }
+    let array = this.peekAll(normalizedModelName);
+    let fetch;
 
-  /**
-    @method _fetchAll
-    @private
-    @param {Model} modelName
-    @param {RecordArray} array
-    @return {Promise} promise
-  */
-  _fetchAll(
-    modelName: string,
-    array: RecordArray,
-    options: { reload?: boolean; backgroundReload?: boolean }
-  ): Promise<RecordArray> {
-    let adapter = this.adapterFor(modelName);
+    let adapter = this.adapterFor(normalizedModelName);
 
-    assert(`You tried to load all records but you have no adapter (for ${modelName})`, adapter);
+    assert(`You tried to load all records but you have no adapter (for ${normalizedModelName})`, adapter);
     assert(
       `You tried to load all records but your adapter does not implement 'findAll'`,
       typeof adapter.findAll === 'function'
     );
 
     if (options.reload) {
-      set(array, 'isUpdating', true);
-      return _findAll(adapter, this, modelName, options);
-    }
-
-    let snapshotArray = array._createSnapshot(options);
-
-    if (options.reload !== false) {
-      if (
-        (adapter.shouldReloadAll && adapter.shouldReloadAll(this, snapshotArray)) ||
-        (!adapter.shouldReloadAll && snapshotArray.length === 0)
-      ) {
-        set(array, 'isUpdating', true);
-        return _findAll(adapter, this, modelName, options);
+      array.isUpdating = true;
+      fetch = _findAll(adapter, this, normalizedModelName, options);
+    } else {
+      let snapshotArray = array._createSnapshot(options);
+
+      if (options.reload !== false) {
+        if (
+          (adapter.shouldReloadAll && adapter.shouldReloadAll(this, snapshotArray)) ||
+          (!adapter.shouldReloadAll && snapshotArray.length === 0)
+        ) {
+          array.isUpdating = true;
+          fetch = _findAll(adapter, this, modelName, options);
+        }
       }
-    }
 
-    if (options.backgroundReload === false) {
-      return resolve(array);
-    }
+      if (!fetch) {
+        if (options.backgroundReload === false) {
+          fetch = resolve(array);
+        } else if (
+          options.backgroundReload ||
+          !adapter.shouldBackgroundReloadAll ||
+          adapter.shouldBackgroundReloadAll(this, snapshotArray)
+        ) {
+          array.isUpdating = true;
+          _findAll(adapter, this, modelName, options);
+        }
 
-    if (
-      options.backgroundReload ||
-      !adapter.shouldBackgroundReloadAll ||
-      adapter.shouldBackgroundReloadAll(this, snapshotArray)
-    ) {
-      set(array, 'isUpdating', true);
-      _findAll(adapter, this, modelName, options);
+        fetch = resolve(array);
+      }
     }
 
-    return resolve(array);
-  }
-
-  /**
-    @method _didUpdateAll
-    @param {String} modelName
-    @private
-  */
-  _didUpdateAll(modelName: string): void {
-    this.recordArrayManager._didUpdateAll(modelName);
+    return promiseArray(fetch);
   }
 
   /**
@@ -2195,7 +1719,7 @@ abstract class CoreStore extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'peekAll');
     }
-    assert(`You need to pass a model name to the store's peekAll method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's peekAll method`, modelName);
     assert(
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
@@ -2238,141 +1762,6 @@ abstract class CoreStore extends Service {
     }
   }
 
-  filter() {
-    assert(
-      'The filter API has been moved to a plugin. To enable store.filter using an environment flag, or to use an alternative, you can visit the ember-data-filter addon page. https://github.com/ember-data/ember-data-filter',
-      false
-    );
-  }
-
-  // ..............
-  // . PERSISTING .
-  // ..............
-
-  /**
-    This method is called by `record.save`, and gets passed a
-    resolver for the promise that `record.save` returns.
-
-    It schedules saving to happen at the end of the run loop.
-
-    @method scheduleSave
-    @private
-    @param {InternalModel} internalModel
-    @param {Resolver} resolver
-    @param {Object} options
-  */
-  scheduleSave(
-    internalModel: InternalModel,
-    resolver: RSVP.Deferred<void>,
-    options: FindOptions
-  ): void | Promise<void> {
-    if (internalModel._isRecordFullyDeleted()) {
-      resolver.resolve();
-      return resolver.promise;
-    }
-
-    internalModel.adapterWillCommit();
-
-    if (!options) {
-      options = {};
-    }
-    let recordData = internalModel._recordData;
-    let operation: 'createRecord' | 'deleteRecord' | 'updateRecord' = 'updateRecord';
-
-    // TODO handle missing isNew
-    if (recordData.isNew && recordData.isNew()) {
-      operation = 'createRecord';
-    } else if (recordData.isDeleted && recordData.isDeleted()) {
-      operation = 'deleteRecord';
-    }
-
-    const saveOptions = Object.assign({ [SaveOp]: operation }, options);
-    let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, saveOptions);
-    let promise = fetchManagerPromise.then(
-      (payload) => {
-        /*
-        Note to future spelunkers hoping to optimize.
-        We rely on this `run` to create a run loop if needed
-        that `store._push` and `store.didSaveRecord` will both share.
-
-        We use `join` because it is often the case that we
-        have an outer run loop available still from the first
-        call to `store._push`;
-       */
-        this._backburner.join(() => {
-          let data = payload && payload.data;
-          this.didSaveRecord(internalModel, { data }, operation);
-          if (payload && payload.included) {
-            this._push({ data: null, included: payload.included });
-          }
-        });
-      },
-      (e) => {
-        if (typeof e === 'string') {
-          throw e;
-        }
-        const { error, parsedErrors } = e;
-        this.recordWasInvalid(internalModel, parsedErrors, error);
-        throw error;
-      }
-    );
-
-    return promise;
-  }
-
-  /**
-    This method is called at the end of the run loop, and
-    flushes any records passed into `scheduleSave`
-
-    @method flushPendingSave
-    @private
-  */
-  flushPendingSave() {
-    // assert here
-    return;
-  }
-
-  /**
-    This method is called once the promise returned by an
-    adapter's `createRecord`, `updateRecord` or `deleteRecord`
-    is resolved.
-
-    If the data provides a server-generated ID, it will
-    update the record and the store's indexes.
-
-    @method didSaveRecord
-    @private
-    @param {InternalModel} internalModel the in-flight internal model
-    @param {Object} data optional data (see above)
-    @param {string} op the adapter operation that was committed
-  */
-  didSaveRecord(internalModel, dataArg, op: 'createRecord' | 'updateRecord' | 'deleteRecord') {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'didSaveRecord');
-    }
-    let data;
-    if (dataArg) {
-      data = dataArg.data;
-    }
-    if (!data) {
-      assert(
-        `Your ${internalModel.modelName} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`,
-        internalModel.id
-      );
-    }
-
-    const cache = this.identifierCache;
-    const identifier = internalModel.identifier;
-
-    if (op !== 'deleteRecord' && data) {
-      cache.updateRecordIdentifier(identifier, data);
-    }
-
-    //We first make sure the primary data has been updated
-    //TODO try to move notification to the user to the end of the runloop
-    internalModel.adapterDidCommit(data);
-  }
-
   /**
     This method is called once the promise returned by an
     adapter's `createRecord`, `updateRecord` or `deleteRecord`
@@ -2380,96 +1769,28 @@ abstract class CoreStore extends Service {
 
     @method recordWasInvalid
     @private
+    @deprecated
     @param {InternalModel} internalModel
     @param {Object} errors
   */
   recordWasInvalid(internalModel, parsedErrors, error) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'recordWasInvalid');
-    }
-    internalModel.adapterDidInvalidate(parsedErrors, error);
-  }
-
-  /**
-    This method is called once the promise returned by an
-    adapter's `createRecord`, `updateRecord` or `deleteRecord`
-    is rejected (with anything other than a `InvalidError`).
-
-    @method recordWasError
-    @private
-    @param {InternalModel} internalModel
-    @param {Error} error
-  */
-  recordWasError(internalModel, error) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'recordWasError');
-    }
-    internalModel.adapterDidError(error);
-  }
-
-  /**
-    Sets newly received ID from the adapter's `createRecord`, `updateRecord`
-    or `deleteRecord`.
-
-    @method setRecordId
-    @private
-    @param {String} modelName
-    @param {string} newId
-    @param {string} clientId
-   */
-  setRecordId(modelName: string, newId: string, clientId: string) {
-    if (DEBUG) {
-      assertDestroyingStore(this, 'setRecordId');
-    }
-    internalModelFactoryFor(this).setRecordId(modelName, newId, clientId);
-  }
-
-  // ................
-  // . LOADING DATA .
-  // ................
-
-  /**
-    This internal method is used by `push`.
-
-    @method _load
-    @private
-    @param {Object} data
-  */
-  _load(data: ExistingResourceObject) {
-    // TODO this should determine identifier via the cache before making assumptions
-    const resource = constructResource(normalizeModelName(data.type), ensureStringId(data.id), coerceId(data.lid));
-
-    let internalModel = internalModelFactoryFor(this).lookup(resource, data);
-
-    // store.push will be from empty
-    // findRecord will be from root.loading
-    // all else will be updates
-    const isLoading = internalModel.currentState.stateName === 'root.loading';
-    const isUpdate = internalModel.currentState.isEmpty === false && !isLoading;
-
-    // exclude store.push (root.empty) case
-    let identifier = internalModel.identifier;
-    if (isUpdate || isLoading) {
-      let updatedIdentifier = this.identifierCache.updateRecordIdentifier(identifier, data);
-
-      if (updatedIdentifier !== identifier) {
-        // we encountered a merge of identifiers in which
-        // two identifiers (and likely two internalModels)
-        // existed for the same resource. Now that we have
-        // determined the correct identifier to use, make sure
-        // that we also use the correct internalModel.
-        identifier = updatedIdentifier;
-        internalModel = internalModelFactoryFor(this).lookup(identifier);
+    if (DEPRECATE_RECORD_WAS_INVALID) {
+      deprecate(
+        `The private API recordWasInvalid will be removed in an upcoming release. Use record.errors add/remove instead if the intent was to move the record into an invalid state manually.`,
+        false,
+        {
+          id: 'ember-data:deprecate-record-was-invalid',
+          for: 'ember-data',
+          until: '5.0',
+          since: { enabled: '4.5', available: '4.5' },
+        }
+      );
+      if (DEBUG) {
+        assertDestroyingStore(this, 'recordWasInvalid');
       }
+      internalModel.adapterDidInvalidate(parsedErrors, error);
     }
-
-    internalModel.setupData(data);
-
-    if (!isUpdate) {
-      this.recordArrayManager.recordDidChange(identifier);
-    }
-
-    return internalModel;
+    assert(`store.recordWasInvalid has been removed`);
   }
 
   /**
@@ -2633,7 +1954,7 @@ abstract class CoreStore extends Service {
     let pushed = this._push(data);
 
     if (Array.isArray(pushed)) {
-      let records = pushed.map((internalModel) => internalModel.getRecord());
+      let records = pushed.map((identifier) => this._instanceCache.getRecord(identifier));
       return records;
     }
 
@@ -2641,8 +1962,7 @@ abstract class CoreStore extends Service {
       return null;
     }
 
-    let record = pushed.getRecord();
-    return record;
+    return this._instanceCache.getRecord(pushed);
   }
 
   /**
@@ -2654,28 +1974,28 @@ abstract class CoreStore extends Service {
     @param {Object} jsonApiDoc
     @return {InternalModel|Array<InternalModel>} pushed InternalModel(s)
   */
-  _push(jsonApiDoc): InternalModel | InternalModel[] | null {
+  _push(jsonApiDoc): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null {
     if (DEBUG) {
       assertDestroyingStore(this, '_push');
     }
-    let internalModelOrModels = this._backburner.join(() => {
+    let identifiers = this._backburner.join(() => {
       let included = jsonApiDoc.included;
       let i, length;
 
       if (included) {
         for (i = 0, length = included.length; i < length; i++) {
-          this._pushInternalModel(included[i]);
+          this._instanceCache._load(included[i]);
         }
       }
 
       if (Array.isArray(jsonApiDoc.data)) {
         length = jsonApiDoc.data.length;
-        let internalModels = new Array(length);
+        let identifiers = new Array(length);
 
         for (i = 0; i < length; i++) {
-          internalModels[i] = this._pushInternalModel(jsonApiDoc.data[i]);
+          identifiers[i] = this._instanceCache._load(jsonApiDoc.data[i]);
         }
-        return internalModels;
+        return identifiers;
       }
 
       if (jsonApiDoc.data === null) {
@@ -2683,66 +2003,17 @@ abstract class CoreStore extends Service {
       }
 
       assert(
-        `Expected an object in the 'data' property in a call to 'push' for ${jsonApiDoc.type}, but was ${typeOf(
-          jsonApiDoc.data
-        )}`,
-        typeOf(jsonApiDoc.data) === 'object'
+        `Expected an object in the 'data' property in a call to 'push' for ${
+          jsonApiDoc.type
+        }, but was ${typeof jsonApiDoc.data}`,
+        typeof jsonApiDoc.data === 'object'
       );
 
-      return this._pushInternalModel(jsonApiDoc.data);
+      return this._instanceCache._load(jsonApiDoc.data);
     });
 
     // this typecast is necessary because `backburner.join` is mistyped to return void
-    return internalModelOrModels as unknown as InternalModel | InternalModel[];
-  }
-
-  _pushInternalModel(data) {
-    // TODO type should be pulled from the identifier for debug
-    let modelName = data.type;
-    assert(
-      `You must include an 'id' for ${modelName} in an object passed to 'push'`,
-      data.id !== null && data.id !== undefined && data.id !== ''
-    );
-    assert(
-      `You tried to push data with a type '${modelName}' but no model could be found with that name.`,
-      this._hasModelFor(modelName)
-    );
-
-    if (DEBUG) {
-      // If ENV.DS_WARN_ON_UNKNOWN_KEYS is set to true and the payload
-      // contains unknown attributes or relationships, log a warning.
-
-      if (ENV.DS_WARN_ON_UNKNOWN_KEYS) {
-        let unknownAttributes, unknownRelationships;
-        let relationships = this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);
-        let attributes = this.getSchemaDefinitionService().attributesDefinitionFor(modelName);
-        // Check unknown attributes
-        unknownAttributes = Object.keys(data.attributes || {}).filter((key) => {
-          return !attributes[key];
-        });
-
-        // Check unknown relationships
-        unknownRelationships = Object.keys(data.relationships || {}).filter((key) => {
-          return !relationships[key];
-        });
-        let unknownAttributesMessage = `The payload for '${modelName}' contains these unknown attributes: ${unknownAttributes}. Make sure they've been defined in your model.`;
-        warn(unknownAttributesMessage, unknownAttributes.length === 0, {
-          id: 'ds.store.unknown-keys-in-payload',
-        });
-
-        let unknownRelationshipsMessage = `The payload for '${modelName}' contains these unknown relationships: ${unknownRelationships}. Make sure they've been defined in your model.`;
-        warn(unknownRelationshipsMessage, unknownRelationships.length === 0, {
-          id: 'ds.store.unknown-keys-in-payload',
-        });
-      }
-    }
-
-    // Actually load the record into the store.
-    let internalModel = this._load(data);
-
-    //    this._setupRelationshipsForModel(internalModel, data);
-
-    return internalModel;
+    return identifiers;
   }
 
   /**
@@ -2801,6 +2072,7 @@ abstract class CoreStore extends Service {
     @param {String} modelName Optionally, a model type used to determine which serializer will be used
     @param {Object} inputPayload
   */
+  // TODO @runspired @deprecate pushPayload in favor of looking up the serializer
   pushPayload(modelName, inputPayload) {
     if (DEBUG) {
       assertDestroyingStore(this, 'pushPayload');
@@ -2830,62 +2102,103 @@ abstract class CoreStore extends Service {
     serializer.pushPayload(this, payload);
   }
 
-  reloadBelongsTo(belongsToProxy, internalModel, key, options) {
-    return internalModel.reloadBelongsTo(key, options);
-  }
-
-  _internalModelForResource(resource: ResourceIdentifierObject): InternalModel {
-    return internalModelFactoryFor(this).getByResource(resource);
-  }
-
-  /**
-   * TODO Only needed temporarily for test support
-   *
-   * @method _internalModelForId
-   * @internal
-   */
-  _internalModelForId(type: string, id: string | null, lid: string | null): InternalModel {
-    const resource = constructResource(type, id, lid);
-    return internalModelFactoryFor(this).lookup(resource);
-  }
-
+  // TODO @runspired @deprecate records should implement their own serialization if desired
   serializeRecord(record: RecordInstance, options?: Dict<unknown>): unknown {
-    let identifier = recordIdentifierFor(record);
-    let internalModel = internalModelFactoryFor(this).peek(identifier);
     // TODO we used to check if the record was destroyed here
-    return internalModel!.createSnapshot(options).serialize(options);
+    return this._instanceCache.createSnapshot(recordIdentifierFor(record)).serialize(options);
   }
 
-  saveRecord(record: RecordInstance, options?: Dict<unknown>): Promise<RecordInstance> {
+  // todo @runspired this should likely be publicly @documented for custom records
+  saveRecord(record: RecordInstance, options: Dict<unknown> = {}): Promise<RecordInstance> {
+    assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
     let identifier = recordIdentifierFor(record);
-    let internalModel = internalModelFactoryFor(this).peek(identifier);
+    let internalModel = identifier && internalModelFactoryFor(this).peek(identifier)!;
+
+    if (!internalModel) {
+      // this commonly means we're disconnected
+      // but just in case we reject here to prevent bad things.
+      return reject(`Record Is Disconnected`);
+    }
     // TODO we used to check if the record was destroyed here
     // Casting can be removed once REQUEST_SERVICE ff is turned on
     // because a `Record` is provided there will always be a matching internalModel
-    return (internalModel!.save(options) as Promise<void>).then(() => record);
-  }
 
-  relationshipReferenceFor(identifier: RecordIdentifier, key: string): BelongsToReference | HasManyReference {
-    let stableIdentifier = this.identifierCache.getOrCreateRecordIdentifier(identifier);
-    let internalModel = internalModelFactoryFor(this).peek(stableIdentifier);
-    // TODO we used to check if the record was destroyed here
-    return internalModel!.referenceFor(null, key);
-  }
+    assert(
+      `Cannot initiate a save request for an unloaded record: ${identifier}`,
+      !internalModel.isEmpty && !internalModel.isDestroyed
+    );
+    if (internalModel._isRecordFullyDeleted()) {
+      return resolve(record);
+    }
 
-  /**
-   * Manages setting setting up the recordData returned by createRecordDataFor
-   *
-   * @method _createRecordData
-   * @internal
-   */
-  _createRecordData(identifier: StableRecordIdentifier): RecordData {
-    const recordData = this.createRecordDataFor(identifier.type, identifier.id, identifier.lid, this._storeWrapper);
-    setRecordDataFor(identifier, recordData);
-    // TODO this is invalid for v2 recordData but required
-    // for v1 recordData. Remember to remove this once the
-    // RecordData manager handles converting recordData to identifier
-    setRecordIdentifier(recordData, identifier);
-    return recordData;
+    internalModel.adapterWillCommit();
+
+    if (!options) {
+      options = {};
+    }
+    let recordData = this._instanceCache.getRecordData(identifier);
+    let operation: 'createRecord' | 'deleteRecord' | 'updateRecord' = 'updateRecord';
+
+    // TODO handle missing isNew
+    if (recordData.isNew && recordData.isNew()) {
+      operation = 'createRecord';
+    } else if (recordData.isDeleted && recordData.isDeleted()) {
+      operation = 'deleteRecord';
+    }
+
+    const saveOptions = Object.assign({ [SaveOp]: operation }, options);
+    let fetchManagerPromise = this._fetchManager.scheduleSave(identifier, saveOptions);
+    return fetchManagerPromise.then(
+      (payload) => {
+        /*
+        // TODO @runspired re-evaluate the below claim now that
+        // the save request pipeline is more streamlined.
+
+        Note to future spelunkers hoping to optimize.
+        We rely on this `run` to create a run loop if needed
+        that `store._push` and `store.saveRecord` will both share.
+
+        We use `join` because it is often the case that we
+        have an outer run loop available still from the first
+        call to `store._push`;
+       */
+        this._backburner.join(() => {
+          if (DEBUG) {
+            assertDestroyingStore(this, 'saveRecord');
+          }
+
+          let data = payload && payload.data;
+          if (!data) {
+            assert(
+              `Your ${internalModel.modelName} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`,
+              internalModel.id
+            );
+          }
+
+          const cache = this.identifierCache;
+          if (operation !== 'deleteRecord' && data) {
+            cache.updateRecordIdentifier(identifier, data);
+          }
+
+          //We first make sure the primary data has been updated
+          //TODO try to move notification to the user to the end of the runloop
+          internalModel.adapterDidCommit(data);
+
+          if (payload && payload.included) {
+            this._push({ data: null, included: payload.included });
+          }
+        });
+        return record;
+      },
+      (e) => {
+        if (typeof e === 'string') {
+          throw e;
+        }
+        const { error, parsedErrors } = e;
+        internalModel.adapterDidInvalidate(parsedErrors, error);
+        throw error;
+      }
+    );
   }
 
   /**
@@ -2928,30 +2241,6 @@ abstract class CoreStore extends Service {
     assert(`Expected store.createRecordDataFor to be implemented but it wasn't`);
   }
 
-  /**
-   * @internal
-   */
-  __recordDataFor(resource: RecordIdentifier) {
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    return this.recordDataFor(identifier, false);
-  }
-
-  /**
-   * @internal
-   */
-  recordDataFor(identifier: StableRecordIdentifier | { type: string }, isCreate: boolean): RecordData {
-    let internalModel: InternalModel;
-    if (isCreate === true) {
-      internalModel = internalModelFactoryFor(this).build({ type: identifier.type, id: null });
-      internalModel.send('loadedData');
-      internalModel.didCreateRecord();
-    } else {
-      internalModel = internalModelFactoryFor(this).lookup(identifier as StableRecordIdentifier);
-    }
-
-    return internalModel._recordData;
-  }
-
   /**
     `normalize` converts a json payload into the normalized form that
     [push](../methods/push?anchor=push) expects.
@@ -2972,15 +2261,14 @@ abstract class CoreStore extends Service {
     @param {Object} payload
     @return {Object} The normalized payload
   */
+  // TODO @runspired @deprecate users should call normalize on the associated serializer directly
   normalize(modelName: string, payload) {
     if (DEBUG) {
       assertDestroyingStore(this, 'normalize');
     }
-    assert(`You need to pass a model name to the store's normalize method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's normalize method`, modelName);
     assert(
-      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${inspect(
-        modelName
-      )}`,
+      `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`,
       typeof modelName === 'string'
     );
     let normalizedModelName = normalizeModelName(modelName);
@@ -2993,49 +2281,25 @@ abstract class CoreStore extends Service {
     return serializer.normalize(model, payload);
   }
 
-  newClientId() {
-    assert(`Private API Removed`, false);
-  }
-
-  // ...............
-  // . DESTRUCTION .
-  // ...............
-
-  /**
-   * TODO remove test usage
-   *
-   * @internal
-   */
-  _internalModelsFor(modelName: string) {
-    return internalModelFactoryFor(this).modelMapFor(modelName);
-  }
-
-  // ......................
-  // . PER-TYPE ADAPTERS
-  // ......................
-
   /**
     Returns an instance of the adapter for a given type. For
     example, `adapterFor('person')` will return an instance of
-    `App.PersonAdapter`.
+    the adapter located at `app/adapters/person.js`
 
-    If no `App.PersonAdapter` is found, this method will look
-    for an `App.ApplicationAdapter` (the default adapter for
+    If no `person` adapter is found, this method will look
+    for an `application` adapter (the default adapter for
     your entire application).
 
-    If no `App.ApplicationAdapter` is found, it will return
-    the value of the `defaultAdapter`.
-
     @method adapterFor
     @public
     @param {String} modelName
     @return Adapter
   */
-  adapterFor(modelName) {
+  adapterFor(modelName: string) {
     if (DEBUG) {
       assertDestroyingStore(this, 'adapterFor');
     }
-    assert(`You need to pass a model name to the store's adapterFor method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's adapterFor method`, modelName);
     assert(
       `Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
@@ -3048,12 +2312,11 @@ abstract class CoreStore extends Service {
       return adapter;
     }
 
-    let owner = getOwner(this);
+    let owner: any = getOwner(this);
 
     // name specific adapter
     adapter = owner.lookup(`adapter:${normalizedModelName}`);
     if (adapter !== undefined) {
-      set(adapter, 'store', this);
       _adapterCache[normalizedModelName] = adapter;
       return adapter;
     }
@@ -3061,29 +2324,35 @@ abstract class CoreStore extends Service {
     // no adapter found for the specific name, fallback and check for application adapter
     adapter = _adapterCache.application || owner.lookup('adapter:application');
     if (adapter !== undefined) {
-      set(adapter, 'store', this);
       _adapterCache[normalizedModelName] = adapter;
       _adapterCache.application = adapter;
       return adapter;
     }
 
-    // final fallback, no model specific adapter, no application adapter, no
-    // `adapter` property on store: use json-api adapter
-    // TODO we should likely deprecate this?
-    adapter = _adapterCache['-json-api'] || owner.lookup('adapter:-json-api');
-    assert(
-      `No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`,
-      adapter !== undefined
-    );
-    set(adapter, 'store', this);
-    _adapterCache[normalizedModelName] = adapter;
-    _adapterCache['-json-api'] = adapter;
-    return adapter;
-  }
+    if (DEPRECATE_JSON_API_FALLBACK) {
+      // final fallback, no model specific adapter, no application adapter, no
+      // `adapter` property on store: use json-api adapter
+      adapter = _adapterCache['-json-api'] || owner.lookup('adapter:-json-api');
+      if (adapter !== undefined) {
+        deprecate(
+          `Your application is utilizing a deprecated hidden fallback adapter (-json-api). Please implement an application adapter to function as your fallback.`,
+          false,
+          {
+            id: 'ember-data:deprecate-secret-adapter-fallback',
+            for: 'ember-data',
+            until: '5.0',
+            since: { available: '4.5', enabled: '4.5' },
+          }
+        );
+        _adapterCache[normalizedModelName] = adapter;
+        _adapterCache['-json-api'] = adapter;
 
-  // ..............................
-  // . RECORD CHANGE NOTIFICATION .
-  // ..............................
+        return adapter;
+      }
+    }
+
+    assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`);
+  }
 
   /**
     Returns an instance of the serializer for a given type. For
@@ -3106,7 +2375,7 @@ abstract class CoreStore extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'serializerFor');
     }
-    assert(`You need to pass a model name to the store's serializerFor method`, isPresent(modelName));
+    assert(`You need to pass a model name to the store's serializerFor method`, modelName);
     assert(
       `Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
@@ -3119,12 +2388,11 @@ abstract class CoreStore extends Service {
       return serializer;
     }
 
-    let owner = getOwner(this);
+    let owner: any = getOwner(this);
 
     // by name
     serializer = owner.lookup(`serializer:${normalizedModelName}`);
     if (serializer !== undefined) {
-      set(serializer, 'store', this);
       _serializerCache[normalizedModelName] = serializer;
       return serializer;
     }
@@ -3132,7 +2400,6 @@ abstract class CoreStore extends Service {
     // no serializer found for the specific model, fallback and check for application serializer
     serializer = _serializerCache.application || owner.lookup('serializer:application');
     if (serializer !== undefined) {
-      set(serializer, 'store', this);
       _serializerCache[normalizedModelName] = serializer;
       _serializerCache.application = serializer;
       return serializer;
@@ -3193,32 +2460,20 @@ abstract class CoreStore extends Service {
 
     if (DEBUG) {
       unregisterWaiter(this.__asyncWaiter);
-      let shouldTrack = this.shouldTrackAsyncRequests;
       let tracked = this._trackedAsyncRequests;
       let isSettled = tracked.length === 0;
 
       if (!isSettled) {
-        if (shouldTrack) {
-          throw new Error(
-            'Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\n\t - ' +
-              tracked.map((o) => o.label).join('\n\t - ')
-          );
-        } else {
-          warn(
-            'Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\n\t - ' +
-              tracked.map((o) => o.label).join('\n\t - '),
-            false,
-            {
-              id: 'ds.async.leak.detected',
-            }
-          );
-        }
+        throw new Error(
+          'Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\n\t - ' +
+            tracked.map((o) => o.label).join('\n\t - ')
+        );
       }
     }
   }
 }
 
-export default CoreStore;
+export default Store;
 
 let assertDestroyingStore: Function;
 let assertDestroyedStoreOnly: Function;
@@ -3238,47 +2493,6 @@ if (DEBUG) {
   };
 }
 
-/**
- * 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: CoreStore, resource: JsonApiRelationship): boolean {
-  const cache = store.identifierCache;
-
-  if (Array.isArray(resource.data)) {
-    // treat as collection
-    // check for unloaded records
-    let hasEmptyRecords = resource.data.reduce((hasEmptyModel, resourceIdentifier) => {
-      return hasEmptyModel || internalModelForRelatedResource(store, cache, resourceIdentifier).currentState.isEmpty;
-    }, false);
-
-    return !hasEmptyRecords;
-  } else {
-    // treat as single resource
-    if (!resource.data) {
-      return true;
-    } else {
-      const internalModel = internalModelForRelatedResource(store, cache, resource.data);
-      return !internalModel.currentState.isEmpty;
-    }
-  }
-}
-
-function internalModelForRelatedResource(
-  store: CoreStore,
-  cache: IdentifierCache,
-  resource: ResourceIdentifierObject
-): InternalModel {
-  const identifier = cache.getOrCreateRecordIdentifier(resource);
-  return store._internalModelForResource(identifier);
-}
-
 function isMaybeIdentifier(
   maybeIdentifier: string | ResourceIdentifierObject
 ): maybeIdentifier is ResourceIdentifierObject {
@@ -3290,7 +2504,7 @@ function isMaybeIdentifier(
   );
 }
 
-function assertIdentifierHasId(
+export function assertIdentifierHasId(
   identifier: StableRecordIdentifier
 ): asserts identifier is StableExistingRecordIdentifier {
   assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);