@ember-data/store 4.6.1 → 4.7.0

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

@@ -3,8 +3,7 @@
  */
 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 { _backburner as emberBackburner, run } from '@ember/runloop';
 import Service from '@ember/service';
 import { registerWaiter, unregisterWaiter } from '@ember/test';
 import { DEBUG } from '@glimmer/env';
@@ -17,8 +16,9 @@ import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-
 import {
   DEPRECATE_HAS_RECORD,
   DEPRECATE_JSON_API_FALLBACK,
-  DEPRECATE_RECORD_WAS_INVALID,
+  DEPRECATE_PROMISE_PROXIES,
   DEPRECATE_STORE_FIND,
+  DEPRECATE_V1CACHE_STORE_APIS,
 } 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';
@@ -32,39 +32,42 @@ import type {
 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 { RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
+import { JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
+import type { RecordDataStoreWrapper } from '@ember-data/types/q/record-data-store-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 { _findAll, _query, _queryRecord } from './finders';
-import { IdentifierCache } from './identifier-cache';
-import { InstanceCache, storeFor, StoreMap } from './instance-cache';
+import { IdentifierCache } from './caches/identifier-cache';
 import {
-  internalModelFactoryFor,
+  InstanceCache,
   peekRecordIdentifier,
+  recordDataIsFullyDeleted,
   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 { PromiseArray, promiseArray, PromiseObject, promiseObject } from './promise-proxies';
-import RecordArrayManager from './record-array-manager';
-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 RequestCache from './request-cache';
-import { DSModelSchemaDefinitionService, getModelFactory } from './schema-definition-service';
+  storeFor,
+  StoreMap,
+} from './caches/instance-cache';
+import recordDataFor, { setRecordDataFor } from './caches/record-data-for';
+import RecordReference from './legacy-model-support/record-reference';
+import { DSModelSchemaDefinitionService, getModelFactory } from './legacy-model-support/schema-definition-service';
+import type ShimModelClass from './legacy-model-support/shim-model-class';
+import { getShimClass } from './legacy-model-support/shim-model-class';
+import RecordArrayManager from './managers/record-array-manager';
+import type { NonSingletonRecordDataManager } from './managers/record-data-manager';
+import NotificationManager from './managers/record-notification-manager';
+import FetchManager, { SaveOp } from './network/fetch-manager';
+import { _findAll, _query, _queryRecord } from './network/finders';
+import type RequestCache from './network/request-cache';
+import type Snapshot from './network/snapshot';
+import SnapshotRecordArray from './network/snapshot-record-array';
+import { PromiseArray, promiseArray, PromiseObject, promiseObject } from './proxies/promise-proxies';
+import IdentifierArray, { Collection } from './record-arrays/identifier-array';
+import coerceId, { ensureStringId } from './utils/coerce-id';
 import constructResource from './utils/construct-resource';
+import normalizeModelName from './utils/normalize-model-name';
 import promiseRecord from './utils/promise-record';
 
 export { storeFor };
@@ -162,18 +165,8 @@ export interface CreateRecordProperties {
 */
 
 class Store extends Service {
-  /**
-   * Ember Data uses several specialized micro-queues for organizing
-    and coalescing similar async work.
+  __private_singleton_recordData!: RecordData;
 
-    These queues are currently controlled by a flush scheduled into
-    ember-data's custom backburner instance.
-   *
-   * EmberData specific backburner instance
-   * @property _backburner
-   * @private
-   */
-  declare _backburner: Backburner;
   declare recordArrayManager: RecordArrayManager;
 
   declare _notificationManager: NotificationManager;
@@ -191,6 +184,7 @@ class Store extends Service {
   declare _trackAsyncRequestStart: (str: string) => void;
   declare _trackAsyncRequestEnd: (token: AsyncTrackingToken) => void;
   declare __asyncWaiter: () => boolean;
+  declare DISABLE_WAITER?: boolean;
 
   /**
     @method init
@@ -224,10 +218,6 @@ class Store extends Service {
     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.generateStackTracesForTrackedRequests === undefined) {
         this.generateStackTracesForTrackedRequests = false;
@@ -268,50 +258,115 @@ class Store extends Service {
 
       this.__asyncWaiter = () => {
         let tracked = this._trackedAsyncRequests;
-        return tracked.length === 0;
+        return this.DISABLE_WAITER || tracked.length === 0;
       };
 
       registerWaiter(this.__asyncWaiter);
     }
   }
 
+  declare _cbs: { coalesce?: () => void; sync?: () => void; notify?: () => void } | null;
+  _run(cb: () => void) {
+    assert(`EmberData should never encounter a nested run`, !this._cbs);
+    const _cbs: { coalesce?: () => void; sync?: () => void; notify?: () => void } = (this._cbs = {});
+    cb();
+    if (_cbs.coalesce) {
+      _cbs.coalesce();
+    }
+    if (_cbs.sync) {
+      _cbs.sync();
+    }
+    if (_cbs.notify) {
+      _cbs.notify();
+    }
+    this._cbs = null;
+  }
+  _join(cb: () => void): void {
+    if (this._cbs) {
+      cb();
+    } else {
+      this._run(cb);
+    }
+  }
+
+  _schedule(name: 'coalesce' | 'sync' | 'notify', cb: () => void): void {
+    assert(`EmberData expects to schedule only when there is an active run`, !!this._cbs);
+    assert(`EmberData expects only one flush per queue name, cannot schedule ${name}`, !this._cbs[name]);
+
+    this._cbs[name] = cb;
+  }
+
+  /**
+   * Retrieve the RequestStateService instance
+   * associated with this Store.
+   *
+   * This can be used to query the status of requests
+   * that have been initiated for a given identifier.
+   *
+   * @method getRequestStateService
+   * @returns {RequestStateService}
+   * @public
+   */
   getRequestStateService(): RequestCache {
     return this._fetchManager.requestCache;
   }
 
+  /**
+   * A hook which an app or addon may implement. Called when
+   * the Store is attempting to create a Record Instance for
+   * a resource.
+   *
+   * This hook can be used to select or instantiate any desired
+   * mechanism of presentating cache data to the ui for access
+   * mutation, and interaction.
+   *
+   * @method instantiateRecord (hook)
+   * @param identifier
+   * @param createRecordArgs
+   * @param recordDataFor
+   * @param notificationManager
+   * @returns A record instance
+   * @public
+   */
   instantiateRecord(
     identifier: StableRecordIdentifier,
     createRecordArgs: { [key: string]: unknown },
-    recordDataFor: (identifier: StableRecordIdentifier) => RecordDataRecordWrapper,
+    recordDataFor: (identifier: StableRecordIdentifier) => RecordData,
     notificationManager: NotificationManager
   ): DSModel | RecordInstance {
     if (HAS_MODEL_PACKAGE) {
       let modelName = identifier.type;
-      let store = this;
 
-      let internalModel = this._instanceCache._internalModelForResource(identifier);
+      let recordData = this._instanceCache.getRecordData(identifier);
+      // TODO deprecate allowing unknown args setting
       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);
+        _secretInit: {
+          identifier,
+          recordData,
+          store: this,
+          cb: secretInit,
         },
-        container: null, // necessary hack for setOwner?
       };
 
       // 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);
+      return getModelFactory(this, this._modelFactoryCache, modelName).class.create(createOptions);
     }
     assert(`You must implement the store's instantiateRecord hook for your custom model class.`);
   }
 
+  /**
+   * A hook which an app or addon may implement. Called when
+   * the Store is destroying a Record Instance. This hook should
+   * be used to teardown any custom record instances instantiated
+   * with `instantiateRecord`.
+   *
+   * @method teardownRecord (hook)
+   * @public
+   * @param record
+   */
   teardownRecord(record: DSModel | RecordInstance): void {
     if (HAS_MODEL_PACKAGE) {
       assert(
@@ -324,8 +379,20 @@ class Store extends Service {
     }
   }
 
+  /**
+   * Provides access to the SchemaDefinitionService instance
+   * for this Store instance.
+   *
+   * The SchemaDefinitionService can be used to query for
+   * information about the schema of a resource.
+   *
+   * @method getSchemaDefinitionService
+   * @public
+   */
   getSchemaDefinitionService(): SchemaDefinitionService {
     if (HAS_MODEL_PACKAGE && !this._schemaDefinitionService) {
+      // 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.
       this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
     }
     assert(
@@ -335,6 +402,57 @@ class Store extends Service {
     return this._schemaDefinitionService;
   }
 
+  /**
+   * Allows an app to register a custom SchemaDefinitionService
+   * for use when information about a resource's schema needs
+   * to be queried.
+   *
+   * This method can only be called more than once, but only one schema
+   * definition service may exist. Therefore if you wish to chain services
+   * you must lookup the existing service and close over it with the new
+   * service by calling `getSchemaDefinitionService` prior to registration.
+   *
+   * For Example:
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   *
+   * class SchemaDelegator {
+   *   constructor(schema) {
+   *     this._schema = schema;
+   *   }
+   *
+   *   doesTypeExist(type: string): boolean {
+   *     if (AbstractSchemas.has(type)) {
+   *       return true;
+   *     }
+   *     return this._schema.doesTypeExist(type);
+   *   }
+   *
+   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+   *     return this._schema.attributesDefinitionFor(identifier);
+   *   }
+   *
+   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+   *     const schema = AbstractSchemas.get(identifier.type);
+   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
+   *   }
+   * }
+   *
+   * export default class extends Store {
+   *   constructor(...args) {
+   *     super(...args);
+   *
+   *     const schema = this.getSchemaDefinitionService();
+   *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
+   *   }
+   * }
+   * ```
+   *
+   * @method registerSchemaDefinitionService
+   * @param {SchemaDefinitionService} schema
+   * @public
+   */
   registerSchemaDefinitionService(schema: SchemaDefinitionService) {
     this._schemaDefinitionService = schema;
   }
@@ -345,6 +463,12 @@ class Store extends Service {
     When used with Model from @ember-data/model the return is the model class,
     but this is not guaranteed.
 
+    If looking to query attribute or relationship information it is
+    recommended to use `getSchemaDefinitionService` instead. This method
+    should be considered legacy and exists primarily to continue to support
+    Adapter/Serializer APIs which expect it's return value in their method
+    signatures.
+
     The class of a model might be useful if you want to get a list of all the
     relationship names of the model, see
     [`relationshipNames`](/ember-data/release/classes/Model?anchor=relationshipNames)
@@ -367,10 +491,6 @@ class Store extends Service {
     );
     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
@@ -439,8 +559,9 @@ class Store extends Service {
     //   of record-arrays via ember's run loop, not our own.
     //
     //   to remove this, we would need to move to a new `async` API.
-    return emberBackburner.join(() => {
-      return this._backburner.join(() => {
+    let record!: RecordInstance;
+    emberBackburner.join(() => {
+      this._join(() => {
         let normalizedModelName = normalizeModelName(modelName);
         let properties = { ...inputProperties };
 
@@ -461,17 +582,33 @@ class Store extends Service {
 
         // Coerce ID to a string
         properties.id = coerceId(properties.id);
+        const resource = { type: normalizedModelName, id: properties.id };
 
-        const factory = internalModelFactoryFor(this);
-        const internalModel = factory.build({ type: normalizedModelName, id: properties.id });
-        const { identifier } = internalModel;
+        if (resource.id) {
+          const identifier = this.identifierCache.peekRecordIdentifier(resource as ResourceIdentifierObject);
 
-        this._instanceCache.getRecordData(identifier).clientDidCreate();
-        this.recordArrayManager.recordDidChange(identifier);
+          assert(
+            `The id ${properties.id} has already been used with another '${normalizedModelName}' record.`,
+            !identifier
+          );
+        }
+
+        const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
+        const recordData = this._instanceCache.getRecordData(identifier);
 
-        return this._instanceCache.getRecord(identifier, properties);
+        const createOptions = normalizeProperties(
+          this,
+          identifier,
+          properties,
+          (recordData as NonSingletonRecordDataManager).managedVersion === '1'
+        );
+        const resultProps = recordData.clientDidCreate(identifier, createOptions);
+        this.recordArrayManager.identifierAdded(identifier);
+
+        record = this._instanceCache.getRecord(identifier, resultProps);
       });
     });
+    return record;
   }
 
   /**
@@ -495,13 +632,17 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'deleteRecord');
     }
-    this._backburner.join(() => {
-      let identifier = peekRecordIdentifier(record);
-      if (identifier) {
-        let internalModel = internalModelFactoryFor(this).peek(identifier);
-        if (internalModel) {
-          internalModel.deleteRecord();
-        }
+
+    const identifier = peekRecordIdentifier(record);
+    const recordData = identifier && this._instanceCache.peek({ identifier, bucket: 'recordData' });
+    assert(`expected a recordData instance to exist for the record`, recordData);
+    this._join(() => {
+      recordData.setIsDeleted(identifier, true);
+
+      if (recordData.isNew(identifier)) {
+        run(() => {
+          this._instanceCache.unloadRecord(identifier);
+        });
       }
     });
   }
@@ -526,12 +667,9 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'unloadRecord');
     }
-    let identifier = peekRecordIdentifier(record);
+    const identifier = peekRecordIdentifier(record);
     if (identifier) {
-      let internalModel = internalModelFactoryFor(this).peek(identifier);
-      if (internalModel) {
-        internalModel.unloadRecord();
-      }
+      this._instanceCache.unloadRecord(identifier);
     }
   }
 
@@ -745,7 +883,7 @@ class Store extends Service {
     //   }
     // ]
     store.findRecord('post', 1, { reload: true }).then(function(post) {
-      post.get('revision'); // 2
+      post.revision; // 2
     });
     ```
 
@@ -783,7 +921,7 @@ class Store extends Service {
     });
 
     let blogPost = store.findRecord('post', 1).then(function(post) {
-      post.get('revision'); // 1
+      post.revision; // 1
     });
 
     // later, once adapter#findRecord resolved with
@@ -795,7 +933,7 @@ class Store extends Service {
     //   }
     // ]
 
-    blogPost.get('revision'); // 2
+    blogPost.revision; // 2
     ```
 
     If you would like to force or prevent background reloading, you can set a
@@ -983,13 +1121,12 @@ class Store extends Service {
       resource = constructResource(type, normalizedId);
     }
 
-    const internalModel = internalModelFactoryFor(this).lookup(resource);
-    const { identifier } = internalModel;
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     let promise;
     options = options || {};
 
     // if not loaded start loading
-    if (!internalModel.isLoaded) {
+    if (!this._instanceCache.recordIsLoaded(identifier)) {
       promise = this._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
 
       // Refetch if the reload option is passed
@@ -997,14 +1134,14 @@ class Store extends Service {
       assertIdentifierHasId(identifier);
       promise = this._fetchManager.scheduleFetch(identifier, options);
     } else {
-      let snapshot = this._instanceCache.createSnapshot(identifier, options);
+      let snapshot: Snapshot | null = null;
       let adapter = this.adapterFor(identifier.type);
 
       // Refetch the record if the adapter thinks the record is stale
       if (
         typeof options.reload === 'undefined' &&
         adapter.shouldReloadRecord &&
-        adapter.shouldReloadRecord(this, snapshot)
+        adapter.shouldReloadRecord(this, (snapshot = this._instanceCache.createSnapshot(identifier, options)))
       ) {
         assertIdentifierHasId(identifier);
         promise = this._fetchManager.scheduleFetch(identifier, options);
@@ -1014,7 +1151,10 @@ class Store extends Service {
           options.backgroundReload !== false &&
           (options.backgroundReload ||
             !adapter.shouldBackgroundReloadRecord ||
-            adapter.shouldBackgroundReloadRecord(this, snapshot))
+            adapter.shouldBackgroundReloadRecord(
+              this,
+              (snapshot = snapshot || this._instanceCache.createSnapshot(identifier, options))
+            ))
         ) {
           assertIdentifierHasId(identifier);
           this._fetchManager.scheduleFetch(identifier, options);
@@ -1025,7 +1165,11 @@ class Store extends Service {
       }
     }
 
-    return promiseRecord(this, promise, `DS: Store#findRecord ${identifier}`);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseRecord(this, promise);
+    }
+
+    return promise.then((identifier: StableRecordIdentifier) => this.peekRecord(identifier));
   }
 
   /**
@@ -1144,10 +1288,10 @@ class Store extends Service {
   peekRecord(identifier: ResourceIdentifierObject | string, id?: string | number): RecordInstance | null {
     if (arguments.length === 1 && isMaybeIdentifier(identifier)) {
       const stableIdentifier = this.identifierCache.peekRecordIdentifier(identifier);
-      const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
+      const isLoaded = stableIdentifier && this._instanceCache.recordIsLoaded(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;
+      return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
 
     if (DEBUG) {
@@ -1164,9 +1308,9 @@ class Store extends Service {
     const normalizedId = ensureStringId(id);
     const resource = { type, id: normalizedId };
     const stableIdentifier = this.identifierCache.peekRecordIdentifier(resource);
-    const internalModel = stableIdentifier && internalModelFactoryFor(this).peek(stableIdentifier);
+    const isLoaded = stableIdentifier && this._instanceCache.recordIsLoaded(stableIdentifier);
 
-    return internalModel && internalModel.isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
+    return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
   }
 
   /**
@@ -1184,6 +1328,7 @@ class Store extends Service {
    ```
 
     @method hasRecordForId
+    @deprecated
     @public
     @param {String} modelName
     @param {(String|Integer)} id
@@ -1211,9 +1356,7 @@ class Store extends Service {
       const resource = { type, id: trueId };
 
       const identifier = this.identifierCache.peekRecordIdentifier(resource);
-      const internalModel = identifier && internalModelFactoryFor(this).peek(identifier);
-
-      return !!internalModel && internalModel.isLoaded;
+      return Boolean(identifier && this._instanceCache.recordIsLoaded(identifier));
     }
     assert(`store.hasRecordForId has been removed`);
   }
@@ -1257,8 +1400,8 @@ class Store extends Service {
     decoded: "/api/v1/person?ids[]=1&ids[]=2&ids[]=3"
     ```
 
-    This method returns a promise, which is resolved with an
-    [`AdapterPopulatedRecordArray`](/ember-data/release/classes/AdapterPopulatedRecordArray)
+    This method returns a promise, which is resolved with a
+    [`Collection`](/ember-data/release/classes/Collection)
     once the server returns.
 
     @since 1.13.0
@@ -1269,7 +1412,7 @@ class Store extends Service {
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
     @return {Promise} promise
   */
-  query(modelName: string, query, options): PromiseArray<RecordInstance, AdapterPopulatedRecordArray> {
+  query(modelName: string, query, options): PromiseArray<RecordInstance, Collection> | Promise<Collection> {
     if (DEBUG) {
       assertDestroyingStore(this, 'query');
     }
@@ -1303,9 +1446,12 @@ class Store extends Service {
       query,
       recordArray,
       adapterOptionsWrapper
-    ) as unknown as Promise<AdapterPopulatedRecordArray>;
+    ) as unknown as Promise<Collection>;
 
-    return promiseArray(queryPromise);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray(queryPromise);
+    }
+    return queryPromise;
   }
 
   /**
@@ -1336,8 +1482,8 @@ class Store extends Service {
 
     ```javascript
     store.queryRecord('user', {}).then(function(user) {
-      let username = user.get('username');
-      console.log(`Currently logged in as ${username}`);
+      let username = user.username;
+      // do thing
     });
     ```
 
@@ -1374,9 +1520,9 @@ class Store extends Service {
 
     ```javascript
     store.query('user', { username: 'unique' }).then(function(users) {
-      return users.get('firstObject');
+      return users.firstObject;
     }).then(function(user) {
-      let id = user.get('id');
+      let id = user.id;
     });
     ```
 
@@ -1394,7 +1540,7 @@ class Store extends Service {
 
     ```javascript
     store.queryRecord('user', { username: 'unique' }).then(function(user) {
-      console.log(user); // null
+       // user is null
     });
     ```
 
@@ -1406,7 +1552,11 @@ class Store 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> | Promise<RecordInstance | null> {
     if (DEBUG) {
       assertDestroyingStore(this, 'queryRecord');
     }
@@ -1439,7 +1589,10 @@ class Store extends Service {
       adapterOptionsWrapper
     ) as Promise<StableRecordIdentifier | null>;
 
-    return promiseObject(promise.then((identifier) => identifier && this.peekRecord(identifier)));
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseObject(promise.then((identifier) => identifier && this.peekRecord(identifier)));
+    }
+    return promise.then((identifier) => identifier && this.peekRecord(identifier));
   }
 
   /**
@@ -1633,7 +1786,7 @@ class Store extends Service {
   findAll(
     modelName: string,
     options: { reload?: boolean; backgroundReload?: boolean } = {}
-  ): PromiseArray<RecordInstance, RecordArray> {
+  ): PromiseArray<RecordInstance, IdentifierArray> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
@@ -1659,7 +1812,7 @@ class Store extends Service {
       array.isUpdating = true;
       fetch = _findAll(adapter, this, normalizedModelName, options);
     } else {
-      let snapshotArray = array._createSnapshot(options);
+      let snapshotArray = new SnapshotRecordArray(this, array, options);
 
       if (options.reload !== false) {
         if (
@@ -1667,7 +1820,7 @@ class Store extends Service {
           (!adapter.shouldReloadAll && snapshotArray.length === 0)
         ) {
           array.isUpdating = true;
-          fetch = _findAll(adapter, this, modelName, options);
+          fetch = _findAll(adapter, this, modelName, options, snapshotArray);
         }
       }
 
@@ -1680,14 +1833,17 @@ class Store extends Service {
           adapter.shouldBackgroundReloadAll(this, snapshotArray)
         ) {
           array.isUpdating = true;
-          _findAll(adapter, this, modelName, options);
+          _findAll(adapter, this, modelName, options, snapshotArray);
         }
 
         fetch = resolve(array);
       }
     }
 
-    return promiseArray(fetch);
+    if (DEPRECATE_PROMISE_PROXIES) {
+      return promiseArray(fetch);
+    }
+    return fetch;
   }
 
   /**
@@ -1715,7 +1871,7 @@ class Store extends Service {
     @param {String} modelName
     @return {RecordArray}
   */
-  peekAll(modelName) {
+  peekAll(modelName: string): IdentifierArray {
     if (DEBUG) {
       assertDestroyingStore(this, 'peekAll');
     }
@@ -1724,8 +1880,9 @@ class Store extends Service {
       `Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`,
       typeof modelName === 'string'
     );
-    let normalizedModelName = normalizeModelName(modelName);
-    return this.recordArrayManager.liveRecordArrayFor(normalizedModelName);
+
+    let type = normalizeModelName(modelName);
+    return this.recordArrayManager.liveArrayFor(type);
   }
 
   /**
@@ -1752,45 +1909,29 @@ class Store extends Service {
       !modelName || typeof modelName === 'string'
     );
 
-    const factory = internalModelFactoryFor(this);
-
-    if (modelName === undefined) {
-      factory.clear();
-    } else {
-      let normalizedModelName = normalizeModelName(modelName);
-      factory.clear(normalizedModelName);
-    }
-  }
-
-  /**
-    This method is called once the promise returned by an
-    adapter's `createRecord`, `updateRecord` or `deleteRecord`
-    is rejected with a `InvalidError`.
-
-    @method recordWasInvalid
-    @private
-    @deprecated
-    @param {InternalModel} internalModel
-    @param {Object} errors
-  */
-  recordWasInvalid(internalModel, parsedErrors, error) {
-    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' },
+    this._join(() => {
+      if (modelName === undefined) {
+        // destroy the graph before unloadAll
+        // since then we avoid churning relationships
+        // during unload
+        if (HAS_RECORD_DATA_PACKAGE) {
+          const peekGraph = (
+            importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+          ).peekGraph;
+          let graph = peekGraph(this);
+          if (graph) {
+            graph.identifiers.clear();
+          }
         }
-      );
-      if (DEBUG) {
-        assertDestroyingStore(this, 'recordWasInvalid');
+        this._notificationManager.destroy();
+
+        this.recordArrayManager.clear();
+        this._instanceCache.clear();
+      } else {
+        let normalizedModelName = normalizeModelName(modelName);
+        this._instanceCache.clear(normalizedModelName);
       }
-      internalModel.adapterDidInvalidate(parsedErrors, error);
-    }
-    assert(`store.recordWasInvalid has been removed`);
+    });
   }
 
   /**
@@ -1972,19 +2113,20 @@ class Store extends Service {
     @method _push
     @private
     @param {Object} jsonApiDoc
-    @return {InternalModel|Array<InternalModel>} pushed InternalModel(s)
+    @return {StableRecordIdentifier|Array<StableRecordIdentifier>} identifiers for the primary records that had data loaded
   */
   _push(jsonApiDoc): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null {
     if (DEBUG) {
       assertDestroyingStore(this, '_push');
     }
-    let identifiers = this._backburner.join(() => {
+    let ret;
+    this._join(() => {
       let included = jsonApiDoc.included;
       let i, length;
 
       if (included) {
         for (i = 0, length = included.length; i < length; i++) {
-          this._instanceCache._load(included[i]);
+          this._instanceCache.loadData(included[i]);
         }
       }
 
@@ -1993,13 +2135,15 @@ class Store extends Service {
         let identifiers = new Array(length);
 
         for (i = 0; i < length; i++) {
-          identifiers[i] = this._instanceCache._load(jsonApiDoc.data[i]);
+          identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
         }
-        return identifiers;
+        ret = identifiers;
+        return;
       }
 
       if (jsonApiDoc.data === null) {
-        return null;
+        ret = null;
+        return;
       }
 
       assert(
@@ -2009,11 +2153,11 @@ class Store extends Service {
         typeof jsonApiDoc.data === 'object'
       );
 
-      return this._instanceCache._load(jsonApiDoc.data);
+      ret = this._instanceCache.loadData(jsonApiDoc.data);
+      return;
     });
 
-    // this typecast is necessary because `backburner.join` is mistyped to return void
-    return identifiers;
+    return ret;
   }
 
   /**
@@ -2108,41 +2252,47 @@ class Store extends Service {
     return this._instanceCache.createSnapshot(recordIdentifierFor(record)).serialize(options);
   }
 
-  // todo @runspired this should likely be publicly @documented for custom records
+  /**
+   * Trigger a save for a Record.
+   *
+   * @method saveRecord
+   * @public
+   * @param {RecordInstance} record
+   * @param options
+   * @returns {Promise<RecordInstance>}
+   */
   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 = identifier && internalModelFactoryFor(this).peek(identifier)!;
+    let recordData = identifier && this._instanceCache.peek({ identifier, bucket: 'recordData' });
 
-    if (!internalModel) {
+    if (!recordData) {
       // 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
-
     assert(
       `Cannot initiate a save request for an unloaded record: ${identifier}`,
-      !internalModel.isEmpty && !internalModel.isDestroyed
+      recordData && this._instanceCache.recordIsLoaded(identifier)
     );
-    if (internalModel._isRecordFullyDeleted()) {
+    if (recordDataIsFullyDeleted(this._instanceCache, identifier)) {
       return resolve(record);
     }
 
-    internalModel.adapterWillCommit();
+    recordData.willCommit(identifier);
+    if (isDSModel(record)) {
+      record.errors.clear();
+    }
 
     if (!options) {
       options = {};
     }
-    let recordData = this._instanceCache.getRecordData(identifier);
     let operation: 'createRecord' | 'deleteRecord' | 'updateRecord' = 'updateRecord';
 
-    // TODO handle missing isNew
-    if (recordData.isNew && recordData.isNew()) {
+    if (recordData.isNew(identifier)) {
       operation = 'createRecord';
-    } else if (recordData.isDeleted && recordData.isDeleted()) {
+    } else if (recordData.isDeleted(identifier)) {
       operation = 'deleteRecord';
     }
 
@@ -2162,7 +2312,7 @@ class Store extends Service {
         have an outer run loop available still from the first
         call to `store._push`;
        */
-        this._backburner.join(() => {
+        this._join(() => {
           if (DEBUG) {
             assertDestroyingStore(this, 'saveRecord');
           }
@@ -2170,19 +2320,24 @@ class Store extends Service {
           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
+              `Your ${identifier.type} 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.`,
+              identifier.id
             );
           }
 
           const cache = this.identifierCache;
+          let actualIdentifier = identifier;
           if (operation !== 'deleteRecord' && data) {
-            cache.updateRecordIdentifier(identifier, data);
+            actualIdentifier = 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);
+          const recordData = this._instanceCache.getRecordData(actualIdentifier);
+          recordData.didCommit(identifier, data);
+
+          if (operation === 'deleteRecord') {
+            this.recordArrayManager.identifierRemoved(actualIdentifier);
+          }
 
           if (payload && payload.included) {
             this._push({ data: null, included: payload.included });
@@ -2191,12 +2346,14 @@ class Store extends Service {
         return record;
       },
       (e) => {
-        if (typeof e === 'string') {
-          throw e;
+        let err = e;
+        if (!e) {
+          err = new Error(`Unknown Error Occurred During Request`);
+        } else if (typeof e === 'string') {
+          err = new Error(e);
         }
-        const { error, parsedErrors } = e;
-        internalModel.adapterDidInvalidate(parsedErrors, error);
-        throw error;
+        adapterDidInvalidate(this, identifier, err);
+        throw err;
       }
     );
   }
@@ -2205,19 +2362,15 @@ class Store extends Service {
    * Instantiation hook allowing applications or addons to configure the store
    * to utilize a custom RecordData implementation.
    *
-   * @method createRecordDataFor
+   * @method createRecordDataFor (hook)
    * @public
-   * @param modelName
-   * @param id
-   * @param clientId
+   * @param identifier
    * @param storeWrapper
    */
   createRecordDataFor(
-    modelName: string,
-    id: string | null,
-    clientId: string,
+    identifier: StableRecordIdentifier,
     storeWrapper: RecordDataStoreWrapper
-  ): RecordData {
+  ): RecordData | RecordDataV1 {
     if (HAS_RECORD_DATA_PACKAGE) {
       // we can't greedily use require as this causes
       // a cycle we can't easily fix (or clearly pin point) at present.
@@ -2227,15 +2380,33 @@ class Store extends Service {
       if (_RecordData === undefined) {
         _RecordData = (
           importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-        ).RecordData as RecordDataConstruct;
+        ).RecordData;
       }
 
-      let identifier = this.identifierCache.getOrCreateRecordIdentifier({
-        type: modelName,
-        id,
-        lid: clientId,
-      });
-      return new _RecordData(identifier, storeWrapper);
+      if (DEPRECATE_V1CACHE_STORE_APIS && arguments.length === 4) {
+        deprecate(
+          `Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createRecordDataFor(<identifier>, <storeWrapper>)`,
+          false,
+          {
+            id: 'ember-data:deprecate-v1cache-store-apis',
+            for: 'ember-data',
+            until: '5.0',
+            since: { enabled: '4.8', available: '4.8' },
+          }
+        );
+        identifier = this.identifierCache.getOrCreateRecordIdentifier({
+          type: arguments[0],
+          id: arguments[1],
+          lid: arguments[2],
+        });
+        storeWrapper = arguments[3];
+      }
+
+      this.__private_singleton_recordData = this.__private_singleton_recordData || new _RecordData(storeWrapper);
+      (
+        this.__private_singleton_recordData as RecordData & { createCache(identifier: StableRecordIdentifier): void }
+      ).createCache(identifier);
+      return this.__private_singleton_recordData;
     }
 
     assert(`Expected store.createRecordDataFor to be implemented but it wasn't`);
@@ -2440,22 +2611,8 @@ class Store extends Service {
   willDestroy() {
     super.willDestroy();
     this.recordArrayManager.destroy();
-
     this.identifierCache.destroy();
 
-    // destroy the graph before unloadAll
-    // since then we avoid churning relationships
-    // during unload
-    if (HAS_RECORD_DATA_PACKAGE) {
-      const peekGraph = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).peekGraph;
-      let graph = peekGraph(this);
-      if (graph) {
-        graph.willDestroy();
-      }
-    }
-
     this.unloadAll();
 
     if (DEBUG) {
@@ -2509,3 +2666,205 @@ export function assertIdentifierHasId(
 ): asserts identifier is StableExistingRecordIdentifier {
   assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
 }
+
+function isDSModel(record: RecordInstance | null): record is DSModel {
+  return (
+    HAS_MODEL_PACKAGE &&
+    !!record &&
+    'constructor' in record &&
+    'isModel' in record.constructor &&
+    record.constructor.isModel === true
+  );
+}
+
+type AdapterErrors = Error & { errors?: unknown[]; isAdapterError?: true; code?: string };
+type SerializerWithParseErrors = MinimumSerializerInterface & {
+  extractErrors?(store: Store, modelClass: ShimModelClass, error: AdapterErrors, recordId: string | null): any;
+};
+
+function adapterDidInvalidate(
+  store: Store,
+  identifier: StableRecordIdentifier,
+  error: Error & { errors?: JsonApiValidationError[]; isAdapterError?: true; code?: string }
+) {
+  if (error && error.isAdapterError === true && error.code === 'InvalidError') {
+    let serializer = store.serializerFor(identifier.type) as SerializerWithParseErrors;
+
+    // TODO @deprecate extractErrors being called
+    // TODO remove extractErrors from the default serializers.
+    if (serializer && typeof serializer.extractErrors === 'function') {
+      let errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
+      error.errors = errorsHashToArray(errorsHash);
+    }
+  }
+  const recordData = store._instanceCache.getRecordData(identifier);
+
+  if (error.errors) {
+    assert(
+      `Expected the RecordData implementation for ${identifier} to have a getErrors(identifier) method for retreiving errors.`,
+      typeof recordData.getErrors === 'function'
+    );
+
+    let jsonApiErrors: JsonApiValidationError[] = error.errors;
+    if (jsonApiErrors.length === 0) {
+      jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];
+    }
+    recordData.commitWasRejected(identifier, jsonApiErrors);
+  } else {
+    recordData.commitWasRejected(identifier);
+  }
+}
+
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const PRIMARY_ATTRIBUTE_KEY = 'base';
+
+function errorsHashToArray(errors): JsonApiValidationError[] {
+  const out: JsonApiValidationError[] = [];
+
+  if (errors) {
+    Object.keys(errors).forEach((key) => {
+      let messages = makeArray(errors[key]);
+      for (let i = 0; i < messages.length; i++) {
+        let title = 'Invalid Attribute';
+        let pointer = `/data/attributes/${key}`;
+        if (key === PRIMARY_ATTRIBUTE_KEY) {
+          title = 'Invalid Document';
+          pointer = `/data`;
+        }
+        out.push({
+          title: title,
+          detail: messages[i],
+          source: {
+            pointer: pointer,
+          },
+        });
+      }
+    });
+  }
+
+  return out;
+}
+
+function normalizeProperties(
+  store: Store,
+  identifier: StableRecordIdentifier,
+  properties?: { [key: string]: unknown },
+  isForV1: boolean = false
+): { [key: string]: unknown } | undefined {
+  // assert here
+  if (properties !== undefined) {
+    if ('id' in properties) {
+      assert(`expected id to be a string or null`, properties.id !== undefined);
+    }
+    assert(
+      `You passed '${typeof properties}' as properties for record creation instead of an object.`,
+      typeof properties === 'object' && properties !== null
+    );
+
+    const { type } = identifier;
+
+    // convert relationship Records to RecordDatas before passing to RecordData
+    let defs = store.getSchemaDefinitionService().relationshipsDefinitionFor({ type });
+
+    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] as RecordInstance[]);
+            }
+            relationshipValue = extractIdentifiersFromRecords(properties[prop] as RecordInstance[], isForV1);
+          } else {
+            relationshipValue = extractIdentifierFromRecord(properties[prop] as RecordInstance, isForV1);
+          }
+
+          properties[prop] = relationshipValue;
+        }
+      }
+    }
+  }
+  return properties;
+}
+
+function assertRecordsPassedToHasMany(records: RecordInstance[]) {
+  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
+  assert(
+    `All elements of a hasMany relationship must be instances of Model, you passed ${records
+      .map((r) => `${typeof r}`)
+      .join(', ')}`,
+    (function () {
+      return records.every((record) => {
+        try {
+          recordIdentifierFor(record);
+          return true;
+        } catch {
+          return false;
+        }
+      });
+    })()
+  );
+}
+
+function extractIdentifiersFromRecords(records: RecordInstance[], isForV1: boolean = false): StableRecordIdentifier[] {
+  return records.map((record) => extractIdentifierFromRecord(record, isForV1)) as StableRecordIdentifier[];
+}
+
+type PromiseProxyRecord = { then(): void; content: RecordInstance | null | undefined };
+
+function extractIdentifierFromRecord(
+  recordOrPromiseRecord: PromiseProxyRecord | RecordInstance | null,
+  isForV1: boolean = false
+) {
+  if (!recordOrPromiseRecord) {
+    return null;
+  }
+  const extract = isForV1 ? recordDataFor : recordIdentifierFor;
+
+  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
+    let content = recordOrPromiseRecord.content;
+    assert(
+      'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
+      content !== undefined
+    );
+    deprecate(
+      `You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`,
+      false,
+      {
+        id: 'ember-data:deprecate-promise-proxies',
+        until: '5.0',
+        since: {
+          enabled: '4.8',
+          available: '4.8',
+        },
+        for: 'ember-data',
+      }
+    );
+    return content ? extract(content) : null;
+  }
+
+  return extract(recordOrPromiseRecord);
+}
+
+function isPromiseRecord(record: PromiseProxyRecord | RecordInstance): record is PromiseProxyRecord {
+  return !!record.then;
+}
+
+function secretInit(
+  record: RecordInstance,
+  recordData: RecordData,
+  identifier: StableRecordIdentifier,
+  store: Store
+): void {
+  setRecordIdentifier(record, identifier);
+  StoreMap.set(record, store);
+  setRecordDataFor(record, recordData);
+}