@ember-data/model 4.9.0-alpha.6 → 4.9.0-beta.1

package/LICENSE.md

@@ -1,6 +1,8 @@
 The MIT License (MIT)
 
-Copyright (c) 2019
+Copyright (C) 2017-2022 Ember.js contributors
+Portions Copyright (C) 2011-2017 Tilde, Inc. and contributors.
+Portions Copyright (C) 2011 LivingSocial Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/addon/-private/belongs-to.js

@@ -13,8 +13,10 @@ import { lookupLegacySupport } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
 function normalizeType(type) {
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && !type) {
-    return;
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
+    if (!type) {
+      return;
+    }
   }
 
   return dasherize(type);
@@ -127,60 +129,69 @@ function normalizeType(type) {
 function belongsTo(modelName, options) {
   let opts = options;
   let userEnteredModelName = modelName;
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && (typeof modelName !== 'string' || !modelName.length)) {
-    deprecate('belongsTo() must specify the string type of the related resource as the first parameter', false, {
-      id: 'ember-data:deprecate-non-strict-relationships',
-      for: 'ember-data',
-      until: '5.0',
-      since: { enabled: '4.7', available: '4.7' },
-    });
-
-    if (typeof modelName === 'object') {
-      opts = modelName;
-      userEnteredModelName = undefined;
-    } else {
-      opts = options;
-      userEnteredModelName = modelName;
-    }
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
+    if (typeof modelName !== 'string' || !modelName.length) {
+      deprecate('belongsTo() must specify the string type of the related resource as the first parameter', false, {
+        id: 'ember-data:deprecate-non-strict-relationships',
+        for: 'ember-data',
+        until: '5.0',
+        since: { enabled: '4.7', available: '4.7' },
+      });
 
-    assert(
-      'The first argument to belongsTo must be a string representing a model type key, not an instance of ' +
-        typeof userEnteredModelName +
-        ". E.g., to define a relation to the Person model, use belongsTo('person')",
-      typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'
-    );
-  }
+      if (typeof modelName === 'object') {
+        opts = modelName;
+        userEnteredModelName = undefined;
+      } else {
+        opts = options;
+        userEnteredModelName = modelName;
+      }
 
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC && (!opts || typeof opts.async !== 'boolean')) {
-    opts = opts || {};
-    if (!('async' in opts)) {
-      opts.async = true;
+      assert(
+        'The first argument to belongsTo must be a string representing a model type key, not an instance of ' +
+          typeof userEnteredModelName +
+          ". E.g., to define a relation to the Person model, use belongsTo('person')",
+        typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'
+      );
     }
-    deprecate('belongsTo(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
-      id: 'ember-data:deprecate-non-strict-relationships',
-      for: 'ember-data',
-      until: '5.0',
-      since: { enabled: '4.7', available: '4.7' },
-    });
-  } else {
-    assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
   }
 
-  if (
-    DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE &&
-    opts.inverse !== null &&
-    (typeof opts.inverse !== 'string' || opts.inverse.length === 0)
-  ) {
-    deprecate(
-      'belongsTo(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
-      false,
-      {
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC) {
+    if (!opts || typeof opts.async !== 'boolean') {
+      opts = opts || {};
+      if (!('async' in opts)) {
+        opts.async = true;
+      }
+      deprecate('belongsTo(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
         id: 'ember-data:deprecate-non-strict-relationships',
         for: 'ember-data',
         until: '5.0',
         since: { enabled: '4.7', available: '4.7' },
-      }
-    );
+      });
+    } else {
+      assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
+    }
+  } else {
+    assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
+  }
+
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE) {
+    if (opts.inverse !== null && (typeof opts.inverse !== 'string' || opts.inverse.length === 0)) {
+      deprecate(
+        'belongsTo(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
+        false,
+        {
+          id: 'ember-data:deprecate-non-strict-relationships',
+          for: 'ember-data',
+          until: '5.0',
+          since: { enabled: '4.7', available: '4.7' },
+        }
+      );
+    } else {
+      assert(
+        `Expected belongsTo options.inverse to be either null or the string type of the related resource.`,
+        opts.inverse === null || (typeof opts.inverse === 'string' && opts.inverse.length > 0)
+      );
+    }
   } else {
     assert(
       `Expected belongsTo options.inverse to be either null or the string type of the related resource.`,

package/addon/-private/debug/assert-polymorphic-type.js

@@ -0,0 +1,71 @@
+import { assert } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+import { DEPRECATE_NON_EXPLICIT_POLYMORPHISM } from '@ember-data/private-build-infra/deprecations';
+
+/*
+  Assert that `addedRecord` has a valid type so it can be added to the
+  relationship of the `record`.
+
+  The assert basically checks if the `addedRecord` can be added to the
+  relationship (specified via `relationshipMeta`) of the `record`.
+
+  This utility should only be used internally, as both record parameters must
+  be stable record identifiers and the `relationshipMeta` needs to be the meta
+  information about the relationship, retrieved via
+  `record.relationshipFor(key)`.
+*/
+let assertPolymorphicType;
+
+if (DEBUG) {
+  let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {
+    if (modelClass.__isMixin) {
+      return (
+        modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||
+        // handle native class extension e.g. `class Post extends Model.extend(Commentable) {}`
+        modelClass.__mixin.detect(Object.getPrototypeOf(addedModelClass).PrototypeMixin)
+      );
+    }
+
+    return addedModelClass.prototype instanceof modelClass || modelClass.detect(addedModelClass);
+  };
+
+  assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
+    let asserted = false;
+
+    if (parentDefinition.inverseIsImplicit) {
+      return;
+    }
+    if (parentDefinition.isPolymorphic) {
+      let meta = store.getSchemaDefinitionService().relationshipsDefinitionFor(addedIdentifier)[
+        parentDefinition.inverseKey
+      ];
+      if (meta?.options?.as) {
+        asserted = true;
+        assert(
+          `The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`,
+          meta.options.as === parentDefinition.type
+        );
+      }
+    }
+
+    if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
+      if (!asserted) {
+        store = store._store ? store._store : store; // allow usage with storeWrapper
+        let addedModelName = addedIdentifier.type;
+        let parentModelName = parentIdentifier.type;
+        let key = parentDefinition.key;
+        let relationshipModelName = parentDefinition.type;
+        let relationshipClass = store.modelFor(relationshipModelName);
+        let addedClass = store.modelFor(addedModelName);
+
+        let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;
+        let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);
+
+        assert(assertionMessage, isPolymorphic);
+      }
+    }
+  };
+}
+
+export { assertPolymorphicType };

package/addon/-private/deprecated-promise-proxy.ts

@@ -1,4 +1,6 @@
 import { deprecate } from '@ember/debug';
+import { get } from '@ember/object';
+import { DEBUG } from '@glimmer/env';
 
 import { resolve } from 'rsvp';
 
@@ -12,18 +14,36 @@ function promiseObject<T>(promise: Promise<T>): PromiseObject<T> {
 
 // constructor is accessed in some internals but not including it in the copyright for the deprecation
 const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
+const ALLOWABLE_PROPS = ['__ec_yieldable__', '__ec_cancel__'];
 const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
 
+const ProxySymbolString = String(Symbol.for('PROXY_CONTENT'));
+
 export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObject<T> {
   const promiseObjectProxy: PromiseObject<T> = promiseObject(promise);
+  if (!DEBUG) {
+    return promiseObjectProxy;
+  }
   const handler = {
-    get(target: object, prop: string, receiver?: object): unknown {
+    get(target: object, prop: string, receiver: object): unknown {
       if (typeof prop === 'symbol') {
+        if (String(prop) === ProxySymbolString) {
+          return;
+        }
         return Reflect.get(target, prop, receiver);
       }
+
+      if (prop === 'constructor') {
+        return target.constructor;
+      }
+
+      if (ALLOWABLE_PROPS.includes(prop)) {
+        return target[prop];
+      }
+
       if (!ALLOWABLE_METHODS.includes(prop)) {
         deprecate(
-          `Accessing ${prop} is deprecated. The return type is being changed fomr PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          `Accessing ${prop} is deprecated. The return type is being changed from PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
           false,
           {
             id: 'ember-data:model-save-promise',
@@ -35,15 +55,17 @@ export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObject<T
             },
           }
         );
+      } else {
+        return (target[prop] as () => unknown).bind(target);
       }
 
-      const value: unknown = target[prop];
-      if (value && typeof value === 'function' && typeof value.bind === 'function') {
-        return value.bind(target);
+      if (PROXIED_OBJECT_PROPS.includes(prop)) {
+        return target[prop];
       }
 
-      if (PROXIED_OBJECT_PROPS.includes(prop)) {
-        return value;
+      const value: unknown = get(target, prop);
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(receiver);
       }
 
       return undefined;

package/addon/-private/has-many.js

@@ -19,8 +19,10 @@ import { lookupLegacySupport } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
 function normalizeType(type) {
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && !type) {
-    return;
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
+    if (!type) {
+      return;
+    }
   }
 
   return singularize(dasherize(type));
@@ -168,60 +170,64 @@ function normalizeType(type) {
   @return {Ember.computed} relationship
 */
 function hasMany(type, options) {
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && (typeof type !== 'string' || !type.length)) {
-    deprecate(
-      'hasMany(<type>, <options>) must specify the string type of the related resource as the first parameter',
-      false,
-      {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: { enabled: '4.7', available: '4.7' },
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE) {
+    if (typeof type !== 'string' || !type.length) {
+      deprecate(
+        'hasMany(<type>, <options>) must specify the string type of the related resource as the first parameter',
+        false,
+        {
+          id: 'ember-data:deprecate-non-strict-relationships',
+          for: 'ember-data',
+          until: '5.0',
+          since: { enabled: '4.7', available: '4.7' },
+        }
+      );
+      if (typeof type === 'object') {
+        options = type;
+        type = undefined;
       }
-    );
-    if (typeof type === 'object') {
-      options = type;
-      type = undefined;
-    }
-
-    assert(
-      `The first argument to hasMany must be a string representing a model type key, not an instance of ${inspect(
-        type
-      )}. E.g., to define a relation to the Comment model, use hasMany('comment')`,
-      typeof type === 'string' || typeof type === 'undefined'
-    );
-  }
 
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC && (!options || typeof options.async !== 'boolean')) {
-    options = options || {};
-    if (!('async' in options)) {
-      options.async = true;
+      assert(
+        `The first argument to hasMany must be a string representing a model type key, not an instance of ${inspect(
+          type
+        )}. E.g., to define a relation to the Comment model, use hasMany('comment')`,
+        typeof type === 'string' || typeof type === 'undefined'
+      );
     }
-    deprecate('hasMany(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
-      id: 'ember-data:deprecate-non-strict-relationships',
-      for: 'ember-data',
-      until: '5.0',
-      since: { enabled: '4.7', available: '4.7' },
-    });
-  } else {
-    assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
   }
 
-  if (
-    DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE &&
-    options.inverse !== null &&
-    (typeof options.inverse !== 'string' || options.inverse.length === 0)
-  ) {
-    deprecate(
-      'hasMany(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
-      false,
-      {
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC) {
+    if (!options || typeof options.async !== 'boolean') {
+      options = options || {};
+      if (!('async' in options)) {
+        options.async = true;
+      }
+      deprecate('hasMany(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
         id: 'ember-data:deprecate-non-strict-relationships',
         for: 'ember-data',
         until: '5.0',
         since: { enabled: '4.7', available: '4.7' },
-      }
-    );
+      });
+    } else {
+      assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
+    }
+  } else {
+    assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
+  }
+
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE) {
+    if (options.inverse !== null && (typeof options.inverse !== 'string' || options.inverse.length === 0)) {
+      deprecate(
+        'hasMany(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
+        false,
+        {
+          id: 'ember-data:deprecate-non-strict-relationships',
+          for: 'ember-data',
+          until: '5.0',
+          since: { enabled: '4.7', available: '4.7' },
+        }
+      );
+    }
   }
 
   // Metadata about relationships is stored on the meta of

package/addon/-private/legacy-data-fetch.js

@@ -195,36 +195,37 @@ function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, paren
 
     let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
 
-    if (
-      DEBUG &&
-      typeof relationshipData !== 'undefined' &&
-      !relationshipDataPointsToParent(relationshipData, parentIdentifier)
-    ) {
-      let inspect = function inspect(thing) {
-        return `'${JSON.stringify(thing)}'`;
-      };
-      let quotedType = inspect(type);
-      let quotedInverse = inspect(inverseKey);
-      let expected = inspect({
-        id: parentIdentifier.id,
-        type: parentIdentifier.type,
-      });
-      let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
-      let got = inspect(relationshipData);
-      let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
-      let path = `${prefix}.relationships.${inverseKey}.data`;
-      let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
-      let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
-      let includedRecord = `<${type}:${id}>`;
-      let message = [
-        `Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`,
-        `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`,
-        `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`,
-        `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`,
-        `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`,
-      ].join('\n');
-
-      assert(message);
+    if (DEBUG) {
+      if (
+        typeof relationshipData !== 'undefined' &&
+        !relationshipDataPointsToParent(relationshipData, parentIdentifier)
+      ) {
+        let inspect = function inspect(thing) {
+          return `'${JSON.stringify(thing)}'`;
+        };
+        let quotedType = inspect(type);
+        let quotedInverse = inspect(inverseKey);
+        let expected = inspect({
+          id: parentIdentifier.id,
+          type: parentIdentifier.type,
+        });
+        let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
+        let got = inspect(relationshipData);
+        let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
+        let path = `${prefix}.relationships.${inverseKey}.data`;
+        let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
+        let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
+        let includedRecord = `<${type}:${id}>`;
+        let message = [
+          `Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`,
+          `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`,
+          `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`,
+          `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`,
+          `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`,
+        ].join('\n');
+
+        assert(message);
+      }
     }
 
     if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
@@ -244,9 +245,11 @@ function inverseForRelationship(store, identifier, key) {
     return null;
   }
 
-  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE && metaIsRelationshipDefinition(definition)) {
-    const modelClass = store.modelFor(identifier.type);
-    return definition._inverseKey(store, modelClass);
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE) {
+    if (metaIsRelationshipDefinition(definition)) {
+      const modelClass = store.modelFor(identifier.type);
+      return definition._inverseKey(store, modelClass);
+    }
   }
   assert(
     `Expected the relationship defintion to specify the inverse type or null.`,

package/addon/-private/legacy-relationships-support.ts

@@ -389,13 +389,15 @@ export class LegacySupport {
       const graph = graphFor(this.store);
       const relationship = graph.get(this.identifier, name);
 
-      if (DEBUG && kind) {
-        let modelName = this.identifier.type;
-        let actualRelationshipKind = relationship.definition.kind;
-        assert(
-          `You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`,
-          actualRelationshipKind === kind
-        );
+      if (DEBUG) {
+        if (kind) {
+          let modelName = this.identifier.type;
+          let actualRelationshipKind = relationship.definition.kind;
+          assert(
+            `You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`,
+            actualRelationshipKind === kind
+          );
+        }
       }
 
       let relationshipKind = relationship.definition.kind;
@@ -705,26 +707,28 @@ function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord |
     return null;
   }
 
-  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
-    let content = recordOrPromiseRecord.content;
-    assert(
-      'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
-      content !== undefined
-    );
-    deprecate(
-      `You passed in a PromiseProxy to a Relationship 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.7',
-          available: '4.7',
-        },
-        for: 'ember-data',
-      }
-    );
-    return content ? recordIdentifierFor(content) : null;
+  if (DEPRECATE_PROMISE_PROXIES) {
+    if (isPromiseRecord(recordOrPromiseRecord)) {
+      let content = recordOrPromiseRecord.content;
+      assert(
+        'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.',
+        content !== undefined
+      );
+      deprecate(
+        `You passed in a PromiseProxy to a Relationship 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.7',
+            available: '4.7',
+          },
+          for: 'ember-data',
+        }
+      );
+      return content ? recordIdentifierFor(content) : null;
+    }
   }
 
   return recordIdentifierFor(recordOrPromiseRecord);

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

@@ -367,27 +367,29 @@ function extractIdentifiersFromRecords(records: RecordInstance[]): StableRecordI
 }
 
 function extractIdentifierFromRecord(recordOrPromiseRecord: PromiseProxyRecord | RecordInstance) {
-  if (DEPRECATE_PROMISE_PROXIES && isPromiseRecord(recordOrPromiseRecord)) {
-    let content = recordOrPromiseRecord.content;
-    assert(
-      'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo relationship.',
-      content !== undefined && content !== null
-    );
-    deprecate(
-      `You passed in a PromiseProxy to a Relationship 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.7',
-          available: '4.7',
-        },
-        for: 'ember-data',
-      }
-    );
-    assertRecordPassedToHasMany(content);
-    return recordIdentifierFor(content);
+  if (DEPRECATE_PROMISE_PROXIES) {
+    if (isPromiseRecord(recordOrPromiseRecord)) {
+      let content = recordOrPromiseRecord.content;
+      assert(
+        'You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo relationship.',
+        content !== undefined && content !== null
+      );
+      deprecate(
+        `You passed in a PromiseProxy to a Relationship 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.7',
+            available: '4.7',
+          },
+          for: 'ember-data',
+        }
+      );
+      assertRecordPassedToHasMany(content);
+      return recordIdentifierFor(content);
+    }
   }
 
   assertRecordPassedToHasMany(recordOrPromiseRecord);

package/addon/-private/model.js

@@ -3,7 +3,6 @@
  */
 
 import { assert, deprecate, warn } from '@ember/debug';
-import EmberError from '@ember/error';
 import EmberObject from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
@@ -125,10 +124,12 @@ class Model extends EmberObject {
   ___private_notifications;
 
   init(options = {}) {
-    if (DEBUG && !options._secretInit && !options._createProps) {
-      throw new EmberError(
-        'You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.'
-      );
+    if (DEBUG) {
+      if (!options._secretInit && !options._createProps) {
+        throw new Error(
+          'You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.'
+        );
+      }
     }
     const createProps = options._createProps;
     const _secretInit = options._secretInit;
@@ -521,8 +522,10 @@ class Model extends EmberObject {
     // when using legacy/classic ember classes. Basically: lazy in prod and eager in dev.
     // so we do this to try to steer folks to the nicer "dont user currentState"
     // error.
-    if (!DEBUG && !this.___recordState) {
-      this.___recordState = new RecordState(this);
+    if (!DEBUG) {
+      if (!this.___recordState) {
+        this.___recordState = new RecordState(this);
+      }
     }
     return this.___recordState;
   }
@@ -1489,56 +1492,60 @@ class Model extends EmberObject {
     }
 
     // ensure inverse is properly configured
-    if (DEBUG && isPolymorphic) {
-      if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
-        if (!inverseOptions.as) {
-          deprecate(
+    if (DEBUG) {
+      if (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.7', available: '4.7' },
+                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.`,
-            false,
-            {
-              id: 'ember-data:non-explicit-relationships',
-              since: { enabled: '4.7', available: '4.7' },
-              until: '5.0',
-              for: 'ember-data',
-            }
+            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
           );
         }
-      } 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(
+    if (DEBUG) {
+      if (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.7', available: '4.7' },
+                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.`,
-            false,
-            {
-              id: 'ember-data:non-explicit-relationships',
-              since: { enabled: '4.7', available: '4.7' },
-              until: '5.0',
-              for: 'ember-data',
-            }
+            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
           );
         }
-      } 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
-        );
       }
     }
 
@@ -2469,7 +2476,7 @@ if (DEBUG) {
       let idDesc = lookupDescriptor(this, 'id');
 
       if (idDesc.get !== ID_DESCRIPTOR.get) {
-        throw new EmberError(
+        throw new Error(
           `You may not set 'id' as an attribute on your model. Please remove any lines that look like: \`id: attr('<type>')\` from ${this.constructor.toString()}`
         );
       }

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

@@ -8,6 +8,7 @@ import { storeFor } from '@ember-data/store';
 import { recordIdentifierFor } from '@ember-data/store/-private';
 import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
 import type RequestCache from '@ember-data/store/-private/network/request-cache';
+import { addToTransaction, subscribe } from '@ember-data/tracking/-private';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 
@@ -35,21 +36,19 @@ class Tag {
   declare rev: number;
   declare isDirty: boolean;
   declare value: any;
+  declare t: boolean;
 
   constructor() {
     this.rev = 1;
     this.isDirty = true;
     this.value = undefined;
+    this.t = false;
   }
-  @tracked _tracking = 0;
-
-  subscribe() {
-    this._tracking;
-  }
+  @tracked ref = null;
 
   notify() {
     this.isDirty = true;
-    this._tracking = this.rev;
+    addToTransaction(this);
     this.rev++;
   }
   consume(v) {
@@ -86,7 +85,7 @@ export function tagged(_target, key, desc) {
   const setter = desc.set;
   desc.get = function () {
     let tag = getTag(this, key);
-    tag.subscribe();
+    subscribe(tag);
 
     if (tag.isDirty) {
       tag.consume(getter.call(this));

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

@@ -1,5 +1,6 @@
 import { deprecate } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
+import { DEBUG } from '@glimmer/env';
 import { cached, tracked } from '@glimmer/tracking';
 
 import type { Object as JSONObject, Value as JSONValue } from 'json-typescript';
@@ -9,7 +10,6 @@ import { DEPRECATE_PROMISE_PROXIES } from '@ember-data/private-build-infra/depre
 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 {
@@ -22,6 +22,7 @@ import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 import type { Dict } from '@ember-data/types/q/utils';
 
+import { assertPolymorphicType } from '../debug/assert-polymorphic-type';
 import type { LegacySupport } from '../legacy-relationships-support';
 import { LEGACY_SUPPORT } from '../model';
 
@@ -101,9 +102,16 @@ export default class BelongsToReference {
     }
   }
 
+  /**
+   * The identifier of the record that this reference refers to.
+   * `null` if no related record is known.
+   *
+   * @property {StableRecordIdentifier | null} identifier
+   * @public
+   */
   @cached
   @dependentKeyCompat
-  get _relatedIdentifier(): StableRecordIdentifier | null {
+  get identifier(): StableRecordIdentifier | null {
     this._ref; // consume the tracked prop
     if (this.___relatedToken) {
       this.store._notificationManager.unsubscribe(this.___relatedToken);
@@ -165,11 +173,11 @@ export default class BelongsToReference {
    ```
 
    @method id
-    @public
+   @public
    @return {String} The id of the record in this belongsTo relationship.
    */
   id(): string | null {
-    return this._relatedIdentifier?.id || null;
+    return this.identifier?.id || null;
   }
 
   /**
@@ -388,33 +396,37 @@ export default class BelongsToReference {
    */
   async push(data: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<RecordInstance> {
     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.7',
-              available: '4.7',
-            },
-            for: 'ember-data',
-          }
-        );
+    if (DEPRECATE_PROMISE_PROXIES) {
+      if ((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.7',
+                available: '4.7',
+              },
+              for: 'ember-data',
+            }
+          );
+        }
       }
     }
     let record = this.store.push(jsonApiDoc);
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-    assertPolymorphicType(
-      this.belongsToRelationship.identifier,
-      this.belongsToRelationship.definition,
-      recordIdentifierFor(record),
-      this.store
-    );
+    if (DEBUG) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      assertPolymorphicType(
+        this.belongsToRelationship.identifier,
+        this.belongsToRelationship.definition,
+        recordIdentifierFor(record),
+        this.store
+      );
+    }
 
     const { identifier } = this.belongsToRelationship;
     this.store._join(() => {

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

@@ -13,7 +13,6 @@ 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';
-import { assertPolymorphicType } from '@ember-data/store/-debug';
 import type { NotificationType } from '@ember-data/store/-private/managers/record-notification-manager';
 import type {
   CollectionResourceDocument,
@@ -28,6 +27,7 @@ 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 { assertPolymorphicType } from '../debug/assert-polymorphic-type';
 import type { LegacySupport } from '../legacy-relationships-support';
 import { LEGACY_SUPPORT } from '../model';
 
@@ -102,9 +102,15 @@ export default class HasManyReference {
     this.___relatedTokenMap.clear();
   }
 
+  /**
+   * An array of identifiers for the records that this reference refers to.
+   *
+   * @property {StableRecordIdentifier[]} identifiers
+   * @public
+   */
   @cached
   @dependentKeyCompat
-  get _relatedIdentifiers(): StableRecordIdentifier[] {
+  get identifiers(): StableRecordIdentifier[] {
     this._ref; // consume the tracked prop
 
     let resource = this._resource();
@@ -236,7 +242,7 @@ export default class HasManyReference {
    @return {Array} The ids in this has-many relationship
    */
   ids(): Array<string | null> {
-    return this._relatedIdentifiers.map((identifier) => identifier.id);
+    return this.identifiers.map((identifier) => identifier.id);
   }
 
   /**
@@ -400,22 +406,24 @@ export default class HasManyReference {
     objectOrPromise: ExistingResourceObject[] | CollectionResourceDocument | { data: SingleResourceDocument[] }
   ): Promise<ManyArray> {
     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.7',
-              available: '4.7',
-            },
-            for: 'ember-data',
-          }
-        );
+    if (DEPRECATE_PROMISE_PROXIES) {
+      if ((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.7',
+                available: '4.7',
+              },
+              for: 'ember-data',
+            }
+          );
+        }
       }
     }
     let array: Array<ExistingResourceObject | SingleResourceDocument>;
@@ -519,7 +527,16 @@ export default class HasManyReference {
       this.___identifier
     )!;
 
-    return this._isLoaded() ? support.getManyArray(this.key) : null;
+    const loaded = this._isLoaded();
+
+    if (!loaded) {
+      // subscribe to changes
+      // for when we are not loaded yet
+      this._ref;
+      return null;
+    }
+
+    return support.getManyArray(this.key);
   }
 
   /**

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

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

package/addon/index.ts

@@ -36,5 +36,4 @@
   @module @ember-data/model
   @main @ember-data/model
  */
-
 export { Model as default, attr, belongsTo, hasMany } from './-private';

package/blueprints/model-test/mocha-files/__root__/__path__/__test__.js

@@ -1,15 +1,16 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
+
 import { setupModelTest } from 'ember-mocha';
 
-describe('<%= friendlyTestDescription %>', function() {
+describe('<%= friendlyTestDescription %>', function () {
   setupModelTest('<%= dasherizedModuleName %>', {
     // Specify the other units that are required for this test.
-  <%= typeof needs !== 'undefined' ? needs : '' %>
+  <%= typeof needs !== 'undefined' ? needs : '' %>,
   });
 
   // Replace this with your real tests.
-  it('exists', function() {
+  it('exists', function () {
     let model = this.subject();
     // var store = this.store();
     expect(model).to.be.ok;

package/blueprints/model-test/mocha-rfc-232-files/__root__/__path__/__test__.js

@@ -1,12 +1,13 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
+
 import { setupTest } from '<%= modulePrefix %>/tests/helpers';
 
-describe('<%= friendlyTestDescription %>', function() {
+describe('<%= friendlyTestDescription %>', function () {
   setupTest();
 
   // Replace this with your real tests.
-  it('exists', function() {
+  it('exists', function () {
     let store = this.owner.lookup('service:store');
     let model = store.createRecord('<%= dasherizedModuleName %>', {});
     expect(model).to.be.ok;

package/blueprints/model-test/qunit-files/__root__/__path__/__test__.js

@@ -1,11 +1,12 @@
 import { module, test } from 'qunit';
+
 import { setupTest } from '<%= modulePrefix %>/tests/helpers';
 
-module('<%= friendlyTestDescription %>', function(hooks) {
+module('<%= friendlyTestDescription %>', function (hooks) {
   setupTest(hooks);
 
   // Replace this with your real tests.
-  test('it exists', function(assert) {
+  test('it exists', function (assert) {
     let store = this.owner.lookup('service:store');
     let model = store.createRecord('<%= dasherizedModuleName %>', {});
     assert.ok(model);

package/index.js

@@ -15,10 +15,10 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember-data/canary-features',
       '@ember-data/store',
       '@ember-data/store/-private',
-      '@ember-data/store/-debug',
       '@embroider/macros',
       '@ember/string',
       '@embroider/macros/es-compat',
+      '@ember-data/tracking/-private',
 
       '@ember/object/proxy',
       '@ember/object/promise-proxy-mixin',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.9.0-alpha.6",
+  "version": "4.9.0-beta.1",
   "description": "A presentation layer for apps built with @ember-data/store",
   "keywords": [
     "ember-addon"
@@ -13,62 +13,52 @@
   "license": "MIT",
   "author": "",
   "directories": {},
-  "scripts": {
-    "build": "ember build",
-    "start": "ember serve",
-    "test:node": "mocha"
+  "scripts": {},
+  "peerDependencies": {
+    "@ember-data/record-data": "workspace:4.9.0-alpha.6",
+    "@ember-data/store": "workspace:4.9.0-alpha.6",
+    "@ember-data/tracking": "workspace:4.9.0-alpha.6",
+    "@ember/string": "^3.0.0",
+    "ember-inflector": "^4.0.2"
+  },
+  "peerDependenciesMeta": {
+    "@ember-data/record-data": {
+      "optional": true
+    }
+  },
+  "dependenciesMeta": {
+    "@ember-data/canary-features": {
+      "injected": true
+    },
+    "@ember-data/private-build-infra": {
+      "injected": true
+    }
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.9.0-alpha.6",
-    "@ember-data/private-build-infra": "4.9.0-alpha.6",
-    "@ember-data/store": "4.9.0-alpha.6",
+    "@ember-data/canary-features": "workspace:4.9.0-beta.1",
+    "@ember-data/private-build-infra": "workspace:4.9.0-beta.1",
     "@ember/edition-utils": "^1.2.0",
-    "@ember/string": "^3.0.0",
-    "@embroider/macros": "^1.8.3",
-    "ember-auto-import": "^2.4.2",
-    "ember-cached-decorator-polyfill": "^0.1.4",
+    "@embroider/macros": "^1.9.0",
+    "ember-auto-import": "^2.4.3",
+    "ember-cached-decorator-polyfill": "^1.0.1",
     "ember-cli-babel": "^7.26.11",
     "ember-cli-string-utils": "^1.1.0",
     "ember-cli-test-info": "^1.0.0",
-    "ember-cli-typescript": "^5.1.1",
     "ember-compatibility-helpers": "^1.2.6",
-    "inflection": "~1.13.2"
+    "inflection": "~1.13.4"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.9.0-alpha.6",
-    "@ember/optional-features": "^2.0.0",
-    "@ember/test-helpers": "~2.7.0",
-    "broccoli-asset-rev": "^3.0.0",
-    "ember-cli": "~4.7.0",
-    "ember-cli-blueprint-test-helpers": "^0.19.2",
-    "ember-cli-dependency-checker": "^3.3.1",
-    "ember-cli-htmlbars": "^6.1.1",
-    "ember-cli-inject-live-reload": "^2.1.0",
-    "ember-cli-sri": "^2.1.1",
-    "ember-cli-terser": "~4.0.2",
-    "ember-disable-prototype-extensions": "^1.1.3",
-    "ember-export-application-global": "^2.0.1",
-    "ember-load-initializers": "^2.1.2",
-    "ember-maybe-import-regenerator": "^1.0.0",
-    "ember-qunit": "^5.1.5",
-    "ember-resolver": "^8.0.3",
-    "ember-source": "~4.7.0",
-    "ember-source-channel-url": "^3.0.0",
-    "ember-try": "^2.0.0",
-    "loader.js": "^4.7.0",
-    "qunit": "^2.19.1",
-    "qunit-dom": "^2.0.0",
-    "silent-error": "^1.1.1",
+    "@babel/core": "^7.19.6",
+    "@glimmer/component": "^1.1.2",
+    "ember-source": "~4.8.0",
     "webpack": "^5.74.0"
   },
   "engines": {
     "node": "^14.8.0 || 16.* || >= 18.*"
   },
-  "ember-addon": {
-    "configPath": "tests/dummy/config"
-  },
+  "ember-addon": {},
   "volta": {
-    "node": "16.17.0",
-    "yarn": "1.22.19"
-  }
+    "extends": "../../package.json"
+  },
+  "packageManager": "pnpm@7.14.1"
 }

package/config/environment.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = function (/* environment, appConfig */) {
-  return {};
-};