@ember-data/model 4.4.0-alpha.5 → 4.4.0-alpha.8

package/addon/-private/{errors.js → errors.ts}

@@ -1,11 +1,29 @@
-import { A, makeArray } from '@ember/array';
+import { A } from '@ember/array';
+import type NativeArray from '@ember/array/-private/native-array';
 import ArrayProxy from '@ember/array/proxy';
 import { computed, get } from '@ember/object';
 import { mapBy, not } from '@ember/object/computed';
 
+type ValidationError = {
+  attribute: string;
+  message: string;
+};
 /**
-  @module @ember-data/store
+  @module @ember-data/model
 */
+interface ArrayProxyWithCustomOverrides<T, M = T> extends Omit<ArrayProxy<T, M>, 'clear' | 'content'> {
+  // Omit causes `content` to be merged with the class def for ArrayProxy
+  // which then causes it to be seen as a property, disallowing defining it
+  // as an accessor. This restores our ability to define it as an accessor.
+  content: NativeArray<T>;
+  clear(): void;
+  _has(name: string): boolean;
+}
+
+// we force the type here to our own construct because mixin and extend patterns
+// lose generic signatures. We also do this because we need to Omit `clear` from
+// the type of ArrayProxy as we override it's signature.
+const ArrayProxyWithCustomOverrides = ArrayProxy as unknown as new <T, M = T>() => ArrayProxyWithCustomOverrides<T, M>;
 
 /**
   Holds validation errors for a given record, organized by attribute names.
@@ -82,28 +100,34 @@ import { mapBy, not } from '@ember/object/computed';
   @public
   @extends Ember.ArrayProxy
  */
-export default ArrayProxy.extend({
+export default class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
+  declare _registeredHandlers?: {
+    becameInvalid: () => void;
+    becameValid: () => void;
+  };
+
   /**
     Register with target handler
 
     @method _registerHandlers
     @private
   */
-  _registerHandlers(becameInvalid, becameValid) {
+  _registerHandlers(becameInvalid: () => void, becameValid: () => void): void {
     this._registeredHandlers = {
       becameInvalid,
       becameValid,
     };
-  },
+  }
 
   /**
     @property errorsByAttributeName
     @type {MapWithDefault}
     @private
   */
-  errorsByAttributeName: computed(function () {
+  @computed()
+  get errorsByAttributeName(): Map<string, NativeArray<ValidationError>> {
     return new Map();
-  }),
+  }
 
   /**
     Returns errors for a given attribute
@@ -124,13 +148,13 @@ export default ArrayProxy.extend({
     @param {String} attribute
     @return {Array}
   */
-  errorsFor(attribute) {
-    let map = get(this, 'errorsByAttributeName');
+  errorsFor(attribute: string): NativeArray<ValidationError> {
+    let map = this.errorsByAttributeName;
 
     let errors = map.get(attribute);
 
     if (errors === undefined) {
-      errors = A();
+      errors = A<ValidationError>();
       map.set(attribute, errors);
     }
 
@@ -141,7 +165,7 @@ export default ArrayProxy.extend({
     get(errors, '[]');
 
     return errors;
-  },
+  }
 
   /**
     An array containing all of the error messages for this
@@ -159,28 +183,30 @@ export default ArrayProxy.extend({
     @public
     @type {Array}
   */
-  messages: mapBy('content', 'message'),
+  @mapBy('content', 'message')
+  declare messages: string[];
 
   /**
     @property content
     @type {Array}
     @private
   */
-  content: computed(function () {
+  @computed()
+  get content(): NativeArray<ValidationError> {
     return A();
-  }),
+  }
 
   /**
     @method unknownProperty
     @private
   */
-  unknownProperty(attribute) {
+  unknownProperty(attribute: string) {
     let errors = this.errorsFor(attribute);
     if (errors.length === 0) {
       return undefined;
     }
     return errors;
-  },
+  }
 
   /**
     Total number of errors.
@@ -199,7 +225,8 @@ export default ArrayProxy.extend({
     @public
     @readOnly
   */
-  isEmpty: not('length').readOnly(),
+  @not('length')
+  declare isEmpty: boolean;
 
   /**
    Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
@@ -233,20 +260,20 @@ export default ArrayProxy.extend({
     //   { attribute: 'username', message: 'This field is required' },
     // ]
    ```
-  @method add
+    @method add
     @public
-  @param {string} attribute - the property name of an attribute or relationship
-  @param {string[]|string} messages - an error message or array of error messages for the attribute
+    @param {string} attribute - the property name of an attribute or relationship
+    @param {string[]|string} messages - an error message or array of error messages for the attribute
    */
-  add(attribute, messages) {
-    let wasEmpty = get(this, 'isEmpty');
+  add(attribute: string, messages: string[] | string): void {
+    let wasEmpty: boolean = this.isEmpty;
 
     this._add(attribute, messages);
 
-    if (wasEmpty && !get(this, 'isEmpty')) {
+    if (wasEmpty && !this.isEmpty) {
       this._registeredHandlers && this._registeredHandlers.becameInvalid();
     }
-  },
+  }
 
   /**
     Adds error messages to a given attribute without sending event.
@@ -254,23 +281,23 @@ export default ArrayProxy.extend({
     @method _add
     @private
   */
-  _add(attribute, messages) {
-    messages = this._findOrCreateMessages(attribute, messages);
-    this.addObjects(messages);
+  _add(attribute: string, messages: string[] | string) {
+    const errors = this._findOrCreateMessages(attribute, messages);
+    this.addObjects(errors);
 
-    this.errorsFor(attribute).addObjects(messages);
+    this.errorsFor(attribute).addObjects(errors);
 
     this.notifyPropertyChange(attribute);
-  },
+  }
 
   /**
     @method _findOrCreateMessages
     @private
   */
-  _findOrCreateMessages(attribute, messages) {
+  _findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[] {
     let errors = this.errorsFor(attribute);
-    let messagesArray = makeArray(messages);
-    let _messages = new Array(messagesArray.length);
+    let messagesArray = Array.isArray(messages) ? messages : [messages];
+    let _messages: ValidationError[] = new Array(messagesArray.length) as ValidationError[];
 
     for (let i = 0; i < messagesArray.length; i++) {
       let message = messagesArray[i];
@@ -280,13 +307,13 @@ export default ArrayProxy.extend({
       } else {
         _messages[i] = {
           attribute: attribute,
-          message: message,
+          message,
         };
       }
     }
 
     return _messages;
-  },
+  }
 
   /**
    Manually removes all errors for a given member from the record.
@@ -315,17 +342,17 @@ export default ArrayProxy.extend({
     @public
    @param {string} member - the property name of an attribute or relationship
    */
-  remove(attribute) {
-    if (get(this, 'isEmpty')) {
+  remove(attribute: string) {
+    if (this.isEmpty) {
       return;
     }
 
     this._remove(attribute);
 
-    if (get(this, 'isEmpty')) {
+    if (this.isEmpty) {
       this._registeredHandlers && this._registeredHandlers.becameValid();
     }
-  },
+  }
 
   /**
     Removes all error messages from the given attribute without sending event.
@@ -333,13 +360,13 @@ export default ArrayProxy.extend({
     @method _remove
     @private
   */
-  _remove(attribute) {
-    if (get(this, 'isEmpty')) {
+  _remove(attribute: string) {
+    if (this.isEmpty) {
       return;
     }
 
     let content = this.rejectBy('attribute', attribute);
-    get(this, 'content').setObjects(content);
+    this.content.setObjects(content);
 
     // Although errorsByAttributeName.delete is technically enough to sync errors state, we also
     // must mutate the array as well for autotracking
@@ -350,11 +377,11 @@ export default ArrayProxy.extend({
         errors.replace(i, 1);
       }
     }
-    get(this, 'errorsByAttributeName').delete(attribute);
+    this.errorsByAttributeName.delete(attribute);
 
     this.notifyPropertyChange(attribute);
     this.notifyPropertyChange('length');
-  },
+  }
 
   /**
    Manually clears all errors for the record.
@@ -393,16 +420,16 @@ export default ArrayProxy.extend({
    // => []
    ```
    @method clear
-    @public
+   @public
    */
-  clear() {
-    if (get(this, 'isEmpty')) {
+  clear(): void {
+    if (this.isEmpty) {
       return;
     }
 
     this._clear();
     this._registeredHandlers && this._registeredHandlers.becameValid();
-  },
+  }
 
   /**
     Removes all error messages.
@@ -411,13 +438,13 @@ export default ArrayProxy.extend({
     @method _clear
     @private
   */
-  _clear() {
-    if (get(this, 'isEmpty')) {
+  _clear(): void {
+    if (this.isEmpty) {
       return;
     }
 
-    let errorsByAttributeName = get(this, 'errorsByAttributeName');
-    let attributes = [];
+    let errorsByAttributeName = this.errorsByAttributeName;
+    let attributes: string[] = [];
 
     errorsByAttributeName.forEach(function (_, attribute) {
       attributes.push(attribute);
@@ -429,7 +456,7 @@ export default ArrayProxy.extend({
     });
 
     ArrayProxy.prototype.clear.call(this);
-  },
+  }
 
   /**
     Checks if there are error messages for the given attribute.
@@ -454,7 +481,7 @@ export default ArrayProxy.extend({
     @param {String} attribute
     @return {Boolean} true if there some errors on given attribute
   */
-  has(attribute) {
+  has(attribute: string): boolean {
     return this.errorsFor(attribute).length > 0;
-  },
-});
+  }
+}

package/addon/-private/system/{diff-array.js → diff-array.ts}

@@ -2,6 +2,12 @@
   @module @ember-data/model
 */
 
+export interface ArrayDiffResult {
+  firstChangeIndex: number | null;
+  removedCount: number;
+  addedCount: number;
+}
+
 /**
   @method diffArray
   @internal
@@ -13,12 +19,12 @@
       removedCount: <integer>       // 0 if no change
     }
 */
-export default function diffArray(oldArray, newArray) {
+export default function diffArray(oldArray: unknown[], newArray: unknown[]): ArrayDiffResult {
   const oldLength = oldArray.length;
   const newLength = newArray.length;
 
   const shortestLength = Math.min(oldLength, newLength);
-  let firstChangeIndex = null; // null signifies no changes
+  let firstChangeIndex: number | null = null; // null signifies no changes
 
   // find the first change
   for (let i = 0; i < shortestLength; i++) {

package/addon/-private/system/{many-array.js → many-array.ts}

@@ -8,10 +8,36 @@ import EmberObject, { get } from '@ember/object';
 
 import { all } from 'rsvp';
 
+import type { RelationshipRecordData } from '@ember-data/record-data/-private/ts-interfaces/relationship-record-data';
+import type { InternalModel } from '@ember-data/store/-private';
 import { PromiseArray, recordDataFor } from '@ember-data/store/-private';
+import type CoreStore from '@ember-data/store/-private/system/core-store';
+import type { CreateRecordProperties } from '@ember-data/store/-private/system/core-store';
+import ShimModelClass from '@ember-data/store/-private/system/model/shim-model-class';
+import type { DSModelSchema } from '@ember-data/store/-private/ts-interfaces/ds-model';
+import type { Links, PaginationLinks } from '@ember-data/store/-private/ts-interfaces/ember-data-json-api';
+import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
+import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
 
 import diffArray from './diff-array';
 
+interface MutableArrayWithObject<T, M = T> extends EmberObject, MutableArray<M> {}
+const MutableArrayWithObject = EmberObject.extend(MutableArray) as unknown as new <
+  T,
+  M = T
+>() => MutableArrayWithObject<T, M>;
+
+export interface ManyArrayCreateArgs {
+  store: CoreStore;
+  type: ShimModelClass;
+  recordData: RelationshipRecordData;
+  key: string;
+  isPolymorphic: boolean;
+  isAsync: boolean;
+  _inverseIsAsync: boolean;
+  internalModel: InternalModel;
+  isLoaded: boolean;
+}
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
   relationship.
@@ -57,12 +83,27 @@ import diffArray from './diff-array';
   @extends Ember.EmberObject
   @uses Ember.MutableArray
 */
-export default EmberObject.extend(MutableArray, {
-  isAsync: false,
-  isLoaded: false,
+export default class ManyArray extends MutableArrayWithObject<InternalModel, RecordInstance> {
+  declare isAsync: boolean;
+  declare isLoaded: boolean;
+  declare isPolymorphic: boolean;
+  declare _isDirty: boolean;
+  declare _isUpdating: boolean;
+  declare _hasNotified: boolean;
+  declare __hasArrayObservers: boolean;
+  declare hasArrayObservers: boolean; // override the base declaration
+  declare _length: number;
+  declare _meta: Dict<unknown> | null;
+  declare _links: Links | PaginationLinks | null;
+  declare currentState: InternalModel[];
+  declare recordData: RelationshipRecordData;
+  declare internalModel: InternalModel;
+  declare store: CoreStore;
+  declare key: string;
+  declare type: DSModelSchema;
 
   init() {
-    this._super(...arguments);
+    super.init();
 
     /**
     The loading state of this array
@@ -71,6 +112,7 @@ export default EmberObject.extend(MutableArray, {
     @public
     */
     this.isLoaded = this.isLoaded || false;
+    this.isAsync = this.isAsync || false;
 
     this._length = 0;
 
@@ -158,12 +200,13 @@ export default EmberObject.extend(MutableArray, {
     // make sure we initialize to the correct state
     // since the user has already accessed
     this.retrieveLatest();
-  },
+  }
 
   // TODO refactor away _hasArrayObservers for tests
   get _hasArrayObservers() {
+    // cast necessary because hasArrayObservers is typed as a ComputedProperty<boolean> vs a boolean;
     return this.hasArrayObservers || this.__hasArrayObservers;
-  },
+  }
 
   notify() {
     this._isDirty = true;
@@ -175,7 +218,7 @@ export default EmberObject.extend(MutableArray, {
       this.notifyPropertyChange('firstObject');
       this.notifyPropertyChange('lastObject');
     }
-  },
+  }
 
   get length() {
     if (this._isDirty) {
@@ -185,11 +228,11 @@ export default EmberObject.extend(MutableArray, {
     get(this, '[]');
 
     return this._length;
-  },
+  }
 
   set length(value) {
     this._length = value;
-  },
+  }
 
   get links() {
     get(this, '[]');
@@ -197,10 +240,10 @@ export default EmberObject.extend(MutableArray, {
       this.retrieveLatest();
     }
     return this._links;
-  },
+  }
   set links(v) {
     this._links = v;
-  },
+  }
 
   get meta() {
     get(this, '[]');
@@ -208,12 +251,12 @@ export default EmberObject.extend(MutableArray, {
       this.retrieveLatest();
     }
     return this._meta;
-  },
+  }
   set meta(v) {
     this._meta = v;
-  },
+  }
 
-  objectAt(index) {
+  objectAt(index: number): RecordInstance | undefined {
     if (this._isDirty) {
       this.retrieveLatest();
     }
@@ -223,12 +266,12 @@ export default EmberObject.extend(MutableArray, {
     }
 
     return internalModel.getRecord();
-  },
+  }
 
-  replace(idx, amt, objects) {
+  replace(idx: number, amt: number, objects?: RecordInstance[]) {
     assert(`Cannot push mutations to the cache while updating the relationship from cache`, !this._isUpdating);
     this.store._backburner.join(() => {
-      let internalModels;
+      let internalModels: InternalModel[];
       if (amt > 0) {
         internalModels = this.currentState.slice(idx, idx + amt);
         this.recordData.removeFromHasMany(
@@ -243,13 +286,13 @@ export default EmberObject.extend(MutableArray, {
         );
         this.recordData.addToHasMany(
           this.key,
-          objects.map((obj) => recordDataFor(obj)),
+          objects.map((obj: RecordInstance) => recordDataFor(obj)),
           idx
         );
       }
       this.notify();
     });
-  },
+  }
 
   retrieveLatest() {
     // It’s possible the parent side of the relationship may have been destroyed by this point
@@ -260,7 +303,7 @@ export default EmberObject.extend(MutableArray, {
     this._isUpdating = true;
     let jsonApi = this.recordData.getHasMany(this.key);
 
-    let internalModels = [];
+    let internalModels: InternalModel[] = [];
     if (jsonApi.data) {
       for (let i = 0; i < jsonApi.data.length; i++) {
         let im = this.store._internalModelForResource(jsonApi.data[i]);
@@ -298,7 +341,7 @@ export default EmberObject.extend(MutableArray, {
     }
 
     this._isUpdating = false;
-  },
+  }
 
   /**
     Reloads all of the records in the manyArray. If the manyArray
@@ -324,8 +367,8 @@ export default EmberObject.extend(MutableArray, {
   */
   reload(options) {
     // TODO this is odd, we don't ask the store for anything else like this?
-    return this.store.reloadManyArray(this, this.internalModel, this.key, options);
-  },
+    return this.internalModel.reloadHasMany(this.key, options);
+  }
 
   /**
     Saves all of the records in the `ManyArray`.
@@ -347,7 +390,7 @@ export default EmberObject.extend(MutableArray, {
   */
   save() {
     let manyArray = this;
-    let promiseLabel = 'DS: ManyArray#save ' + this.type;
+    let promiseLabel = 'DS: ManyArray#save ' + this.type.modelName;
     let promise = all(this.invoke('save'), promiseLabel).then(
       () => manyArray,
       null,
@@ -356,7 +399,7 @@ export default EmberObject.extend(MutableArray, {
 
     // TODO deprecate returning a promiseArray here
     return PromiseArray.create({ promise });
-  },
+  }
 
   /**
     Create a child record within the owner
@@ -366,12 +409,12 @@ export default EmberObject.extend(MutableArray, {
     @param {Object} hash
     @return {Model} record
   */
-  createRecord(hash) {
+  createRecord(hash: CreateRecordProperties): RecordInstance {
     const { store, type } = this;
 
-    let record = store.createRecord(type.modelName, hash);
+    const record = store.createRecord(type.modelName, hash);
     this.pushObject(record);
 
     return record;
-  },
-});
+  }
+}

package/addon/-private/system/promise-belongs-to.ts

@@ -0,0 +1,72 @@
+import { assert } from '@ember/debug';
+import { computed } from '@ember/object';
+import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import type ObjectProxy from '@ember/object/proxy';
+
+import type { InternalModel } from '@ember-data/store/-private';
+import { PromiseObject } from '@ember-data/store/-private';
+import type CoreStore from '@ember-data/store/-private/system/core-store';
+import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
+import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
+
+export interface BelongsToProxyMeta {
+  key: string;
+  store: CoreStore;
+  originatingInternalModel: InternalModel;
+  modelName: string;
+}
+export interface BelongsToProxyCreateArgs {
+  promise: Promise<RecordInstance | null>;
+  content?: RecordInstance | null;
+  _belongsToState: BelongsToProxyMeta;
+}
+
+interface PromiseObjectType<T extends object> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
+  new <T extends object>(...args: unknown[]): PromiseObjectType<T>;
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class PromiseObjectType<T extends object> {}
+
+const Extended: PromiseObjectType<RecordInstance> = PromiseObject as unknown as PromiseObjectType<RecordInstance>;
+
+/**
+ @module @ember-data/model
+ */
+
+/**
+  A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+  to the underlying belongsTo model.
+  Right now we proxy:
+    * `reload()`
+  @class PromiseBelongsTo
+  @extends PromiseObject
+  @private
+*/
+class PromiseBelongsTo extends Extended<RecordInstance> {
+  declare _belongsToState: BelongsToProxyMeta;
+  // we don't proxy meta because we would need to proxy it to the relationship state container
+  //  however, meta on relationships does not trigger change notifications.
+  //  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
+  @computed()
+  get meta() {
+    // eslint-disable-next-line no-constant-condition
+    if (1) {
+      assert(
+        'You attempted to access meta on the promise for the async belongsTo relationship ' +
+          `${this.get('_belongsToState').modelName}:${this.get('_belongsToState').key}'.` +
+          '\nUse `record.belongsTo(relationshipName).meta()` instead.',
+        false
+      );
+    }
+    return;
+  }
+
+  async reload(options: Dict<unknown>): Promise<this> {
+    assert('You are trying to reload an async belongsTo before it has been created', this.content !== undefined);
+    let { key, store, originatingInternalModel } = this._belongsToState;
+    await store.reloadBelongsTo(this, originatingInternalModel, key, options);
+    return this;
+  }
+}
+
+export default PromiseBelongsTo;

package/addon/-private/system/promise-many-array.ts

@@ -1,4 +1,5 @@
 import ArrayMixin from '@ember/array';
+import type ArrayProxy from '@ember/array/proxy';
 import { assert } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { tracked } from '@glimmer/tracking';
@@ -6,6 +7,16 @@ import Ember from 'ember';
 
 import { resolve } from 'rsvp';
 
+import type { ManyArray } from 'ember-data/-private';
+
+import type { InternalModel } from '@ember-data/store/-private';
+import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
+
+export interface HasManyProxyCreateArgs {
+  promise: Promise<ManyArray>;
+  content?: ManyArray;
+}
+
 /**
  @module @ember-data/model
  */
@@ -31,12 +42,13 @@ import { resolve } from 'rsvp';
   @class PromiseManyArray
   @public
 */
+export default interface PromiseManyArray extends Omit<ArrayProxy<InternalModel, RecordInstance>, 'destroy'> {}
 export default class PromiseManyArray {
-  declare promise: Promise<any> | null;
+  declare promise: Promise<ManyArray> | null;
   declare isDestroyed: boolean;
   declare isDestroying: boolean;
 
-  constructor(promise, content) {
+  constructor(promise: Promise<ManyArray>, content?: ManyArray) {
     this._update(promise, content);
     this.isDestroyed = false;
     this.isDestroying = false;
@@ -61,6 +73,9 @@ export default class PromiseManyArray {
    */
   @dependentKeyCompat
   get length(): number {
+    // shouldn't be needed, but ends up being needed
+    // for computed chains even in 4.x
+    this['[]'];
     return this.content ? this.content.length : 0;
   }
 
@@ -201,7 +216,7 @@ export default class PromiseManyArray {
 
   //---- Our own stuff
 
-  _update(promise, content) {
+  _update(promise: Promise<ManyArray>, content?: ManyArray) {
     if (content !== undefined) {
       this.content = content;
     }
@@ -209,7 +224,7 @@ export default class PromiseManyArray {
     this.promise = tapPromise(this, promise);
   }
 
-  static create({ promise, content }) {
+  static create({ promise, content }: HasManyProxyCreateArgs): PromiseManyArray {
     return new this(promise, content);
   }
 
@@ -230,7 +245,7 @@ export default class PromiseManyArray {
   }
 }
 
-function tapPromise(proxy, promise) {
+function tapPromise(proxy: PromiseManyArray, promise: Promise<ManyArray>) {
   proxy.isPending = true;
   proxy.isSettled = false;
   proxy.isFulfilled = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.4.0-alpha.5",
+  "version": "4.4.0-alpha.8",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -18,9 +18,9 @@
     "test:node": "mocha"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.4.0-alpha.5",
-    "@ember-data/private-build-infra": "4.4.0-alpha.5",
-    "@ember-data/store": "4.4.0-alpha.5",
+    "@ember-data/canary-features": "4.4.0-alpha.8",
+    "@ember-data/private-build-infra": "4.4.0-alpha.8",
+    "@ember-data/store": "4.4.0-alpha.8",
     "@ember/edition-utils": "^1.2.0",
     "@ember/string": "^3.0.0",
     "ember-auto-import": "^2.2.4",
@@ -33,7 +33,7 @@
     "inflection": "~1.13.1"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.4.0-alpha.5",
+    "@ember-data/unpublished-test-infra": "4.4.0-alpha.8",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "^2.6.0",
     "broccoli-asset-rev": "^3.0.0",
@@ -50,7 +50,7 @@
     "ember-maybe-import-regenerator": "^1.0.0",
     "ember-qunit": "^5.1.5",
     "ember-resolver": "^8.0.3",
-    "ember-source": "~4.2.0",
+    "ember-source": "~4.3.0",
     "ember-source-channel-url": "^3.0.0",
     "ember-try": "^2.0.0",
     "loader.js": "^4.7.0",

package/addon/-private/system/promise-belongs-to.js

@@ -1,41 +0,0 @@
-import { assert } from '@ember/debug';
-import { computed } from '@ember/object';
-
-import { PromiseObject } from '@ember-data/store/-private';
-
-/**
- @module @ember-data/model
- */
-
-/**
-  A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
-  to the underlying belongsTo model.
-  Right now we proxy:
-
-    * `reload()`
-
-  @class PromiseBelongsTo
-  @extends PromiseObject
-  @private
-*/
-const PromiseBelongsTo = PromiseObject.extend({
-  // we don't proxy meta because we would need to proxy it to the relationship state container
-  //  however, meta on relationships does not trigger change notifications.
-  //  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
-  meta: computed(function () {
-    assert(
-      'You attempted to access meta on the promise for the async belongsTo relationship ' +
-        `${this.get('_belongsToState').modelName}:${this.get('_belongsToState').key}'.` +
-        '\nUse `record.belongsTo(relationshipName).meta()` instead.',
-      false
-    );
-  }),
-
-  reload(options) {
-    assert('You are trying to reload an async belongsTo before it has been created', this.get('content') !== undefined);
-    let { key, store, originatingInternalModel } = this._belongsToState;
-    return store.reloadBelongsTo(this, originatingInternalModel, key, options).then(() => this);
-  },
-});
-
-export default PromiseBelongsTo;