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

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

@@ -50,9 +50,13 @@ class LegacyWrapper implements LegacyRecordDataStoreWrapper {
     }
 
     this._willNotify = true;
-    let backburner: any = this._store._backburner;
-
-    backburner.schedule('notify', this, 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 {
@@ -83,7 +87,7 @@ class LegacyWrapper implements LegacyRecordDataStoreWrapper {
     this._store._notificationManager.notify(identifier, namespace, key);
 
     if (namespace === 'state') {
-      this._store.recordArrayManager.recordDidChange(identifier);
+      this._store.recordArrayManager.identifierChanged(identifier);
     }
   }
 
@@ -205,7 +209,7 @@ class LegacyWrapper implements LegacyRecordDataStoreWrapper {
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
 
     this._store._notificationManager.notify(identifier, 'state');
-    this._store.recordArrayManager.recordDidChange(identifier);
+    this._store.recordArrayManager.identifierChanged(identifier);
   }
 
   recordDataFor(type: string, id: string, lid?: string | null): RecordData;
@@ -239,7 +243,7 @@ class LegacyWrapper implements LegacyRecordDataStoreWrapper {
 
     if (!id && !lid) {
       recordData.clientDidCreate(identifier);
-      this._store.recordArrayManager.recordDidChange(identifier);
+      this._store.recordArrayManager.identifierAdded(identifier);
     }
 
     return recordData;
@@ -346,9 +350,7 @@ class V2RecordDataStoreWrapper implements StoreWrapper {
     }
 
     this._willNotify = true;
-    let backburner: any = this._store._backburner;
-
-    backburner.schedule('notify', this, this._flushNotifications);
+    this._store._schedule('notify', () => this._flushNotifications());
   }
 
   _flushNotifications(): void {
@@ -379,7 +381,7 @@ class V2RecordDataStoreWrapper implements StoreWrapper {
     this._store._notificationManager.notify(identifier, namespace, key);
 
     if (namespace === 'state') {
-      this._store.recordArrayManager.recordDidChange(identifier);
+      this._store.recordArrayManager.identifierChanged(identifier);
     }
   }
 

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

@@ -6,15 +6,12 @@ import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
 import { isStableIdentifier } from '../caches/identifier-cache';
 import type Store from '../store-service';
-import WeakCache from '../utils/weak-cache';
 
 type UnsubscribeToken = object;
 let tokenId = 0;
-const Cache = new WeakCache<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>(
-  DEBUG ? 'subscribers' : ''
-);
-Cache._generator = () => new Map();
-const Tokens = new WeakCache<UnsubscribeToken, StableRecordIdentifier>(DEBUG ? 'identifier' : '');
+
+const Cache = new Map<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>();
+const Tokens = new Map<UnsubscribeToken, StableRecordIdentifier>();
 
 export type NotificationType = 'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | 'state';
 
@@ -24,25 +21,38 @@ export interface NotificationCallback {
   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
 }
 
+// TODO this isn't importable anyway, remove and use a map on the manager?
 export function unsubscribe(token: UnsubscribeToken) {
   let identifier = Tokens.get(token);
-  assert('Passed unknown unsubscribe token to unsubscribe', identifier);
-  Tokens.delete(token);
-  const map = Cache.get(identifier);
-  map?.delete(token);
+  if (LOG_NOTIFICATIONS && !identifier) {
+    // eslint-disable-next-line no-console
+    console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
+  }
+  if (identifier) {
+    Tokens.delete(token);
+    const map = Cache.get(identifier);
+    map?.delete(token);
+  }
 }
 /*
   Currently only support a single callback per identifier
 */
 export default class NotificationManager {
   declare store: Store;
+  declare isDestroyed: boolean;
   constructor(store: Store) {
     this.store = store;
+    this.isDestroyed = false;
   }
 
   subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
     assert(`Expected to receive a stable Identifier to subscribe to`, isStableIdentifier(identifier));
-    let map = Cache.lookup(identifier);
+    let map = Cache.get(identifier);
+
+    if (!map) {
+      map = new Map();
+      Cache.set(identifier, map);
+    }
     let unsubToken = DEBUG ? { _tokenRef: tokenId++ } : {};
     map.set(unsubToken, callback);
     Tokens.set(unsubToken, identifier);
@@ -50,7 +60,9 @@ export default class NotificationManager {
   }
 
   unsubscribe(token: UnsubscribeToken) {
-    unsubscribe(token);
+    if (!this.isDestroyed) {
+      unsubscribe(token);
+    }
   }
 
   // deactivated type signature overloads because pass-through was failing to match any. Bring back if possible.
@@ -87,4 +99,10 @@ export default class NotificationManager {
     });
     return true;
   }
+
+  destroy() {
+    this.isDestroyed = true;
+    Tokens.clear();
+    Cache.clear();
+  }
 }

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

@@ -86,7 +86,7 @@ export default class FetchManager {
   }
 
   clearEntries(identifier: StableRecordIdentifier) {
-    delete this.requestCache._done[identifier.lid];
+    this.requestCache._done.delete(identifier);
   }
 
   /**
@@ -213,7 +213,7 @@ export default class FetchManager {
       },
       (error) => {
         const recordData = store._instanceCache.peek({ identifier, bucket: 'recordData' });
-        if (!recordData || recordData.isEmpty?.(identifier) || isLoading) {
+        if (!recordData || recordData.isEmpty(identifier) || isLoading) {
           store._instanceCache.unloadRecord(identifier);
         }
         throw error;

package/addon/-private/network/finders.js

@@ -4,6 +4,7 @@ import { Promise } from 'rsvp';
 
 import { guardDestroyedStore } from '../utils/common';
 import { normalizeResponseHelper } from '../utils/serializer-response';
+import SnapshotRecordArray from './snapshot-record-array';
 
 /**
   @module @ember-data/store
@@ -17,10 +18,10 @@ function payloadIsNotBlank(adapterPayload) {
   }
 }
 
-export function _findAll(adapter, store, modelName, options) {
+export function _findAll(adapter, store, modelName, options, snapshotArray) {
   let modelClass = store.modelFor(modelName); // adapter.findAll depends on the class
   let recordArray = store.peekAll(modelName);
-  let snapshotArray = recordArray._createSnapshot(options);
+  snapshotArray = snapshotArray || new SnapshotRecordArray(store, recordArray, options);
   let promise = Promise.resolve().then(() => adapter.findAll(store, modelClass, null, snapshotArray));
   let label = 'DS: Handle Adapter#findAll of ' + modelClass;
 
@@ -36,8 +37,7 @@ export function _findAll(adapter, store, modelName, options) {
       let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findAll');
 
       store._push(payload);
-      store.recordArrayManager._didUpdateAll(modelName);
-
+      recordArray.isUpdating = false;
       return recordArray;
     },
     null,
@@ -49,7 +49,12 @@ export function _query(adapter, store, modelName, query, recordArray, options) {
   let modelClass = store.modelFor(modelName); // adapter.query needs the class
 
   // TODO @deprecate RecordArrays being passed to Adapters
-  recordArray = recordArray || store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);
+  recordArray =
+    recordArray ||
+    store.recordArrayManager.createArray({
+      type: modelName,
+      query,
+    });
   let promise = Promise.resolve().then(() => adapter.query(store, modelClass, query, recordArray, options));
 
   let label = `DS: Handle Adapter#query of ${modelName}`;
@@ -65,7 +70,7 @@ export function _query(adapter, store, modelName, query, recordArray, options) {
         'The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.',
         Array.isArray(identifiers)
       );
-      recordArray._setIdentifiers(identifiers, payload);
+      store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
 
       return recordArray;
     },

package/addon/-private/network/request-cache.ts

@@ -5,7 +5,7 @@ import type {
   RequestState,
   SaveRecordMutation,
 } from '@ember-data/types/q/fetch-manager';
-import type { RecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordIdentifier, StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
 const Touching: unique symbol = Symbol('touching');
 export const RequestPromise: unique symbol = Symbol('promise');
@@ -23,7 +23,7 @@ function hasRecordIdentifier(op: Operation): op is RecordOperation {
 
 export default class RequestCache {
   _pending: { [lid: string]: InternalRequest[] } = Object.create(null);
-  _done: { [lid: string]: InternalRequest[] } = Object.create(null);
+  _done: Map<StableRecordIdentifier, InternalRequest[]> = new Map();
   _subscriptions: { [lid: string]: Function[] } = Object.create(null);
 
   enqueue(promise: Promise<any>, queryRequest: Request) {
@@ -86,22 +86,25 @@ export default class RequestCache {
 
   _addDone(request: InternalRequest) {
     request[Touching].forEach((identifier) => {
-      if (!this._done[identifier.lid]) {
-        this._done[identifier.lid] = [];
-      }
       // TODO add support for multiple
       let requestDataOp = request.request.data[0].op;
-      this._done[identifier.lid] = this._done[identifier.lid].filter((req) => {
-        // TODO add support for multiple
-        let data;
-        if (req.request.data instanceof Array) {
-          data = req.request.data[0];
-        } else {
-          data = req.request.data;
-        }
-        return data.op !== requestDataOp;
-      });
-      this._done[identifier.lid].push(request);
+      let requests = this._done.get(identifier);
+
+      if (requests) {
+        requests = requests.filter((req) => {
+          // TODO add support for multiple
+          let data;
+          if (req.request.data instanceof Array) {
+            data = req.request.data[0];
+          } else {
+            data = req.request.data;
+          }
+          return data.op !== requestDataOp;
+        });
+      }
+      requests = requests || [];
+      requests.push(request);
+      this._done.set(identifier, requests);
     });
   }
 
@@ -120,7 +123,7 @@ export default class RequestCache {
   }
 
   getLastRequestForRecord(identifier: RecordIdentifier): RequestState | null {
-    let requests = this._done[identifier.lid];
+    let requests = this._done.get(identifier);
     if (requests) {
       return requests[requests.length - 1];
     }

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

@@ -6,10 +6,12 @@ import { deprecate } from '@ember/debug';
 
 import { DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS } from '@ember-data/private-build-infra/deprecations';
 import type { ModelSchema } from '@ember-data/types/q/ds-model';
+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 Store from '../store-service';
 import type Snapshot from './snapshot';
 /**
   SnapshotRecordArray is not directly instantiable.
@@ -23,6 +25,7 @@ export default class SnapshotRecordArray {
   declare _snapshots: Snapshot[] | null;
   declare _recordArray: RecordArray;
   declare _type: ModelSchema | null;
+  declare __store: Store;
 
   declare length: number;
   declare meta: Dict<unknown> | null;
@@ -41,7 +44,8 @@ export default class SnapshotRecordArray {
     @param {Object} meta
     @param options
    */
-  constructor(recordArray: RecordArray, meta: Dict<unknown> | null, options: FindOptions = {}) {
+  constructor(store: Store, recordArray: RecordArray, options: FindOptions = {}) {
+    this.__store = store;
     /**
       An array of snapshots
       @private
@@ -79,29 +83,6 @@ export default class SnapshotRecordArray {
     */
     this.length = recordArray.length as unknown as number; // deal with computedProperty shennanigans
 
-    /**
-      Meta objects for the record array.
-
-      Example
-
-      ```app/adapters/post.js
-      import JSONAPIAdapter from '@ember-data/adapter/json-api';
-
-      export default class PostAdapter extends JSONAPIAdapter {
-        shouldReloadAll(store, snapshotRecordArray) {
-          let lastRequestTime = snapshotRecordArray.meta.lastRequestTime;
-          let twentyMinutes = 20 * 60 * 1000;
-          return Date.now() > lastRequestTime + twentyMinutes;
-        }
-      });
-      ```
-
-      @property meta
-      @public
-      @type {Object}
-    */
-    this.meta = meta;
-
     /**
       A hash of adapter options passed into the store method for this request.
 
@@ -200,8 +181,10 @@ export default class SnapshotRecordArray {
     if (this._snapshots !== null) {
       return this._snapshots;
     }
-
-    this._snapshots = this._recordArray._takeSnapshot();
+    const { _instanceCache } = this.__store;
+    this._snapshots = this._recordArray.content.map((identifier: StableRecordIdentifier) =>
+      _instanceCache.createSnapshot(identifier)
+    );
 
     return this._snapshots;
   }

package/addon/-private/record-arrays/adapter-populated-record-array.ts

@@ -1,18 +1,16 @@
 import type NativeArray from '@ember/array/-private/native-array';
 import { assert } from '@ember/debug';
 
-import type { CollectionResourceDocument, Links, Meta, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
+import type { Links, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
-import type { FindOptions } from '@ember-data/types/q/store';
 import type { Dict } from '@ember-data/types/q/utils';
 
 import type RecordArrayManager from '../managers/record-array-manager';
-import SnapshotRecordArray from '../network/snapshot-record-array';
 import type { PromiseArray } from '../proxies/promise-proxies';
 import { promiseArray } from '../proxies/promise-proxies';
 import type Store from '../store-service';
-import RecordArray from './record-array';
+import RecordArray, { MANAGED } from './record-array';
 
 export interface AdapterPopulatedRecordArrayCreateArgs {
   modelName: string;
@@ -20,9 +18,9 @@ export interface AdapterPopulatedRecordArrayCreateArgs {
   manager: RecordArrayManager;
   content: NativeArray<StableRecordIdentifier>;
   isLoaded: boolean;
-  query?: Dict<unknown>;
-  meta?: Meta;
-  links?: Links | PaginationLinks | null;
+  query: Dict<unknown> | null;
+  meta: Dict<unknown> | null;
+  links: Links | PaginationLinks | null;
 }
 
 /**
@@ -71,6 +69,7 @@ export default class AdapterPopulatedRecordArray extends RecordArray {
   declare links: Links | PaginationLinks | null;
   declare meta: Dict<unknown> | null;
   declare query: Dict<unknown> | null;
+  [MANAGED] = true;
 
   init(props?: AdapterPopulatedRecordArrayCreateArgs) {
     assert(`Cannot initialize AdapterPopulatedRecordArray with isUpdating`, !props || !('isUpdating' in props));
@@ -86,43 +85,15 @@ export default class AdapterPopulatedRecordArray extends RecordArray {
 
   _update(): PromiseArray<RecordInstance, AdapterPopulatedRecordArray> {
     const { store, query } = this;
+    const promise = store.query(this.modelName, query, { _recordArray: this });
 
     // TODO save options from initial request?
-    return promiseArray(store.query(this.modelName, query, { _recordArray: this }));
+    return promiseArray(promise);
   }
 
-  _setObjects(identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument) {
-    // 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.content.setObjects(identifiers);
-
-    this.setProperties({
-      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({}, payload.meta),
-      links: Object.assign({}, payload.links),
-    });
-
-    this.manager._associateWithRecordArray(identifiers, this);
-  }
-
-  _createSnapshot(options: FindOptions) {
-    // this is private for users, but public for ember-data internals
-    // meta will only be present for an AdapterPopulatedRecordArray
-    return new SnapshotRecordArray(this, this.meta, options);
-  }
-
-  /**
-    @method _setIdentifiers
-    @param {StableRecordIdentifier[]} identifiers
-    @param {Object} payload normalized payload
-    @private
-  */
-  _setIdentifiers(identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument): void {
-    this._setObjects(identifiers, payload);
+  willDestroy() {
+    super.willDestroy();
+    this.manager._managed.delete(this);
+    this.manager._pending.delete(this);
   }
 }

package/addon/-private/record-arrays/record-array.ts

@@ -9,17 +9,15 @@ import { tracked } from '@glimmer/tracking';
 
 import { Promise } from 'rsvp';
 
-import type { RecordArrayManager, Snapshot } from 'ember-data/-private';
-
 import { DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS } from '@ember-data/private-build-infra/deprecations';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
-import type { FindOptions } from '@ember-data/types/q/store';
 
-import SnapshotRecordArray from '../network/snapshot-record-array';
+import RecordArrayManager, { disassociateIdentifier } from '../managers/record-array-manager';
 import type { PromiseArray } from '../proxies/promise-proxies';
 import { promiseArray } from '../proxies/promise-proxies';
 import type Store from '../store-service';
+import type AdapterPopulatedRecordArray from './adapter-populated-record-array';
 
 function recordForIdentifier(store: Store, identifier: StableRecordIdentifier): RecordInstance {
   return store._instanceCache.getRecord(identifier);
@@ -32,6 +30,7 @@ export interface RecordArrayCreateArgs {
   content: NativeArray<StableRecordIdentifier>;
   isLoaded: boolean;
 }
+export const MANAGED = Symbol('#managed');
 
 /**
   A record array is an array that contains records of a certain modelName. The record
@@ -58,7 +57,6 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @type Ember.Array
   */
   declare content: NativeArray<StableRecordIdentifier>;
-  declare _getDeprecatedEventedInfo: () => string;
   declare modelName: string;
   /**
     The flag to signal a `RecordArray` is finished loading data.
@@ -100,6 +98,7 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     @type Boolean
   */
   @tracked isUpdating: boolean = false;
+  [MANAGED]: boolean = false;
 
   init(props?: RecordArrayCreateArgs) {
     assert(`Cannot initialize RecordArray with isUpdating`, !props || !('isUpdating' in props));
@@ -111,6 +110,12 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     this._updatingPromise = null;
   }
 
+  _notify() {
+    // until we kill ArrayProxy we immediately sync
+    // because otherwise we double notify
+    this.manager._syncArray(this);
+  }
+
   replace() {
     throw new Error(
       `The result of a server query (for all ${this.modelName} types) is immutable. To modify contents, use toArray()`
@@ -216,17 +221,7 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     return promiseArray<RecordInstance, RecordArray>(promise);
   }
 
-  /**
-    @method _unregisterFromManager
-    @internal
-  */
-  _unregisterFromManager() {
-    this.manager.unregisterRecordArray(this);
-  }
-
   willDestroy() {
-    this._unregisterFromManager();
-    this._dissociateFromOwnRecords();
     // TODO: we should not do work during destroy:
     //   * when objects are destroyed, they should simply be left to do
     //   * if logic errors do to this, that logic needs to be more careful during
@@ -241,66 +236,32 @@ export default class RecordArray extends ArrayProxy<StableRecordIdentifier, Reco
     super.willDestroy();
   }
 
-  /**
-    @method _createSnapshot
-    @private
-  */
-  _createSnapshot(options: FindOptions) {
-    // this is private for users, but public for ember-data internals
-    // meta will only be present for an AdapterPopulatedRecordArray
-    return new SnapshotRecordArray(this, null, options);
-  }
-
-  /**
-    @method _dissociateFromOwnRecords
-    @internal
-  */
-  _dissociateFromOwnRecords() {
-    this.content.forEach((identifier) => {
-      let recordArrays = this.manager.getRecordArraysForIdentifier(identifier);
-
-      if (recordArrays) {
-        recordArrays.delete(this);
+  _updateState(changes: Map<StableRecordIdentifier, 'add' | 'del'>) {
+    const content = this.content;
+    const adds: StableRecordIdentifier[] = [];
+    const removes: StableRecordIdentifier[] = [];
+    const isManaged = this[MANAGED];
+    changes.forEach((value, key) => {
+      value === 'add' ? adds.push(key) : removes.push(key);
+      if (isManaged && value === 'del') {
+        disassociateIdentifier(this as unknown as AdapterPopulatedRecordArray, key);
       }
     });
-  }
-
-  /**
-    Adds identifiers to the `RecordArray` without duplicates
-
-    @method _pushIdentifiers
-    @internal
-    @param {StableRecordIdentifier[]} identifiers
-  */
-  _pushIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    this.content.pushObjects(identifiers);
-  }
-
-  /**
-    Removes identifiers from the `RecordArray`.
-
-    @method _removeIdentifiers
-    @internal
-    @param {StableRecordIdentifier[]} identifiers
-  */
-  _removeIdentifiers(identifiers: StableRecordIdentifier[]): void {
-    // if we are unloading all there's no point in an expensive diff
-    // and traversal.
-    if (identifiers.length === this.content.length) {
-      this.content.clear();
-    } else {
-      // TODO This is horribly innefficient, we should refactor RecordArray
-      // to be a native class of our own.
-      this.content.removeObjects(identifiers);
+    if (removes.length) {
+      if (removes.length === content.length) {
+        content.clear();
+      } else {
+        content.removeObjects(removes);
+      }
     }
-  }
 
-  /**
-    @method _takeSnapshot
-    @internal
-  */
-  _takeSnapshot(): Snapshot[] {
-    return this.content.map((identifier) => this.store._instanceCache.createSnapshot(identifier));
+    if (adds.length) {
+      if (content.length === 0) {
+        content.setObjects(adds);
+      } else {
+        content.addObjects(adds);
+      }
+    }
   }
 }