@ember-data/model 4.9.0-alpha.1 → 4.9.0-alpha.12

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.8', available: '4.8' },
-    });
-
-    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.8', available: '4.8' },
-    });
-  } 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.8', available: '4.8' },
-      }
-    );
+        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.8', available: '4.8' },
+  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'
-    );
+      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;
+  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');
     }
-    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.8', available: '4.8' },
-    });
   } 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,
-      {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: { enabled: '4.8', available: '4.8' },
-      }
-    );
+  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.8',
-          available: '4.8',
-        },
-        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.8',
-          available: '4.8',
-        },
-        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);