@ember-data/model 4.8.0-alpha.5 → 4.8.0-alpha.6

package/addon/-private/deprecated-promise-proxy.ts

@@ -0,0 +1,54 @@
+import { deprecate } from '@ember/debug';
+
+import { resolve } from 'rsvp';
+
+import { PromiseObject } from './promise-proxy-base';
+
+function promiseObject<T>(promise: Promise<T>): PromiseObject<T> {
+  return PromiseObject.create({
+    promise: resolve(promise),
+  }) as PromiseObject<T>;
+}
+
+// constructor is accessed in some internals but not including it in the copyright for the deprecation
+const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
+const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
+
+export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObject<T> {
+  const promiseObjectProxy: PromiseObject<T> = promiseObject(promise);
+  const handler = {
+    get(target: object, prop: string, receiver?: object): unknown {
+      if (typeof prop === 'symbol') {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (!ALLOWABLE_METHODS.includes(prop)) {
+        deprecate(
+          `Accessing ${prop} is deprecated. The return type is being changed fomr PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          false,
+          {
+            id: 'ember-data:model-save-promise',
+            until: '5.0',
+            for: '@ember-data/store',
+            since: {
+              available: '4.4',
+              enabled: '4.4',
+            },
+          }
+        );
+      }
+
+      const value: unknown = target[prop];
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(target);
+      }
+
+      if (PROXIED_OBJECT_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
+    },
+  };
+
+  return new Proxy(promiseObjectProxy, handler);
+}

package/addon/-private/has-many.js

@@ -260,8 +260,10 @@ function hasMany(type, options) {
         }
       }
       const support = lookupLegacySupport(this);
+      const manyArray = support.getManyArray(key);
+      assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
       this.store._join(() => {
-        support.setDirtyHasMany(key, records);
+        manyArray.splice(0, manyArray.length, ...records);
       });
 
       return support.getHasMany(key);

package/addon/-private/legacy-relationships-support.ts

@@ -1,23 +1,21 @@
-import { assert } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 import { importSync } from '@embroider/macros';
 import { all, resolve } from 'rsvp';
 
 import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
 import type { UpgradedMeta } from '@ember-data/record-data/-private/graph/-edge-definition';
+import type { LocalRelationshipOperation } from '@ember-data/record-data/-private/graph/-operations';
 import type { ImplicitRelationship } from '@ember-data/record-data/-private/graph/index';
 import type BelongsToRelationship from '@ember-data/record-data/-private/relationships/state/belongs-to';
 import type ManyRelationship from '@ember-data/record-data/-private/relationships/state/has-many';
 import type Store from '@ember-data/store';
-import { recordIdentifierFor, storeFor } from '@ember-data/store/-private';
-import { IdentifierCache } from '@ember-data/store/-private/caches/identifier-cache';
+import { fastPush, isStableIdentifier, recordIdentifierFor, SOURCE, storeFor } from '@ember-data/store/-private';
+import type { NonSingletonRecordDataManager } from '@ember-data/store/-private/managers/record-data-manager';
 import type { DSModel } from '@ember-data/types/q/ds-model';
-import {
-  CollectionResourceRelationship,
-  ResourceIdentifierObject,
-  SingleResourceRelationship,
-} from '@ember-data/types/q/ember-data-json-api';
+import { CollectionResourceRelationship, SingleResourceRelationship } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 import type { JsonApiRelationship } from '@ember-data/types/q/record-data-json-api';
@@ -27,8 +25,7 @@ import type { Dict } from '@ember-data/types/q/utils';
 
 import { _findBelongsTo, _findHasMany } from './legacy-data-fetch';
 import { assertIdentifierHasId } from './legacy-data-utils';
-import type { ManyArrayCreateArgs } from './many-array';
-import ManyArray from './many-array';
+import RelatedCollection from './many-array';
 import type { BelongsToProxyCreateArgs, BelongsToProxyMeta } from './promise-belongs-to';
 import PromiseBelongsTo from './promise-belongs-to';
 import type { HasManyProxyCreateArgs } from './promise-many-array';
@@ -36,7 +33,6 @@ import PromiseManyArray from './promise-many-array';
 import BelongsToReference from './references/belongs-to';
 import HasManyReference from './references/has-many';
 
-type ManyArrayFactory = { create(args: ManyArrayCreateArgs): ManyArray };
 type PromiseBelongsToFactory = { create(args: BelongsToProxyCreateArgs): PromiseBelongsTo };
 
 export class LegacySupport {
@@ -45,8 +41,8 @@ export class LegacySupport {
   declare recordData: RecordData;
   declare references: Dict<BelongsToReference | HasManyReference>;
   declare identifier: StableRecordIdentifier;
-  declare _manyArrayCache: Dict<ManyArray>;
-  declare _relationshipPromisesCache: Dict<Promise<ManyArray | RecordInstance>>;
+  declare _manyArrayCache: Dict<RelatedCollection>;
+  declare _relationshipPromisesCache: Dict<Promise<RelatedCollection | RecordInstance>>;
   declare _relationshipProxyCache: Dict<PromiseManyArray | PromiseBelongsTo>;
 
   declare isDestroying: boolean;
@@ -58,12 +54,38 @@ export class LegacySupport {
     this.identifier = recordIdentifierFor(record);
     this.recordData = this.store._instanceCache.getRecordData(this.identifier);
 
-    this._manyArrayCache = Object.create(null) as Dict<ManyArray>;
-    this._relationshipPromisesCache = Object.create(null) as Dict<Promise<ManyArray | RecordInstance>>;
+    this._manyArrayCache = Object.create(null) as Dict<RelatedCollection>;
+    this._relationshipPromisesCache = Object.create(null) as Dict<Promise<RelatedCollection | RecordInstance>>;
     this._relationshipProxyCache = Object.create(null) as Dict<PromiseManyArray | PromiseBelongsTo>;
     this.references = Object.create(null) as Dict<BelongsToReference>;
   }
 
+  _syncArray(array: RelatedCollection) {
+    // It’s possible the parent side of the relationship may have been destroyed by this point
+    if (this.isDestroyed || this.isDestroying) {
+      return;
+    }
+    const currentState = array[SOURCE];
+    const identifier = this.identifier;
+
+    let [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
+
+    if (jsonApi.meta) {
+      array.meta = jsonApi.meta;
+    }
+
+    if (jsonApi.links) {
+      array.links = jsonApi.links;
+    }
+
+    currentState.length = 0;
+    fastPush(currentState, identifiers);
+  }
+
+  updateCache(operation: LocalRelationshipOperation): void {
+    this.recordData.update(operation);
+  }
+
   _findBelongsTo(
     key: string,
     resource: SingleResourceRelationship,
@@ -104,8 +126,8 @@ export class LegacySupport {
   getBelongsTo(key: string, options?: FindOptions): PromiseBelongsTo | RecordInstance | null {
     const { identifier, recordData } = this;
     let resource = recordData.getRelationship(this.identifier, key) as SingleResourceRelationship;
-    let relatedIdentifier =
-      resource && resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
+    let relatedIdentifier = resource && resource.data ? resource.data : null;
+    assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
 
     const store = this.store;
     const graphFor = (
@@ -151,12 +173,45 @@ export class LegacySupport {
   }
 
   setDirtyBelongsTo(key: string, value: RecordInstance | null) {
-    return this.recordData.setBelongsTo(this.identifier, key, extractIdentifierFromRecord(value));
+    return this.recordData.update(
+      {
+        op: 'replaceRelatedRecord',
+        record: this.identifier,
+        field: key,
+        value: extractIdentifierFromRecord(value),
+      },
+      // @ts-expect-error
+      true
+    );
   }
 
-  getManyArray(key: string, definition?: UpgradedMeta): ManyArray {
+  _getCurrentState(
+    identifier: StableRecordIdentifier,
+    field: string
+  ): [StableRecordIdentifier[], CollectionResourceRelationship] {
+    let jsonApi = (this.recordData as NonSingletonRecordDataManager).getRelationship(
+      identifier,
+      field,
+      true
+    ) as CollectionResourceRelationship;
+    const cache = this.store._instanceCache;
+    let identifiers: StableRecordIdentifier[] = [];
+    if (jsonApi.data) {
+      for (let i = 0; i < jsonApi.data.length; i++) {
+        const identifier = jsonApi.data[i];
+        assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+        if (cache.recordIsLoaded(identifier, true)) {
+          identifiers.push(identifier);
+        }
+      }
+    }
+
+    return [identifiers, jsonApi];
+  }
+
+  getManyArray(key: string, definition?: UpgradedMeta): RelatedCollection {
     assert('hasMany only works with the @ember-data/record-data package', HAS_RECORD_DATA_PACKAGE);
-    let manyArray: ManyArray | undefined = this._manyArrayCache[key];
+    let manyArray: RelatedCollection | undefined = this._manyArrayCache[key];
     if (!definition) {
       const graphFor = (
         importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
@@ -165,17 +220,23 @@ export class LegacySupport {
     }
 
     if (!manyArray) {
-      manyArray = (ManyArray as unknown as ManyArrayFactory).create({
+      const [identifiers, doc] = this._getCurrentState(this.identifier, key);
+
+      manyArray = new RelatedCollection({
         store: this.store,
-        type: this.store.modelFor(definition.type),
+        type: definition.type,
         identifier: this.identifier,
         recordData: this.recordData,
+        identifiers,
         key,
+        meta: doc.meta || null,
+        links: doc.links || null,
         isPolymorphic: definition.isPolymorphic,
         isAsync: definition.isAsync,
         _inverseIsAsync: definition.inverseIsAsync,
-        legacySupport: this,
+        manager: this,
         isLoaded: !definition.isAsync,
+        allowMutation: true,
       });
       this._manyArrayCache[key] = manyArray;
     }
@@ -186,18 +247,24 @@ export class LegacySupport {
   fetchAsyncHasMany(
     key: string,
     relationship: ManyRelationship,
-    manyArray: ManyArray,
+    manyArray: RelatedCollection,
     options?: FindOptions
-  ): Promise<ManyArray> {
+  ): Promise<RelatedCollection> {
     if (HAS_RECORD_DATA_PACKAGE) {
-      let loadingPromise = this._relationshipPromisesCache[key] as Promise<ManyArray> | undefined;
+      let loadingPromise = this._relationshipPromisesCache[key] as Promise<RelatedCollection> | undefined;
       if (loadingPromise) {
         return loadingPromise;
       }
 
       const jsonApi = this.recordData.getRelationship(this.identifier, key) as CollectionResourceRelationship;
+      const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
 
-      loadingPromise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options).then(
+      if (!promise) {
+        manyArray.isLoaded = true;
+        return resolve(manyArray);
+      }
+
+      loadingPromise = promise.then(
         () => handleCompletedRelationshipRequest(this, key, relationship, manyArray),
         (e: Error) => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e)
       );
@@ -233,7 +300,7 @@ export class LegacySupport {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  getHasMany(key: string, options?: FindOptions): PromiseManyArray | ManyArray {
+  getHasMany(key: string, options?: FindOptions): PromiseManyArray | RelatedCollection {
     if (HAS_RECORD_DATA_PACKAGE) {
       const graphFor = (
         importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
@@ -264,11 +331,6 @@ export class LegacySupport {
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
 
-  setDirtyHasMany(key: string, records: RecordInstance[]) {
-    assertRecordsPassedToHasMany(records);
-    return this.recordData.setHasMany(this.identifier, key, extractIdentifiersFromRecords(records));
-  }
-
   _updatePromiseProxyFor(kind: 'hasMany', key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
   _updatePromiseProxyFor(kind: 'belongsTo', key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
   _updatePromiseProxyFor(
@@ -358,10 +420,10 @@ export class LegacySupport {
     parentIdentifier: StableRecordIdentifier,
     relationship: ManyRelationship,
     options: FindOptions = {}
-  ): Promise<void | unknown[]> {
+  ): Promise<void | unknown[]> | void {
     if (HAS_RECORD_DATA_PACKAGE) {
       if (!resource) {
-        return resolve();
+        return;
       }
       const { definition, state } = relationship;
       const adapter = this.store.adapterFor(definition.type);
@@ -411,11 +473,19 @@ export class LegacySupport {
 
       // fetch using data, pulling from local cache if possible
       if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
+        if (allInverseRecordsAreLoaded) {
+          return;
+        }
         assert(`Expected collection to be an array`, Array.isArray(resource.data));
+        if (allInverseRecordsAreLoaded) {
+          return;
+        }
         let finds = new Array(resource.data.length);
+        let cache = this.store._instanceCache;
         for (let i = 0; i < resource.data.length; i++) {
-          let identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data[i]);
-          finds[i] = this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
+          const identifier = resource.data[i];
+          assert(`expected a stable identifier`, isStableIdentifier(identifier));
+          finds[i] = cache._fetchDataIfNeededForIdentifier(identifier, options);
         }
 
         return all(finds);
@@ -425,8 +495,9 @@ export class LegacySupport {
 
       // fetch by data
       if (hasData || hasLocalPartialData) {
-        assert(`Expected collection to be an array`, Array.isArray(resource.data));
-        let identifiers = resource.data.map((json) => this.store.identifierCache.getOrCreateRecordIdentifier(json));
+        const identifiers = resource.data;
+        assert(`Expected collection to be an array`, Array.isArray(identifiers));
+        assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
         let fetches = new Array(identifiers.length);
         const manager = this.store._fetchManager;
 
@@ -441,7 +512,7 @@ export class LegacySupport {
 
       // we were explicitly told we have no data and no links.
       //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-      return resolve();
+      return;
     }
     assert(`hasMany only works with the @ember-data/record-data package`);
   }
@@ -456,7 +527,8 @@ export class LegacySupport {
       return resolve(null);
     }
 
-    const identifier = resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;
+    const identifier = resource.data ? resource.data : null;
+    assert(`Expected a stable identifier`, !identifier || isStableIdentifier(identifier));
 
     let { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = relationship.state;
 
@@ -557,8 +629,8 @@ function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: ManyRelationship,
-  value: ManyArray
-): ManyArray;
+  value: RelatedCollection
+): RelatedCollection;
 function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
@@ -570,16 +642,16 @@ function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: ManyRelationship,
-  value: ManyArray,
+  value: RelatedCollection,
   error: Error
 ): never;
 function handleCompletedRelationshipRequest(
   recordExt: LegacySupport,
   key: string,
   relationship: BelongsToRelationship | ManyRelationship,
-  value: ManyArray | StableRecordIdentifier | null,
+  value: RelatedCollection | StableRecordIdentifier | null,
   error?: Error
-): ManyArray | RecordInstance | null {
+): RelatedCollection | RecordInstance | null {
   delete recordExt._relationshipPromisesCache[key];
   relationship.state.shouldForceReload = false;
   const isHasMany = relationship.definition.kind === 'hasMany';
@@ -587,7 +659,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 as RelatedCollection).notify();
   }
 
   if (error) {
@@ -611,7 +683,7 @@ function handleCompletedRelationshipRequest(
   }
 
   if (isHasMany) {
-    (value as ManyArray).set('isLoaded', true);
+    (value as RelatedCollection).isLoaded = true;
   }
 
   relationship.state.hasFailedLoadAttempt = false;
@@ -619,33 +691,10 @@ function handleCompletedRelationshipRequest(
   relationship.state.isStale = false;
 
   return isHasMany || !value
-    ? (value as ManyArray | null)
+    ? (value as RelatedCollection | null)
     : recordExt.store.peekRecord(value as StableRecordIdentifier);
 }
 
-function assertRecordsPassedToHasMany(records: RecordInstance[]) {
-  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
-  assert(
-    `All elements of a hasMany relationship must be instances of Model, you passed ${records
-      .map((r) => `${typeof r}`)
-      .join(', ')}`,
-    (function () {
-      return records.every((record) => {
-        try {
-          recordIdentifierFor(record);
-          return true;
-        } catch {
-          return false;
-        }
-      });
-    })()
-  );
-}
-
-function extractIdentifiersFromRecords(records: RecordInstance[]): StableRecordIdentifier[] {
-  return records.map(extractIdentifierFromRecord) as StableRecordIdentifier[];
-}
-
 type PromiseProxyRecord = { then(): void; content: RecordInstance | null | undefined };
 
 function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord | RecordInstance | null) {
@@ -653,12 +702,25 @@ function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord |
     return null;
   }
 
-  if (isPromiseRecord(recordOrPromiseRecord)) {
+  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
     let content = recordOrPromiseRecord.content;
     assert(
       'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
       content !== undefined
     );
+    deprecate(
+      `You passed in a PromiseProxy to a Relationship 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',
+      }
+    );
     return content ? recordIdentifierFor(content) : null;
   }
 
@@ -681,30 +743,21 @@ function anyUnloaded(store: Store, relationship: ManyRelationship) {
 }
 
 function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship): boolean {
-  const cache = store.identifierCache;
+  const instanceCache = store._instanceCache;
+  const identifiers = resource.data;
 
-  if (Array.isArray(resource.data)) {
+  if (Array.isArray(identifiers)) {
+    assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
     // treat as collection
     // check for unloaded records
-    let hasEmptyRecords = resource.data.reduce((hasEmptyModel, resourceIdentifier) => {
-      return hasEmptyModel || isEmpty(store, cache, resourceIdentifier);
-    }, false);
-
-    return !hasEmptyRecords;
-  } else {
-    // treat as single resource
-    if (!resource.data) {
-      return true;
-    } else {
-      return !isEmpty(store, cache, resource.data);
-    }
+    return identifiers.every((identifier: StableRecordIdentifier) => instanceCache.recordIsLoaded(identifier));
   }
-}
 
-function isEmpty(store: Store, cache: IdentifierCache, resource: ResourceIdentifierObject): boolean {
-  const identifier = cache.getOrCreateRecordIdentifier(resource);
-  const recordData = store._instanceCache.__instances.recordData.get(identifier);
-  return !recordData || recordData.isEmpty(identifier);
+  // treat as single resource
+  if (!identifiers) return true;
+
+  assert(`Expected stable identifiers`, isStableIdentifier(identifiers));
+  return instanceCache.recordIsLoaded(identifiers);
 }
 
 function isBelongsTo(