@ember-data/model 4.8.0-alpha.4 → 4.8.0-beta.0

package/addon/-private/model.js

@@ -7,8 +7,6 @@ import EmberError from '@ember/error';
 import EmberObject from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
-import { inject as service } from '@ember/service';
-import { isNone } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
 import Ember from 'ember';
@@ -19,12 +17,14 @@ import { HAS_DEBUG_PACKAGE } from '@ember-data/private-build-infra';
 import {
   DEPRECATE_EARLY_STATIC,
   DEPRECATE_MODEL_REOPEN,
+  DEPRECATE_NON_EXPLICIT_POLYMORPHISM,
   DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
   DEPRECATE_SAVE_PROMISE_ACCESS,
 } from '@ember-data/private-build-infra/deprecations';
 import { recordIdentifierFor, storeFor } from '@ember-data/store';
-import { coerceId, deprecatedPromiseObject, recordDataFor, WeakCache } from '@ember-data/store/-private';
+import { coerceId, recordDataFor } from '@ember-data/store/-private';
 
+import { deprecatedPromiseObject } from './deprecated-promise-proxy';
 import Errors from './errors';
 import { LegacySupport } from './legacy-relationships-support';
 import notifyChanges from './notify-changes';
@@ -32,18 +32,21 @@ import RecordState, { peekTag, tagged } from './record-state';
 import { relationshipFromMeta } from './relationship-meta';
 
 const { changeProperties } = Ember;
-export const LEGACY_SUPPORT = new WeakCache(DEBUG ? 'legacy-relationships' : '');
-LEGACY_SUPPORT._generator = (record) => {
+export const LEGACY_SUPPORT = new Map();
+
+export function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
   let support = LEGACY_SUPPORT.get(identifier);
 
   if (!support) {
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
+    LEGACY_SUPPORT.set(record, support);
   }
 
   return support;
-};
+}
+
 function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let possibleRelationships = relationshipsSoFar || [];
 
@@ -55,7 +58,7 @@ function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let relationshipsForType = relationshipMap.get(type.modelName);
   let relationships = Array.isArray(relationshipsForType)
     ? relationshipsForType.filter((relationship) => {
-        let optionsForRelationship = inverseType.metaForProperty(relationship.name).options;
+        let optionsForRelationship = relationship.options;
 
         if (!optionsForRelationship.inverse && optionsForRelationship.inverse !== null) {
           return true;
@@ -119,7 +122,6 @@ function computeOnce(target, key, desc) {
   @extends Ember.EmberObject
 */
 class Model extends EmberObject {
-  @service store;
   ___private_notifications;
 
   init(options = {}) {
@@ -130,29 +132,29 @@ class Model extends EmberObject {
     }
     const createProps = options._createProps;
     const _secretInit = options._secretInit;
-    delete options._createProps;
-    delete options._secretInit;
+    options._createProps = null;
+    options._secretInit = null;
+
+    let store = (this.store = _secretInit.store);
     super.init(options);
 
-    _secretInit(this);
+    let identity = _secretInit.identifier;
+    _secretInit.cb(this, _secretInit.recordData, identity, _secretInit.store);
+
     this.___recordState = DEBUG ? new RecordState(this) : null;
 
     this.setProperties(createProps);
 
-    let store = storeFor(this);
     let notifications = store._notificationManager;
-    let identity = recordIdentifierFor(this);
-
     this.___private_notifications = notifications.subscribe(identity, (identifier, type, key) => {
       notifyChanges(identifier, type, key, this, store);
     });
   }
 
   destroy() {
-    LEGACY_SUPPORT.get(this)?.destroy();
+    const identifier = recordIdentifierFor(this);
     this.___recordState?.destroy();
     const store = storeFor(this);
-    const identifier = recordIdentifierFor(this);
     store._notificationManager.unsubscribe(this.___private_notifications);
     // Legacy behavior is to notify the relationships on destroy
     // such that they "clear". It's uncertain this behavior would
@@ -160,7 +162,16 @@ class Model extends EmberObject {
     // to simply not notify, for this reason the store does not itself
     // notify individual changes once the delete has been signaled,
     // this decision is left to model instances.
-    notifyChanges(identifier, 'relationships', undefined, this, store);
+
+    this.eachRelationship((key, meta) => {
+      if (meta.kind === 'belongsTo') {
+        this.notifyPropertyChange(key);
+      }
+    });
+    LEGACY_SUPPORT.get(this)?.destroy();
+    LEGACY_SUPPORT.delete(this);
+    LEGACY_SUPPORT.delete(identifier);
+
     super.destroy();
   }
 
@@ -493,9 +504,8 @@ class Model extends EmberObject {
     }
   }
 
-  // TODO just write a nice toString
-  toStringExtension() {
-    return this.id;
+  toString() {
+    return `<model::${this.constructor.modelName}:${this.id}>`;
   }
 
   /**
@@ -838,12 +848,15 @@ class Model extends EmberObject {
   rollbackAttributes() {
     const { currentState } = this;
     const { isNew } = currentState;
-    recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
-    this.errors.clear();
-    currentState.cleanErrorRequests();
-    if (isNew) {
-      this.unloadRecord();
-    }
+
+    storeFor(this)._join(() => {
+      recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
+      this.errors.clear();
+      currentState.cleanErrorRequests();
+      if (isNew) {
+        this.unloadRecord();
+      }
+    });
   }
 
   /**
@@ -1037,7 +1050,7 @@ class Model extends EmberObject {
     @return {BelongsToReference} reference for this relationship
   */
   belongsTo(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('belongsTo', name);
+    return lookupLegacySupport(this).referenceFor('belongsTo', name);
   }
 
   /**
@@ -1100,7 +1113,7 @@ class Model extends EmberObject {
     @return {HasManyReference} reference for this relationship
   */
   hasMany(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('hasMany', name);
+    return lookupLegacySupport(this).referenceFor('hasMany', name);
   }
 
   /**
@@ -1142,7 +1155,7 @@ class Model extends EmberObject {
       record.eachRelationship(function(name, descriptor) {
         if (descriptor.kind === 'hasMany') {
           let serializedHasManyName = name.toUpperCase() + '_IDS';
-          json[serializedHasManyName] = record.get(name).mapBy('id');
+          json[serializedHasManyName] = record.get(name).map(r => r.id);
         }
       });
 
@@ -1381,42 +1394,46 @@ class Model extends EmberObject {
         this.modelName
       );
     }
-    let inverseType = this.typeForRelationship(name, store);
-    if (!inverseType) {
-      return null;
-    }
 
-    let propertyMeta = this.metaForProperty(name);
+    const relationship = this.relationshipsByName.get(name);
+    const { options } = relationship;
+    const isPolymorphic = options.polymorphic;
+
     //If inverse is manually specified to be null, like  `comments: hasMany('message', { inverse: null })`
-    let options = propertyMeta.options;
-    if (options.inverse === null) {
+    const isExplicitInverseNull = options.inverse === null;
+    const isAbstractType =
+      !isExplicitInverseNull && isPolymorphic && !store.getSchemaDefinitionService().doesTypeExist(relationship.type);
+
+    if (isExplicitInverseNull || isAbstractType) {
+      assert(
+        `No schema for the abstract type '${relationship.type}' for the polymorphic relationship '${name}' on '${this.modelName}' was provided by the SchemaDefinitionService.`,
+        !isPolymorphic || isExplicitInverseNull
+      );
       return null;
     }
 
-    let inverseName, inverseKind, inverse, inverseOptions;
+    let fieldOnInverse, inverseKind, inverseRelationship, inverseOptions;
+    let inverseSchema = this.typeForRelationship(name, store);
 
+    // if the type does not exist and we are not polymorphic
     //If inverse is specified manually, return the inverse
-    if (options.inverse) {
-      inverseName = options.inverse;
-      inverse = inverseType.relationshipsByName.get(inverseName);
+    if (options.inverse !== undefined) {
+      fieldOnInverse = options.inverse;
+      inverseRelationship = inverseSchema && inverseSchema.relationshipsByName.get(fieldOnInverse);
 
       assert(
-        "We found no inverse relationships by the name of '" +
-          inverseName +
-          "' on the '" +
-          inverseType.modelName +
-          "' model. This is most likely due to a missing attribute on your model definition.",
-        !isNone(inverse)
+        `We found no field named '${fieldOnInverse}' on the schema for '${inverseSchema.modelName}' to be the inverse of the '${name}' relationship on '${this.modelName}'. This is most likely due to a missing field on your model definition.`,
+        inverseRelationship
       );
 
       // TODO probably just return the whole inverse here
-      inverseKind = inverse.kind;
-      inverseOptions = inverse.options;
+      inverseKind = inverseRelationship.kind;
+      inverseOptions = inverseRelationship.options;
     } else {
       //No inverse was specified manually, we need to use a heuristic to guess one
-      if (propertyMeta.type === propertyMeta.parentModelName) {
+      if (relationship.type === relationship.parentModelName) {
         warn(
-          `Detected a reflexive relationship by the name of '${name}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`,
+          `Detected a reflexive relationship named '${name}' on the schema for '${relationship.type}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`,
           false,
           {
             id: 'ds.model.reflexive-relationship-without-inverse',
@@ -1424,30 +1441,33 @@ class Model extends EmberObject {
         );
       }
 
-      let possibleRelationships = findPossibleInverses(this, inverseType, name);
+      let possibleRelationships = findPossibleInverses(this, inverseSchema, name);
 
       if (possibleRelationships.length === 0) {
         return null;
       }
 
-      let filteredRelationships = possibleRelationships.filter((possibleRelationship) => {
-        let optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;
-        return name === optionsForRelationship.inverse;
-      });
+      if (DEBUG) {
+        let filteredRelationships = possibleRelationships.filter((possibleRelationship) => {
+          let optionsForRelationship = possibleRelationship.options;
+          return name === optionsForRelationship.inverse;
+        });
 
-      assert(
-        "You defined the '" +
-          name +
-          "' relationship on " +
-          this +
-          ', but you defined the inverse relationships of type ' +
-          inverseType.toString() +
-          ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
-        filteredRelationships.length < 2
-      );
+        assert(
+          "You defined the '" +
+            name +
+            "' relationship on " +
+            this +
+            ', but you defined the inverse relationships of type ' +
+            inverseSchema.toString() +
+            ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
+          filteredRelationships.length < 2
+        );
+      }
 
-      if (filteredRelationships.length === 1) {
-        possibleRelationships = filteredRelationships;
+      let explicitRelationship = possibleRelationships.find((relationship) => relationship.options.inverse === name);
+      if (explicitRelationship) {
+        possibleRelationships = [explicitRelationship];
       }
 
       assert(
@@ -1458,24 +1478,78 @@ class Model extends EmberObject {
           ', but multiple possible inverse relationships of type ' +
           this +
           ' were found on ' +
-          inverseType +
+          inverseSchema +
           '. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
         possibleRelationships.length === 1
       );
 
-      inverseName = possibleRelationships[0].name;
+      fieldOnInverse = possibleRelationships[0].name;
       inverseKind = possibleRelationships[0].kind;
       inverseOptions = possibleRelationships[0].options;
     }
 
+    // ensure inverse is properly configured
+    if (DEBUG && isPolymorphic) {
+      if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
+        if (!inverseOptions.as) {
+          deprecate(
+            `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`,
+            false,
+            {
+              id: 'ember-data:non-explicit-relationships',
+              since: { enabled: '4.8', available: '4.8' },
+              until: '5.0',
+              for: 'ember-data',
+            }
+          );
+        }
+      } else {
+        assert(
+          `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`,
+          inverseOptions.as
+        );
+        assert(
+          `options.as should match the expected type of the polymorphic relationship. Expected field '${fieldOnInverse}' on type '${inverseSchema.modelName}' to specify '${relationship.type}' but found '${inverseOptions.as}'`,
+          !!inverseOptions.as && relationship.type === inverseOptions.as
+        );
+      }
+    }
+
+    // ensure we are properly configured
+    if (DEBUG && inverseOptions.polymorphic) {
+      if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
+        if (!options.as) {
+          deprecate(
+            `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`,
+            false,
+            {
+              id: 'ember-data:non-explicit-relationships',
+              since: { enabled: '4.8', available: '4.8' },
+              until: '5.0',
+              for: 'ember-data',
+            }
+          );
+        }
+      } else {
+        assert(
+          `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`,
+          options.as
+        );
+        assert(
+          `options.as should match the expected type of the polymorphic relationship. Expected field '${name}' on type '${this.modelName}' to specify '${inverseRelationship.type}' but found '${options.as}'`,
+          !!options.as && inverseRelationship.type === options.as
+        );
+      }
+    }
+
     assert(
-      `The ${inverseType.modelName}:${inverseName} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`,
-      !inverseOptions || inverseOptions.inverse !== null
+      `The ${inverseSchema.modelName}:${fieldOnInverse} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`,
+      inverseOptions.inverse !== null
     );
 
     return {
-      type: inverseType,
-      name: inverseName,
+      type: inverseSchema,
+      name: fieldOnInverse,
       kind: inverseKind,
       options: inverseOptions,
     };

package/addon/-private/promise-belongs-to.ts

@@ -4,11 +4,11 @@ import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import type ObjectProxy from '@ember/object/proxy';
 
 import type Store from '@ember-data/store';
-import { PromiseObject } from '@ember-data/store/-private';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import type { Dict } from '@ember-data/types/q/utils';
 
 import { LegacySupport } from './legacy-relationships-support';
+import { PromiseObject } from './promise-proxy-base';
 
 export interface BelongsToProxyMeta {
   key: string;

package/addon/-private/promise-many-array.ts

@@ -2,18 +2,23 @@ import ArrayMixin, { NativeArray } from '@ember/array';
 import type ArrayProxy from '@ember/array/proxy';
 import { assert, deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
+import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
 import Ember from 'ember';
 
 import { resolve } from 'rsvp';
 
-import type { ManyArray } from 'ember-data/-private';
-
-import { DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS } from '@ember-data/private-build-infra/deprecations';
+import {
+  DEPRECATE_A_USAGE,
+  DEPRECATE_COMPUTED_CHAINS,
+  DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS,
+} from '@ember-data/private-build-infra/deprecations';
 import { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import { FindOptions } from '@ember-data/types/q/store';
 
+import type ManyArray from './many-array';
+
 export interface HasManyProxyCreateArgs {
   promise: Promise<ManyArray>;
   content?: ManyArray;
@@ -53,13 +58,27 @@ export default class PromiseManyArray {
     this.isDestroyed = false;
     this.isDestroying = false;
 
-    const meta = Ember.meta(this);
-    meta.hasMixin = (mixin: Object) => {
-      if (mixin === NativeArray || mixin === ArrayMixin) {
-        return true;
-      }
-      return false;
-    };
+    if (DEPRECATE_A_USAGE) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        deprecate(`Do not use A() on an EmberData PromiseManyArray`, false, {
+          id: 'ember-data:no-a-with-array-like',
+          until: '5.0',
+          since: { enabled: '4.8', available: '4.8' },
+          for: 'ember-data',
+        });
+        // @ts-expect-error ArrayMixin is more than a type
+        if (mixin === NativeArray || mixin === ArrayMixin) {
+          return true;
+        }
+        return false;
+      };
+    } else if (DEBUG) {
+      const meta = Ember.meta(this);
+      meta.hasMixin = (mixin: Object) => {
+        assert(`Do not use A() on an EmberData PromiseManyArray`);
+      };
+    }
   }
 
   //---- Methods/Properties on ArrayProxy that we will keep as our API
@@ -75,7 +94,9 @@ export default class PromiseManyArray {
   get length(): number {
     // shouldn't be needed, but ends up being needed
     // for computed chains even in 4.x
-    this['[]'];
+    if (DEPRECATE_COMPUTED_CHAINS) {
+      this['[]'];
+    }
     return this.content ? this.content.length : 0;
   }
 
@@ -85,7 +106,9 @@ export default class PromiseManyArray {
   // to recompute. We entangle the '[]' tag from
   @dependentKeyCompat
   get '[]'() {
-    return this.content ? this.content['[]'] : this.content;
+    if (DEPRECATE_COMPUTED_CHAINS) {
+      return this.content?.length && this.content;
+    }
   }
 
   /**
@@ -99,7 +122,6 @@ export default class PromiseManyArray {
    * @private
    */
   forEach(cb) {
-    this['[]']; // needed for < 3.23 support e.g. 3.20 lts
     if (this.content && this.length) {
       this.content.forEach(cb);
     }

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

@@ -0,0 +1,4 @@
+import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import ObjectProxy from '@ember/object/proxy';
+
+export const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);

package/addon/-private/record-state.ts

@@ -105,7 +105,7 @@ export function tagged(_target, key, desc) {
 
 /**
 Historically EmberData managed a state machine
-for each record, the currentState for which
+for each record, the localState for which
 was reflected onto Model.
 
 This implements the flags and stateName for backwards compat

package/addon/-private/references/belongs-to.ts

@@ -1,15 +1,17 @@
+import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { cached, tracked } from '@glimmer/tracking';
 
 import type { Object as JSONObject, Value as JSONValue } from 'json-typescript';
 import { resolve } from 'rsvp';
 
-import type { BelongsToRelationship } from '@ember-data/record-data/-private';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph/graph';
+import type BelongsToRelationship from '@ember-data/record-data/-private/relationships/state/belongs-to';
 import type Store from '@ember-data/store';
 import { assertPolymorphicType } from '@ember-data/store/-debug';
 import { recordIdentifierFor } from '@ember-data/store/-private';
 import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
-import type { DebugWeakCache } from '@ember-data/store/-private/utils/weak-cache';
 import type {
   LinkObject,
   Links,
@@ -54,6 +56,7 @@ export default class BelongsToReference {
   declare type: string;
   ___identifier: StableRecordIdentifier;
   declare store: Store;
+  declare graph: Graph;
 
   // unsubscribe tokens given to us by the notification manager
   ___token!: object;
@@ -63,10 +66,12 @@ export default class BelongsToReference {
 
   constructor(
     store: Store,
+    graph: Graph,
     parentIdentifier: StableRecordIdentifier,
     belongsToRelationship: BelongsToRelationship,
     key: string
   ) {
+    this.graph = graph;
     this.key = key;
     this.belongsToRelationship = belongsToRelationship;
     this.type = belongsToRelationship.definition.type;
@@ -382,8 +387,25 @@ export default class BelongsToReference {
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
   async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<RecordInstance> {
-    // TODO @deprecate pushing unresolved payloads
-    const jsonApiDoc = await resolve(data);
+    let jsonApiDoc: SingleResourceDocument = data as SingleResourceDocument;
+    if (DEPRECATE_PROMISE_PROXIES && (data as { then: unknown }).then) {
+      jsonApiDoc = await resolve(data);
+      if (jsonApiDoc !== data) {
+        deprecate(
+          `You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`,
+          false,
+          {
+            id: 'ember-data:deprecate-promise-proxies',
+            until: '5.0',
+            since: {
+              enabled: '4.8',
+              available: '4.8',
+            },
+            for: 'ember-data',
+          }
+        );
+      }
+    }
     let record = this.store.push(jsonApiDoc);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -394,9 +416,9 @@ export default class BelongsToReference {
       this.store
     );
 
-    const { graph, identifier } = this.belongsToRelationship;
-    this.store._backburner.join(() => {
-      graph.push({
+    const { identifier } = this.belongsToRelationship;
+    this.store._join(() => {
+      this.graph.push({
         op: 'replaceRelatedRecord',
         record: identifier,
         field: this.key,
@@ -525,9 +547,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship.
    */
   load(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.___identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.getBelongsTo(this.key, options);
   }
 
@@ -582,9 +604,9 @@ export default class BelongsToReference {
    @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
    */
   reload(options?: Dict<unknown>) {
-    const support: LegacySupport = (
-      LEGACY_SUPPORT as DebugWeakCache<StableRecordIdentifier, LegacySupport>
-    ).getWithError(this.___identifier);
+    const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
+      this.___identifier
+    )!;
     return support.reloadBelongsTo(this.key, options).then(() => this.value());
   }
 }