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

package/addon/-private/system/model/internal-model.ts

@@ -5,19 +5,8 @@ import { get } from '@ember/object';
 import { _backburner as emberBackburner, cancel, run } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-import { importSync } from '@embroider/macros';
-import RSVP, { resolve } from 'rsvp';
+import RSVP, { Promise } from 'rsvp';
 
-import type { ManyArray } from '@ember-data/model/-private';
-import RecordState from '@ember-data/model/-private/record-state';
-import type { ManyArrayCreateArgs } from '@ember-data/model/-private/system/many-array';
-import type {
-  BelongsToProxyCreateArgs,
-  BelongsToProxyMeta,
-} from '@ember-data/model/-private/system/promise-belongs-to';
-import type PromiseBelongsTo from '@ember-data/model/-private/system/promise-belongs-to';
-import type { HasManyProxyCreateArgs } from '@ember-data/model/-private/system/promise-many-array';
-import type PromiseManyArray from '@ember-data/model/-private/system/promise-many-array';
 import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import type {
   BelongsToRelationship,
@@ -25,21 +14,16 @@ import type {
   RecordData as DefaultRecordData,
 } from '@ember-data/record-data/-private';
 import type { UpgradedMeta } from '@ember-data/record-data/-private/graph/-edge-definition';
-import type {
-  DefaultSingleResourceRelationship,
-  RelationshipRecordData,
-} from '@ember-data/record-data/-private/ts-interfaces/relationship-record-data';
 
-import type { DSModel } from '../../ts-interfaces/ds-model';
+import { DSModel } from '../../ts-interfaces/ds-model';
 import type { StableRecordIdentifier } from '../../ts-interfaces/identifier';
-import type { ChangedAttributesHash, RecordData } from '../../ts-interfaces/record-data';
+import type { RecordData } from '../../ts-interfaces/record-data';
 import type { JsonApiResource, JsonApiValidationError } from '../../ts-interfaces/record-data-json-api';
-import type { RelationshipSchema } from '../../ts-interfaces/record-data-schemas';
 import type { RecordInstance } from '../../ts-interfaces/record-instance';
 import type { FindOptions } from '../../ts-interfaces/store';
-import type { Dict } from '../../ts-interfaces/utils';
+import type { ConfidentDict } from '../../ts-interfaces/utils';
 import type CoreStore from '../core-store';
-import type { CreateRecordProperties } from '../core-store';
+import type Store from '../ds-model-store';
 import { errorsHashToArray } from '../errors-utils';
 import recordDataFor from '../record-data-for';
 import { BelongsToReference, HasManyReference, RecordReference } from '../references';
@@ -47,11 +31,10 @@ import Snapshot from '../snapshot';
 import { internalModelFactoryFor } from '../store/internal-model-factory';
 import RootState from './states';
 
-type PrivateModelModule = {
-  ManyArray: { create(args: ManyArrayCreateArgs): ManyArray };
-  PromiseBelongsTo: { create(args: BelongsToProxyCreateArgs): PromiseBelongsTo };
-  PromiseManyArray: new (...args: unknown[]) => PromiseManyArray;
-};
+// move to TS hacks module that we can delete when this is no longer a necessary recast
+type ManyArray = InstanceType<typeof import('@ember-data/model/-private').ManyArray>;
+type PromiseBelongsTo = InstanceType<typeof import('@ember-data/model/-private').PromiseBelongsTo>;
+type PromiseManyArray = InstanceType<typeof import('@ember-data/model/-private').PromiseManyArray>;
 
 /**
   @module @ember-data/store
@@ -59,22 +42,18 @@ type PrivateModelModule = {
 
 const { hasOwnProperty } = Object.prototype;
 
-let _ManyArray: PrivateModelModule['ManyArray'];
-let _PromiseBelongsTo: PrivateModelModule['PromiseBelongsTo'];
-let _PromiseManyArray: PrivateModelModule['PromiseManyArray'];
+let ManyArray: ManyArray;
+let PromiseBelongsTo: PromiseBelongsTo;
+let _PromiseManyArray: any; // TODO find a way to get the klass type here
 
 let _found = false;
 let _getModelPackage: () => boolean;
 if (HAS_MODEL_PACKAGE) {
   _getModelPackage = function () {
     if (!_found) {
-      let modelPackage = importSync('@ember-data/model/-private') as PrivateModelModule;
-      ({
-        ManyArray: _ManyArray,
-        PromiseBelongsTo: _PromiseBelongsTo,
-        PromiseManyArray: _PromiseManyArray,
-      } = modelPackage);
-      if (_ManyArray && _PromiseBelongsTo && _PromiseManyArray) {
+      let modelPackage = require('@ember-data/model/-private');
+      ({ ManyArray, PromiseBelongsTo, PromiseManyArray: _PromiseManyArray } = modelPackage);
+      if (ManyArray && PromiseBelongsTo && _PromiseManyArray) {
         _found = true;
       }
     }
@@ -82,6 +61,13 @@ if (HAS_MODEL_PACKAGE) {
   };
 }
 
+interface BelongsToMetaWrapper {
+  key: string;
+  store: CoreStore;
+  originatingInternalModel: InternalModel;
+  modelName: string;
+}
+
 /*
   The TransitionChainMap caches the `state.enters`, `state.setups`, and final state reached
   when transitioning from one state to another, so that future transitions can replay the
@@ -92,32 +78,18 @@ if (HAS_MODEL_PACKAGE) {
    and setups. It may also be faster to do a two level cache (from: { to }) instead of caching based
    on a key that adds the two together.
  */
-// TODO before deleting the state machine we should
-// ensure all things in this map were properly accounted for.
-// in the RecordState class.
 const TransitionChainMap = Object.create(null);
 
 const _extractPivotNameCache = Object.create(null);
 const _splitOnDotCache = Object.create(null);
 
-function splitOnDot(name: string): string[] {
+function splitOnDot(name) {
   return _splitOnDotCache[name] || (_splitOnDotCache[name] = name.split('.'));
 }
 
-function extractPivotName(name: string): string {
+function extractPivotName(name) {
   return _extractPivotNameCache[name] || (_extractPivotNameCache[name] = splitOnDot(name)[0]);
 }
-
-function isDSModel(record: RecordInstance | null): record is DSModel {
-  return (
-    HAS_MODEL_PACKAGE &&
-    !!record &&
-    'constructor' in record &&
-    'isModel' in record.constructor &&
-    record.constructor.isModel === true
-  );
-}
-
 export default class InternalModel {
   declare _id: string | null;
   declare modelName: string;
@@ -134,28 +106,25 @@ export default class InternalModel {
 
   // Not typed yet
   declare _promiseProxy: any;
-  declare _record: RecordInstance | null;
+  declare _record: any;
   declare _scheduledDestroy: any;
   declare _modelClass: any;
+  declare _deferredTriggers: any;
   declare __recordArrays: any;
   declare references: any;
   declare _recordReference: RecordReference;
-  declare _manyArrayCache: Dict<ManyArray>;
+  declare _manyArrayCache: ConfidentDict<ManyArray>;
 
-  declare _relationshipPromisesCache: Dict<Promise<ManyArray | RecordInstance>>;
-  declare _relationshipProxyCache: Dict<PromiseManyArray | PromiseBelongsTo>;
+  declare _relationshipPromisesCache: ConfidentDict<RSVP.Promise<any>>;
+  declare _relationshipProxyCache: ConfidentDict<PromiseManyArray | PromiseBelongsTo>;
   declare error: any;
-  declare currentState: RecordState;
+  declare currentState: any;
   declare _previousState: any;
-  declare store: CoreStore;
-  declare identifier: StableRecordIdentifier;
 
-  constructor(store: CoreStore, identifier: StableRecordIdentifier) {
+  constructor(public store: CoreStore | Store, public identifier: StableRecordIdentifier) {
     if (HAS_MODEL_PACKAGE) {
       _getModelPackage();
     }
-    this.store = store;
-    this.identifier = identifier;
     this._id = identifier.id;
     this._isUpdatingId = false;
     this.modelName = identifier.type;
@@ -194,6 +163,7 @@ export default class InternalModel {
     this._relationshipPromisesCache = Object.create(null);
     this._relationshipProxyCache = Object.create(null);
     this.references = Object.create(null);
+    this._deferredTriggers = [];
     this.currentState = RootState.empty;
   }
 
@@ -286,27 +256,15 @@ export default class InternalModel {
     }
   }
 
-  getRecord(properties?: CreateRecordProperties): RecordInstance {
-    let record = this._record;
-
-    if (this._isDematerializing) {
-      // TODO we should assert here instead of this return.
-      return null as unknown as RecordInstance;
-    }
-
-    if (!record) {
+  getRecord(properties?): Object {
+    if (!this._record && !this._isDematerializing) {
       let { store } = this;
 
-      record = this._record = store._instantiateRecord(
-        this,
-        this.modelName,
-        this._recordData,
-        this.identifier,
-        properties
-      );
+      this._record = store._instantiateRecord(this, this.modelName, this._recordData, this.identifier, properties);
+      this._triggerDeferredTriggers();
     }
 
-    return record;
+    return this._record;
   }
 
   dematerializeRecord() {
@@ -330,11 +288,9 @@ export default class InternalModel {
     });
 
     if (this._record) {
-      let keys = Object.keys(this._relationshipProxyCache);
-      keys.forEach((key) => {
-        let proxy = this._relationshipProxyCache[key]!;
-        if (proxy.destroy) {
-          proxy.destroy();
+      Object.keys(this._relationshipProxyCache).forEach((key) => {
+        if (this._relationshipProxyCache[key].destroy) {
+          this._relationshipProxyCache[key].destroy();
         }
         delete this._relationshipProxyCache[key];
       });
@@ -359,6 +315,7 @@ export default class InternalModel {
           // destroyRecord follows up deleteRecord with save(). This prevents an unecessary save for a new record
           this._deletedRecordWasNew = true;
           this.send('deleteRecord');
+          this._triggerDeferredTriggers();
           this.unloadRecord();
         } else {
           this.send('deleteRecord');
@@ -367,9 +324,9 @@ export default class InternalModel {
     });
   }
 
-  save(options: FindOptions = {}): Promise<void> {
+  save(options): Promise<void> {
     if (this._deletedRecordWasNew) {
-      return resolve();
+      return Promise.resolve();
     }
     let promiseLabel = 'DS: Model#save ' + this;
     let resolver = RSVP.defer<void>(promiseLabel);
@@ -378,8 +335,22 @@ export default class InternalModel {
     return this.store.scheduleSave(this, resolver, options) as Promise<void>;
   }
 
-  reload(options: Dict<unknown> = {}): Promise<InternalModel> {
-    return this.store._reloadRecord(this, options);
+  reload(options) {
+    if (!options) {
+      options = {};
+    }
+    let internalModel = this;
+
+    return internalModel.store._reloadRecord(internalModel, options).then(
+      function () {
+        //TODO NOW seems like we shouldn't need to do this
+        return internalModel;
+      },
+      function (error) {
+        throw error;
+      },
+      'DS: Model#reload complete, update flags'
+    );
   }
 
   /*
@@ -454,32 +425,26 @@ export default class InternalModel {
     }
   }
 
-  _findBelongsTo(
-    key: string,
-    resource: DefaultSingleResourceRelationship,
-    relationshipMeta: RelationshipSchema,
-    options?: Dict<unknown>
-  ): Promise<RecordInstance | null> {
+  _findBelongsTo(key, resource, relationshipMeta, options) {
     // TODO @runspired follow up if parent isNew then we should not be attempting load here
-    // TODO @runspired follow up on whether this should be in the relationship requests cache
     return this.store._findBelongsToByJsonApiResource(resource, this, relationshipMeta, options).then(
-      (internalModel) => handleCompletedRelationshipRequest(this, key, resource._relationship, internalModel),
+      (internalModel) => handleCompletedRelationshipRequest(this, key, resource._relationship, internalModel, null),
       (e) => handleCompletedRelationshipRequest(this, key, resource._relationship, null, e)
     );
   }
 
-  getBelongsTo(key: string, options?: Dict<unknown>): PromiseBelongsTo | RecordInstance | null {
+  getBelongsTo(key, options) {
     let resource = (this._recordData as DefaultRecordData).getBelongsTo(key);
     let identifier =
       resource && resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
     let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);
-    assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
+    if (!relationshipMeta) return;
 
     let store = this.store;
     let parentInternalModel = this;
     let async = relationshipMeta.options.async;
     let isAsync = typeof async === 'undefined' ? true : async;
-    let _belongsToState: BelongsToProxyMeta = {
+    let _belongsToState: BelongsToMetaWrapper = {
       key,
       store,
       originatingInternalModel: this,
@@ -490,7 +455,7 @@ export default class InternalModel {
       let internalModel = identifier !== null ? store._internalModelForResource(identifier) : null;
 
       if (resource._relationship.state.hasFailedLoadAttempt) {
-        return this._relationshipProxyCache[key] as PromiseBelongsTo;
+        return this._relationshipProxyCache[key];
       }
 
       let promise = this._findBelongsTo(key, resource, relationshipMeta, options);
@@ -514,49 +479,49 @@ export default class InternalModel {
             "' with id " +
             parentInternalModel.id +
             ' but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`belongsTo({ async: true })`)',
-          toReturn === null || !internalModel.currentState.isEmpty
+          toReturn === null || !(toReturn as DSModel).isEmpty
         );
         return toReturn;
       }
     }
   }
 
-  getManyArray(key: string, definition?: UpgradedMeta): ManyArray {
-    assert('hasMany only works with the @ember-data/record-data package', HAS_RECORD_DATA_PACKAGE);
-    let manyArray: ManyArray | undefined = this._manyArrayCache[key];
-    if (!definition) {
-      const graphFor = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).graphFor;
-      definition = graphFor(this.store).get(this.identifier, key).definition as UpgradedMeta;
-    }
-
-    if (!manyArray) {
-      manyArray = _ManyArray.create({
-        store: this.store,
-        type: this.store.modelFor(definition.type),
-        recordData: this._recordData as RelationshipRecordData,
-        key,
-        isPolymorphic: definition.isPolymorphic,
-        isAsync: definition.isAsync,
-        _inverseIsAsync: definition.inverseIsAsync,
-        internalModel: this,
-        isLoaded: !definition.isAsync,
-      });
-      this._manyArrayCache[key] = manyArray;
-    }
+  getManyArray(key: string, definition?: UpgradedMeta) {
+    if (HAS_RECORD_DATA_PACKAGE) {
+      let manyArray = this._manyArrayCache[key];
+      if (!definition) {
+        const graphFor = require('@ember-data/record-data/-private').graphFor;
+        definition = graphFor(this.store).get(this.identifier, key).definition as UpgradedMeta;
+      }
+
+      if (!manyArray) {
+        manyArray = ManyArray.create({
+          store: this.store,
+          type: this.store.modelFor(definition.type),
+          recordData: this._recordData,
+          key,
+          isPolymorphic: definition.isPolymorphic,
+          isAsync: definition.isAsync,
+          _inverseIsAsync: definition.inverseIsAsync,
+          internalModel: this,
+          isLoaded: !definition.isAsync,
+        });
+        this._manyArrayCache[key] = manyArray;
+      }
 
-    return manyArray;
+      return manyArray;
+    }
+    assert(`hasMany only works with the @ember-data/record-data package`, HAS_RECORD_DATA_PACKAGE);
   }
 
   fetchAsyncHasMany(
     key: string,
-    relationship: ManyRelationship,
-    manyArray: ManyArray,
-    options?: Dict<unknown>
-  ): Promise<ManyArray> {
+    relationship: ManyRelationship | BelongsToRelationship,
+    manyArray,
+    options
+  ): RSVP.Promise<unknown> {
     if (HAS_RECORD_DATA_PACKAGE) {
-      let loadingPromise = this._relationshipPromisesCache[key] as Promise<ManyArray> | undefined;
+      let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
       }
@@ -564,27 +529,25 @@ export default class InternalModel {
       const jsonApi = this._recordData.getHasMany(key);
 
       loadingPromise = this.store._findHasManyByJsonApiResource(jsonApi, this, relationship, options).then(
-        () => handleCompletedRelationshipRequest(this, key, relationship, manyArray),
+        () => handleCompletedRelationshipRequest(this, key, relationship, manyArray, null),
         (e) => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e)
       );
       this._relationshipPromisesCache[key] = loadingPromise;
       return loadingPromise;
     }
-    assert('hasMany only works with the @ember-data/record-data package');
+    assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  getHasMany(key: string, options?): PromiseManyArray | ManyArray {
+  getHasMany(key: string, options?) {
     if (HAS_RECORD_DATA_PACKAGE) {
-      const graphFor = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).graphFor;
-      const relationship = graphFor(this.store).get(this.identifier, key) as ManyRelationship;
+      const graphFor = require('@ember-data/record-data/-private').graphFor;
+      const relationship = graphFor(this.store).get(this.identifier, key);
       const { definition, state } = relationship;
       let manyArray = this.getManyArray(key, definition);
 
       if (definition.isAsync) {
         if (state.hasFailedLoadAttempt) {
-          return this._relationshipProxyCache[key] as PromiseManyArray;
+          return this._relationshipProxyCache[key];
         }
 
         let promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);
@@ -602,55 +565,47 @@ export default class InternalModel {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  _updatePromiseProxyFor(kind: 'hasMany', key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
-  _updatePromiseProxyFor(kind: 'belongsTo', key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
-  _updatePromiseProxyFor(
-    kind: 'belongsTo',
-    key: string,
-    args: { promise: Promise<RecordInstance | null> }
-  ): PromiseBelongsTo;
   _updatePromiseProxyFor(
     kind: 'hasMany' | 'belongsTo',
     key: string,
-    args: BelongsToProxyCreateArgs | HasManyProxyCreateArgs | { promise: Promise<RecordInstance | null> }
-  ): PromiseBelongsTo | PromiseManyArray {
+    args: {
+      promise: RSVP.Promise<any>;
+      content?: RecordInstance | ManyArray | null;
+      _belongsToState?: BelongsToMetaWrapper;
+    }
+  ) {
     let promiseProxy = this._relationshipProxyCache[key];
     if (kind === 'hasMany') {
-      const { promise, content } = args as HasManyProxyCreateArgs;
       if (promiseProxy) {
-        assert(`Expected a PromiseManyArray`, '_update' in promiseProxy);
-        promiseProxy._update(promise, content);
+        promiseProxy._update(args.promise, args.content);
       } else {
-        promiseProxy = this._relationshipProxyCache[key] = new _PromiseManyArray(promise, content);
+        promiseProxy = this._relationshipProxyCache[key] = new _PromiseManyArray(args.promise, args.content);
       }
       return promiseProxy;
     }
     if (promiseProxy) {
-      const { promise, content } = args as BelongsToProxyCreateArgs;
-      assert(`Expected a PromiseBelongsTo`, '_belongsToState' in promiseProxy);
-
-      if (content !== undefined) {
-        promiseProxy.set('content', content);
+      if (args.content !== undefined) {
+        // this usage of `any` can be removed when `@types/ember_object` proxy allows `null` for content
+        promiseProxy.set('content', args.content as any);
       }
-      promiseProxy.set('promise', promise);
+      promiseProxy.set('promise', args.promise);
     } else {
+      const klass = PromiseBelongsTo;
       // this usage of `any` can be removed when `@types/ember_object` proxy allows `null` for content
-      this._relationshipProxyCache[key] = promiseProxy = _PromiseBelongsTo.create(args as any);
+      this._relationshipProxyCache[key] = klass.create(args as any);
     }
 
-    return promiseProxy;
+    return this._relationshipProxyCache[key];
   }
 
-  reloadHasMany(key: string, options) {
+  reloadHasMany(key, options) {
     if (HAS_RECORD_DATA_PACKAGE) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
       }
-      const graphFor = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).graphFor;
-      const relationship = graphFor(this.store).get(this.identifier, key) as ManyRelationship;
+      const graphFor = require('@ember-data/record-data/-private').graphFor;
+      const relationship = graphFor(this.store).get(this.identifier, key);
       const { definition, state } = relationship;
 
       state.hasFailedLoadAttempt = false;
@@ -667,8 +622,8 @@ export default class InternalModel {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  reloadBelongsTo(key: string, options?: Dict<unknown>): Promise<RecordInstance | null> {
-    let loadingPromise = this._relationshipPromisesCache[key] as Promise<RecordInstance | null> | undefined;
+  reloadBelongsTo(key, options) {
+    let loadingPromise = this._relationshipPromisesCache[key];
     if (loadingPromise) {
       return loadingPromise;
     }
@@ -680,7 +635,6 @@ export default class InternalModel {
       resource._relationship.state.shouldForceReload = true;
     }
     let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);
-    assert(`Attempted to reload a belongsTo relationship but no definition exists for it`, relationshipMeta);
     let promise = this._findBelongsTo(key, resource, relationshipMeta, options);
     if (this._relationshipProxyCache[key]) {
       return this._updatePromiseProxyFor('belongsTo', key, { promise });
@@ -699,7 +653,7 @@ export default class InternalModel {
   destroy() {
     assert(
       'Cannot destroy an internalModel while its record is materialized',
-      !this._record || this._record.isDestroyed || this._record.isDestroying
+      !this._record || this._record.get('isDestroyed') || this._record.get('isDestroying')
     );
     this.isDestroying = true;
     if (this._recordReference) {
@@ -708,13 +662,13 @@ export default class InternalModel {
     this._recordReference = null;
     let cache = this._manyArrayCache;
     Object.keys(cache).forEach((key) => {
-      cache[key]!.destroy();
+      cache[key].destroy();
       delete cache[key];
     });
     if (this.references) {
       cache = this.references;
       Object.keys(cache).forEach((key) => {
-        cache[key]!.destroy();
+        cache[key].destroy();
         delete cache[key];
       });
     }
@@ -724,35 +678,24 @@ export default class InternalModel {
   }
 
   setupData(data) {
-    const hasRecord = this.hasRecord;
-    if (hasRecord) {
-      let changedKeys = this._recordData.pushData(data, true);
-      this.notifyAttributes(changedKeys);
-    } else {
-      this._recordData.pushData(data);
+    let changedKeys = this._recordData.pushData(data, this.hasRecord);
+    if (this.hasRecord) {
+      // TODO @runspired should this be going through the notification manager?
+      this._record._notifyProperties(changedKeys);
     }
     this.send('pushedData');
   }
 
-  notifyAttributes(keys: string[]): void {
-    let manager = this.store._notificationManager;
-    let { identifier } = this;
-
-    for (let i = 0; i < keys.length; i++) {
-      manager.notify(identifier, 'attributes', keys[i]);
-    }
-  }
-
-  setDirtyHasMany(key: string, records) {
+  setDirtyHasMany(key, records) {
     assertRecordsPassedToHasMany(records);
     return this._recordData.setDirtyHasMany(key, extractRecordDatasFromRecords(records));
   }
 
-  setDirtyBelongsTo(key: string, value) {
+  setDirtyBelongsTo(key, value) {
     return this._recordData.setDirtyBelongsTo(key, extractRecordDataFromRecord(value));
   }
 
-  setDirtyAttribute<T>(key: string, value: T): T {
+  setDirtyAttribute(key, value) {
     if (this.isDeleted()) {
       if (DEBUG) {
         throw new EmberError(`Attempted to set '${key}' to '${value}' on the deleted record ${this}`);
@@ -774,11 +717,11 @@ export default class InternalModel {
     return value;
   }
 
-  get isDestroyed(): boolean {
+  get isDestroyed() {
     return this._isDestroyed;
   }
 
-  get hasRecord(): boolean {
+  get hasRecord() {
     return !!this._record;
   }
 
@@ -786,7 +729,7 @@ export default class InternalModel {
     return new Snapshot(options, this.identifier, this.store);
   }
 
-  hasChangedAttributes(): boolean {
+  hasChangedAttributes() {
     if (!this.__recordData) {
       // no need to calculate changed attributes when calling `findRecord`
       return false;
@@ -794,7 +737,7 @@ export default class InternalModel {
     return this._recordData.hasChangedAttributes();
   }
 
-  changedAttributes(): ChangedAttributesHash {
+  changedAttributes() {
     if (!this.__recordData) {
       // no need to calculate changed attributes when calling `findRecord`
       return {};
@@ -802,16 +745,16 @@ export default class InternalModel {
     return this._recordData.changedAttributes();
   }
 
-  adapterWillCommit(): void {
+  adapterWillCommit() {
     this._recordData.willCommit();
     this.send('willCommit');
   }
 
-  adapterDidDirty(): void {
+  adapterDidDirty() {
     this.send('becomeDirty');
   }
 
-  send(name: string, context?) {
+  send(name, context?) {
     let currentState = this.currentState;
 
     if (!currentState[name]) {
@@ -842,7 +785,7 @@ export default class InternalModel {
     }
   }
 
-  notifyPropertyChange(key: string) {
+  notifyPropertyChange(key) {
     if (this.hasRecord) {
       // TODO this should likely *mostly* be the `attributes` bucket
       // but it seems for local mutations we rely on computed updating
@@ -852,7 +795,7 @@ export default class InternalModel {
     }
   }
 
-  notifyStateChange(key?: string) {
+  notifyStateChange(key?) {
     if (this.hasRecord) {
       this.store._notificationManager.notify(this.identifier, 'state');
     }
@@ -868,24 +811,24 @@ export default class InternalModel {
   rollbackAttributes() {
     this.store._backburner.join(() => {
       let dirtyKeys = this._recordData.rollbackAttributes();
-      if (this.isError) {
+      if (get(this, 'isError')) {
         this.didCleanError();
       }
 
       this.send('rolledBack');
 
-      if (this.hasRecord && dirtyKeys && dirtyKeys.length > 0) {
-        this.notifyAttributes(dirtyKeys);
+      if (this._record && dirtyKeys && dirtyKeys.length > 0) {
+        this._record._notifyProperties(dirtyKeys);
       }
     });
   }
 
-  transitionTo(name: string) {
+  transitionTo(name) {
     // POSSIBLE TODO: Remove this code and replace with
     // always having direct reference to state objects
 
     let pivotName = extractPivotName(name);
-    let state: any = this.currentState;
+    let state = this.currentState;
     let transitionMapId = `${state.stateName}->${name}`;
 
     do {
@@ -930,12 +873,13 @@ export default class InternalModel {
     }
 
     this.currentState = state;
-
-    // isDSModel is the guard we want, but may be too restrictive if
-    // ember-m3 / ember-data-model-fragments were relying on this still.
-    if (this.hasRecord && isDSModel(this._record)) {
-      // TODO eliminate this.
+    if (this.hasRecord && typeof this._record.notifyPropertyChange === 'function') {
+      // TODO refactor Model to have all flags pull from the notification manager
+      // and for currentState.stateName to be constructed from flag state.
+      // Probably just port this work from ember-m3
+      // After that we can eliminate this.
       this.notifyStateChange('currentState');
+      // this._record.notifyPropertyChange('currentState');
     }
 
     for (i = 0, l = setups.length; i < l; i++) {
@@ -943,7 +887,7 @@ export default class InternalModel {
     }
   }
 
-  _unhandledEvent(state, name: string, context) {
+  _unhandledEvent(state, name, context) {
     let errorMessage = 'Attempted to handle event `' + name + '` ';
     errorMessage += 'on ' + String(this) + ' while in state ';
     errorMessage += state.stateName + '. ';
@@ -955,6 +899,35 @@ export default class InternalModel {
     throw new EmberError(errorMessage);
   }
 
+  triggerLater(...args) {
+    if (this._deferredTriggers.push(args) !== 1) {
+      return;
+    }
+
+    this.store._updateInternalModel(this);
+  }
+
+  _triggerDeferredTriggers() {
+    //TODO: Before 1.0 we want to remove all the events that happen on the pre materialized record,
+    //but for now, we queue up all the events triggered before the record was materialized, and flush
+    //them once we have the record
+    if (!this.hasRecord) {
+      return;
+    }
+    let triggers = this._deferredTriggers;
+    let record = this._record;
+    let trigger = record.trigger;
+    // TODO Igor make nicer check
+    if (trigger && typeof trigger === 'function') {
+      for (let i = 0, l = triggers.length; i < l; i++) {
+        let eventName = triggers[i];
+        trigger.apply(record, eventName);
+      }
+    }
+
+    triggers.length = 0;
+  }
+
   removeFromInverseRelationships() {
     if (this.__recordData) {
       this.store._backburner.join(() => {
@@ -1084,34 +1057,26 @@ export default class InternalModel {
     this.store._notificationManager.notify(this.identifier, 'attributes');
   }
 
-  hasErrors(): boolean {
-    // TODO add assertion forcing consuming RecordData's to implement getErrors
+  hasErrors() {
     if (this._recordData.getErrors) {
       return this._recordData.getErrors(this.identifier).length > 0;
     } else {
-      // we can't have errors if we never tried loading
-      if (!this._record) {
-        return false;
-      }
-      let errors = (this._record as DSModel).errors;
+      let errors = (this.getRecord() as DSModel).errors;
       return errors.length > 0;
     }
   }
 
   // FOR USE DURING COMMIT PROCESS
-  adapterDidInvalidate(parsedErrors, error?) {
+  adapterDidInvalidate(parsedErrors, error) {
     // TODO @runspired this should be handled by RecordState
     // and errors should be dirtied but lazily fetch if at
     // all possible. We should only notify errors here.
     let attribute;
     if (error && parsedErrors) {
-      // TODO add assertion forcing consuming RecordData's to implement getErrors
       if (!this._recordData.getErrors) {
-        let record = this.getRecord() as DSModel;
-        let errors = record.errors;
         for (attribute in parsedErrors) {
           if (hasOwnProperty.call(parsedErrors, attribute)) {
-            errors._add(attribute, parsedErrors[attribute]);
+            (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
           }
         }
       }
@@ -1152,9 +1117,7 @@ export default class InternalModel {
         // because of the intimate API access involved. This is something we will need to redesign.
         assert(`snapshot.belongsTo only supported for @ember-data/record-data`);
       }
-      const graphFor = (
-        importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
-      ).graphFor;
+      const graphFor = require('@ember-data/record-data/-private').graphFor;
       const relationship = graphFor(this.store._storeWrapper).get(this.identifier, name);
 
       if (DEBUG && kind) {
@@ -1182,39 +1145,7 @@ export default class InternalModel {
   }
 }
 
-function handleCompletedRelationshipRequest(
-  internalModel: InternalModel,
-  key: string,
-  relationship: BelongsToRelationship,
-  value: InternalModel | null
-): RecordInstance | null;
-function handleCompletedRelationshipRequest(
-  internalModel: InternalModel,
-  key: string,
-  relationship: ManyRelationship,
-  value: ManyArray
-): ManyArray;
-function handleCompletedRelationshipRequest(
-  internalModel: InternalModel,
-  key: string,
-  relationship: BelongsToRelationship,
-  value: null,
-  error: Error
-): never;
-function handleCompletedRelationshipRequest(
-  internalModel: InternalModel,
-  key: string,
-  relationship: ManyRelationship,
-  value: ManyArray,
-  error: Error
-): never;
-function handleCompletedRelationshipRequest(
-  internalModel: InternalModel,
-  key: string,
-  relationship: BelongsToRelationship | ManyRelationship,
-  value: ManyArray | InternalModel | null,
-  error?: Error
-): ManyArray | RecordInstance | null {
+function handleCompletedRelationshipRequest(internalModel, key, relationship, value, error) {
   delete internalModel._relationshipPromisesCache[key];
   relationship.state.shouldForceReload = false;
   const isHasMany = relationship.definition.kind === 'hasMany';
@@ -1222,7 +1153,7 @@ function handleCompletedRelationshipRequest(
   if (isHasMany) {
     // we don't notify the record property here to avoid refetch
     // only the many array
-    (value as ManyArray).notify();
+    value.notify();
   }
 
   if (error) {
@@ -1237,9 +1168,7 @@ function handleCompletedRelationshipRequest(
     // has never been accessed
     if (proxy && !isHasMany) {
       if (proxy.content && proxy.content.isDestroying) {
-        // TODO @types/ember__object incorrectly disallows `null`, we should either
-        // override or fix upstream
-        (proxy as PromiseBelongsTo).set('content', null as unknown as undefined);
+        proxy.set('content', null);
       }
     }
 
@@ -1247,14 +1176,14 @@ function handleCompletedRelationshipRequest(
   }
 
   if (isHasMany) {
-    (value as ManyArray).set('isLoaded', true);
+    value.set('isLoaded', true);
   }
 
   relationship.state.hasFailedLoadAttempt = false;
   // only set to not stale if no error is thrown
   relationship.state.isStale = false;
 
-  return isHasMany || !value ? (value as ManyArray | null) : (value as InternalModel).getRecord();
+  return value;
 }
 
 export function assertRecordsPassedToHasMany(records) {