@ember-data/model 4.8.0-alpha.5 → 4.9.0-alpha.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 } 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';
@@ -58,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;
@@ -122,7 +122,6 @@ function computeOnce(target, key, desc) {
   @extends Ember.EmberObject
 */
 class Model extends EmberObject {
-  @service store;
   ___private_notifications;
 
   init(options = {}) {
@@ -135,27 +134,27 @@ class Model extends EmberObject {
     const _secretInit = options._secretInit;
     options._createProps = null;
     options._secretInit = null;
+
+    let store = (this.store = _secretInit.store);
     super.init(options);
 
     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;
-
     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
@@ -163,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();
   }
 
@@ -840,6 +848,7 @@ class Model extends EmberObject {
   rollbackAttributes() {
     const { currentState } = this;
     const { isNew } = currentState;
+
     storeFor(this)._join(() => {
       recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
       this.errors.clear();
@@ -1146,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);
         }
       });
 
@@ -1385,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',
@@ -1428,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(
@@ -1462,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/references/belongs-to.ts

@@ -1,10 +1,12 @@
+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 { Graph } from '@ember-data/record-data/-private/graph';
+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';
@@ -385,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

package/addon/-private/references/has-many.ts

@@ -1,3 +1,4 @@
+import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { DEBUG } from '@glimmer/env';
 import { cached, tracked } from '@glimmer/tracking';
@@ -7,7 +8,8 @@ import { resolve } from 'rsvp';
 
 import { ManyArray } from 'ember-data/-private';
 
-import type { Graph } from '@ember-data/record-data/-private/graph';
+import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/deprecations';
+import type { Graph } from '@ember-data/record-data/-private/graph/graph';
 import type ManyRelationship from '@ember-data/record-data/-private/relationships/state/has-many';
 import type Store from '@ember-data/store';
 import { recordIdentifierFor } from '@ember-data/store';
@@ -397,7 +399,25 @@ export default class HasManyReference {
   async push(
     objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
   ): Promise<ManyArray> {
-    const payload = await resolve(objectOrPromise);
+    let payload = objectOrPromise;
+    if (DEPRECATE_PROMISE_PROXIES && (objectOrPromise as unknown as { then: unknown }).then) {
+      payload = await resolve(objectOrPromise);
+      if (payload !== objectOrPromise) {
+        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 array: Array<ExistingResourceObject | SingleResourceDocument>;
 
     if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {

package/addon/-private/relationship-meta.ts

@@ -75,7 +75,9 @@ class RelationshipDefinition implements RelationshipSchema {
 
     if (shouldFindInverse(this.meta)) {
       inverse = modelClass.inverseFor(this.key, store);
-    } else if (DEBUG) {
+    }
+    // TODO make this error again for the non-polymorphic case
+    if (DEBUG && !this.options.polymorphic) {
       modelClass.typeForRelationship(this.key, store);
     }
 

package/index.js

@@ -20,6 +20,8 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember/string',
       '@embroider/macros/es-compat',
 
+      '@ember/object/proxy',
+      '@ember/object/promise-proxy-mixin',
       '@ember/application',
       '@ember/array',
       '@ember/array/mutable',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.8.0-alpha.5",
+  "version": "4.9.0-alpha.0",
   "description": "A presentation layer for apps built with @ember-data/store",
   "keywords": [
     "ember-addon"
@@ -22,9 +22,9 @@
     "test:node": "mocha"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.8.0-alpha.5",
-    "@ember-data/private-build-infra": "4.8.0-alpha.5",
-    "@ember-data/store": "4.8.0-alpha.5",
+    "@ember-data/canary-features": "4.9.0-alpha.0",
+    "@ember-data/private-build-infra": "4.9.0-alpha.0",
+    "@ember-data/store": "4.9.0-alpha.0",
     "@ember/edition-utils": "^1.2.0",
     "@ember/string": "^3.0.0",
     "@embroider/macros": "^1.8.3",
@@ -38,7 +38,7 @@
     "inflection": "~1.13.2"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.8.0-alpha.5",
+    "@ember-data/unpublished-test-infra": "4.9.0-alpha.0",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "~2.7.0",
     "broccoli-asset-rev": "^3.0.0",