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

package/addon/-private/store-service.ts

@@ -4,7 +4,6 @@
 import { getOwner, setOwner } from '@ember/application';
 import { assert, deprecate } from '@ember/debug';
 import { _backburner as emberBackburner, run } from '@ember/runloop';
-import type { Backburner } from '@ember/runloop/-private/backburner';
 import Service from '@ember/service';
 import { registerWaiter, unregisterWaiter } from '@ember/test';
 import { DEBUG } from '@glimmer/env';
@@ -17,7 +16,9 @@ import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-
 import {
   DEPRECATE_HAS_RECORD,
   DEPRECATE_JSON_API_FALLBACK,
+  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';
@@ -31,15 +32,14 @@ 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 { RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
 import { JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
-import type { RecordDataWrapper } from '@ember-data/types/q/record-data-record-wrapper';
+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 { IdentifierCache } from './caches/identifier-cache';
 import {
   InstanceCache,
@@ -50,20 +50,21 @@ import {
   storeFor,
   StoreMap,
 } from './caches/instance-cache';
-import { setRecordDataFor } from './caches/record-data-for';
+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 RecordDataStoreWrapper from './managers/record-data-store-wrapper';
+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 AdapterPopulatedRecordArray from './record-arrays/adapter-populated-record-array';
-import RecordArray from './record-arrays/record-array';
+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';
@@ -164,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;
@@ -227,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;
@@ -278,41 +265,108 @@ class Store extends Service {
     }
   }
 
+  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) => RecordDataWrapper,
+    recordDataFor: (identifier: StableRecordIdentifier) => RecordData,
     notificationManager: NotificationManager
   ): DSModel | RecordInstance {
     if (HAS_MODEL_PACKAGE) {
       let modelName = identifier.type;
-      let store = this;
 
       let recordData = this._instanceCache.getRecordData(identifier);
+      // TODO deprecate allowing unknown args setting
       let createOptions: any = {
-        // 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, 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;
-      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(
@@ -325,6 +379,16 @@ 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.
@@ -338,7 +402,20 @@ 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 once and needs to be called before
+   * `getSchemaDefinitionService` is called when using `@ember-data/model`.
+   *
+   * @method registerSchemaDefinitionService
+   * @param {SchemaDefinitionService} schema
+   * @public
+   */
   registerSchemaDefinitionService(schema: SchemaDefinitionService) {
+    assert(`Cannot register a schema definition service when one already exists`, !this._schemaDefinitionService);
     this._schemaDefinitionService = schema;
   }
 
@@ -348,6 +425,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)
@@ -438,8 +521,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 };
 
@@ -473,12 +557,20 @@ class Store extends Service {
 
         const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
         const recordData = this._instanceCache.getRecordData(identifier);
-        recordData.clientDidCreate();
-        this.recordArrayManager.recordDidChange(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;
   }
 
   /**
@@ -502,26 +594,16 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'deleteRecord');
     }
-    // TODO eliminate this interleaving
-    // it is unlikely we need both an outer join and the inner run
-    // of our own queue
-    this._backburner.join(() => {
-      const identifier = peekRecordIdentifier(record);
-      if (identifier) {
-        run(() => {
-          const backburner = this._backburner;
-          backburner.run(() => {
-            const recordData = this._instanceCache.peek({ identifier, bucket: 'recordData' });
 
-            if (recordData) {
-              if (recordData?.setIsDeleted) {
-                recordData.setIsDeleted(true);
-              }
-              if (recordData.isNew?.()) {
-                this._instanceCache.unloadRecord(identifier);
-              }
-            }
-          });
+    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);
         });
       }
     });
@@ -547,7 +629,7 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, 'unloadRecord');
     }
-    let identifier = peekRecordIdentifier(record);
+    const identifier = peekRecordIdentifier(record);
     if (identifier) {
       this._instanceCache.unloadRecord(identifier);
     }
@@ -1014,14 +1096,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);
@@ -1031,7 +1113,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);
@@ -1042,7 +1127,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));
   }
 
   /**
@@ -1201,6 +1290,7 @@ class Store extends Service {
    ```
 
     @method hasRecordForId
+    @deprecated
     @public
     @param {String} modelName
     @param {(String|Integer)} id
@@ -1272,8 +1362,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
@@ -1284,7 +1374,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');
     }
@@ -1318,9 +1408,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;
   }
 
   /**
@@ -1421,7 +1514,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');
     }
@@ -1454,7 +1551,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));
   }
 
   /**
@@ -1648,7 +1748,7 @@ class Store extends Service {
   findAll(
     modelName: string,
     options: { reload?: boolean; backgroundReload?: boolean } = {}
-  ): PromiseArray<RecordInstance, RecordArray> {
+  ): PromiseArray<RecordInstance, IdentifierArray> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
@@ -1674,7 +1774,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 (
@@ -1682,7 +1782,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);
         }
       }
 
@@ -1695,14 +1795,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;
   }
 
   /**
@@ -1730,7 +1833,7 @@ class Store extends Service {
     @param {String} modelName
     @return {RecordArray}
   */
-  peekAll(modelName) {
+  peekAll(modelName: string): IdentifierArray {
     if (DEBUG) {
       assertDestroyingStore(this, 'peekAll');
     }
@@ -1739,8 +1842,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);
   }
 
   /**
@@ -1767,12 +1871,29 @@ class Store extends Service {
       !modelName || typeof modelName === 'string'
     );
 
-    if (modelName === undefined) {
-      this._instanceCache.clear();
-    } else {
-      let normalizedModelName = normalizeModelName(modelName);
-      this._instanceCache.clear(normalizedModelName);
-    }
+    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();
+          }
+        }
+        this._notificationManager.destroy();
+
+        this.recordArrayManager.clear();
+        this._instanceCache.clear();
+      } else {
+        let normalizedModelName = normalizeModelName(modelName);
+        this._instanceCache.clear(normalizedModelName);
+      }
+    });
   }
 
   /**
@@ -1960,7 +2081,8 @@ class Store extends Service {
     if (DEBUG) {
       assertDestroyingStore(this, '_push');
     }
-    let identifiers = this._backburner.join(() => {
+    let ret;
+    this._join(() => {
       let included = jsonApiDoc.included;
       let i, length;
 
@@ -1977,11 +2099,13 @@ class Store extends Service {
         for (i = 0; i < length; i++) {
           identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
         }
-        return identifiers;
+        ret = identifiers;
+        return;
       }
 
       if (jsonApiDoc.data === null) {
-        return null;
+        ret = null;
+        return;
       }
 
       assert(
@@ -1991,11 +2115,11 @@ class Store extends Service {
         typeof jsonApiDoc.data === 'object'
       );
 
-      return this._instanceCache.loadData(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;
   }
 
   /**
@@ -2090,7 +2214,15 @@ 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);
@@ -2110,7 +2242,7 @@ class Store extends Service {
       return resolve(record);
     }
 
-    recordData.willCommit();
+    recordData.willCommit(identifier);
     if (isDSModel(record)) {
       record.errors.clear();
     }
@@ -2120,9 +2252,9 @@ class Store extends Service {
     }
     let operation: 'createRecord' | 'deleteRecord' | 'updateRecord' = 'updateRecord';
 
-    if (recordData.isNew?.()) {
+    if (recordData.isNew(identifier)) {
       operation = 'createRecord';
-    } else if (recordData.isDeleted?.()) {
+    } else if (recordData.isDeleted(identifier)) {
       operation = 'deleteRecord';
     }
 
@@ -2142,7 +2274,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');
           }
@@ -2163,8 +2295,11 @@ class Store extends Service {
 
           //We first make sure the primary data has been updated
           const recordData = this._instanceCache.getRecordData(actualIdentifier);
-          recordData.didCommit(data);
-          this.recordArrayManager.recordDidChange(actualIdentifier);
+          recordData.didCommit(identifier, data);
+
+          if (operation === 'deleteRecord') {
+            this.recordArrayManager.identifierRemoved(actualIdentifier);
+          }
 
           if (payload && payload.included) {
             this._push({ data: null, included: payload.included });
@@ -2189,19 +2324,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 lid
+   * @param identifier
    * @param storeWrapper
    */
   createRecordDataFor(
-    modelName: string,
-    id: string | null,
-    lid: 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.
@@ -2214,12 +2345,30 @@ class Store extends Service {
         ).RecordData;
       }
 
-      let identifier = this.identifierCache.getOrCreateRecordIdentifier({
-        type: modelName,
-        id,
-        lid,
-      });
-      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`);
@@ -2424,12 +2573,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')
@@ -2574,3 +2719,124 @@ function errorsHashToArray(errors): JsonApiValidationError[] {
 
   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);
+}