@ember-data/store 4.4.0-beta.1 → 4.5.0-alpha.1

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

@@ -13,19 +13,14 @@ import { isNone, isPresent, typeOf } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 import Ember from 'ember';
 
-import require from 'require';
-import { all, default as RSVP, Promise, resolve } from 'rsvp';
+import { importSync } from '@embroider/macros';
+import { all, default as RSVP, resolve } from 'rsvp';
 
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
-import type {
-  BelongsToRelationship,
-  ManyRelationship,
-  RecordData as RecordDataClass,
-} from '@ember-data/record-data/-private';
+import type { ManyRelationship, RecordData as RecordDataClass } from '@ember-data/record-data/-private';
 import type { RelationshipState } from '@ember-data/record-data/-private/graph/-state';
 
 import { IdentifierCache } from '../identifiers/cache';
-import type { DSModel } from '../ts-interfaces/ds-model';
 import type {
   CollectionResourceDocument,
   EmptyResourceDocument,
@@ -39,11 +34,12 @@ import type {
   StableExistingRecordIdentifier,
   StableRecordIdentifier,
 } from '../ts-interfaces/identifier';
-import type { PromiseProxy } from '../ts-interfaces/promise-proxies';
+import { MinimumAdapterInterface } from '../ts-interfaces/minimum-adapter-interface';
+import type { MinimumSerializerInterface } from '../ts-interfaces/minimum-serializer-interface';
 import type { RecordData } from '../ts-interfaces/record-data';
 import type { JsonApiRelationship } from '../ts-interfaces/record-data-json-api';
 import type { RecordDataRecordWrapper } from '../ts-interfaces/record-data-record-wrapper';
-import type { AttributesSchema } from '../ts-interfaces/record-data-schemas';
+import type { AttributesSchema, RelationshipsSchema } from '../ts-interfaces/record-data-schemas';
 import type { RecordInstance } from '../ts-interfaces/record-instance';
 import type { SchemaDefinitionService } from '../ts-interfaces/schema-definition-service';
 import type { FindOptions } from '../ts-interfaces/store';
@@ -62,8 +58,10 @@ 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';
@@ -84,7 +82,6 @@ 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' : '');
 
@@ -96,6 +93,11 @@ 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
@@ -172,36 +174,31 @@ function freeze<T>(obj: T): T {
 
 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
    */
-  public _backburner: Backburner = edBackburner;
-  public recordArrayManager: RecordArrayManager = new RecordArrayManager({ store: this });
+  declare _backburner: Backburner;
+  declare recordArrayManager: RecordArrayManager;
 
   declare _notificationManager: NotificationManager;
   declare identifierCache: IdentifierCache;
-  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 _adapterCache: Dict<MinimumAdapterInterface & { store: CoreStore }>;
+  declare _serializerCache: Dict<MinimumSerializerInterface & { store: CoreStore }>;
+  declare _storeWrapper: RecordDataStoreWrapper;
   declare _fetchManager: FetchManager;
   declare _schemaDefinitionService: SchemaDefinitionService;
 
   // DEBUG-only properties
   declare _trackedAsyncRequests: AsyncTrackingToken[];
-  shouldTrackAsyncRequests: boolean = false;
-  generateStackTracesForTrackedRequests: boolean = false;
+  declare shouldTrackAsyncRequests: boolean;
+  declare generateStackTracesForTrackedRequests: boolean;
   declare _trackAsyncRequestStart: (str: string) => void;
   declare _trackAsyncRequestEnd: (token: AsyncTrackingToken) => void;
   declare __asyncWaiter: () => boolean;
@@ -252,6 +249,11 @@ 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);
@@ -390,19 +392,14 @@ 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 }) {
+  _relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
     return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);
   }
 
@@ -410,11 +407,6 @@ 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];
   }
@@ -499,7 +491,7 @@ abstract class CoreStore extends Service {
       newly created record.
     @return {Model} record
   */
-  createRecord(modelName, inputProperties) {
+  createRecord(modelName: string, inputProperties: CreateRecordProperties): RecordInstance {
     if (DEBUG) {
       assertDestroyingStore(this, 'createRecord');
     }
@@ -553,7 +545,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, properties) {
+  _generateId(modelName: string, properties: CreateRecordProperties): string | null {
     let adapter = this.adapterFor(modelName);
 
     if (adapter && adapter.generateIdForRecord) {
@@ -584,7 +576,7 @@ abstract class CoreStore extends Service {
     @public
     @param {Model} record
   */
-  deleteRecord(record) {
+  deleteRecord(record: RecordInstance): void {
     if (DEBUG) {
       assertDestroyingStore(this, 'deleteRecord');
     }
@@ -615,7 +607,7 @@ abstract class CoreStore extends Service {
     @public
     @param {Model} record
   */
-  unloadRecord(record) {
+  unloadRecord(record: RecordInstance): void {
     if (DEBUG) {
       assertDestroyingStore(this, 'unloadRecord');
     }
@@ -640,7 +632,7 @@ abstract class CoreStore extends Service {
     @return {Promise} promise
     @private
   */
-  find(modelName, id, options) {
+  find(modelName: string, id: string | number, options?): PromiseObject<RecordInstance> {
     if (DEBUG) {
       assertDestroyingStore(this, 'find');
     }
@@ -1039,13 +1031,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): PromiseProxy<DSModel>;
-  findRecord(resource: ResourceIdentifierObject, id?: FindOptions): PromiseProxy<DSModel>;
+  findRecord(resource: string, id: string | number, options?: FindOptions): PromiseObject<RecordInstance>;
+  findRecord(resource: ResourceIdentifierObject, id?: FindOptions): PromiseObject<RecordInstance>;
   findRecord(
     resource: string | ResourceIdentifierObject,
     id?: string | number | FindOptions,
     options?: FindOptions
-  ): PromiseProxy<DSModel> {
+  ): PromiseObject<RecordInstance> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findRecord');
     }
@@ -1070,7 +1062,10 @@ abstract class CoreStore extends Service {
     options = options || {};
 
     if (!internalModel.currentState.isLoaded) {
-      return this._findByInternalModel(internalModel, options);
+      return promiseRecord(
+        this._findByInternalModel(internalModel, options),
+        `DS: Store#findRecord ${internalModel.identifier}`
+      );
     }
 
     let fetchedInternalModel = this._findRecord(internalModel, options);
@@ -1078,7 +1073,7 @@ abstract class CoreStore extends Service {
     return promiseRecord(fetchedInternalModel, `DS: Store#findRecord ${internalModel.identifier}`);
   }
 
-  _findRecord(internalModel: InternalModel, options: FindOptions) {
+  _findRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
     // Refetch if the reload option is passed
     if (options.reload) {
       return this._scheduleFetch(internalModel, options);
@@ -1097,7 +1092,7 @@ abstract class CoreStore extends Service {
     }
 
     if (options.backgroundReload === false) {
-      return Promise.resolve(internalModel);
+      return resolve(internalModel);
     }
 
     // Trigger the background refetch if backgroundReload option is passed
@@ -1110,25 +1105,20 @@ abstract class CoreStore extends Service {
     }
 
     // Return the cached record
-    return Promise.resolve(internalModel);
+    return resolve(internalModel);
   }
 
-  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}) {
+  _findByInternalModel(internalModel: InternalModel, options: FindOptions = {}): Promise<InternalModel> {
     if (options.preload) {
       this._backburner.join(() => {
         internalModel.preloadData(options.preload);
       });
     }
 
-    let fetchedInternalModel = this._findEmptyInternalModel(internalModel, options);
-
-    return promiseRecord(
-      fetchedInternalModel,
-      `DS: Store#findRecord ${internalModel.modelName} with id: ${internalModel.id}`
-    );
+    return this._findEmptyInternalModel(internalModel, options);
   }
 
-  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions) {
+  _findEmptyInternalModel(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
     if (internalModel.currentState.isEmpty) {
       return this._scheduleFetch(internalModel, options);
     }
@@ -1136,12 +1126,12 @@ abstract class CoreStore extends Service {
     if (internalModel.currentState.isLoading) {
       let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);
       if (pendingRequest) {
-        return pendingRequest.then(() => Promise.resolve(internalModel));
+        return pendingRequest.then(() => resolve(internalModel));
       }
       return this._scheduleFetch(internalModel, options);
     }
 
-    return Promise.resolve(internalModel);
+    return resolve(internalModel);
   }
 
   /**
@@ -1182,10 +1172,10 @@ abstract class CoreStore extends Service {
       fetches[i] = this._scheduleFetch(internalModels[i], options);
     }
 
-    return Promise.all(fetches);
+    return all(fetches);
   }
 
-  _scheduleFetch(internalModel: InternalModel, options = {}): RSVP.Promise<InternalModel> {
+  _scheduleFetch(internalModel: InternalModel, options = {}): Promise<InternalModel> {
     let generateStackTrace = this.generateStackTracesForTrackedRequests;
     // TODO  remove this once we don't rely on state machine
     internalModel.send('loadingData');
@@ -1376,7 +1366,7 @@ abstract class CoreStore extends Service {
     @param options optional to include adapterOptions
     @return {Promise} promise
   */
-  _reloadRecord(internalModel, options): RSVP.Promise<InternalModel> {
+  _reloadRecord(internalModel: InternalModel, options: FindOptions): Promise<InternalModel> {
     options.isReloading = true;
     let { id, modelName } = internalModel;
     let adapter = this.adapterFor(modelName);
@@ -1385,7 +1375,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.find === 'function'
+      typeof adapter.findRecord === 'function'
     );
 
     return this._scheduleFetch(internalModel, options);
@@ -1472,7 +1462,7 @@ abstract class CoreStore extends Service {
       finds[i] = this._findEmptyInternalModel(internalModels[i], options);
     }
 
-    return Promise.all(finds);
+    return all(finds);
   }
 
   /**
@@ -1514,12 +1504,12 @@ abstract class CoreStore extends Service {
   _findHasManyByJsonApiResource(
     resource,
     parentInternalModel: InternalModel,
-    relationship: ManyRelationship | BelongsToRelationship,
-    options: any
-  ): RSVP.Promise<unknown> {
+    relationship: ManyRelationship,
+    options?: Dict<unknown>
+  ): Promise<void | unknown[]> {
     if (HAS_RECORD_DATA_PACKAGE) {
       if (!resource) {
-        return resolve([]);
+        return resolve();
       }
       const { definition, state } = relationship;
       let adapter = this.adapterFor(definition.type);
@@ -1564,7 +1554,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`);
   }
@@ -1577,7 +1567,7 @@ abstract class CoreStore extends Service {
     @param {Relationship} relationship
     @return {Promise} promise
   */
-  findBelongsTo(internalModel, link, relationship, options) {
+  findBelongsTo(internalModel, link, relationship, options): Promise<InternalModel> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findBelongsTo');
     }
@@ -1595,19 +1585,25 @@ abstract class CoreStore extends Service {
     return _findBelongsTo(adapter, this, internalModel, link, relationship, options);
   }
 
-  _fetchBelongsToLinkFromResource(resource, parentInternalModel, relationshipMeta, options) {
+  _fetchBelongsToLinkFromResource(
+    resource,
+    parentInternalModel: InternalModel,
+    relationshipMeta,
+    options
+  ): Promise<InternalModel | null> {
     if (!resource || !resource.links || !resource.links.related) {
       // should we warn here, not sure cause its an internal method
       return resolve(null);
     }
-    return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options).then(
-      (internalModel) => {
-        return internalModel ? internalModel.getRecord() : null;
-      }
-    );
+    return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options);
   }
 
-  _findBelongsToByJsonApiResource(resource, parentInternalModel, relationshipMeta, options) {
+  _findBelongsToByJsonApiResource(
+    resource,
+    parentInternalModel: InternalModel,
+    relationshipMeta,
+    options
+  ): Promise<InternalModel | null> {
     if (!resource) {
       return resolve(null);
     }
@@ -1626,7 +1622,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.getRecord());
+        return pendingRequest.then(() => internalModel);
       }
     }
 
@@ -1659,14 +1655,12 @@ abstract class CoreStore extends Service {
     let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
 
     if (internalModel && resourceIsLocal) {
-      return resolve(internalModel.getRecord());
+      return resolve(internalModel);
     }
 
     // fetch by data
     if (internalModel && !localDataIsEmpty) {
-      return this._scheduleFetch(internalModel, options).then(() => {
-        return internalModel.getRecord();
-      });
+      return this._scheduleFetch(internalModel, options);
     }
 
     // we were explicitly told we have no data and no links.
@@ -1725,7 +1719,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<DSModel> {
+  query(modelName: string, query, options): PromiseArray<RecordInstance, AdapterPopulatedRecordArray> {
     if (DEBUG) {
       assertDestroyingStore(this, 'query');
     }
@@ -1743,10 +1737,10 @@ abstract class CoreStore extends Service {
     }
 
     let normalizedModelName = normalizeModelName(modelName);
-    return this._query(normalizedModelName, query, null, adapterOptionsWrapper);
+    return promiseArray(this._query(normalizedModelName, query, null, adapterOptionsWrapper));
   }
 
-  _query(modelName: string, query, array, options): PromiseArray<DSModel> {
+  _query(modelName: string, query, array, options): Promise<AdapterPopulatedRecordArray> {
     assert(`You need to pass a model name to the store's query method`, isPresent(modelName));
     assert(`You need to pass a query hash to the store's query method`, query);
     assert(
@@ -1762,7 +1756,7 @@ abstract class CoreStore extends Service {
       typeof adapter.query === 'function'
     );
 
-    return promiseArray(_query(adapter, this, modelName, query, array, options));
+    return _query(adapter, this, modelName, query, array, options) as unknown as Promise<AdapterPopulatedRecordArray>;
   }
 
   /**
@@ -1863,7 +1857,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, query, options) {
+  queryRecord(modelName: string, query, options): PromiseObject<RecordInstance | null> {
     if (DEBUG) {
       assertDestroyingStore(this, 'queryRecord');
     }
@@ -1888,15 +1882,17 @@ abstract class CoreStore extends Service {
       typeof adapter.queryRecord === 'function'
     );
 
-    return promiseObject(
-      _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();
-        }
+    const promise: Promise<InternalModel | null> = _queryRecord(
+      adapter,
+      this,
+      normalizedModelName,
+      query,
+      adapterOptionsWrapper
+    ) as Promise<InternalModel | null>;
 
-        return null;
+    return promiseObject(
+      promise.then((internalModel: InternalModel | null) => {
+        return internalModel ? internalModel.getRecord() : null;
       })
     );
   }
@@ -2089,7 +2085,10 @@ abstract class CoreStore extends Service {
     @param {Object} options
     @return {Promise} promise
   */
-  findAll(modelName, options) {
+  findAll(
+    modelName: string,
+    options: { reload?: boolean; backgroundReload?: boolean } = {}
+  ): PromiseArray<RecordInstance, RecordArray> {
     if (DEBUG) {
       assertDestroyingStore(this, 'findAll');
     }
@@ -2102,7 +2101,7 @@ abstract class CoreStore extends Service {
     let normalizedModelName = normalizeModelName(modelName);
     let fetch = this._fetchAll(normalizedModelName, this.peekAll(normalizedModelName), options);
 
-    return fetch;
+    return promiseArray(fetch);
   }
 
   /**
@@ -2112,7 +2111,11 @@ abstract class CoreStore extends Service {
     @param {RecordArray} array
     @return {Promise} promise
   */
-  _fetchAll(modelName, array, options: { reload?: boolean; backgroundReload?: boolean } = {}) {
+  _fetchAll(
+    modelName: string,
+    array: RecordArray,
+    options: { reload?: boolean; backgroundReload?: boolean }
+  ): Promise<RecordArray> {
     let adapter = this.adapterFor(modelName);
 
     assert(`You tried to load all records but you have no adapter (for ${modelName})`, adapter);
@@ -2123,7 +2126,7 @@ abstract class CoreStore extends Service {
 
     if (options.reload) {
       set(array, 'isUpdating', true);
-      return promiseArray(_findAll(adapter, this, modelName, options));
+      return _findAll(adapter, this, modelName, options);
     }
 
     let snapshotArray = array._createSnapshot(options);
@@ -2134,12 +2137,12 @@ abstract class CoreStore extends Service {
         (!adapter.shouldReloadAll && snapshotArray.length === 0)
       ) {
         set(array, 'isUpdating', true);
-        return promiseArray(_findAll(adapter, this, modelName, options));
+        return _findAll(adapter, this, modelName, options);
       }
     }
 
     if (options.backgroundReload === false) {
-      return promiseArray(Promise.resolve(array));
+      return resolve(array);
     }
 
     if (
@@ -2151,7 +2154,7 @@ abstract class CoreStore extends Service {
       _findAll(adapter, this, modelName, options);
     }
 
-    return promiseArray(Promise.resolve(array));
+    return resolve(array);
   }
 
   /**
@@ -2159,7 +2162,7 @@ abstract class CoreStore extends Service {
     @param {String} modelName
     @private
   */
-  _didUpdateAll(modelName) {
+  _didUpdateAll(modelName: string): void {
     this.recordArrayManager._didUpdateAll(modelName);
   }
 
@@ -2258,7 +2261,11 @@ abstract class CoreStore extends Service {
     @param {Resolver} resolver
     @param {Object} options
   */
-  scheduleSave(internalModel: InternalModel, resolver: RSVP.Deferred<void>, options): void | RSVP.Promise<void> {
+  scheduleSave(
+    internalModel: InternalModel,
+    resolver: RSVP.Deferred<void>,
+    options: FindOptions
+  ): void | Promise<void> {
     if (internalModel._isRecordFullyDeleted()) {
       resolver.resolve();
       return resolver.promise;
@@ -2279,9 +2286,8 @@ abstract class CoreStore extends Service {
       operation = 'deleteRecord';
     }
 
-    options[SaveOp] = operation;
-
-    let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, options);
+    const saveOptions = Object.assign({ [SaveOp]: operation }, options);
+    let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, saveOptions);
     let promise = fetchManagerPromise.then(
       (payload) => {
         /*
@@ -2430,6 +2436,7 @@ abstract class CoreStore extends Service {
     @param {Object} data
   */
   _load(data: ExistingResourceObject) {
+    // TODO this should determine identifier via the cache before making assumptions
     const resource = constructResource(normalizeModelName(data.type), ensureStringId(data.id), coerceId(data.lid));
 
     let internalModel = internalModelFactoryFor(this).lookup(resource, data);
@@ -2690,6 +2697,7 @@ abstract class CoreStore extends Service {
   }
 
   _pushInternalModel(data) {
+    // TODO type should be pulled from the identifier for debug
     let modelName = data.type;
     assert(
       `You must include an 'id' for ${modelName} in an object passed to 'push'`,
@@ -2822,10 +2830,6 @@ 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);
   }
@@ -2852,13 +2856,13 @@ abstract class CoreStore extends Service {
     return internalModel!.createSnapshot(options).serialize(options);
   }
 
-  saveRecord(record: RecordInstance, options?: Dict<unknown>): RSVP.Promise<RecordInstance> {
+  saveRecord(record: RecordInstance, options?: Dict<unknown>): 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 RSVP.Promise<void>).then(() => record);
+    return (internalModel!.save(options) as Promise<void>).then(() => record);
   }
 
   relationshipReferenceFor(identifier: RecordIdentifier, key: string): BelongsToReference | HasManyReference {
@@ -2908,7 +2912,9 @@ 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 = require('@ember-data/record-data/-private').RecordData as RecordDataConstruct;
+        _RecordData = (
+          importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+        ).RecordData as RecordDataConstruct;
       }
 
       let identifier = this.identifierCache.getOrCreateRecordIdentifier({
@@ -2966,7 +2972,7 @@ abstract class CoreStore extends Service {
     @param {Object} payload
     @return {Object} The normalized payload
   */
-  normalize(modelName, payload) {
+  normalize(modelName: string, payload) {
     if (DEBUG) {
       assertDestroyingStore(this, 'normalize');
     }
@@ -2982,7 +2988,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);
   }
@@ -3096,7 +3102,7 @@ abstract class CoreStore extends Service {
     @param {String} modelName the record to serialize
     @return {Serializer}
   */
-  serializerFor(modelName) {
+  serializerFor(modelName: string): MinimumSerializerInterface | null {
     if (DEBUG) {
       assertDestroyingStore(this, 'serializerFor');
     }
@@ -3132,30 +3138,29 @@ abstract class CoreStore extends Service {
       return serializer;
     }
 
-    assert(
-      `No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`,
-      serializer !== undefined
-    );
+    return null;
   }
 
   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 = require('@ember-data/record-data/-private').peekGraph;
+      const peekGraph = (
+        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+      ).peekGraph;
       let graph = peekGraph(this);
       if (graph) {
         graph.destroy();
@@ -3175,7 +3180,9 @@ abstract class CoreStore extends Service {
     // since then we avoid churning relationships
     // during unload
     if (HAS_RECORD_DATA_PACKAGE) {
-      const peekGraph = require('@ember-data/record-data/-private').peekGraph;
+      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();
@@ -3209,24 +3216,6 @@ 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;