@ember-data/store 4.4.0-alpha.8 → 4.4.0

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);
 

package/addon/-private/system/record-arrays/adapter-populated-record-array.js

@@ -0,0 +1,95 @@
+import { A } from '@ember/array';
+import { get } from '@ember/object';
+
+import RecordArray from './record-array';
+
+/**
+  @module @ember-data/store
+*/
+
+/**
+  Represents an ordered list of records whose order and membership is
+  determined by the adapter. For example, a query sent to the adapter
+  may trigger a search on the server, whose results would be loaded
+  into an instance of the `AdapterPopulatedRecordArray`.
+
+  This class should not be imported and instantiated by consuming applications.
+
+  ---
+
+  If you want to update the array and get the latest records from the
+  adapter, you can invoke [`update()`](AdapterPopulatedRecordArray/methods/update?anchor=update):
+
+  Example
+
+  ```javascript
+  // GET /users?isAdmin=true
+  store.query('user', { isAdmin: true }).then(function(admins) {
+
+    admins.then(function() {
+      console.log(admins.get("length")); // 42
+    });
+
+    // somewhere later in the app code, when new admins have been created
+    // in the meantime
+    //
+    // GET /users?isAdmin=true
+    admins.update().then(function() {
+      admins.get('isUpdating'); // false
+      console.log(admins.get("length")); // 123
+    });
+
+    admins.get('isUpdating'); // true
+  }
+  ```
+
+  @class AdapterPopulatedRecordArray
+  @public
+  @extends RecordArray
+*/
+export default RecordArray.extend({
+  init() {
+    this.set('content', this.get('content') || A());
+
+    this._super(...arguments);
+    this.query = this.query || null;
+    this.links = this.links || null;
+  },
+
+  replace() {
+    throw new Error(`The result of a server query (on ${this.modelName}) is immutable.`);
+  },
+
+  _update() {
+    let store = get(this, 'store');
+    let query = get(this, 'query');
+
+    return store._query(this.modelName, query, this);
+  },
+
+  _setObjects(identifiersOrInternalModels, payload) {
+    // TODO: initial load should not cause change events at all, only
+    // subsequent. This requires changing the public api of adapter.query, but
+    // hopefully we can do that soon.
+    this.get('content').setObjects(identifiersOrInternalModels);
+
+    this.setProperties({
+      isLoaded: true,
+      isUpdating: false,
+      meta: { ...payload.meta },
+      links: { ...payload.links },
+    });
+
+    this.manager._associateWithRecordArray(identifiersOrInternalModels, this);
+  },
+
+  /**
+    @method _setIdentifiers
+    @param {StableRecordIdentifier[]} identifiers
+    @param {Object} payload normalized payload
+    @private
+  */
+  _setIdentifiers(identifiers, payload) {
+    this._setObjects(identifiers, payload);
+  },
+});