@ember-data/store 4.4.0 → 4.5.0-alpha.2

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

@@ -262,7 +262,6 @@ const DirtyState = {
 
     rolledBack(internalModel) {
       internalModel.transitionTo('loaded.saved');
-      internalModel.triggerLater('rolledBack');
     },
 
     becameInvalid(internalModel) {
@@ -271,7 +270,6 @@ const DirtyState = {
 
     rollback(internalModel) {
       internalModel.rollbackAttributes();
-      internalModel.triggerLater('ready');
     },
   },
 
@@ -297,9 +295,7 @@ const DirtyState = {
       internalModel.send('invokeLifecycleCallbacks', this.dirtyType);
     },
 
-    rolledBack(internalModel) {
-      internalModel.triggerLater('rolledBack');
-    },
+    rolledBack() {},
 
     becameInvalid(internalModel) {
       internalModel.transitionTo('invalid');
@@ -308,7 +304,6 @@ const DirtyState = {
 
     becameError(internalModel) {
       internalModel.transitionTo('uncommitted');
-      internalModel.triggerLater('becameError', internalModel);
     },
   },
 
@@ -345,16 +340,13 @@ const DirtyState = {
     rolledBack(internalModel) {
       clearErrorMessages(internalModel);
       internalModel.transitionTo('loaded.saved');
-      internalModel.triggerLater('ready');
     },
 
     becameValid(internalModel) {
       internalModel.transitionTo('uncommitted');
     },
 
-    invokeLifecycleCallbacks(internalModel) {
-      internalModel.triggerLater('becameInvalid', internalModel);
-    },
+    invokeLifecycleCallbacks() {},
   },
 };
 
@@ -403,12 +395,10 @@ 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({
@@ -433,7 +423,6 @@ 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 () {};
@@ -458,7 +447,6 @@ updatedState.uncommitted.deleteRecord = function (internalModel) {
 updatedState.invalid.rolledBack = function (internalModel) {
   clearErrorMessages(internalModel);
   internalModel.transitionTo('loaded.saved');
-  internalModel.triggerLater('rolledBack');
 };
 
 const RootState = {
@@ -500,13 +488,10 @@ 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
@@ -533,15 +518,11 @@ 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(internalModel) {
-      internalModel.triggerLater('becameError', internalModel);
-    },
+    becameError() {},
 
     notFound(internalModel) {
       internalModel.transitionTo('empty');
@@ -640,7 +621,6 @@ const RootState = {
 
       rollback(internalModel) {
         internalModel.rollbackAttributes();
-        internalModel.triggerLater('ready');
       },
 
       pushedData() {},
@@ -649,8 +629,6 @@ const RootState = {
 
       rolledBack(internalModel) {
         internalModel.transitionTo('loaded.saved');
-        internalModel.triggerLater('ready');
-        internalModel.triggerLater('rolledBack');
       },
     },
 
@@ -676,12 +654,10 @@ const RootState = {
 
       becameError(internalModel) {
         internalModel.transitionTo('uncommitted');
-        internalModel.triggerLater('becameError', internalModel);
       },
 
       becameInvalid(internalModel) {
         internalModel.transitionTo('invalid');
-        internalModel.triggerLater('becameInvalid', internalModel);
       },
     },
 
@@ -696,10 +672,7 @@ const RootState = {
         internalModel.removeFromInverseRelationships();
       },
 
-      invokeLifecycleCallbacks(internalModel) {
-        internalModel.triggerLater('didDelete', internalModel);
-        internalModel.triggerLater('didCommit', internalModel);
-      },
+      invokeLifecycleCallbacks() {},
 
       willCommit() {},
       didCommit() {},
@@ -727,7 +700,6 @@ const RootState = {
       rolledBack(internalModel) {
         clearErrorMessages(internalModel);
         internalModel.transitionTo('loaded.saved');
-        internalModel.triggerLater('ready');
       },
 
       becameValid(internalModel) {
@@ -736,15 +708,7 @@ const RootState = {
     },
   },
 
-  invokeLifecycleCallbacks(internalModel, dirtyType) {
-    if (dirtyType === 'created') {
-      internalModel.triggerLater('didCreate', internalModel);
-    } else {
-      internalModel.triggerLater('didUpdate', internalModel);
-    }
-
-    internalModel.triggerLater('didCommit', internalModel);
-  },
+  invokeLifecycleCallbacks() {},
 };
 
 function wireState(object, parent, name) {

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

@@ -1,10 +1,11 @@
-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 { Promise } from 'rsvp';
+import { resolve } from 'rsvp';
+
+import type { Dict } from '../ts-interfaces/utils';
+import { PromiseArrayProxy, PromiseObjectProxy } from './promise-proxy-base';
 
 /**
   @module @ember-data/store
@@ -41,9 +42,20 @@ import { Promise } from 'rsvp';
   @extends Ember.ArrayProxy
   @uses Ember.PromiseProxyMixin
 */
-export const PromiseArray = ArrayProxy.extend(PromiseProxyMixin, {
-  meta: reads('content.meta'),
-});
+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>;
+}
 
 /**
   A `PromiseObject` is an object that acts like both an `EmberObject`
@@ -76,26 +88,26 @@ export const PromiseArray = ArrayProxy.extend(PromiseProxyMixin, {
   @extends Ember.ObjectProxy
   @uses Ember.PromiseProxyMixin
 */
-export let PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
+export { PromiseObjectProxy as PromiseObject };
 
-export function promiseObject(promise, label) {
-  return PromiseObject.create({
-    promise: Promise.resolve(promise, label),
-  });
+export function promiseObject<T>(promise: Promise<T>, label?: string): PromiseObjectProxy<T> {
+  return PromiseObjectProxy.create({
+    promise: resolve(promise, label),
+  }) as PromiseObjectProxy<T>;
 }
 
-export function promiseArray(promise, label) {
+export function promiseArray<I, T extends EmberArrayLike<I>>(promise: Promise<T>, label?: string): PromiseArray<I, T> {
   return PromiseArray.create({
-    promise: Promise.resolve(promise, label),
-  });
+    promise: resolve(promise, label),
+  }) as unknown as PromiseArray<I, T>;
 }
 
 // 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(promise) {
+export function deprecatedPromiseObject<T>(promise: PromiseObjectProxy<T>): PromiseObjectProxy<T> {
   const handler = {
-    get(target, prop) {
+    get(target: object, prop: string, receiver?: object): unknown {
       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`,
@@ -112,11 +124,9 @@ export function deprecatedPromiseObject(promise) {
         );
       }
 
-      /* global Reflect */
-      return Reflect.get(...arguments).bind(target);
+      return (Reflect.get(target, prop, receiver) as Function).bind(target);
     },
   };
 
-  /* global Proxy */
-  return new Proxy(promise, handler);
+  return new Proxy(promise, handler) as PromiseObjectProxy<T>;
 }

package/addon/-private/system/promise-proxy-base.js

@@ -0,0 +1,7 @@
+import ArrayProxy from '@ember/array/proxy';
+import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import ObjectProxy from '@ember/object/proxy';
+
+export const PromiseArrayProxy = ArrayProxy.extend(PromiseProxyMixin);
+
+export const PromiseObjectProxy = ObjectProxy.extend(PromiseProxyMixin);

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

@@ -4,37 +4,39 @@
 
 import { A } from '@ember/array';
 import { assert } from '@ember/debug';
-import { get, set } from '@ember/object';
+import { set } from '@ember/object';
 import { _backburner as emberBackburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
-import isStableIdentifier from '../identifiers/is-stable-identifier';
+// 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 { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { internalModelFactoryFor } from './store/internal-model-factory';
 import WeakCache from './weak-cache';
 
-const RecordArraysCache = new WeakCache(DEBUG ? 'record-arrays' : '');
+const RecordArraysCache = new WeakCache<StableRecordIdentifier, Set<RecordArray>>(DEBUG ? 'record-arrays' : '');
 RecordArraysCache._generator = () => new Set();
-export function recordArraysForIdentifier(identifierOrInternalModel) {
-  return RecordArraysCache.lookup(identifierOrInternalModel);
+export function recordArraysForIdentifier(identifier: StableRecordIdentifier): Set<RecordArray> {
+  return RecordArraysCache.lookup(identifier);
 }
 
-const pendingForIdentifier = new Set([]);
+const pendingForIdentifier: Set<StableRecordIdentifier> = new Set([]);
 
-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;
-  }
+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 });
+  // }
 
-  return i;
+  return identifier;
 }
 
-function shouldIncludeInRecordArrays(store, identifier) {
+function shouldIncludeInRecordArrays(store: CoreStore, identifier: StableRecordIdentifier): boolean {
   const cache = internalModelFactoryFor(store);
   const internalModel = cache.peek(identifier);
 
@@ -49,12 +51,19 @@ function shouldIncludeInRecordArrays(store, identifier) {
   @internal
 */
 class RecordArrayManager {
-  constructor(options) {
+  declare store: CoreStore;
+  declare isDestroying: boolean;
+  declare isDestroyed: boolean;
+  declare _liveRecordArrays: Dict<RecordArray>;
+  declare _pendingIdentifiers: Dict<StableRecordIdentifier[]>;
+  declare _adapterPopulatedRecordArrays: RecordArray[];
+
+  constructor(options: { store: CoreStore }) {
     this.store = options.store;
     this.isDestroying = false;
     this.isDestroyed = false;
-    this._liveRecordArrays = Object.create(null);
-    this._pendingIdentifiers = Object.create(null);
+    this._liveRecordArrays = Object.create(null) as Dict<RecordArray>;
+    this._pendingIdentifiers = Object.create(null) as Dict<StableRecordIdentifier[]>;
     this._adapterPopulatedRecordArrays = [];
   }
 
@@ -64,15 +73,15 @@ class RecordArrayManager {
    * @param {StableIdentifier} param
    * @return {RecordArray} array
    */
-  getRecordArraysForIdentifier(identifier) {
+  getRecordArraysForIdentifier(identifier: StableRecordIdentifier): Set<RecordArray> {
     return recordArraysForIdentifier(identifier);
   }
 
-  _flushPendingIdentifiersForModelName(modelName, identifiers) {
+  _flushPendingIdentifiersForModelName(modelName: string, identifiers: StableRecordIdentifier[]): void {
     if (this.isDestroying || this.isDestroyed) {
       return;
     }
-    let modelsToRemove = [];
+    let identifiersToRemove: StableRecordIdentifier[] = [];
 
     for (let j = 0; j < identifiers.length; j++) {
       let i = identifiers[j];
@@ -82,7 +91,7 @@ class RecordArrayManager {
       // build up a set of models to ensure we have purged correctly;
       let isIncluded = shouldIncludeInRecordArrays(this.store, i);
       if (!isIncluded) {
-        modelsToRemove.push(i);
+        identifiersToRemove.push(i);
       }
     }
 
@@ -94,30 +103,33 @@ class RecordArrayManager {
     }
 
     // process adapterPopulatedRecordArrays
-    if (modelsToRemove.length > 0) {
-      removeFromAdapterPopulatedRecordArrays(this.store, modelsToRemove);
+    if (identifiersToRemove.length > 0) {
+      removeFromAdapterPopulatedRecordArrays(this.store, identifiersToRemove);
     }
   }
 
   _flush() {
     let pending = this._pendingIdentifiers;
-    this._pendingIdentifiers = Object.create(null);
+    this._pendingIdentifiers = Object.create(null) as Dict<StableRecordIdentifier[]>;
 
     for (let modelName in pending) {
-      this._flushPendingIdentifiersForModelName(modelName, pending[modelName]);
+      this._flushPendingIdentifiersForModelName(modelName, pending[modelName]!);
     }
   }
 
-  _syncLiveRecordArray(array, modelName) {
+  _syncLiveRecordArray(array: RecordArray, modelName: string) {
     assert(
       `recordArrayManger.syncLiveRecordArray expects modelName not modelClass as the second param`,
       typeof modelName === 'string'
     );
     let pending = this._pendingIdentifiers[modelName];
-    let hasPendingChanges = Array.isArray(pending);
-    let hasNoPotentialDeletions = !hasPendingChanges || pending.length === 0;
+
+    if (!Array.isArray(pending)) {
+      return;
+    }
+    let hasNoPotentialDeletions = pending.length === 0;
     let map = internalModelFactoryFor(this.store).modelMapFor(modelName);
-    let hasNoInsertionsOrRemovals = get(map, 'length') === get(array, 'length');
+    let hasNoInsertionsOrRemovals = map.length === array.length;
 
     /*
       Ideally the recordArrayManager has knowledge of the changes to be applied to
@@ -129,28 +141,26 @@ class RecordArrayManager {
       return;
     }
 
-    if (hasPendingChanges) {
-      this._flushPendingIdentifiersForModelName(modelName, pending);
-      delete this._pendingIdentifiers[modelName];
-    }
+    this._flushPendingIdentifiersForModelName(modelName, pending);
+    delete this._pendingIdentifiers[modelName];
 
     let identifiers = this._visibleIdentifiersByType(modelName);
-    let modelsToAdd = [];
+    let identifiersToAdd: StableRecordIdentifier[] = [];
     for (let i = 0; i < identifiers.length; i++) {
       let identifier = identifiers[i];
       let recordArrays = recordArraysForIdentifier(identifier);
       if (recordArrays.has(array) === false) {
         recordArrays.add(array);
-        modelsToAdd.push(identifier);
+        identifiersToAdd.push(identifier);
       }
     }
 
-    if (modelsToAdd.length) {
-      array._pushIdentifiers(modelsToAdd);
+    if (identifiersToAdd.length) {
+      array._pushIdentifiers(identifiersToAdd);
     }
   }
 
-  _didUpdateAll(modelName) {
+  _didUpdateAll(modelName: string): void {
     let recordArray = this._liveRecordArrays[modelName];
     if (recordArray) {
       set(recordArray, 'isUpdating', false);
@@ -166,7 +176,7 @@ class RecordArrayManager {
     @param {String} modelName
     @return {RecordArray}
   */
-  liveRecordArrayFor(modelName) {
+  liveRecordArrayFor(modelName: string): RecordArray {
     assert(
       `recordArrayManger.liveRecordArrayFor expects modelName not modelClass as the param`,
       typeof modelName === 'string'
@@ -188,9 +198,9 @@ class RecordArrayManager {
     return array;
   }
 
-  _visibleIdentifiersByType(modelName) {
+  _visibleIdentifiersByType(modelName: string) {
     let all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;
-    let visible = [];
+    let visible: StableRecordIdentifier[] = [];
     for (let i = 0; i < all.length; i++) {
       let identifier = all[i];
       let shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);
@@ -211,7 +221,7 @@ class RecordArrayManager {
     @param {Array} [identifiers]
     @return {RecordArray}
   */
-  createRecordArray(modelName, identifiers) {
+  createRecordArray(modelName: string, identifiers: StableRecordIdentifier[] = []): RecordArray {
     assert(
       `recordArrayManger.createRecordArray expects modelName not modelClass as the param`,
       typeof modelName === 'string'
@@ -241,13 +251,18 @@ class RecordArrayManager {
     @param {Object} query
     @return {AdapterPopulatedRecordArray}
   */
-  createAdapterPopulatedRecordArray(modelName, query, identifiers, payload) {
+  createAdapterPopulatedRecordArray(
+    modelName: string,
+    query: Dict<unknown> | undefined,
+    identifiers: StableRecordIdentifier[],
+    payload?: CollectionResourceDocument
+  ): AdapterPopulatedRecordArray {
     assert(
       `recordArrayManger.createAdapterPopulatedRecordArray expects modelName not modelClass as the first param, received ${modelName}`,
       typeof modelName === 'string'
     );
 
-    let array;
+    let array: AdapterPopulatedRecordArray;
     if (Array.isArray(identifiers)) {
       array = AdapterPopulatedRecordArray.create({
         modelName,
@@ -257,8 +272,11 @@ class RecordArrayManager {
         manager: this,
         isLoaded: true,
         isUpdating: false,
-        meta: { ...payload.meta },
-        links: { ...payload.links },
+        // 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),
       });
 
       this._associateWithRecordArray(identifiers, array);
@@ -266,7 +284,8 @@ class RecordArrayManager {
       array = AdapterPopulatedRecordArray.create({
         modelName,
         query: query,
-        content: A(),
+        content: A<StableRecordIdentifier>(),
+        isLoaded: false,
         store: this.store,
         manager: this,
       });
@@ -285,7 +304,7 @@ class RecordArrayManager {
     @internal
     @param {RecordArray} array
   */
-  unregisterRecordArray(array) {
+  unregisterRecordArray(array: RecordArray): void {
     let modelName = array.modelName;
 
     // remove from adapter populated record array
@@ -308,7 +327,7 @@ class RecordArrayManager {
    * @param {StableIdentifier} identifiers
    * @param {RecordArray} array
    */
-  _associateWithRecordArray(identifiers, array) {
+  _associateWithRecordArray(identifiers: StableRecordIdentifier[], array: RecordArray): void {
     for (let i = 0, l = identifiers.length; i < l; i++) {
       let identifier = identifiers[i];
       identifier = getIdentifier(identifier);
@@ -321,7 +340,7 @@ class RecordArrayManager {
     @method recordDidChange
     @internal
   */
-  recordDidChange(identifier) {
+  recordDidChange(identifier: StableRecordIdentifier): void {
     if (this.isDestroying || this.isDestroyed) {
       return;
     }
@@ -340,22 +359,26 @@ 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, item) {
+function removeFromArray(array: RecordArray[], item: RecordArray): boolean {
   let index = array.indexOf(item);
 
   if (index !== -1) {
@@ -366,9 +389,13 @@ function removeFromArray(array, item) {
   return false;
 }
 
-function updateLiveRecordArray(store, recordArray, identifiers) {
-  let identifiersToAdd = [];
-  let identifiersToRemove = [];
+function updateLiveRecordArray(
+  store: CoreStore,
+  recordArray: RecordArray,
+  identifiers: StableRecordIdentifier[]
+): void {
+  let identifiersToAdd: StableRecordIdentifier[] = [];
+  let identifiersToRemove: StableRecordIdentifier[] = [];
 
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
@@ -396,13 +423,13 @@ function updateLiveRecordArray(store, recordArray, identifiers) {
   }
 }
 
-function removeFromAdapterPopulatedRecordArrays(store, identifiers) {
+function removeFromAdapterPopulatedRecordArrays(store: CoreStore, identifiers: StableRecordIdentifier[]): void {
   for (let i = 0; i < identifiers.length; i++) {
     removeFromAll(store, identifiers[i]);
   }
 }
 
-function removeFromAll(store, identifier) {
+function removeFromAll(store: CoreStore, identifier: StableRecordIdentifier): void {
   identifier = getIdentifier(identifier);
   const recordArrays = recordArraysForIdentifier(identifier);