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

package/addon/-private/managers/record-data-manager.ts

@@ -1,13 +1,17 @@
-import { assert } from '@ember/debug';
-
-import { CollectionResourceRelationship, SingleResourceRelationship } from '@ember-data/types/q/ember-data-json-api';
-import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
-import { ChangedAttributesHash, RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
-import { JsonApiResource, JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
-import { Dict } from '@ember-data/types/q/utils';
+import { assert, deprecate } from '@ember/debug';
+
+import type { LocalRelationshipOperation } from '@ember-data/record-data/-private/graph/-operations';
+import type {
+  CollectionResourceRelationship,
+  SingleResourceRelationship,
+} from '@ember-data/types/q/ember-data-json-api';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { ChangedAttributesHash, RecordData, RecordDataV1 } from '@ember-data/types/q/record-data';
+import type { JsonApiResource, JsonApiValidationError } from '@ember-data/types/q/record-data-json-api';
+import type { Dict } from '@ember-data/types/q/utils';
 
 import { isStableIdentifier } from '../caches/identifier-cache';
-import Store from '../store-service';
+import type Store from '../store-service';
 
 /**
  * The RecordDataManager wraps a RecordData cache
@@ -64,6 +68,19 @@ export class NonSingletonRecordDataManager implements RecordData {
     this.#store = store;
     this.#recordData = recordData;
     this.#identifier = identifier;
+
+    if (this.#isDeprecated(recordData)) {
+      deprecate(
+        `This RecordData uses the deprecated V1 RecordData Spec. Upgrade to V2 to maintain compatibility.`,
+        false,
+        {
+          id: 'ember-data:deprecate-v1-cache',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+          for: 'ember-data',
+        }
+      );
+    }
   }
 
   #isDeprecated(recordData: RecordData | RecordDataV1): recordData is RecordDataV1 {
@@ -111,6 +128,59 @@ export class NonSingletonRecordDataManager implements RecordData {
     return recordData.pushData(identifier, data, hasRecord);
   }
 
+  /**
+   * Update resource data with a local mutation. Currently supports operations
+   * on relationships only.
+   *
+   * @method update
+   * @public
+   * @param operation
+   */
+  // isCollection is only needed for interop with v1 cache
+  update(operation: LocalRelationshipOperation, isResource?: boolean): void {
+    if (this.#isDeprecated(this.#recordData)) {
+      const cache = this.#store._instanceCache;
+      switch (operation.op) {
+        case 'addToRelatedRecords':
+          this.#recordData.addToHasMany(
+            operation.field,
+            (operation.value as StableRecordIdentifier[]).map((i) => cache.getRecordData(i)),
+            operation.index
+          );
+          return;
+        case 'removeFromRelatedRecords':
+          this.#recordData.removeFromHasMany(
+            operation.field,
+            (operation.value as StableRecordIdentifier[]).map((i) => cache.getRecordData(i))
+          );
+          return;
+        case 'replaceRelatedRecords':
+          this.#recordData.setDirtyHasMany(
+            operation.field,
+            operation.value.map((i) => cache.getRecordData(i))
+          );
+          return;
+        case 'replaceRelatedRecord':
+          if (isResource) {
+            this.#recordData.setDirtyBelongsTo(
+              operation.field,
+              operation.value ? cache.getRecordData(operation.value) : null
+            );
+            return;
+          }
+          this.#recordData.removeFromHasMany(operation.field, [cache.getRecordData(operation.prior!)]);
+          this.#recordData.addToHasMany(operation.field, [cache.getRecordData(operation.value!)], operation.index);
+          return;
+        case 'sortRelatedRecords':
+          return;
+        default:
+          return;
+      }
+    } else {
+      this.#recordData.update(operation);
+    }
+  }
+
   /**
    * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
    *
@@ -457,25 +527,7 @@ export class NonSingletonRecordDataManager implements RecordData {
   /**
    * Mutate the current state of a belongsTo relationship
    *
-   * @method setBelongsTo
-   * @public
-   * @param identifier
-   * @param propertyName
-   * @param value
-   */
-  setBelongsTo(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier | null) {
-    const store = this.#store;
-    const recordData = this.#recordData;
-
-    this.#isDeprecated(recordData)
-      ? recordData.setDirtyBelongsTo(propertyName, value ? store._instanceCache.getRecordData(value) : null)
-      : recordData.setBelongsTo(identifier, propertyName, value);
-  }
-
-  /**
-   * Mutate the current state of a belongsTo relationship
-   *
-   * DEPRECATED use setBelongsTo
+   * DEPRECATED use update
    *
    * @method setDirtyBelongsTo
    * @public
@@ -487,8 +539,13 @@ export class NonSingletonRecordDataManager implements RecordData {
     const recordData = this.#recordData;
 
     this.#isDeprecated(recordData)
-      ? recordData.setDirtyBelongsTo(propertyName, value as unknown as RecordData)
-      : recordData.setBelongsTo(this.#identifier, propertyName, value ? value.getResourceIdentifier() : null);
+      ? recordData.setDirtyBelongsTo(propertyName, value)
+      : recordData.update({
+          op: 'replaceRelatedRecord',
+          record: this.#identifier,
+          field: propertyName,
+          value: value ? value.getResourceIdentifier() : null,
+        });
   }
 
   /**
@@ -496,98 +553,52 @@ export class NonSingletonRecordDataManager implements RecordData {
    * An index may optionally be specified which the cache should use for
    * where in the list to insert the records
    *
+   * DEPRECATED use update
+   *
    * @method addToHasMany
+   * @deprecated
    * @public
-   * @param identifier
    * @param propertyName
    * @param value
    * @param idx
    */
-  addToHasMany(
-    identifier: StableRecordIdentifier,
-    propertyName: string,
-    value: StableRecordIdentifier[],
-    idx?: number
-  ): void {
-    // called by something V1
-    let isFromV1 = false;
-    if (!isStableIdentifier(identifier)) {
-      isFromV1 = true;
-      idx = value as unknown as number;
-      value = propertyName as unknown as StableRecordIdentifier[];
-      propertyName = identifier as unknown as string;
-      identifier = this.#identifier;
-    }
-    const cache = this.#store._instanceCache;
+  addToHasMany(propertyName: string, value: NonSingletonRecordDataManager[], idx?: number): void {
+    const identifier = this.#identifier;
     const recordData = this.#recordData;
 
     this.#isDeprecated(recordData)
-      ? recordData.addToHasMany(
-          propertyName,
-          isFromV1 ? (value as unknown as RecordData[]) : value.map((v) => cache.getRecordData(v)),
-          idx
-        )
-      : recordData.addToHasMany(
-          identifier,
-          propertyName,
-          isFromV1
-            ? (value as unknown as NonSingletonRecordDataManager[]).map((v) => v.getResourceIdentifier())
-            : value,
-          idx
-        );
+      ? recordData.addToHasMany(propertyName, value, idx)
+      : recordData.update({
+          op: 'addToRelatedRecords',
+          field: propertyName,
+          record: identifier,
+          value: value.map((v) => v.getResourceIdentifier()),
+        });
   }
 
   /**
    * Mutate the current state of a hasMany relationship by removing values.
    *
-   * @method removeFromHasMany
-   * @public
-   * @param identifier
-   * @param propertyName
-   * @param value
-   */
-  removeFromHasMany(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier[]): void {
-    let isFromV1 = false;
-    if (!isStableIdentifier(identifier)) {
-      isFromV1 = true;
-      value = propertyName as unknown as StableRecordIdentifier[];
-      propertyName = identifier as unknown as string;
-      identifier = this.#identifier;
-    }
-    const cache = this.#store._instanceCache;
-    const recordData = this.#recordData;
-
-    this.#isDeprecated(recordData)
-      ? recordData.removeFromHasMany(
-          propertyName,
-          isFromV1 ? (value as unknown as RecordData[]) : value.map((v) => cache.getRecordData(v))
-        )
-      : recordData.removeFromHasMany(
-          identifier,
-          propertyName,
-          isFromV1 ? (value as unknown as NonSingletonRecordDataManager[]).map((v) => v.getResourceIdentifier()) : value
-        );
-  }
-
-  /**
-   * Mutate the current state of a hasMany relationship by replacing it entirely
+   * DEPRECATED use update
    *
-   * @method setHasMany
+   * @method removeFromHasMany
+   * @deprecated
    * @public
-   * @param identifier
    * @param propertyName
    * @param value
    */
-  setHasMany(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier[]): void {
-    const cache = this.#store._instanceCache;
+  removeFromHasMany(propertyName: string, value: RecordData[]): void {
+    const identifier = this.#identifier;
     const recordData = this.#recordData;
 
     this.#isDeprecated(recordData)
-      ? recordData.setDirtyHasMany(
-          propertyName,
-          value.map((identifier) => cache.getRecordData(identifier))
-        )
-      : recordData.setHasMany(identifier, propertyName, value);
+      ? recordData.removeFromHasMany(propertyName, value)
+      : recordData.update({
+          op: 'removeFromRelatedRecords',
+          record: identifier,
+          field: propertyName,
+          value: (value as unknown as NonSingletonRecordDataManager[]).map((v) => v.getResourceIdentifier()),
+        });
   }
 
   /**
@@ -601,16 +612,17 @@ export class NonSingletonRecordDataManager implements RecordData {
    * @param propertyName
    * @param value
    */
-  setDirtyHasMany(propertyName: string, value: RecordData[]) {
+  setDirtyHasMany(propertyName: string, value: NonSingletonRecordDataManager[]) {
     let recordData = this.#recordData;
 
     this.#isDeprecated(recordData)
       ? recordData.setDirtyHasMany(propertyName, value)
-      : recordData.setHasMany(
-          this.#identifier,
-          propertyName,
-          (value as unknown as NonSingletonRecordDataManager[]).map((rd) => rd.getResourceIdentifier())
-        );
+      : recordData.update({
+          op: 'replaceRelatedRecords',
+          record: this.#identifier,
+          field: propertyName,
+          value: value.map((rd) => rd.getResourceIdentifier()),
+        });
   }
 
   // State
@@ -706,11 +718,9 @@ export class NonSingletonRecordDataManager implements RecordData {
 export class SingletonRecordDataManager implements RecordData {
   version: '2' = '2';
 
-  #store: Store;
   #recordDatas: Map<StableRecordIdentifier, RecordData>;
 
-  constructor(store: Store) {
-    this.#store = store;
+  constructor() {
     this.#recordDatas = new Map();
   }
 
@@ -779,26 +789,8 @@ export class SingletonRecordDataManager implements RecordData {
   ): SingleResourceRelationship | CollectionResourceRelationship {
     return this.#recordData(identifier).getRelationship(identifier, propertyName);
   }
-
-  setBelongsTo(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier | null) {
-    this.#recordData(identifier).setBelongsTo(identifier, propertyName, value);
-  }
-
-  addToHasMany(
-    identifier: StableRecordIdentifier,
-    propertyName: string,
-    value: StableRecordIdentifier[],
-    idx?: number
-  ): void {
-    this.#recordData(identifier).addToHasMany(identifier, propertyName, value, idx);
-  }
-
-  removeFromHasMany(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier[]): void {
-    this.#recordData(identifier).removeFromHasMany(identifier, propertyName, value);
-  }
-
-  setHasMany(identifier: StableRecordIdentifier, propertyName: string, value: StableRecordIdentifier[]): void {
-    this.#recordData(identifier).setHasMany(identifier, propertyName, value);
+  update(operation: LocalRelationshipOperation): void {
+    this.#recordData(operation.record).update(operation);
   }
 
   // State

package/addon/-private/managers/record-data-store-wrapper.ts

@@ -350,7 +350,13 @@ class V2RecordDataStoreWrapper implements StoreWrapper {
     }
 
     this._willNotify = true;
-    this._store._schedule('notify', () => this._flushNotifications());
+    // it's possible a RecordData adhoc notifies us,
+    // in which case we sync flush
+    if (this._store._cbs) {
+      this._store._schedule('notify', () => this._flushNotifications());
+    } else {
+      this._flushNotifications();
+    }
   }
 
   _flushNotifications(): void {

package/addon/-private/managers/record-notification-manager.ts

@@ -53,6 +53,7 @@ export default class NotificationManager {
       map = new Map();
       Cache.set(identifier, map);
     }
+
     let unsubToken = DEBUG ? { _tokenRef: tokenId++ } : {};
     map.set(unsubToken, callback);
     Tokens.set(unsubToken, identifier);

package/addon/-private/network/fetch-manager.ts

@@ -5,8 +5,10 @@ import { assert, deprecate, warn } from '@ember/debug';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
+import { importSync } from '@embroider/macros';
 import { default as RSVP, resolve } from 'rsvp';
 
+import { HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
 import type { CollectionResourceDocument, SingleResourceDocument } from '@ember-data/types/q/ember-data-json-api';
 import type { FindRecordQuery, Request, SaveRecordMutation } from '@ember-data/types/q/fetch-manager';
@@ -214,7 +216,20 @@ export default class FetchManager {
       (error) => {
         const recordData = store._instanceCache.peek({ identifier, bucket: 'recordData' });
         if (!recordData || recordData.isEmpty(identifier) || isLoading) {
-          store._instanceCache.unloadRecord(identifier);
+          let isReleasable = true;
+          if (!recordData && HAS_RECORD_DATA_PACKAGE) {
+            const graphFor = (
+              importSync('@ember-data/record-data/-private') as typeof import('@ember-data/record-data/-private')
+            ).graphFor;
+            const graph = graphFor(store);
+            isReleasable = graph.isReleasable(identifier);
+            if (!isReleasable) {
+              graph.unload(identifier, true);
+            }
+          }
+          if (recordData || isReleasable) {
+            store._instanceCache.unloadRecord(identifier);
+          }
         }
         throw error;
       }

package/addon/-private/network/snapshot-record-array.ts

@@ -10,7 +10,8 @@ import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
-import type RecordArray from '../record-arrays/record-array';
+import type IdentifierArray from '../record-arrays/identifier-array';
+import { SOURCE } from '../record-arrays/identifier-array';
 import Store from '../store-service';
 import type Snapshot from './snapshot';
 /**
@@ -23,12 +24,11 @@ import type Snapshot from './snapshot';
 */
 export default class SnapshotRecordArray {
   declare _snapshots: Snapshot[] | null;
-  declare _recordArray: RecordArray;
+  declare _recordArray: IdentifierArray;
   declare _type: ModelSchema | null;
   declare __store: Store;
 
   declare length: number;
-  declare meta: Dict<unknown> | null;
   declare adapterOptions?: Dict<unknown>;
   declare include?: string;
 
@@ -41,10 +41,9 @@ export default class SnapshotRecordArray {
     @private
     @constructor
     @param {RecordArray} recordArray
-    @param {Object} meta
     @param options
    */
-  constructor(store: Store, recordArray: RecordArray, options: FindOptions = {}) {
+  constructor(store: Store, recordArray: IdentifierArray, options: FindOptions = {}) {
     this.__store = store;
     /**
       An array of snapshots
@@ -181,8 +180,9 @@ export default class SnapshotRecordArray {
     if (this._snapshots !== null) {
       return this._snapshots;
     }
+
     const { _instanceCache } = this.__store;
-    this._snapshots = this._recordArray.content.map((identifier: StableRecordIdentifier) =>
+    this._snapshots = this._recordArray[SOURCE].map((identifier: StableRecordIdentifier) =>
       _instanceCache.createSnapshot(identifier)
     );
 

package/addon/-private/proxies/promise-proxies.ts

@@ -91,13 +91,13 @@ export class PromiseArray<I, T extends EmberArrayLike<I>> extends PromiseArrayPr
 */
 export { PromiseObjectProxy as PromiseObject };
 
-export function promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
+function _promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
   return PromiseObjectProxy.create({
     promise: resolve(promise, label),
   }) as PromiseObjectProxy<T>;
 }
 
-export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
+function _promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
   return PromiseArray.create({
     promise: resolve(promise, label),
   }) as unknown as PromiseArray<I, T>;
@@ -105,35 +105,96 @@ export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<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_ARRAY_PROPS = [
+  'length',
+  '[]',
+  'firstObject',
+  'lastObject',
+  'meta',
+  'content',
+  'isPending',
+  'isSettled',
+  'isRejected',
+  'isFulfilled',
+  'promise',
+  'reason',
+];
+const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
+
+export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>): PromiseArray<I, T> {
+  const promiseObjectProxy: PromiseArray<I, T> = _promiseArray(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} on this PromiseArray is deprecated. The return type is being changed from PromiseArray to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            for: '@ember-data/store',
+            since: {
+              available: '4.8',
+              enabled: '4.8',
+            },
+          }
+        );
+      }
 
-export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObjectProxy<T> {
-  const promiseObjectProxy: PromiseObjectProxy<T> = promiseObject(promise);
+      const value: unknown = target[prop];
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(target);
+      }
+
+      if (PROXIED_ARRAY_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
+    },
+  };
+
+  return new Proxy(promiseObjectProxy, handler);
+}
+
+export function promiseObject<T>(promise: Promise<T>): PromiseObjectProxy<T> {
+  const promiseObjectProxy: PromiseObjectProxy<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`,
+          `Accessing ${prop} on this PromiseObject is deprecated. The return type is being changed from PromiseObject to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
           false,
           {
-            id: 'ember-data:model-save-promise',
+            id: 'ember-data:deprecate-promise-proxies',
             until: '5.0',
             for: '@ember-data/store',
             since: {
-              available: '4.4',
-              enabled: '4.4',
+              available: '4.8',
+              enabled: '4.8',
             },
           }
         );
       }
 
-      const value: unknown = Reflect.get(target, prop, receiver);
+      const value: unknown = target[prop];
       if (value && typeof value === 'function' && typeof value.bind === 'function') {
         return value.bind(target);
       }
 
-      return value;
+      if (PROXIED_OBJECT_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
     },
   };
 
-  return new Proxy(promiseObjectProxy, handler) as PromiseObjectProxy<T>;
+  return new Proxy(promiseObjectProxy, handler);
 }