@ember-data/store 4.4.0-alpha.9 → 4.4.1

package/addon/-private/system/core-store.ts

@@ -13,14 +13,19 @@ 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 require from 'require';
+import { all, default as RSVP, Promise, 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 {
+  BelongsToRelationship,
+  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 { DSModel } from '../ts-interfaces/ds-model';
 import type {
   CollectionResourceDocument,
   EmptyResourceDocument,
@@ -34,12 +39,11 @@ import type {
   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 { PromiseProxy } from '../ts-interfaces/promise-proxies';
 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 { AttributesSchema } 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';
@@ -58,10 +62,8 @@ import {
 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 RecordArrayManager from './record-array-manager';
-import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { setRecordDataFor } from './record-data-for';
 import NotificationManager from './record-notification-manager';
 import type { BelongsToReference, HasManyReference } from './references';
@@ -82,6 +84,7 @@ let _RecordData: RecordDataConstruct | undefined;
 
 const { ENV } = Ember;
 type AsyncTrackingToken = Readonly<{ label: string; trace: Error | string }>;
+type PromiseArray<T> = Promise<T[]>;
 
 const RECORD_REFERENCES = new WeakCache<StableRecordIdentifier, RecordReference>(DEBUG ? 'reference' : '');
 
@@ -93,11 +96,6 @@ function freeze<T>(obj: T): T {
   return obj;
 }
 
-export interface CreateRecordProperties {
-  id?: string | null;
-  [key: string]: unknown;
-}
-
 /**
   The store contains all of the data for records loaded from the server.
   It is also responsible for creating instances of `Model` that wrap
@@ -174,31 +172,36 @@ export interface CreateRecordProperties {
 
 abstract class CoreStore extends Service {
   /**
-   * Ember Data uses several specialized micro-queues for organizing
-    and coalescing similar async work.
-
-    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;
+  public _backburner: Backburner = edBackburner;
+  public recordArrayManager: RecordArrayManager = new RecordArrayManager({ store: this });
 
   declare _notificationManager: NotificationManager;
   declare identifierCache: IdentifierCache;
-  declare _adapterCache: Dict<MinimumAdapterInterface & { store: CoreStore }>;
-  declare _serializerCache: Dict<MinimumSerializerInterface & { store: CoreStore }>;
-  declare _storeWrapper: RecordDataStoreWrapper;
+  private _adapterCache = Object.create(null);
+  private _serializerCache = Object.create(null);
+  public _storeWrapper = new RecordDataStoreWrapper(this);
+
+  /*
+    Ember Data uses several specialized micro-queues for organizing
+    and coalescing similar async work.
+
+    These queues are currently controlled by a flush scheduled into
+    ember-data's custom backburner instance.
+    */
+  // used for coalescing internal model updates
+  private _updatedInternalModels: InternalModel[] = [];
+
   declare _fetchManager: FetchManager;
   declare _schemaDefinitionService: SchemaDefinitionService;
 
   // DEBUG-only properties
   declare _trackedAsyncRequests: AsyncTrackingToken[];
-  declare shouldTrackAsyncRequests: boolean;
-  declare generateStackTracesForTrackedRequests: boolean;
+  shouldTrackAsyncRequests: boolean = false;
+  generateStackTracesForTrackedRequests: boolean = false;
   declare _trackAsyncRequestStart: (str: string) => void;
   declare _trackAsyncRequestEnd: (token: AsyncTrackingToken) => void;
   declare __asyncWaiter: () => boolean;
@@ -249,11 +252,6 @@ abstract class CoreStore extends Service {
   */
   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);
@@ -392,14 +390,19 @@ abstract class CoreStore extends Service {
     recordDataFor: (identifier: RecordIdentifier) => RecordDataRecordWrapper,
     notificationManager: NotificationManager
   ): RecordInstance;
+
   abstract teardownRecord(record: RecordInstance): void;
-  abstract getSchemaDefinitionService(): SchemaDefinitionService;
 
+  _internalDeleteRecord(internalModel: InternalModel) {
+    internalModel.deleteRecord();
+  }
+
+  // FeatureFlagged in the DSModelStore claas
   _attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
     return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);
   }
 
-  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }) {
     return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
   }
 
@@ -407,6 +410,11 @@ abstract class CoreStore extends Service {
     this._schemaDefinitionService = schema;
   }
 
+  getSchemaDefinitionService(): SchemaDefinitionService {
+    return this._schemaDefinitionService;
+  }
+
+  // TODO Double check this return value is correct
   _relationshipMetaFor(modelName: string, id: string | null, key: string) {
     return this._relationshipsDefinitionFor({ type: modelName })[key];
   }
@@ -491,7 +499,7 @@ abstract class CoreStore extends Service {
       newly created record.
     @return {Model} record
   */
-  createRecord(modelName: string, inputProperties: CreateRecordProperties): RecordInstance {
+  createRecord(modelName, inputProperties) {
     if (DEBUG) {
       assertDestroyingStore(this, 'createRecord');
     }
@@ -545,7 +553,7 @@ abstract class CoreStore extends Service {
     @param {Object} properties from the new record
     @return {String} if the adapter can generate one, an ID
   */
-  _generateId(modelName: string, properties: CreateRecordProperties): string | null {
+  _generateId(modelName, properties) {
     let adapter = this.adapterFor(modelName);
 
     if (adapter && adapter.generateIdForRecord) {
@@ -576,7 +584,7 @@ abstract class CoreStore extends Service {
     @public
     @param {Model} record
   */
-  deleteRecord(record: RecordInstance): void {
+  deleteRecord(record) {
     if (DEBUG) {
       assertDestroyingStore(this, 'deleteRecord');
     }
@@ -607,7 +615,7 @@ abstract class CoreStore extends Service {
     @public
     @param {Model} record
   */
-  unloadRecord(record: RecordInstance): void {
+  unloadRecord(record) {
     if (DEBUG) {
       assertDestroyingStore(this, 'unloadRecord');
     }
@@ -632,7 +640,7 @@ abstract class CoreStore extends Service {
     @return {Promise} promise
     @private
   */
-  find(modelName: string, id: string | number, options?): PromiseObject<RecordInstance> {
+  find(modelName, id, options) {
     if (DEBUG) {
       assertDestroyingStore(this, 'find');
     }
@@ -1031,13 +1039,13 @@ abstract class CoreStore extends Service {
     @param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
     @return {Promise} promise
   */
-  findRecord(resource: string, id: string | number, options?: FindOptions): PromiseObject<RecordInstance>;
-  findRecord(resource: ResourceIdentifierObject, id?: FindOptions): PromiseObject<RecordInstance>;
+  findRecord(resource: string, id: string | number, options?: FindOptions): PromiseProxy<DSModel>;
+  findRecord(resource: ResourceIdentifierObject, id?: FindOptions): PromiseProxy<DSModel>;
   findRecord(
     resource: string | ResourceIdentifierObject,
     id?: string | number | FindOptions,
     options?: FindOptions
-  ): PromiseObject<RecordInstance> {
+  ): PromiseProxy<DSModel> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findRecord');
     }
@@ -1062,10 +1070,7 @@ abstract class CoreStore extends Service {
     options = options || {};
 
     if (!internalModel.currentState.isLoaded) {
-      return promiseRecord(
-        this._findByInternalModel(internalModel, options),
-        `DS: Store#findRecord ${internalModel.identifier}`
-      );
+      return this._findByInternalModel(internalModel, options);
     }
 
     let fetchedInternalModel = this._findRecord(internalModel, options);
@@ -1073,7 +1078,7 @@ abstract class CoreStore extends Service {
     return promiseRecord(fetchedInternalModel, `DS: Store#findRecord ${internalModel.identifier}`);
   }
 
-  _findRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
+  _findRecord(internalModel: InternalModel, options: FindOptions) {
     // Refetch if the reload option is passed
     if (options.reload) {
       return this._scheduleFetch(internalModel, options);
@@ -1092,7 +1097,7 @@ abstract class CoreStore extends Service {
     }
 
     if (options.backgroundReload === false) {
-      return resolve(internalModel);
+      return Promise.resolve(internalModel);
     }
 
     // Trigger the background refetch if backgroundReload option is passed
@@ -1105,20 +1110,25 @@ abstract class CoreStore extends Service {
     }
 
     // Return the cached record
-    return resolve(internalModel);
+    return Promise.resolve(internalModel);
   }
 
-  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}): Promise<InternalModel> {
+  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}) {
     if (options.preload) {
       this._backburner.join(() => {
         internalModel.preloadData(options.preload);
       });
     }
 
-    return this._findEmptyInternalModel(internalModel, options);
+    let fetchedInternalModel = this._findEmptyInternalModel(internalModel, options);
+
+    return promiseRecord(
+      fetchedInternalModel,
+      `DS: Store#findRecord ${internalModel.modelName} with id: ${internalModel.id}`
+    );
   }
 
-  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
+  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions) {
     if (internalModel.currentState.isEmpty) {
       return this._scheduleFetch(internalModel, options);
     }
@@ -1126,12 +1136,12 @@ abstract class CoreStore extends Service {
     if (internalModel.currentState.isLoading) {
       let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
       if (pendingRequest) {
-        return pendingRequest.then(() => resolve(internalModel));
+        return pendingRequest.then(() => Promise.resolve(internalModel));
       }
       return this._scheduleFetch(internalModel, options);
     }
 
-    return resolve(internalModel);
+    return Promise.resolve(internalModel);
   }
 
   /**
@@ -1172,10 +1182,10 @@ abstract class CoreStore extends Service {
       fetches[i] = this._scheduleFetch(internalModels[i], options);
     }
 
-    return all(fetches);
+    return Promise.all(fetches);
   }
 
-  _scheduleFetch(internalModel: InternalModel, options = {}): Promise<InternalModel> {
+  _scheduleFetch(internalModel: InternalModel, options = {}): RSVP.Promise<InternalModel> {
     let generateStackTrace = this.generateStackTracesForTrackedRequests;
     // TODO  remove this once we don't rely on state machine
     internalModel.send('loadingData');
@@ -1366,7 +1376,7 @@ abstract class CoreStore extends Service {
     @param options optional to include adapterOptions
     @return {Promise} promise
   */
-  _reloadRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
+  _reloadRecord(internalModel, options): RSVP.Promise<InternalModel> {
     options.isReloading = true;
     let { id, modelName } = internalModel;
     let adapter = this.adapterFor(modelName);
@@ -1375,7 +1385,7 @@ abstract class CoreStore extends Service {
     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'
+      typeof adapter.findRecord === 'function' || typeof adapter.find === 'function'
     );
 
     return this._scheduleFetch(internalModel, options);
@@ -1462,7 +1472,7 @@ abstract class CoreStore extends Service {
       finds[i] = this._findEmptyInternalModel(internalModels[i], options);
     }
 
-    return all(finds);
+    return Promise.all(finds);
   }
 
   /**
@@ -1504,12 +1514,12 @@ abstract class CoreStore extends Service {
   _findHasManyByJsonApiResource(
     resource,
     parentInternalModel: InternalModel,
-    relationship: ManyRelationship,
-    options?: Dict<unknown>
-  ): Promise<void | unknown[]> {
+    relationship: ManyRelationship | BelongsToRelationship,
+    options: any
+  ): RSVP.Promise<unknown> {
     if (HAS_RECORD_DATA_PACKAGE) {
       if (!resource) {
-        return resolve();
+        return resolve([]);
       }
       const { definition, state } = relationship;
       let adapter = this.adapterFor(definition.type);
@@ -1554,7 +1564,7 @@ abstract class CoreStore extends Service {
 
       // we were explicitly told we have no data and no links.
       //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-      return resolve();
+      return resolve([]);
     }
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
@@ -1567,7 +1577,7 @@ abstract class CoreStore extends Service {
     @param {Relationship} relationship
     @return {Promise} promise
   */
-  findBelongsTo(internalModel, link, relationship, options): Promise<InternalModel> {
+  findBelongsTo(internalModel, link, relationship, options) {
     if (DEBUG) {
       assertDestroyingStore(this, 'findBelongsTo');
     }
@@ -1585,25 +1595,19 @@ abstract class CoreStore extends Service {
     return _findBelongsTo(adapter, this, internalModel, link, relationship, options);
   }
 
-  _fetchBelongsToLinkFromResource(
-    resource,
-    parentInternalModel: InternalModel,
-    relationshipMeta,
-    options
-  ): Promise<InternalModel | null> {
+  _fetchBelongsToLinkFromResource(resource, parentInternalModel, relationshipMeta, options) {
     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);
+    return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options).then(
+      (internalModel) => {
+        return internalModel ? internalModel.getRecord() : null;
+      }
+    );
   }
 
-  _findBelongsToByJsonApiResource(
-    resource,
-    parentInternalModel: InternalModel,
-    relationshipMeta,
-    options
-  ): Promise<InternalModel | null> {
+  _findBelongsToByJsonApiResource(resource, parentInternalModel, relationshipMeta, options) {
     if (!resource) {
       return resolve(null);
     }
@@ -1622,7 +1626,7 @@ abstract class CoreStore extends Service {
       // short circuit if we are already loading
       let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
       if (pendingRequest) {
-        return pendingRequest.then(() => internalModel);
+        return pendingRequest.then(() => internalModel.getRecord());
       }
     }
 
@@ -1655,12 +1659,14 @@ abstract class CoreStore extends Service {
     let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
 
     if (internalModel && resourceIsLocal) {
-      return resolve(internalModel);
+      return resolve(internalModel.getRecord());
     }
 
     // fetch by data
     if (internalModel && !localDataIsEmpty) {
-      return this._scheduleFetch(internalModel, options);
+      return this._scheduleFetch(internalModel, options).then(() => {
+        return internalModel.getRecord();
+      });
     }
 
     // we were explicitly told we have no data and no links.
@@ -1719,7 +1725,7 @@ abstract class CoreStore 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<DSModel> {
     if (DEBUG) {
       assertDestroyingStore(this, 'query');
     }
@@ -1737,10 +1743,10 @@ abstract class CoreStore extends Service {
     }
 
     let normalizedModelName = normalizeModelName(modelName);
-    return promiseArray(this._query(normalizedModelName, query, null, adapterOptionsWrapper));
+    return this._query(normalizedModelName, query, null, adapterOptionsWrapper);
   }
 
-  _query(modelName: string, query, array, options): Promise<AdapterPopulatedRecordArray> {
+  _query(modelName: string, query, array, options): PromiseArray<DSModel> {
     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(
@@ -1756,7 +1762,7 @@ abstract class CoreStore extends Service {
       typeof adapter.query === 'function'
     );
 
-    return _query(adapter, this, modelName, query, array, options) as unknown as Promise<AdapterPopulatedRecordArray>;
+    return promiseArray(_query(adapter, this, modelName, query, array, options));
   }
 
   /**
@@ -1857,7 +1863,7 @@ 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, query, options) {
     if (DEBUG) {
       assertDestroyingStore(this, 'queryRecord');
     }
@@ -1882,17 +1888,15 @@ abstract class CoreStore extends Service {
       typeof adapter.queryRecord === 'function'
     );
 
-    const promise: Promise<InternalModel | null> = _queryRecord(
-      adapter,
-      this,
-      normalizedModelName,
-      query,
-      adapterOptionsWrapper
-    ) as Promise<InternalModel | null>;
-
     return promiseObject(
-      promise.then((internalModel: InternalModel | null) => {
-        return internalModel ? internalModel.getRecord() : null;
+      _queryRecord(adapter, this, normalizedModelName, query, adapterOptionsWrapper).then((internalModel) => {
+        // the promise returned by store.queryRecord is expected to resolve with
+        // an instance of Model
+        if (internalModel) {
+          return internalModel.getRecord();
+        }
+
+        return null;
       })
     );
   }
@@ -2085,10 +2089,7 @@ abstract class CoreStore extends Service {
     @param {Object} options
     @return {Promise} promise
   */
-  findAll(
-    modelName: string,
-    options: { reload?: boolean; backgroundReload?: boolean } = {}
-  ): PromiseArray<RecordInstance, RecordArray> {
+  findAll(modelName, options) {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
@@ -2101,7 +2102,7 @@ abstract class CoreStore extends Service {
     let normalizedModelName = normalizeModelName(modelName);
     let fetch = this._fetchAll(normalizedModelName, this.peekAll(normalizedModelName), options);
 
-    return promiseArray(fetch);
+    return fetch;
   }
 
   /**
@@ -2111,11 +2112,7 @@ abstract class CoreStore extends Service {
     @param {RecordArray} array
     @return {Promise} promise
   */
-  _fetchAll(
-    modelName: string,
-    array: RecordArray,
-    options: { reload?: boolean; backgroundReload?: boolean }
-  ): Promise<RecordArray> {
+  _fetchAll(modelName, array, options: { reload?: boolean; backgroundReload?: boolean } = {}) {
     let adapter = this.adapterFor(modelName);
 
     assert(`You tried to load all records but you have no adapter (for ${modelName})`, adapter);
@@ -2126,7 +2123,7 @@ abstract class CoreStore extends Service {
 
     if (options.reload) {
       set(array, 'isUpdating', true);
-      return _findAll(adapter, this, modelName, options);
+      return promiseArray(_findAll(adapter, this, modelName, options));
     }
 
     let snapshotArray = array._createSnapshot(options);
@@ -2137,12 +2134,12 @@ abstract class CoreStore extends Service {
         (!adapter.shouldReloadAll && snapshotArray.length === 0)
       ) {
         set(array, 'isUpdating', true);
-        return _findAll(adapter, this, modelName, options);
+        return promiseArray(_findAll(adapter, this, modelName, options));
       }
     }
 
     if (options.backgroundReload === false) {
-      return resolve(array);
+      return promiseArray(Promise.resolve(array));
     }
 
     if (
@@ -2154,7 +2151,7 @@ abstract class CoreStore extends Service {
       _findAll(adapter, this, modelName, options);
     }
 
-    return resolve(array);
+    return promiseArray(Promise.resolve(array));
   }
 
   /**
@@ -2162,7 +2159,7 @@ abstract class CoreStore extends Service {
     @param {String} modelName
     @private
   */
-  _didUpdateAll(modelName: string): void {
+  _didUpdateAll(modelName) {
     this.recordArrayManager._didUpdateAll(modelName);
   }
 
@@ -2261,11 +2258,7 @@ abstract class CoreStore extends Service {
     @param {Resolver} resolver
     @param {Object} options
   */
-  scheduleSave(
-    internalModel: InternalModel,
-    resolver: RSVP.Deferred<void>,
-    options: FindOptions
-  ): void | Promise<void> {
+  scheduleSave(internalModel: InternalModel, resolver: RSVP.Deferred<void>, options): void | RSVP.Promise<void> {
     if (internalModel._isRecordFullyDeleted()) {
       resolver.resolve();
       return resolver.promise;
@@ -2286,8 +2279,9 @@ abstract class CoreStore extends Service {
       operation = 'deleteRecord';
     }
 
-    const saveOptions = Object.assign({ [SaveOp]: operation }, options);
-    let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, saveOptions);
+    options[SaveOp] = operation;
+
+    let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, options);
     let promise = fetchManagerPromise.then(
       (payload) => {
         /*
@@ -2828,6 +2822,10 @@ abstract class CoreStore extends Service {
     serializer.pushPayload(this, payload);
   }
 
+  reloadManyArray(manyArray, internalModel, key, options) {
+    return internalModel.reloadHasMany(key, options);
+  }
+
   reloadBelongsTo(belongsToProxy, internalModel, key, options) {
     return internalModel.reloadBelongsTo(key, options);
   }
@@ -2854,13 +2852,13 @@ abstract class CoreStore extends Service {
     return internalModel!.createSnapshot(options).serialize(options);
   }
 
-  saveRecord(record: RecordInstance, options?: Dict<unknown>): Promise<RecordInstance> {
+  saveRecord(record: RecordInstance, options?: Dict<unknown>): RSVP.Promise<RecordInstance> {
     let identifier = recordIdentifierFor(record);
     let internalModel = internalModelFactoryFor(this).peek(identifier);
     // 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);
+    return (internalModel!.save(options) as RSVP.Promise<void>).then(() => record);
   }
 
   relationshipReferenceFor(identifier: RecordIdentifier, key: string): BelongsToReference | HasManyReference {
@@ -2910,9 +2908,7 @@ abstract class CoreStore extends Service {
       // it can be reproduced in partner tests by running
       // node ./scripts/packages-for-commit.js && yarn test-external:ember-observer
       if (_RecordData === undefined) {
-        _RecordData = (
-          importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-        ).RecordData as RecordDataConstruct;
+        _RecordData = require('@ember-data/record-data/-private').RecordData as RecordDataConstruct;
       }
 
       let identifier = this.identifierCache.getOrCreateRecordIdentifier({
@@ -2970,7 +2966,7 @@ abstract class CoreStore extends Service {
     @param {Object} payload
     @return {Object} The normalized payload
   */
-  normalize(modelName: string, payload) {
+  normalize(modelName, payload) {
     if (DEBUG) {
       assertDestroyingStore(this, 'normalize');
     }
@@ -2986,7 +2982,7 @@ abstract class CoreStore extends Service {
     let model = this.modelFor(normalizedModelName);
     assert(
       `You must define a normalize method in your serializer in order to call store.normalize`,
-      serializer?.normalize
+      serializer.normalize
     );
     return serializer.normalize(model, payload);
   }
@@ -3100,7 +3096,7 @@ abstract class CoreStore extends Service {
     @param {String} modelName the record to serialize
     @return {Serializer}
   */
-  serializerFor(modelName: string): MinimumSerializerInterface | null {
+  serializerFor(modelName) {
     if (DEBUG) {
       assertDestroyingStore(this, 'serializerFor');
     }
@@ -3136,29 +3132,30 @@ abstract class CoreStore extends Service {
       return serializer;
     }
 
-    return null;
+    assert(
+      `No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`,
+      serializer !== undefined
+    );
   }
 
   destroy() {
     // enqueue destruction of any adapters/serializers we have created
     for (let adapterName in this._adapterCache) {
-      let adapter = this._adapterCache[adapterName]!;
+      let adapter = this._adapterCache[adapterName];
       if (typeof adapter.destroy === 'function') {
         adapter.destroy();
       }
     }
 
     for (let serializerName in this._serializerCache) {
-      let serializer = this._serializerCache[serializerName]!;
+      let serializer = this._serializerCache[serializerName];
       if (typeof serializer.destroy === 'function') {
         serializer.destroy();
       }
     }
 
     if (HAS_RECORD_DATA_PACKAGE) {
-      const peekGraph = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).peekGraph;
+      const peekGraph = require('@ember-data/record-data/-private').peekGraph;
       let graph = peekGraph(this);
       if (graph) {
         graph.destroy();
@@ -3178,9 +3175,7 @@ abstract class CoreStore extends Service {
     // 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;
+      const peekGraph = require('@ember-data/record-data/-private').peekGraph;
       let graph = peekGraph(this);
       if (graph) {
         graph.willDestroy();
@@ -3214,6 +3209,24 @@ abstract class CoreStore extends Service {
       }
     }
   }
+
+  _updateInternalModel(internalModel: InternalModel) {
+    if (this._updatedInternalModels.push(internalModel) !== 1) {
+      return;
+    }
+
+    emberBackburner.schedule('actions', this, this._flushUpdatedInternalModels);
+  }
+
+  _flushUpdatedInternalModels() {
+    let updated = this._updatedInternalModels;
+
+    for (let i = 0, l = updated.length; i < l; i++) {
+      updated[i]._triggerDeferredTriggers();
+    }
+
+    updated.length = 0;
+  }
 }
 
 export default CoreStore;