@ember-data/store 4.1.0-alpha.9 → 4.2.0-alpha.2

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

@@ -3,7 +3,6 @@
 */
 import { assert } from '@ember/debug';
 
-import { REQUEST_SERVICE } from '@ember-data/canary-features';
 /*
   This file encapsulates the various states that a record can transition
   through during its lifecycle.
@@ -431,6 +430,8 @@ createdState.uncommitted.rollback = function (internalModel) {
 };
 
 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');
 };
@@ -494,9 +495,6 @@ const RootState = {
 
     // EVENTS
     loadingData(internalModel, promise) {
-      if (!REQUEST_SERVICE) {
-        internalModel._promiseProxy = promise;
-      }
       internalModel.transitionTo('loading');
     },
 
@@ -587,11 +585,7 @@ const RootState = {
         internalModel.transitionTo('updated.inFlight');
       },
 
-      reloadRecord(internalModel, { resolve, options }) {
-        if (!REQUEST_SERVICE) {
-          resolve(internalModel.store._reloadRecord(internalModel, options));
-        }
-      },
+      reloadRecord() {},
 
       deleteRecord(internalModel) {
         internalModel.transitionTo('deleted.uncommitted');

package/addon/-private/system/record-array-manager.js

@@ -5,11 +5,8 @@
 import { A } from '@ember/array';
 import { assert } from '@ember/debug';
 import { get, set } from '@ember/object';
-import { assign } from '@ember/polyfills';
 import { _backburner as emberBackburner } from '@ember/runloop';
 
-import { REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT } from '@ember-data/canary-features';
-
 import isStableIdentifier from '../identifiers/is-stable-identifier';
 import { AdapterPopulatedRecordArray, RecordArray } from './record-arrays';
 import { internalModelFactoryFor } from './store/internal-model-factory';
@@ -28,11 +25,10 @@ export function recordArraysForIdentifier(identifierOrInternalModel) {
 }
 
 const pendingForIdentifier = new Set([]);
-const IMDematerializing = new WeakMap();
 
 const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   let i = identifierOrInternalModel;
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !isStableIdentifier(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
@@ -43,18 +39,7 @@ const getIdentifier = function getIdentifier(identifierOrInternalModel) {
   return i;
 };
 
-// REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT only
 const peekIMCache = function peekIMCache(cache, identifier) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
-    let im = IMDematerializing.get(identifier);
-    if (im === undefined) {
-      // if not im._isDematerializing
-      im = cache.peek(identifier);
-    }
-
-    return im;
-  }
-
   return cache.peek(identifier);
 };
 
@@ -281,8 +266,8 @@ class RecordArrayManager {
         manager: this,
         isLoaded: true,
         isUpdating: false,
-        meta: assign({}, payload.meta),
-        links: assign({}, payload.links),
+        meta: { ...payload.meta },
+        links: { ...payload.links },
       });
 
       this._associateWithRecordArray(identifiers, array);
@@ -352,14 +337,6 @@ class RecordArrayManager {
     let modelName = identifier.type;
     identifier = getIdentifier(identifier);
 
-    if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
-      const cache = internalModelFactoryFor(this.store);
-      const im = peekIMCache(cache, identifier);
-      if (im && im._isDematerializing) {
-        IMDematerializing.set(identifier, im);
-      }
-    }
-
     if (pendingForIdentifier.has(identifier)) {
       return;
     }
@@ -429,15 +406,10 @@ const updateLiveRecordArray = function updateLiveRecordArray(store, recordArray,
 };
 
 const pushIdentifiers = function pushIdentifiers(recordArray, identifiers, cache) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._pushIdentifiers) {
-    // deprecate('not allowed to use this intimate api any more');
-    recordArray._pushInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
-  } else {
-    recordArray._pushIdentifiers(identifiers);
-  }
+  recordArray._pushIdentifiers(identifiers);
 };
 const removeIdentifiers = function removeIdentifiers(recordArray, identifiers, cache) {
-  if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT && !recordArray._removeIdentifiers) {
+  if (!recordArray._removeIdentifiers) {
     // deprecate('not allowed to use this intimate api any more');
     recordArray._removeInternalModels(identifiers.map((i) => peekIMCache(cache, i)));
   } else {

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

@@ -1,6 +1,5 @@
 import { A } from '@ember/array';
 import { get } from '@ember/object';
-import { assign } from '@ember/polyfills';
 import { once } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
@@ -86,8 +85,8 @@ let AdapterPopulatedRecordArray = RecordArray.extend({
     this.setProperties({
       isLoaded: true,
       isUpdating: false,
-      meta: assign({}, payload.meta),
-      links: assign({}, payload.links),
+      meta: { ...payload.meta },
+      links: { ...payload.links },
     });
 
     this.manager._associateWithRecordArray(identifiersOrInternalModels, this);

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

@@ -4,7 +4,7 @@ import type CoreStore from './core-store';
 
 type UnsubscribeToken = Object;
 
-const Cache = new WeakMap<StableRecordIdentifier, NotificationCallback>();
+const Cache = new WeakMap<StableRecordIdentifier, Map<UnsubscribeToken, NotificationCallback>>();
 const Tokens = new WeakMap<UnsubscribeToken, StableRecordIdentifier>();
 
 export type NotificationType =
@@ -29,7 +29,8 @@ export function unsubscribe(token: UnsubscribeToken) {
     throw new Error('Passed unknown unsubscribe token to unsubscribe');
   }
   Tokens.delete(token);
-  Cache.delete(identifier);
+  const map = Cache.get(identifier);
+  map?.delete(token);
 }
 /*
   Currently only support a single callback per identifier
@@ -39,8 +40,13 @@ export default class NotificationManager {
 
   subscribe(identifier: RecordIdentifier, callback: NotificationCallback): UnsubscribeToken {
     let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
-    Cache.set(stableIdentifier, callback);
+    let map = Cache.get(stableIdentifier);
+    if (map === undefined) {
+      map = new Map();
+      Cache.set(stableIdentifier, map);
+    }
     let unsubToken = {};
+    map.set(unsubToken, callback);
     Tokens.set(unsubToken, stableIdentifier);
     return unsubToken;
   }
@@ -49,11 +55,13 @@ export default class NotificationManager {
   notify(identifier: RecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'unload' | 'state'): boolean;
   notify(identifier: RecordIdentifier, value: NotificationType, key?: string): boolean {
     let stableIdentifier = identifierCacheFor(this.store).getOrCreateRecordIdentifier(identifier);
-    let callback = Cache.get(stableIdentifier);
-    if (!callback) {
+    let callbackMap = Cache.get(stableIdentifier);
+    if (!callbackMap || !callbackMap.size) {
       return false;
     }
-    callback(stableIdentifier, value, key);
+    callbackMap.forEach((cb) => {
+      cb(stableIdentifier, value, key);
+    });
     return true;
   }
 }

package/addon/-private/system/references/{belongs-to.js → belongs-to.ts}

@@ -1,11 +1,19 @@
 import { deprecate } from '@ember/debug';
+import { dependentKeyCompat } from '@ember/object/compat';
+import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
 import { DEPRECATE_BELONGS_TO_REFERENCE_PUSH } from '@ember-data/private-build-infra/deprecations';
+import type { BelongsToRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
+import { SingleResourceDocument } from '../../ts-interfaces/ember-data-json-api';
+import { StableRecordIdentifier } from '../../ts-interfaces/identifier';
+import CoreStore from '../core-store';
+import { NotificationType, unsubscribe } from '../record-notification-manager';
 import { internalModelFactoryFor, peekRecordIdentifier, recordIdentifierFor } from '../store/internal-model-factory';
+import RecordReference from './record';
 import Reference from './reference';
 
 /**
@@ -22,17 +30,77 @@ import Reference from './reference';
  @extends Reference
  */
 export default class BelongsToReference extends Reference {
-  constructor(store, parentIMOrIdentifier, belongsToRelationship, key) {
-    super(store, parentIMOrIdentifier);
+  declare key: string;
+  declare belongsToRelationship: BelongsToRelationship;
+  declare type: string;
+  declare parent: RecordReference;
+  declare parentIdentifier: StableRecordIdentifier;
+
+  // unsubscribe tokens given to us by the notification manager
+  #token!: Object;
+  #relatedToken: Object | null = null;
+
+  @tracked _ref = 0;
+
+  constructor(
+    store: CoreStore,
+    parentIdentifier: StableRecordIdentifier,
+    belongsToRelationship: BelongsToRelationship,
+    key: string
+  ) {
+    super(store, parentIdentifier);
     this.key = key;
     this.belongsToRelationship = belongsToRelationship;
     this.type = belongsToRelationship.definition.type;
-    this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference;
-    this.parentIdentifier = parentIMOrIdentifier;
+    const parent = internalModelFactoryFor(store).peek(parentIdentifier);
+    this.parent = parent!.recordReference;
+    this.parentIdentifier = parentIdentifier;
+
+    this.#token = store._notificationManager.subscribe(
+      parentIdentifier,
+      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+          this._ref++;
+        }
+      }
+    );
 
     // TODO inverse
   }
 
+  destroy() {
+    unsubscribe(this.#token);
+    if (this.#relatedToken) {
+      unsubscribe(this.#relatedToken);
+    }
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifier(): StableRecordIdentifier | null {
+    this._ref; // consume the tracked prop
+    if (this.#relatedToken) {
+      unsubscribe(this.#relatedToken);
+    }
+
+    let resource = this._resource();
+    if (resource && resource.data) {
+      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
+      this.#relatedToken = this.store._notificationManager.subscribe(
+        identifier,
+        (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+          if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+            this._ref++;
+          }
+        }
+      );
+
+      return identifier;
+    }
+
+    return null;
+  }
+
   /**
    The `id` of the record that this reference refers to. Together, the
    `type()` and `id()` methods form a composite key for the identity
@@ -73,13 +141,8 @@ export default class BelongsToReference extends Reference {
     @public
    @return {String} The id of the record in this belongsTo relationship.
    */
-  id() {
-    let id = null;
-    let resource = this._resource();
-    if (resource && resource.data) {
-      id = resource.data.id;
-    }
-    return id;
+  id(): string | null {
+    return this._relatedIdentifier?.id || null;
   }
 
   _resource() {
@@ -132,10 +195,10 @@ export default class BelongsToReference extends Reference {
    @param {Object|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
-  push(objectOrPromise) {
+  async push(objectOrPromise: Object | SingleResourceDocument): Promise<Object> {
     // TODO deprecate thenable support
     return resolve(objectOrPromise).then((data) => {
-      let record;
+      let record: Object;
 
       if (DEPRECATE_BELONGS_TO_REFERENCE_PUSH && peekRecordIdentifier(data)) {
         deprecate('Pushing a record into a BelongsToReference is deprecated', false, {
@@ -147,15 +210,16 @@ export default class BelongsToReference extends Reference {
             enabled: '3.16',
           },
         });
-        record = data;
+        record = data as Object;
       } else {
-        record = this.store.push(data);
+        record = this.store.push(data as SingleResourceDocument);
       }
 
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       assertPolymorphicType(
         this.belongsToRelationship.identifier,
         this.belongsToRelationship.definition,
-        record._internalModel.identifier,
+        recordIdentifierFor(record),
         this.store
       );
 
@@ -223,7 +287,7 @@ export default class BelongsToReference extends Reference {
     @public
    @return {Model} the record in this relationship
    */
-  value() {
+  value(): Object | null {
     let resource = this._resource();
     if (resource && resource.data) {
       let inverseInternalModel = this.store._internalModelForResource(resource.data);
@@ -299,7 +363,7 @@ export default class BelongsToReference extends Reference {
    */
   load(options) {
     let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);
-    return parentInternalModel.getBelongsTo(this.key, options);
+    return parentInternalModel!.getBelongsTo(this.key, options);
   }
 
   /**
@@ -354,7 +418,7 @@ export default class BelongsToReference extends Reference {
    */
   reload(options) {
     let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);
-    return parentInternalModel.reloadBelongsTo(this.key, options).then((internalModel) => {
+    return parentInternalModel!.reloadBelongsTo(this.key, options).then((internalModel) => {
       return this.value();
     });
   }

package/addon/-private/system/references/{has-many.js → has-many.ts}

@@ -1,10 +1,22 @@
+import { dependentKeyCompat } from '@ember/object/compat';
 import { DEBUG } from '@glimmer/env';
+import { cached, tracked } from '@glimmer/tracking';
 
 import { resolve } from 'rsvp';
 
+import type { ManyRelationship } from '@ember-data/record-data/-private';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 
+import {
+  CollectionResourceDocument,
+  ExistingResourceObject,
+  SingleResourceDocument,
+} from '../../ts-interfaces/ember-data-json-api';
+import { StableRecordIdentifier } from '../../ts-interfaces/identifier';
+import CoreStore from '../core-store';
+import { NotificationType, unsubscribe } from '../record-notification-manager';
 import { internalModelFactoryFor, recordIdentifierFor } from '../store/internal-model-factory';
+import RecordReference from './record';
 import Reference, { internalModelForReference } from './reference';
 
 /**
@@ -20,17 +32,84 @@ import Reference, { internalModelForReference } from './reference';
  @extends Reference
  */
 export default class HasManyReference extends Reference {
-  constructor(store, parentIMOrIdentifier, hasManyRelationship, key) {
-    super(store, parentIMOrIdentifier);
+  declare key: string;
+  declare hasManyRelationship: ManyRelationship;
+  declare type: string;
+  declare parent: RecordReference;
+  declare parentIdentifier: StableRecordIdentifier;
+
+  // unsubscribe tokens given to us by the notification manager
+  #token!: Object;
+  #relatedTokenMap!: Map<StableRecordIdentifier, Object>;
+
+  @tracked _ref = 0;
+
+  constructor(
+    store: CoreStore,
+    parentIdentifier: StableRecordIdentifier,
+    hasManyRelationship: ManyRelationship,
+    key: string
+  ) {
+    super(store, parentIdentifier);
     this.key = key;
     this.hasManyRelationship = hasManyRelationship;
     this.type = hasManyRelationship.definition.type;
 
-    this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference;
+    this.parent = internalModelFactoryFor(store).peek(parentIdentifier)!.recordReference;
 
+    this.#token = store._notificationManager.subscribe(
+      parentIdentifier,
+      (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+        if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {
+          this._ref++;
+        }
+      }
+    );
+    this.#relatedTokenMap = new Map();
     // TODO inverse
   }
 
+  destroy() {
+    unsubscribe(this.#token);
+    this.#relatedTokenMap.forEach((token) => {
+      unsubscribe(token);
+    });
+    this.#relatedTokenMap.clear();
+  }
+
+  @cached
+  @dependentKeyCompat
+  get _relatedIdentifiers(): StableRecordIdentifier[] {
+    this._ref; // consume the tracked prop
+
+    let resource = this._resource();
+
+    this.#relatedTokenMap.forEach((token) => {
+      unsubscribe(token);
+    });
+    this.#relatedTokenMap.clear();
+
+    if (resource && resource.data) {
+      return resource.data.map((resourceIdentifier) => {
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+        const token = this.store._notificationManager.subscribe(
+          identifier,
+          (_: StableRecordIdentifier, bucket: NotificationType, notifiedKey?: string) => {
+            if (bucket === 'identity' || ((bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id')) {
+              this._ref++;
+            }
+          }
+        );
+
+        this.#relatedTokenMap.set(identifier, token);
+
+        return identifier;
+      });
+    }
+
+    return [];
+  }
+
   _resource() {
     return this.recordData.getHasMany(this.key);
   }
@@ -77,7 +156,7 @@ export default class HasManyReference extends Reference {
    @public
    @return {String} The name of the remote type. This should either be `link` or `ids`
    */
-  remoteType() {
+  remoteType(): 'link' | 'ids' {
     let value = this._resource();
     if (value && value.links && value.links.related) {
       return 'link';
@@ -121,15 +200,8 @@ export default class HasManyReference extends Reference {
     @public
    @return {Array} The ids in this has-many relationship
    */
-  ids() {
-    let resource = this._resource();
-
-    let ids = [];
-    if (resource.data) {
-      ids = resource.data.map((data) => data.id);
-    }
-
-    return ids;
+  ids(): Array<string | null> {
+    return this._relatedIdentifiers.map((identifier) => identifier.id);
   }
 
   /**
@@ -177,45 +249,50 @@ export default class HasManyReference extends Reference {
    @param {Array|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
    @return {ManyArray}
    */
-  push(objectOrPromise) {
-    return resolve(objectOrPromise).then((payload) => {
-      let array = payload;
-
-      if (typeof payload === 'object' && payload.data) {
-        array = payload.data;
-      }
+  async push(
+    objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
+  ): Promise<any> {
+    const payload = await resolve(objectOrPromise);
+    let array: Array<ExistingResourceObject | SingleResourceDocument>;
+
+    if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {
+      array = payload.data;
+    } else {
+      array = payload as ExistingResourceObject[];
+    }
 
-      let internalModel = internalModelForReference(this);
+    const internalModel = internalModelForReference(this)!;
+    const { store } = this;
 
-      let identifiers = array.map((obj) => {
-        let record = this.store.push(obj);
+    let identifiers = array.map((obj) => {
+      let record;
+      if ('data' in obj) {
+        // TODO deprecate pushing non-valid JSON:API here
+        record = store.push(obj);
+      } else {
+        record = store.push({ data: obj });
+      }
 
-        if (DEBUG) {
-          let relationshipMeta = this.hasManyRelationship.definition;
-          assertPolymorphicType(
-            internalModel.identifier,
-            relationshipMeta,
-            record._internalModel.identifier,
-            this.store
-          );
-        }
-        return recordIdentifierFor(record);
-      });
+      if (DEBUG) {
+        let relationshipMeta = this.hasManyRelationship.definition;
+        let identifier = this.hasManyRelationship.identifier;
+        assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor(record), store);
+      }
+      return recordIdentifierFor(record);
+    });
 
-      const { graph, identifier } = this.hasManyRelationship;
-      this.store._backburner.join(() => {
-        graph.push({
-          op: 'replaceRelatedRecords',
-          record: identifier,
-          field: this.key,
-          value: identifiers,
-        });
+    const { graph, identifier } = this.hasManyRelationship;
+    store._backburner.join(() => {
+      graph.push({
+        op: 'replaceRelatedRecords',
+        record: identifier,
+        field: this.key,
+        value: identifiers,
       });
-
-      return internalModel.getHasMany(this.key);
-      // TODO IGOR it seems wrong that we were returning the many array here
-      //return this.hasManyRelationship.manyArray;
     });
+
+    // TODO IGOR it seems wrong that we were returning the many array here
+    return internalModel.getHasMany(this.key);
   }
 
   _isLoaded() {
@@ -275,7 +352,7 @@ export default class HasManyReference extends Reference {
    @return {ManyArray}
    */
   value() {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     if (this._isLoaded()) {
       return internalModel.getManyArray(this.key);
     }
@@ -348,7 +425,7 @@ export default class HasManyReference extends Reference {
    this has-many relationship.
    */
   load(options) {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     return internalModel.getHasMany(this.key, options);
   }
 
@@ -403,7 +480,7 @@ export default class HasManyReference extends Reference {
    @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
    */
   reload(options) {
-    let internalModel = internalModelForReference(this);
+    let internalModel = internalModelForReference(this)!;
     return internalModel.reloadHasMany(this.key, options);
   }
 }