@ember-data/model 4.7.0-beta.1 → 4.7.0

package/addon/-private/references/belongs-to.ts

@@ -1,15 +1,17 @@
+import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { cached, tracked } from '@glimmer/tracking';
 
 import type { Object as JSONObject, Value as JSONValue } from 'json-typescript';
 import { resolve } from 'rsvp';
 
-import type { BelongsToRelationship } from '@ember-data/record-data/-private';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph/graph';
+import type BelongsToRelationship from '@ember-data/record-data/-private/relationships/state/belongs-to';
 import type Store from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 import { recordIdentifierFor } from '@ember-data/store/-private';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/weak-cache';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
 import type {
   LinkObject,
   Links,
@@ -52,31 +54,34 @@ export default class BelongsToReference {
   declare key: string;
   declare belongsToRelationship: BelongsToRelationship;
   declare type: string;
-  #identifier: StableRecordIdentifier;
+  ___identifier: StableRecordIdentifier;
   declare store: Store;
+  declare graph: Graph;
 
   // unsubscribe tokens given to us by the notification manager
-  #token!: Object;
-  #relatedToken: Object | null = null;
+  ___token!: object;
+  ___relatedToken: object | null = null;
 
   @tracked _ref = 0;
 
   constructor(
     store: Store,
+    graph: Graph,
     parentIdentifier: StableRecordIdentifier,
     belongsToRelationship: BelongsToRelationship,
     key: string
   ) {
+    this.graph = graph;
     this.key = key;
     this.belongsToRelationship = belongsToRelationship;
     this.type = belongsToRelationship.definition.type;
     this.store = store;
-    this.#identifier = parentIdentifier;
+    this.___identifier = parentIdentifier;
 
-    this.#token = store._notificationManager.subscribe(
+    this.___token = store._notificationManager.subscribe(
       parentIdentifier,
       (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+        if (bucket === 'relationships' && notifiedKey === key) {
           this._ref++;
         }
       }
@@ -88,9 +93,11 @@ export default class BelongsToReference {
   destroy() {
     // TODO @feature we need the notification manager often enough
     // we should potentially just expose it fully public
-    this.store._notificationManager.unsubscribe(this.#token);
-    if (this.#relatedToken) {
-      this.store._notificationManager.unsubscribe(this.#relatedToken);
+    this.store._notificationManager.unsubscribe(this.___token);
+    this.___token = null as unknown as object;
+    if (this.___relatedToken) {
+      this.store._notificationManager.unsubscribe(this.___relatedToken);
+      this.___relatedToken = null;
     }
   }
 
@@ -98,17 +105,18 @@ export default class BelongsToReference {
   @dependentKeyCompat
   get _relatedIdentifier(): StableRecordIdentifier | null {
     this._ref; // consume the tracked prop
-    if (this.#relatedToken) {
-      this.store._notificationManager.unsubscribe(this.#relatedToken);
+    if (this.___relatedToken) {
+      this.store._notificationManager.unsubscribe(this.___relatedToken);
+      this.___relatedToken = null;
     }
 
     let resource = this._resource();
     if (resource && resource.data) {
       const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
-      this.#relatedToken = this.store._notificationManager.subscribe(
+      this.___relatedToken = this.store._notificationManager.subscribe(
         identifier,
         (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+          if (bucket === 'identity' || (bucket === 'attributes' && notifiedKey === 'id')) {
             this._ref++;
           }
         }
@@ -125,7 +133,7 @@ export default class BelongsToReference {
    `type()` and `id()` methods form a composite key for the identity
    map. This can be used to access the id of an async relationship
    without triggering a fetch that would normally happen if you
-   attempted to use `record.get('relationship.id')`.
+   attempted to use `record.relationship.id`.
 
    Example
 
@@ -134,7 +142,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-    @belongsTo({ async: true }) user;
+    @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -174,7 +182,7 @@ export default class BelongsToReference {
    // models/blog.js
    import Model, { belongsTo } from '@ember-data/model';
    export default Model.extend({
-      user: belongsTo({ async: true })
+      user: belongsTo('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -236,7 +244,7 @@ export default class BelongsToReference {
    // models/blog.js
    import Model, { belongsTo } from '@ember-data/model';
    export default Model.extend({
-      user: belongsTo({ async: true })
+      user: belongsTo('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -277,7 +285,9 @@ export default class BelongsToReference {
   }
 
   _resource() {
-    return this.store._instanceCache.recordDataFor(this.#identifier, false).getBelongsTo(this.key);
+    return this.store._instanceCache
+      .getRecordData(this.___identifier)
+      .getRelationship(this.___identifier, this.key) as SingleResourceRelationship;
   }
 
   /**
@@ -291,7 +301,7 @@ export default class BelongsToReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -341,7 +351,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-      @belongsTo({ async: true }) user;
+      @belongsTo('user', { async: true, inverse: null }) user;
     }
 
    let blog = store.push({
@@ -377,8 +387,25 @@ export default class BelongsToReference {
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
   async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<RecordInstance> {
-    // TODO @deprecate pushing unresolved payloads
-    const jsonApiDoc = await resolve(data);
+    let jsonApiDoc: SingleResourceDocument = data as SingleResourceDocument;
+    if (DEPRECATE_PROMISE_PROXIES && (data as { then: unknown }).then) {
+      jsonApiDoc = await resolve(data);
+      if (jsonApiDoc !== data) {
+        deprecate(
+          `You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            since: {
+              enabled: '4.8',
+              available: '4.8',
+            },
+            for: 'ember-data',
+          }
+        );
+      }
+    }
     let record = this.store.push(jsonApiDoc);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -389,9 +416,9 @@ export default class BelongsToReference {
       this.store
     );
 
-    const { graph, identifier } = this.belongsToRelationship;
-    this.store._backburner.join(() => {
-      graph.push({
+    const { identifier } = this.belongsToRelationship;
+    this.store._join(() => {
+      this.graph.push({
         op: 'replaceRelatedRecord',
         record: identifier,
         field: this.key,
@@ -404,7 +431,7 @@ export default class BelongsToReference {
 
   /**
    `value()` synchronously returns the current value of the belongs-to
-   relationship. Unlike `record.get('relationshipName')`, calling
+   relationship. Unlike `record.relationshipName`, calling
    `value()` on a reference does not trigger a fetch if the async
    relationship is not yet loaded. If the relationship is not loaded
    it will always return `null`.
@@ -416,7 +443,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -469,7 +496,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -520,9 +547,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship.
    */
   load(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.getBelongsTo(this.key, options);
   }
 
@@ -539,7 +566,7 @@ export default class BelongsToReference {
    import Model, { belongsTo } from '@ember-data/model';
 
    export default class BlogModel extends Model {
-     @belongsTo({ async: true }) user;
+     @belongsTo('user', { async: true, inverse: null }) user;
    }
 
    let blog = store.push({
@@ -577,9 +604,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
    */
   reload(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.reloadBelongsTo(this.key, options).then(() => this.value());
   }
 }

package/addon/-private/references/has-many.ts

@@ -1,3 +1,4 @@
+import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { DEBUG } from '@glimmer/env';
 import { cached, tracked } from '@glimmer/tracking';
@@ -7,12 +8,13 @@ import { resolve } from 'rsvp';
 
 import { ManyArray } from 'ember-data/-private';
 
-import type { ManyRelationship } from '@ember-data/record-data/-private';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph/graph';
+import type ManyRelationship from '@ember-data/record-data/-private/relationships/state/has-many';
 import type Store from '@ember-data/store';
 import { recordIdentifierFor } from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
-import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/weak-cache';
+import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
 import type {
   CollectionResourceDocument,
   CollectionResourceRelationship,
@@ -53,48 +55,51 @@ function isResourceIdentiferWithRelatedLinks(
  @extends Reference
  */
 export default class HasManyReference {
+  declare graph: Graph;
   declare key: string;
   declare hasManyRelationship: ManyRelationship;
   declare type: string;
   declare store: Store;
 
   // unsubscribe tokens given to us by the notification manager
-  #token!: Object;
-  #identifier: StableRecordIdentifier;
-  #relatedTokenMap!: Map<StableRecordIdentifier, Object>;
+  ___token!: Object;
+  ___identifier: StableRecordIdentifier;
+  ___relatedTokenMap!: Map<StableRecordIdentifier, Object>;
 
   @tracked _ref = 0;
 
   constructor(
     store: Store,
+    graph: Graph,
     parentIdentifier: StableRecordIdentifier,
     hasManyRelationship: ManyRelationship,
     key: string
   ) {
+    this.graph = graph;
     this.key = key;
     this.hasManyRelationship = hasManyRelationship;
     this.type = hasManyRelationship.definition.type;
 
     this.store = store;
-    this.#identifier = parentIdentifier;
-    this.#token = store._notificationManager.subscribe(
+    this.___identifier = parentIdentifier;
+    this.___token = store._notificationManager.subscribe(
       parentIdentifier,
       (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+        if (bucket === 'relationships' && notifiedKey === key) {
           this._ref++;
         }
       }
     );
-    this.#relatedTokenMap = new Map();
+    this.___relatedTokenMap = new Map();
     // TODO inverse
   }
 
   destroy() {
-    this.store._notificationManager.unsubscribe(this.#token);
-    this.#relatedTokenMap.forEach((token) => {
+    this.store._notificationManager.unsubscribe(this.___token);
+    this.___relatedTokenMap.forEach((token) => {
       this.store._notificationManager.unsubscribe(token);
     });
-    this.#relatedTokenMap.clear();
+    this.___relatedTokenMap.clear();
   }
 
   @cached
@@ -104,34 +109,44 @@ export default class HasManyReference {
 
     let resource = this._resource();
 
-    this.#relatedTokenMap.forEach((token) => {
-      this.store._notificationManager.unsubscribe(token);
-    });
-    this.#relatedTokenMap.clear();
+    let map = this.___relatedTokenMap;
+    this.___relatedTokenMap = new Map();
 
     if (resource && resource.data) {
       return resource.data.map((resourceIdentifier) => {
         const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
-        const token = this.store._notificationManager.subscribe(
-          identifier,
-          (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
-            if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
-              this._ref++;
+        let token = map.get(identifier);
+
+        if (token) {
+          map.delete(identifier);
+        } else {
+          token = this.store._notificationManager.subscribe(
+            identifier,
+            (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+              if (bucket === 'identity' || (bucket === 'attributes' && notifiedKey === 'id')) {
+                this._ref++;
+              }
             }
-          }
-        );
-
-        this.#relatedTokenMap.set(identifier, token);
+          );
+        }
+        this.___relatedTokenMap.set(identifier, token);
 
         return identifier;
       });
     }
 
+    map.forEach((token) => {
+      this.store._notificationManager.unsubscribe(token);
+    });
+    map.clear();
+
     return [];
   }
 
   _resource() {
-    return this.store._instanceCache.recordDataFor(this.#identifier, false).getHasMany(this.key);
+    return this.store._instanceCache
+      .getRecordData(this.___identifier)
+      .getRelationship(this.___identifier, this.key) as CollectionResourceRelationship;
   }
 
   /**
@@ -145,7 +160,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -194,7 +209,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -234,7 +249,7 @@ export default class HasManyReference {
    // models/blog.js
    import Model, { belongsTo } from '@ember-data/model';
    export default Model.extend({
-      user: belongsTo({ async: true })
+      user: belongsTo('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -296,7 +311,7 @@ export default class HasManyReference {
    // models/blog.js
    import Model, { hasMany } from '@ember-data/model';
    export default Model.extend({
-      users: hasMany({ async: true })
+      users: hasMany('user', { async: true, inverse: null })
     });
 
    let blog = store.push({
@@ -347,7 +362,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -384,7 +399,25 @@ export default class HasManyReference {
   async push(
     objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
   ): Promise<ManyArray> {
-    const payload = await resolve(objectOrPromise);
+    let payload = objectOrPromise;
+    if (DEPRECATE_PROMISE_PROXIES && (objectOrPromise as unknown as { then: unknown }).then) {
+      payload = await resolve(objectOrPromise);
+      if (payload !== objectOrPromise) {
+        deprecate(
+          `You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            since: {
+              enabled: '4.8',
+              available: '4.8',
+            },
+            for: 'ember-data',
+          }
+        );
+      }
+    }
     let array: Array<ExistingResourceObject | SingleResourceDocument>;
 
     if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {
@@ -414,9 +447,9 @@ export default class HasManyReference {
       return recordIdentifierFor(record);
     });
 
-    const { graph, identifier } = this.hasManyRelationship;
-    store._backburner.join(() => {
-      graph.push({
+    const { identifier } = this.hasManyRelationship;
+    store._join(() => {
+      this.graph.push({
         op: 'replaceRelatedRecords',
         record: identifier,
         field: this.key,
@@ -433,18 +466,16 @@ export default class HasManyReference {
       return false;
     }
 
-    let members = this.hasManyRelationship.currentState;
+    let localState = this.hasManyRelationship.localState;
 
-    //TODO @runspired determine isLoaded via a better means
-    return members.every((identifier) => {
-      let internalModel = this.store._instanceCache._internalModelForResource(identifier);
-      return internalModel.isLoaded === true;
+    return localState.every((identifier) => {
+      return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
     });
   }
 
   /**
    `value()` synchronously returns the current value of the has-many
-   relationship. Unlike `record.get('relationshipName')`, calling
+   relationship. Unlike `record.relationshipName`, calling
    `value()` on a reference does not trigger a fetch if the async
    relationship is not yet loaded. If the relationship is not loaded
    it will always return `null`.
@@ -455,7 +486,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -474,7 +505,7 @@ export default class HasManyReference {
 
    let commentsRef = post.hasMany('comments');
 
-   post.get('comments').then(function(comments) {
+   post.comments.then(function(comments) {
      commentsRef.value() === comments
    })
    ```
@@ -484,9 +515,9 @@ export default class HasManyReference {
    @return {ManyArray}
    */
   value() {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
 
     return this._isLoaded() ? support.getManyArray(this.key) : null;
   }
@@ -503,7 +534,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -556,9 +587,9 @@ export default class HasManyReference {
    this has-many relationship.
    */
   async load(options?: FindOptions): Promise<ManyArray> {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.getHasMany(this.key, options) as Promise<ManyArray> | ManyArray; // this cast is necessary because typescript does not work properly with custom thenables;
   }
 
@@ -572,7 +603,7 @@ export default class HasManyReference {
    import Model, { hasMany } from '@ember-data/model';
 
    export default class PostModel extends Model {
-     @hasMany({ async: true }) comments;
+     @hasMany('comment', { async: true, inverse: null }) comments;
    }
    ```
 
@@ -613,9 +644,9 @@ export default class HasManyReference {
    @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
    */
   reload(options?: FindOptions) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.#identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.reloadHasMany(this.key, options);
   }
 }

package/addon/-private/relationship-meta.ts

@@ -1,17 +1,13 @@
+import { dasherize } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 
 import { singularize } from 'ember-inflector';
 
 import type Store from '@ember-data/store';
-import { normalizeModelName } from '@ember-data/store/-private';
 import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 
-/**
-  @module @ember-data/store
-*/
-
 function typeForRelationshipMeta(meta) {
-  let modelName = normalizeModelName(meta.type || meta.key);
+  let modelName = dasherize(meta.type || meta.key);
 
   if (meta.kind === 'hasMany') {
     modelName = singularize(modelName);
@@ -25,10 +21,9 @@ function shouldFindInverse(relationshipMeta) {
   return !(options && options.inverse === null);
 }
 
-export class RelationshipDefinition implements RelationshipSchema {
+class RelationshipDefinition implements RelationshipSchema {
   declare _type: string;
   declare __inverseKey: string;
-  declare __inverseIsAsync: boolean;
   declare __hasCalculatedInverse: boolean;
   declare parentModelName: string;
   declare inverseIsAsync: string | null;
@@ -37,7 +32,6 @@ export class RelationshipDefinition implements RelationshipSchema {
   constructor(meta: any) {
     this._type = '';
     this.__inverseKey = '';
-    this.__inverseIsAsync = true;
     this.__hasCalculatedInverse = false;
     this.parentModelName = meta.parentModelName;
     this.meta = meta;
@@ -74,40 +68,28 @@ export class RelationshipDefinition implements RelationshipSchema {
     return this.__inverseKey;
   }
 
-  _inverseIsAsync(store: Store, modelClass): boolean {
-    if (this.__hasCalculatedInverse === false) {
-      this._calculateInverse(store, modelClass);
-    }
-    return this.__inverseIsAsync;
-  }
-
   _calculateInverse(store: Store, modelClass): void {
     this.__hasCalculatedInverse = true;
-    let inverseKey, inverseIsAsync;
+    let inverseKey;
     let inverse: any = null;
 
     if (shouldFindInverse(this.meta)) {
       inverse = modelClass.inverseFor(this.key, store);
-    } else if (DEBUG) {
+    }
+    // TODO make this error again for the non-polymorphic case
+    if (DEBUG && !this.options.polymorphic) {
       modelClass.typeForRelationship(this.key, store);
     }
 
     if (inverse) {
       inverseKey = inverse.name;
-      inverseIsAsync = isRelationshipAsync(inverse);
     } else {
       inverseKey = null;
-      inverseIsAsync = false;
     }
     this.__inverseKey = inverseKey;
-    this.__inverseIsAsync = inverseIsAsync;
   }
 }
-
-function isRelationshipAsync(meta: RelationshipSchema): boolean {
-  let inverseAsync = meta.options && meta.options.async;
-  return typeof inverseAsync === 'undefined' ? true : inverseAsync;
-}
+export type { RelationshipDefinition };
 
 export function relationshipFromMeta(meta: RelationshipSchema): RelationshipDefinition {
   return new RelationshipDefinition(meta);

package/index.js

@@ -17,8 +17,11 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember-data/store/-private',
       '@ember-data/store/-debug',
       '@embroider/macros',
+      '@ember/string',
       '@embroider/macros/es-compat',
 
+      '@ember/object/proxy',
+      '@ember/object/promise-proxy-mixin',
       '@ember/application',
       '@ember/array',
       '@ember/array/mutable',