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

package/addon/-private/system/model/states.js

@@ -262,6 +262,7 @@ const DirtyState = {
 
     rolledBack(internalModel) {
       internalModel.transitionTo('loaded.saved');
+      internalModel.triggerLater('rolledBack');
     },
 
     becameInvalid(internalModel) {
@@ -270,6 +271,7 @@ const DirtyState = {
 
     rollback(internalModel) {
       internalModel.rollbackAttributes();
+      internalModel.triggerLater('ready');
     },
   },
 
@@ -295,7 +297,9 @@ const DirtyState = {
       internalModel.send('invokeLifecycleCallbacks', this.dirtyType);
     },
 
-    rolledBack() {},
+    rolledBack(internalModel) {
+      internalModel.triggerLater('rolledBack');
+    },
 
     becameInvalid(internalModel) {
       internalModel.transitionTo('invalid');
@@ -304,6 +308,7 @@ const DirtyState = {
 
     becameError(internalModel) {
       internalModel.transitionTo('uncommitted');
+      internalModel.triggerLater('becameError', internalModel);
     },
   },
 
@@ -340,13 +345,16 @@ const DirtyState = {
     rolledBack(internalModel) {
       clearErrorMessages(internalModel);
       internalModel.transitionTo('loaded.saved');
+      internalModel.triggerLater('ready');
     },
 
     becameValid(internalModel) {
       internalModel.transitionTo('uncommitted');
     },
 
-    invokeLifecycleCallbacks() {},
+    invokeLifecycleCallbacks(internalModel) {
+      internalModel.triggerLater('becameInvalid', internalModel);
+    },
   },
 };
 
@@ -395,10 +403,12 @@ const createdState = dirtyState({
 
 createdState.invalid.rolledBack = function (internalModel) {
   internalModel.transitionTo('deleted.saved');
+  internalModel.triggerLater('rolledBack');
 };
 
 createdState.uncommitted.rolledBack = function (internalModel) {
   internalModel.transitionTo('deleted.saved');
+  internalModel.triggerLater('rolledBack');
 };
 
 const updatedState = dirtyState({
@@ -423,6 +433,7 @@ createdState.uncommitted.pushedData = function (internalModel) {
   // TODO @runspired consider where to do this once we kill off state machine
   internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');
   internalModel.transitionTo('loaded.updated.uncommitted');
+  internalModel.triggerLater('didLoad');
 };
 
 createdState.uncommitted.propertyWasReset = function () {};
@@ -447,6 +458,7 @@ updatedState.uncommitted.deleteRecord = function (internalModel) {
 updatedState.invalid.rolledBack = function (internalModel) {
   clearErrorMessages(internalModel);
   internalModel.transitionTo('loaded.saved');
+  internalModel.triggerLater('rolledBack');
 };
 
 const RootState = {
@@ -488,10 +500,13 @@ const RootState = {
 
     loadedData(internalModel) {
       internalModel.transitionTo('loaded.created.uncommitted');
+      internalModel.triggerLater('ready');
     },
 
     pushedData(internalModel) {
       internalModel.transitionTo('loaded.saved');
+      internalModel.triggerLater('didLoad');
+      internalModel.triggerLater('ready');
     },
 
     // Record is already in an empty state, triggering transition to empty here
@@ -518,11 +533,15 @@ const RootState = {
     // EVENTS
     pushedData(internalModel) {
       internalModel.transitionTo('loaded.saved');
+      internalModel.triggerLater('didLoad');
+      internalModel.triggerLater('ready');
       //TODO this seems out of place here
       internalModel.didCleanError();
     },
 
-    becameError() {},
+    becameError(internalModel) {
+      internalModel.triggerLater('becameError', internalModel);
+    },
 
     notFound(internalModel) {
       internalModel.transitionTo('empty');
@@ -621,6 +640,7 @@ const RootState = {
 
       rollback(internalModel) {
         internalModel.rollbackAttributes();
+        internalModel.triggerLater('ready');
       },
 
       pushedData() {},
@@ -629,6 +649,8 @@ const RootState = {
 
       rolledBack(internalModel) {
         internalModel.transitionTo('loaded.saved');
+        internalModel.triggerLater('ready');
+        internalModel.triggerLater('rolledBack');
       },
     },
 
@@ -654,10 +676,12 @@ const RootState = {
 
       becameError(internalModel) {
         internalModel.transitionTo('uncommitted');
+        internalModel.triggerLater('becameError', internalModel);
       },
 
       becameInvalid(internalModel) {
         internalModel.transitionTo('invalid');
+        internalModel.triggerLater('becameInvalid', internalModel);
       },
     },
 
@@ -672,7 +696,10 @@ const RootState = {
         internalModel.removeFromInverseRelationships();
       },
 
-      invokeLifecycleCallbacks() {},
+      invokeLifecycleCallbacks(internalModel) {
+        internalModel.triggerLater('didDelete', internalModel);
+        internalModel.triggerLater('didCommit', internalModel);
+      },
 
       willCommit() {},
       didCommit() {},
@@ -700,6 +727,7 @@ const RootState = {
       rolledBack(internalModel) {
         clearErrorMessages(internalModel);
         internalModel.transitionTo('loaded.saved');
+        internalModel.triggerLater('ready');
       },
 
       becameValid(internalModel) {
@@ -708,7 +736,15 @@ const RootState = {
     },
   },
 
-  invokeLifecycleCallbacks() {},
+  invokeLifecycleCallbacks(internalModel, dirtyType) {
+    if (dirtyType === 'created') {
+      internalModel.triggerLater('didCreate', internalModel);
+    } else {
+      internalModel.triggerLater('didUpdate', internalModel);
+    }
+
+    internalModel.triggerLater('didCommit', internalModel);
+  },
 };
 
 function wireState(object, parent, name) {

package/addon/-private/system/{promise-proxies.ts → promise-proxies.js}

@@ -1,11 +1,10 @@
+import ArrayProxy from '@ember/array/proxy';
 import { deprecate } from '@ember/debug';
-import type ComputedProperty from '@ember/object/computed';
 import { reads } from '@ember/object/computed';
+import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import ObjectProxy from '@ember/object/proxy';
 
-import { resolve } from 'rsvp';
-
-import type { Dict } from '../ts-interfaces/utils';
-import { PromiseArrayProxy, PromiseObjectProxy } from './promise-proxy-base';
+import { Promise } from 'rsvp';
 
 /**
   @module @ember-data/store
@@ -42,20 +41,9 @@ import { PromiseArrayProxy, PromiseObjectProxy } from './promise-proxy-base';
   @extends Ember.ArrayProxy
   @uses Ember.PromiseProxyMixin
 */
-interface EmberNativeArrayLike<T> {
-  length: number | ComputedProperty<number>;
-  objectAt(idx: number): T | undefined;
-}
-interface EmberArrayProxyLike<T> {
-  length: number | ComputedProperty<number>;
-  objectAtContent(idx: number): T | undefined;
-}
-type EmberArrayLike<T> = EmberNativeArrayLike<T> | EmberArrayProxyLike<T>;
-
-export class PromiseArray<I, T extends EmberArrayLike<I>> extends PromiseArrayProxy<I, T> {
-  @reads('content.meta')
-  declare meta?: Dict<unknown>;
-}
+export const PromiseArray = ArrayProxy.extend(PromiseProxyMixin, {
+  meta: reads('content.meta'),
+});
 
 /**
   A `PromiseObject` is an object that acts like both an `EmberObject`
@@ -88,26 +76,26 @@ export class PromiseArray<I, T extends EmberArrayLike<I>> extends PromiseArrayPr
   @extends Ember.ObjectProxy
   @uses Ember.PromiseProxyMixin
 */
-export { PromiseObjectProxy as PromiseObject };
+export let PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
 
-export function promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
-  return PromiseObjectProxy.create({
-    promise: resolve(promise, label),
-  }) as PromiseObjectProxy<T>;
+export function promiseObject(promise, label) {
+  return PromiseObject.create({
+    promise: Promise.resolve(promise, label),
+  });
 }
 
-export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
+export function promiseArray(promise, label) {
   return PromiseArray.create({
-    promise: resolve(promise, label),
-  }) as unknown as PromiseArray<I, T>;
+    promise: Promise.resolve(promise, label),
+  });
 }
 
 // constructor is accessed in some internals but not including it in the copyright for the deprecation
 const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
 
-export function deprecatedPromiseObject<T>(promise: PromiseObjectProxy<T>): PromiseObjectProxy<T> {
+export function deprecatedPromiseObject(promise) {
   const handler = {
-    get(target: object, prop: string, receiver?: object): unknown {
+    get(target, prop) {
       if (!ALLOWABLE_METHODS.includes(prop)) {
         deprecate(
           `Accessing ${prop} is deprecated.  Only available methods to access on a promise returned from model.save() are .then, .catch and .finally`,
@@ -124,9 +112,11 @@ export function deprecatedPromiseObject<T>(promise: PromiseObjectProxy<T>): Prom
         );
       }
 
-      return (Reflect.get(target, prop, receiver) as Function).bind(target);
+      /* global Reflect */
+      return Reflect.get(...arguments).bind(target);
     },
   };
 
-  return new Proxy(promise, handler) as PromiseObjectProxy<T>;
+  /* global Proxy */
+  return new Proxy(promise, handler);
 }

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

@@ -4,39 +4,37 @@
 
 import { A } from '@ember/array';
 import { assert } from '@ember/debug';
-import { set } from '@ember/object';
+import { get, set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-// import isStableIdentifier from '../identifiers/is-stable-identifier';
-import type { CollectionResourceDocument, Meta } from '../ts-interfaces/ember-data-json-api';
-import type { StableRecordIdentifier } from '../ts-interfaces/identifier';
-import type { Dict } from '../ts-interfaces/utils';
-import type CoreStore from './core-store';
+import isStableIdentifier from '../identifiers/is-stable-identifier';
 import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { internalModelFactoryFor } from './store/internal-model-factory';
 import WeakCache from './weak-cache';
 
-const RecordArraysCache = new WeakCache<StableRecordIdentifier, Set<RecordArray>>(DEBUG ? 'record-arrays' : '');
+const RecordArraysCache = new WeakCache(DEBUG ? 'record-arrays' : '');
 RecordArraysCache._generator = () => new Set();
-export function recordArraysForIdentifier(identifier: StableRecordIdentifier): Set<RecordArray> {
-  return RecordArraysCache.lookup(identifier);
+export function recordArraysForIdentifier(identifierOrInternalModel) {
+  return RecordArraysCache.lookup(identifierOrInternalModel);
 }
 
-const pendingForIdentifier: Set<StableRecordIdentifier> = new Set([]);
+const pendingForIdentifier = new Set([]);
 
-function getIdentifier(identifier: StableRecordIdentifier): StableRecordIdentifier {
-  // during dematerialization we will get an identifier that
-  // has already been removed from the identifiers cache
-  // so it will not behave as if stable. This is a bug we should fix.
-  // if (!isStableIdentifier(identifierOrInternalModel)) {
-  //   console.log({ unstable: i });
-  // }
+function getIdentifier(identifierOrInternalModel) {
+  let i = identifierOrInternalModel;
+  if (!isStableIdentifier(identifierOrInternalModel)) {
+    // identifier may actually be an internalModel
+    // but during materialization we will get an identifier that
+    // has already been removed from the identifiers cache yet
+    // so it will not behave as if stable. This is a bug we should fix.
+    i = identifierOrInternalModel.identifier || i;
+  }
 
-  return identifier;
+  return i;
 }
 
-function shouldIncludeInRecordArrays(store: CoreStore, identifier: StableRecordIdentifier): boolean {
+function shouldIncludeInRecordArrays(store, identifier) {
   const cache = internalModelFactoryFor(store);
   const internalModel = cache.peek(identifier);
 
@@ -51,19 +49,12 @@ function shouldIncludeInRecordArrays(store: CoreStore, identifier: StableRecordI
   @internal
 */
 class RecordArrayManager {
-  declare store: CoreStore;
-  declare isDestroying: boolean;
-  declare isDestroyed: boolean;
-  declare _liveRecordArrays: Dict<RecordArray>;
-  declare _pendingIdentifiers: Dict<StableRecordIdentifier[]>;
-  declare _adapterPopulatedRecordArrays: RecordArray[];
-
-  constructor(options: { store: CoreStore }) {
+  constructor(options) {
     this.store = options.store;
     this.isDestroying = false;
     this.isDestroyed = false;
-    this._liveRecordArrays = Object.create(null) as Dict<RecordArray>;
-    this._pendingIdentifiers = Object.create(null) as Dict<StableRecordIdentifier[]>;
+    this._liveRecordArrays = Object.create(null);
+    this._pendingIdentifiers = Object.create(null);
     this._adapterPopulatedRecordArrays = [];
   }
 
@@ -73,15 +64,15 @@ class RecordArrayManager {
    * @param {StableIdentifier} param
    * @return {RecordArray} array
    */
-  getRecordArraysForIdentifier(identifier: StableRecordIdentifier): Set<RecordArray> {
+  getRecordArraysForIdentifier(identifier) {
     return recordArraysForIdentifier(identifier);
   }
 
-  _flushPendingIdentifiersForModelName(modelName: string, identifiers: StableRecordIdentifier[]): void {
+  _flushPendingIdentifiersForModelName(modelName, identifiers) {
     if (this.isDestroying || this.isDestroyed) {
       return;
     }
-    let identifiersToRemove: StableRecordIdentifier[] = [];
+    let modelsToRemove = [];
 
     for (let j = 0; j < identifiers.length; j++) {
       let i = identifiers[j];
@@ -91,7 +82,7 @@ class RecordArrayManager {
       // build up a set of models to ensure we have purged correctly;
       let isIncluded = shouldIncludeInRecordArrays(this.store, i);
       if (!isIncluded) {
-        identifiersToRemove.push(i);
+        modelsToRemove.push(i);
       }
     }
 
@@ -103,33 +94,30 @@ class RecordArrayManager {
     }
 
     // process adapterPopulatedRecordArrays
-    if (identifiersToRemove.length > 0) {
-      removeFromAdapterPopulatedRecordArrays(this.store, identifiersToRemove);
+    if (modelsToRemove.length > 0) {
+      removeFromAdapterPopulatedRecordArrays(this.store, modelsToRemove);
     }
   }
 
   _flush() {
     let pending = this._pendingIdentifiers;
-    this._pendingIdentifiers = Object.create(null) as Dict<StableRecordIdentifier[]>;
+    this._pendingIdentifiers = Object.create(null);
 
     for (let modelName in pending) {
-      this._flushPendingIdentifiersForModelName(modelName, pending[modelName]!);
+      this._flushPendingIdentifiersForModelName(modelName, pending[modelName]);
     }
   }
 
-  _syncLiveRecordArray(array: RecordArray, modelName: string) {
+  _syncLiveRecordArray(array, modelName) {
     assert(
       `recordArrayManger.syncLiveRecordArray expects modelName not modelClass as the second param`,
       typeof modelName === 'string'
     );
     let pending = this._pendingIdentifiers[modelName];
-
-    if (!Array.isArray(pending)) {
-      return;
-    }
-    let hasNoPotentialDeletions = pending.length === 0;
+    let hasPendingChanges = Array.isArray(pending);
+    let hasNoPotentialDeletions = !hasPendingChanges || pending.length === 0;
     let map = internalModelFactoryFor(this.store).modelMapFor(modelName);
-    let hasNoInsertionsOrRemovals = map.length === array.length;
+    let hasNoInsertionsOrRemovals = get(map, 'length') === get(array, 'length');
 
     /*
       Ideally the recordArrayManager has knowledge of the changes to be applied to
@@ -141,26 +129,28 @@ class RecordArrayManager {
       return;
     }
 
-    this._flushPendingIdentifiersForModelName(modelName, pending);
-    delete this._pendingIdentifiers[modelName];
+    if (hasPendingChanges) {
+      this._flushPendingIdentifiersForModelName(modelName, pending);
+      delete this._pendingIdentifiers[modelName];
+    }
 
     let identifiers = this._visibleIdentifiersByType(modelName);
-    let identifiersToAdd: StableRecordIdentifier[] = [];
+    let modelsToAdd = [];
     for (let i = 0; i < identifiers.length; i++) {
       let identifier = identifiers[i];
       let recordArrays = recordArraysForIdentifier(identifier);
       if (recordArrays.has(array) === false) {
         recordArrays.add(array);
-        identifiersToAdd.push(identifier);
+        modelsToAdd.push(identifier);
       }
     }
 
-    if (identifiersToAdd.length) {
-      array._pushIdentifiers(identifiersToAdd);
+    if (modelsToAdd.length) {
+      array._pushIdentifiers(modelsToAdd);
     }
   }
 
-  _didUpdateAll(modelName: string): void {
+  _didUpdateAll(modelName) {
     let recordArray = this._liveRecordArrays[modelName];
     if (recordArray) {
       set(recordArray, 'isUpdating', false);
@@ -176,7 +166,7 @@ class RecordArrayManager {
     @param {String} modelName
     @return {RecordArray}
   */
-  liveRecordArrayFor(modelName: string): RecordArray {
+  liveRecordArrayFor(modelName) {
     assert(
       `recordArrayManger.liveRecordArrayFor expects modelName not modelClass as the param`,
       typeof modelName === 'string'
@@ -198,9 +188,9 @@ class RecordArrayManager {
     return array;
   }
 
-  _visibleIdentifiersByType(modelName: string) {
+  _visibleIdentifiersByType(modelName) {
     let all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;
-    let visible: StableRecordIdentifier[] = [];
+    let visible = [];
     for (let i = 0; i < all.length; i++) {
       let identifier = all[i];
       let shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);
@@ -221,7 +211,7 @@ class RecordArrayManager {
     @param {Array} [identifiers]
     @return {RecordArray}
   */
-  createRecordArray(modelName: string, identifiers: StableRecordIdentifier[] = []): RecordArray {
+  createRecordArray(modelName, identifiers) {
     assert(
       `recordArrayManger.createRecordArray expects modelName not modelClass as the param`,
       typeof modelName === 'string'
@@ -251,18 +241,13 @@ class RecordArrayManager {
     @param {Object} query
     @return {AdapterPopulatedRecordArray}
   */
-  createAdapterPopulatedRecordArray(
-    modelName: string,
-    query: Dict<unknown> | undefined,
-    identifiers: StableRecordIdentifier[],
-    payload?: CollectionResourceDocument
-  ): AdapterPopulatedRecordArray {
+  createAdapterPopulatedRecordArray(modelName, query, identifiers, payload) {
     assert(
       `recordArrayManger.createAdapterPopulatedRecordArray expects modelName not modelClass as the first param, received ${modelName}`,
       typeof modelName === 'string'
     );
 
-    let array: AdapterPopulatedRecordArray;
+    let array;
     if (Array.isArray(identifiers)) {
       array = AdapterPopulatedRecordArray.create({
         modelName,
@@ -272,11 +257,8 @@ class RecordArrayManager {
         manager: this,
         isLoaded: true,
         isUpdating: false,
-        // TODO this assign kills the root reference but a deep-copy would be required
-        // for both meta and links to actually not be by-ref. We whould likely change
-        // this to a dev-only deep-freeze.
-        meta: Object.assign({} as Meta, payload!.meta),
-        links: Object.assign({}, payload!.links),
+        meta: { ...payload.meta },
+        links: { ...payload.links },
       });
 
       this._associateWithRecordArray(identifiers, array);
@@ -284,8 +266,7 @@ class RecordArrayManager {
       array = AdapterPopulatedRecordArray.create({
         modelName,
         query: query,
-        content: A<StableRecordIdentifier>(),
-        isLoaded: false,
+        content: A(),
         store: this.store,
         manager: this,
       });
@@ -304,7 +285,7 @@ class RecordArrayManager {
     @internal
     @param {RecordArray} array
   */
-  unregisterRecordArray(array: RecordArray): void {
+  unregisterRecordArray(array) {
     let modelName = array.modelName;
 
     // remove from adapter populated record array
@@ -327,7 +308,7 @@ class RecordArrayManager {
    * @param {StableIdentifier} identifiers
    * @param {RecordArray} array
    */
-  _associateWithRecordArray(identifiers: StableRecordIdentifier[], array: RecordArray): void {
+  _associateWithRecordArray(identifiers, array) {
     for (let i = 0, l = identifiers.length; i < l; i++) {
       let identifier = identifiers[i];
       identifier = getIdentifier(identifier);
@@ -340,7 +321,7 @@ class RecordArrayManager {
     @method recordDidChange
     @internal
   */
-  recordDidChange(identifier: StableRecordIdentifier): void {
+  recordDidChange(identifier) {
     if (this.isDestroying || this.isDestroyed) {
       return;
     }
@@ -359,26 +340,22 @@ class RecordArrayManager {
       return;
     }
 
-    // TODO do we still need this schedule?
-    // eslint-disable-next-line @typescript-eslint/unbound-method
     emberBackburner.schedule('actions', this, this._flush);
   }
 
   willDestroy() {
-    Object.keys(this._liveRecordArrays).forEach((modelName) => this._liveRecordArrays[modelName]!.destroy());
+    Object.keys(this._liveRecordArrays).forEach((modelName) => this._liveRecordArrays[modelName].destroy());
     this._adapterPopulatedRecordArrays.forEach((entry) => entry.destroy());
     this.isDestroyed = true;
   }
 
   destroy() {
     this.isDestroying = true;
-    // TODO do we still need this schedule?
-    // eslint-disable-next-line @typescript-eslint/unbound-method
     emberBackburner.schedule('actions', this, this.willDestroy);
   }
 }
 
-function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
+function removeFromArray(array, item) {
   let index = array.indexOf(item);
 
   if (index !== -1) {
@@ -389,13 +366,9 @@ function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
   return false;
 }
 
-function updateLiveRecordArray(
-  store: CoreStore,
-  recordArray: RecordArray,
-  identifiers: StableRecordIdentifier[]
-): void {
-  let identifiersToAdd: StableRecordIdentifier[] = [];
-  let identifiersToRemove: StableRecordIdentifier[] = [];
+function updateLiveRecordArray(store, recordArray, identifiers) {
+  let identifiersToAdd = [];
+  let identifiersToRemove = [];
 
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
@@ -423,13 +396,13 @@ function updateLiveRecordArray(
   }
 }
 
-function removeFromAdapterPopulatedRecordArrays(store: CoreStore, identifiers: StableRecordIdentifier[]): void {
+function removeFromAdapterPopulatedRecordArrays(store, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
     removeFromAll(store, identifiers[i]);
   }
 }
 
-function removeFromAll(store: CoreStore, identifier: StableRecordIdentifier): void {
+function removeFromAll(store, identifier) {
   identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);