@ember-data/model 5.3.0-alpha.0 → 5.3.0-alpha.10

package/addon/{index-8a7de041.js → model-8081bc05.js}

@@ -1,13 +1,13 @@
 import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
-import { assert, warn } from '@ember/debug';
-import EmberObject, { computed, get } from '@ember/object';
-import { recordIdentifierFor, storeFor as storeFor$1 } from '@ember-data/store';
-import { peekCache, RecordArray, MUTATE, SOURCE, recordIdentifierFor as recordIdentifierFor$1, IDENTIFIER_ARRAY_TAG, notifyArray, isStableIdentifier, storeFor, fastPush, coerceId } from '@ember-data/store/-private';
+import { deprecate, assert, warn } from '@ember/debug';
 import { dasherize } from '@ember/string';
+import EmberObject, { computed, get } from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
 import { cached, tracked } from '@glimmer/tracking';
 import Ember from 'ember';
+import { recordIdentifierFor as recordIdentifierFor$1, storeFor as storeFor$1 } from '@ember-data/store';
+import { RecordArray, MUTATE, SOURCE, recordIdentifierFor, IDENTIFIER_ARRAY_TAG, notifyArray, isStableIdentifier, storeFor, peekCache, fastPush, coerceId } from '@ember-data/store/-private';
 import { A } from '@ember/array';
 import ArrayProxy from '@ember/array/proxy';
 import { mapBy, not } from '@ember/object/computed';
@@ -15,7 +15,6 @@ import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
 import { cacheFor } from '@ember/object/internals';
 import { addToTransaction, subscribe } from '@ember-data/tracking/-private';
-import { singularize } from 'ember-inflector';
 function isElementDescriptor(args) {
   let [maybeTarget, maybeKey, maybeDesc] = args;
   return (
@@ -34,152 +33,22 @@ function isElementDescriptor(args) {
 function computedMacroWithOptionalParams(fn) {
   return (...maybeDesc) => isElementDescriptor(maybeDesc) ? fn()(...maybeDesc) : fn(...maybeDesc);
 }
-
-/**
-  @module @ember-data/model
-*/
-
-/**
-  `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
-  By default, attributes are passed through as-is, however you can specify an
-  optional type to have the value automatically transformed.
-  Ember Data ships with four basic transform types: `string`, `number`,
-  `boolean` and `date`. You can define your own transforms by subclassing
-  [Transform](/ember-data/release/classes/Transform).
-
-  Note that you cannot use `attr` to define an attribute of `id`.
-
-  `attr` takes an optional hash as a second parameter, currently
-  supported options are:
-
-  - `defaultValue`: Pass a string or a function to be called to set the attribute
-  to a default value if and only if the key is absent from the payload response.
-
-  Example
-
-  ```app/models/user.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @attr('string') username;
-    @attr('string') email;
-    @attr('boolean', { defaultValue: false }) verified;
-  }
-  ```
-
-  Default value can also be a function. This is useful it you want to return
-  a new object for each attribute.
-
-  ```app/models/user.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @attr('string') username;
-    @attr('string') email;
-
-    @attr({
-      defaultValue() {
-        return {};
-      }
-    })
-    settings;
-  }
-  ```
-
-  The `options` hash is passed as second argument to a transforms'
-  `serialize` and `deserialize` method. This allows to configure a
-  transformation and adapt the corresponding value, based on the config:
-
-  ```app/models/post.js
-  import Model, { attr } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @attr('text', {
-      uppercase: true
-    })
-    text;
-  }
-  ```
-
-  ```app/transforms/text.js
-  export default class TextTransform {
-    serialize(value, options) {
-      if (options.uppercase) {
-        return value.toUpperCase();
+function normalizeModelName(type) {
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_TYPES)) {
+    const result = dasherize(type);
+    deprecate(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`, result === type, {
+      id: 'ember-data:deprecate-non-strict-types',
+      until: '6.0',
+      for: 'ember-data',
+      since: {
+        available: '5.3',
+        enabled: '5.3'
       }
-
-      return value;
-    }
-
-    deserialize(value) {
-      return value;
-    }
-
-    static create() {
-      return new this();
-    }
-  }
-  ```
-
-  @method attr
-  @public
-  @static
-  @for @ember-data/model
-  @param {String|Object} type the attribute type
-  @param {Object} options a hash of options
-  @return {Attribute}
-*/
-function attr(type, options) {
-  if (typeof type === 'object') {
-    options = type;
-    type = undefined;
-  } else {
-    options = options || {};
+    });
+    return result;
   }
-  let meta = {
-    type: type,
-    isAttribute: true,
-    options: options
-  };
-  return computed({
-    get(key) {
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
-        }
-      }
-      if (this.isDestroyed || this.isDestroying) {
-        return;
-      }
-      return peekCache(this).getAttr(recordIdentifierFor(this), key);
-    },
-    set(key, value) {
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
-        }
-      }
-      assert(`Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`, !this.currentState.isDeleted);
-      const identifier = recordIdentifierFor(this);
-      const cache = peekCache(this);
-      let currentValue = cache.getAttr(identifier, key);
-      if (currentValue !== value) {
-        cache.setAttr(identifier, key, value);
-        if (!this.isValid) {
-          const {
-            errors
-          } = this;
-          if (errors.get(key)) {
-            errors.remove(key);
-            this.currentState.cleanErrorRequests();
-          }
-        }
-      }
-      return value;
-    }
-  }).meta(meta);
+  return type;
 }
-var attr$1 = computedMacroWithOptionalParams(attr);
 function _initializerDefineProperty(target, property, descriptor, context) {
   if (!descriptor) return;
   Object.defineProperty(target, property, {
@@ -728,7 +597,7 @@ class RelatedCollection extends RecordArray {
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
-            value: recordIdentifierFor$1(result)
+            value: recordIdentifierFor(result)
           });
         }
         break;
@@ -747,7 +616,7 @@ class RelatedCollection extends RecordArray {
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
-            value: recordIdentifierFor$1(result),
+            value: recordIdentifierFor(result),
             index: 0
           });
         }
@@ -757,7 +626,7 @@ class RelatedCollection extends RecordArray {
           op: 'sortRelatedRecords',
           record: this.identifier,
           field: this.key,
-          value: result.map(recordIdentifierFor$1)
+          value: result.map(recordIdentifierFor)
         });
         break;
       case 'splice':
@@ -778,7 +647,7 @@ class RelatedCollection extends RecordArray {
               op: 'removeFromRelatedRecords',
               record: this.identifier,
               field: this.key,
-              value: result.map(recordIdentifierFor$1),
+              value: result.map(recordIdentifierFor),
               index: start
             });
           }
@@ -858,6 +727,9 @@ class RelatedCollection extends RecordArray {
     this.push(record);
     return record;
   }
+  destroy() {
+    super.destroy(false);
+  }
 }
 RelatedCollection.prototype.isAsync = false;
 RelatedCollection.prototype.isPolymorphic = false;
@@ -869,7 +741,7 @@ RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
 function assertRecordPassedToHasMany(record) {
   assert(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`, function () {
     try {
-      recordIdentifierFor$1(record);
+      recordIdentifierFor(record);
       return true;
     } catch {
       return false;
@@ -881,7 +753,7 @@ function extractIdentifiersFromRecords(records) {
 }
 function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
   assertRecordPassedToHasMany(recordOrPromiseRecord);
-  return recordIdentifierFor$1(recordOrPromiseRecord);
+  return recordIdentifierFor(recordOrPromiseRecord);
 }
 const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
 var _dec, _class$5;
@@ -919,7 +791,7 @@ let PromiseBelongsTo = (_dec = computed(), (_class$5 = class PromiseBelongsTo ex
   get meta() {
     // eslint-disable-next-line no-constant-condition
     {
-      assert('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this.get('_belongsToState').modelName}:${this.get('_belongsToState').key}'.` + '\nUse `record.belongsTo(relationshipName).meta()` instead.', false);
+      assert('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this._belongsToState.modelName}:${this._belongsToState.key}'.` + '\nUse `record.belongsTo(relationshipName).meta()` instead.', false);
     }
     return;
   }
@@ -1224,10 +1096,9 @@ function isResourceIdentiferWithRelatedLinks$1(value) {
  @public
  */
 let BelongsToReference = (_class$3 = class BelongsToReference {
-  // unsubscribe tokens given to us by the notification manager
-
   constructor(store, graph, parentIdentifier, belongsToRelationship, key) {
     this.___identifier = void 0;
+    // unsubscribe tokens given to us by the notification manager
     this.___token = void 0;
     this.___relatedToken = null;
     _initializerDefineProperty(this, "_ref", _descriptor$3, this);
@@ -1512,7 +1383,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
     let record = this.store.push(jsonApiDoc);
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-      assertPolymorphicType(this.belongsToRelationship.identifier, this.belongsToRelationship.definition, recordIdentifierFor$1(record), this.store);
+      assertPolymorphicType(this.belongsToRelationship.identifier, this.belongsToRelationship.definition, recordIdentifierFor(record), this.store);
     }
     const {
       identifier
@@ -1522,7 +1393,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
         op: 'replaceRelatedRecord',
         record: identifier,
         field: this.key,
-        value: recordIdentifierFor$1(record)
+        value: recordIdentifierFor(record)
       });
     });
     return Promise.resolve(record);
@@ -1704,9 +1575,8 @@ function isResourceIdentiferWithRelatedLinks(value) {
  @extends Reference
  */
 let HasManyReference = (_class$2 = class HasManyReference {
-  // unsubscribe tokens given to us by the notification manager
-
   constructor(store, graph, parentIdentifier, hasManyRelationship, key) {
+    // unsubscribe tokens given to us by the notification manager
     this.___token = void 0;
     this.___identifier = void 0;
     this.___relatedTokenMap = void 0;
@@ -2010,9 +1880,9 @@ let HasManyReference = (_class$2 = class HasManyReference {
         let identifier = this.hasManyRelationship.identifier;
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor(record), store);
+        assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor$1(record), store);
       }
-      return recordIdentifierFor(record);
+      return recordIdentifierFor$1(record);
     });
     const {
       identifier
@@ -2199,8 +2069,12 @@ class LegacySupport {
   constructor(record) {
     this.record = record;
     this.store = storeFor(record);
-    this.identifier = recordIdentifierFor$1(record);
+    this.identifier = recordIdentifierFor(record);
     this.cache = peekCache(record);
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+      const graphFor = importSync('@ember-data/graph/-private').graphFor;
+      this.graph = graphFor(this.store);
+    }
     this._manyArrayCache = Object.create(null);
     this._relationshipPromisesCache = Object.create(null);
     this._relationshipProxyCache = Object.create(null);
@@ -2237,14 +2111,14 @@ class LegacySupport {
     if (loadingPromise) {
       return loadingPromise;
     }
-    const graphFor = importSync('@ember-data/graph/-private').graphFor;
-    const relationship = graphFor(this.store).get(this.identifier, key);
+    const relationship = this.graph.get(this.identifier, key);
     assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
     let resource = this.cache.getRelationship(this.identifier, key);
     relationship.state.hasFailedLoadAttempt = false;
     relationship.state.shouldForceReload = true;
     let promise = this._findBelongsTo(key, resource, relationship, options);
     if (this._relationshipProxyCache[key]) {
+      // @ts-expect-error
       return this._updatePromiseProxyFor('belongsTo', key, {
         promise
       });
@@ -2260,8 +2134,7 @@ class LegacySupport {
     let relatedIdentifier = resource && resource.data ? resource.data : null;
     assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
     const store = this.store;
-    const graphFor = importSync('@ember-data/graph/-private').graphFor;
-    const relationship = graphFor(store).get(this.identifier, key);
+    const relationship = this.graph.get(this.identifier, key);
     assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
     let isAsync = relationship.definition.isAsync;
     let _belongsToState = {
@@ -2307,10 +2180,10 @@ class LegacySupport {
     let identifiers = [];
     if (jsonApi.data) {
       for (let i = 0; i < jsonApi.data.length; i++) {
-        const identifier = jsonApi.data[i];
-        assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-        if (cache.recordIsLoaded(identifier, true)) {
-          identifiers.push(identifier);
+        const relatedIdentifier = jsonApi.data[i];
+        assert(`Expected a stable identifier`, isStableIdentifier(relatedIdentifier));
+        if (cache.recordIsLoaded(relatedIdentifier, true)) {
+          identifiers.push(relatedIdentifier);
         }
       }
     }
@@ -2320,8 +2193,7 @@ class LegacySupport {
     if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let manyArray = this._manyArrayCache[key];
       if (!definition) {
-        const graphFor = importSync('@ember-data/graph/-private').graphFor;
-        definition = graphFor(this.store).get(this.identifier, key).definition;
+        definition = this.graph.get(this.identifier, key).definition;
       }
       if (!manyArray) {
         const [identifiers, doc] = this._getCurrentState(this.identifier, key);
@@ -2371,8 +2243,7 @@ class LegacySupport {
       if (loadingPromise) {
         return loadingPromise;
       }
-      const graphFor = importSync('@ember-data/graph/-private').graphFor;
-      const relationship = graphFor(this.store).get(this.identifier, key);
+      const relationship = this.graph.get(this.identifier, key);
       const {
         definition,
         state
@@ -2392,8 +2263,7 @@ class LegacySupport {
   }
   getHasMany(key, options) {
     if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
-      const graphFor = importSync('@ember-data/graph/-private').graphFor;
-      const relationship = graphFor(this.store).get(this.identifier, key);
+      const relationship = this.graph.get(this.identifier, key);
       const {
         definition,
         state
@@ -2455,21 +2325,23 @@ class LegacySupport {
         // because of the intimate API access involved. This is something we will need to redesign.
         assert(`snapshot.belongsTo only supported for @ember-data/json-api`);
       }
-      const graphFor = importSync('@ember-data/graph/-private').graphFor;
-      const graph = graphFor(this.store);
-      const relationship = graph.get(this.identifier, name);
+      const {
+        graph,
+        identifier
+      } = this;
+      const relationship = graph.get(identifier, name);
       if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (kind) {
-          let modelName = this.identifier.type;
+          let modelName = 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;
       if (relationshipKind === 'belongsTo') {
-        reference = new BelongsToReference(this.store, graph, this.identifier, relationship, name);
+        reference = new BelongsToReference(this.store, graph, identifier, relationship, name);
       } else if (relationshipKind === 'hasMany') {
-        reference = new HasManyReference(this.store, graph, this.identifier, relationship, name);
+        reference = new HasManyReference(this.store, graph, identifier, relationship, name);
       }
       this.references[name] = reference;
     }
@@ -2699,7 +2571,7 @@ function extractIdentifierFromRecord(record) {
   if (!record) {
     return null;
   }
-  return recordIdentifierFor$1(record);
+  return recordIdentifierFor(record);
 }
 function anyUnloaded(store, relationship) {
   let state = relationship.localState;
@@ -2733,8 +2605,8 @@ function notifyChanges(identifier, value, key, record, store) {
     if (key) {
       notifyAttribute(store, identifier, key, record);
     } else {
-      record.eachAttribute(key => {
-        notifyAttribute(store, identifier, key, record);
+      record.eachAttribute(name => {
+        notifyAttribute(store, identifier, name, record);
       });
     }
   } else if (value === 'relationships') {
@@ -2742,8 +2614,8 @@ function notifyChanges(identifier, value, key, record, store) {
       let meta = record.constructor.relationshipsByName.get(key);
       notifyRelationship(identifier, key, record, meta);
     } else {
-      record.eachRelationship((key, meta) => {
-        notifyRelationship(identifier, key, record, meta);
+      record.eachRelationship((name, meta) => {
+        notifyRelationship(identifier, name, record, meta);
       });
     }
   } else if (value === 'identity') {
@@ -2803,6 +2675,11 @@ function isInvalidError(error) {
 let Tag = (_class$1 = class Tag {
   constructor() {
     _initializerDefineProperty(this, "ref", _descriptor$1, this);
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      const [base, prop] = arguments;
+      this._debug_base = base;
+      this._debug_prop = prop;
+    }
     this.rev = 1;
     this.isDirty = true;
     this.value = undefined;
@@ -2835,7 +2712,8 @@ function getTag(record, key) {
     tags = Object.create(null);
     Tags.set(record, tags);
   }
-  return tags[key] = tags[key] || new Tag();
+  // @ts-expect-error
+  return tags[key] = tags[key] || (macroCondition(getOwnConfig().env.DEBUG) ? new Tag(record.constructor.modelName, key) : new Tag());
 }
 function peekTag(record, key) {
   let tags = Tags.get(record);
@@ -2913,7 +2791,7 @@ let RecordState = (_class3 = class RecordState {
   constructor(record) {
     _initializerDefineProperty(this, "isSaving", _descriptor2, this);
     const store = storeFor$1(record);
-    const identity = recordIdentifierFor$1(record);
+    const identity = recordIdentifierFor(record);
     this.identifier = identity;
     this.record = record;
     this.cache = store.cache;
@@ -3184,7 +3062,7 @@ const {
 } = Ember;
 const LEGACY_SUPPORT = new Map();
 function lookupLegacySupport(record) {
-  const identifier = recordIdentifierFor(record);
+  const identifier = recordIdentifierFor$1(record);
   let support = LEGACY_SUPPORT.get(identifier);
   if (!support) {
     assert(`Memory Leak Detected`, !record.isDestroyed && !record.isDestroying);
@@ -3301,7 +3179,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     });
   }
   destroy() {
-    const identifier = recordIdentifierFor(this);
+    const identifier = recordIdentifierFor$1(this);
     this.___recordState?.destroy();
     const store = storeFor$1(this);
     store.notifications.unsubscribe(this.___private_notifications);
@@ -3565,16 +3443,16 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // object is real.
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       try {
-        return recordIdentifierFor(this).id;
+        return recordIdentifierFor$1(this).id;
       } catch {
         return void 0;
       }
     }
-    return recordIdentifierFor(this).id;
+    return recordIdentifierFor$1(this).id;
   }
   set id(id) {
     const normalizedId = coerceId(id);
-    const identifier = recordIdentifierFor(this);
+    const identifier = recordIdentifierFor$1(this);
     let didChange = normalizedId !== identifier.id;
     assert(`Cannot set ${identifier.type} record's id to ${id}, because id is already ${identifier.id}`, !didChange || identifier.id === null);
     if (normalizedId !== null && didChange) {
@@ -3866,7 +3744,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return peekCache(this).changedAttrs(recordIdentifierFor(this));
+    return peekCache(this).changedAttrs(recordIdentifierFor$1(this));
   }
 
   /**
@@ -3892,7 +3770,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       isNew
     } = currentState;
     storeFor$1(this)._join(() => {
-      peekCache(this).rollbackAttrs(recordIdentifierFor(this));
+      peekCache(this).rollbackAttrs(recordIdentifierFor$1(this));
       this.errors.clear();
       currentState.cleanErrorRequests();
       if (isNew) {
@@ -3912,7 +3790,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
       store._fetchManager = new FetchManager(store);
     }
-    return store._fetchManager.createSnapshot(recordIdentifierFor(this));
+    return store._fetchManager.createSnapshot(recordIdentifierFor$1(this));
   }
 
   /**
@@ -3954,6 +3832,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     if (this.currentState.isNew && this.currentState.isDeleted) {
       promise = Promise.resolve(this);
     } else {
+      this.errors.clear();
       promise = storeFor$1(this).saveRecord(this, options);
     }
     return promise;
@@ -3985,7 +3864,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   reload(options = {}) {
     options.isReloading = true;
     options.reload = true;
-    const identifier = recordIdentifierFor(this);
+    const identifier = recordIdentifierFor$1(this);
     assert(`You cannot reload a record without an ID`, identifier.id);
     this.isReloading = true;
     const promise = storeFor$1(this).request({
@@ -4167,41 +4046,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
-
-  /**
-    Create should only ever be called by the store. To create an instance of a
-    `Model` in a dirty state use `store.createRecord`.
-    To create instances of `Model` in a clean state, use `store.push`
-     @method create
-    @private
-    @static
-  */
-  /**
-   Represents the model's class name as a string. This can be used to look up the model's class name through
-   `Store`'s modelFor method.
-    `modelName` is generated for you by Ember Data. It will be a lowercased, dasherized string.
-   For example:
-    ```javascript
-   store.modelFor('post').modelName; // 'post'
-   store.modelFor('blog-post').modelName; // 'blog-post'
-   ```
-    The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
-   keys to underscore (instead of dasherized), you might use the following code:
-    ```javascript
-   import RESTSerializer from '@ember-data/serializer/rest';
-   import { underscore } from '<app-name>/utils/string-utils';
-    export default const PostSerializer = RESTSerializer.extend({
-     payloadKeyFromModelName(modelName) {
-       return underscore(modelName);
-     }
-   });
-   ```
-   @property modelName
-    @public
-   @type String
-   @readonly
-   @static
-  */
   /*
    These class methods below provide relationship
    introspection abilities about relationships.
@@ -4868,7 +4712,7 @@ if (macroCondition(getOwnConfig().includeDataAdapter)) {
   Model.prototype._debugInfo = function () {
     let relationships = {};
     let expensiveProperties = [];
-    const identifier = recordIdentifierFor(this);
+    const identifier = recordIdentifierFor$1(this);
     const schema = this.store.getSchemaDefinitionService();
     const attrDefs = schema.attributesDefinitionFor(identifier);
     const relDefs = schema.relationshipsDefinitionFor(identifier);
@@ -4943,344 +4787,4 @@ if (macroCondition(getOwnConfig().env.DEBUG)) {
     assert(`Model.reopenClass is deprecated. Use Foo extends Model to add static methods and properties to your class instead.`);
   };
 }
-function normalizeType$1(type) {
-  return dasherize(type);
-}
-/**
-  @module @ember-data/model
-*/
-
-/**
-  `belongsTo` is used to define One-To-One and One-To-Many
-  relationships on a [Model](/ember-data/release/classes/Model).
-
-
-  `belongsTo` takes an optional hash as a second parameter, currently
-  supported options are:
-
-  - `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.
-  - `inverse`: A string used to identify the inverse property on a
-    related model in a One-To-Many relationship. See [Explicit Inverses](#explicit-inverses)
-  - `polymorphic` A boolean value to mark the relationship as polymorphic
-
-  #### One-To-One
-  To declare a one-to-one relationship between two models, use
-  `belongsTo`:
-
-  ```app/models/user.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @belongsTo('profile') profile;
-  }
-  ```
-
-  ```app/models/profile.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class ProfileModel extends Model {
-    @belongsTo('user') user;
-  }
-  ```
-
-  #### One-To-Many
-
-  To declare a one-to-many relationship between two models, use
-  `belongsTo` in combination with `hasMany`, like this:
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment', { async: false, inverse: 'post' }) comments;
-  }
-  ```
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post', { async: false, inverse: 'comments' }) post;
-  }
-  ```
-
-  #### Sync relationships
-
-  Ember Data resolves sync relationships with the related resources
-  available in its local store, hence it is expected these resources
-  to be loaded before or along-side the primary resource.
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post', {
-      async: false,
-      inverse: null
-    })
-    post;
-  }
-  ```
-
-  In contrast to async relationship, accessing a sync relationship
-  will always return the record (Model instance) for the existing
-  local resource, or null. But it will error on access when
-  a related resource is known to exist and it has not been loaded.
-
-  ```
-  let post = comment.post;
-
-  ```
-
-  @method belongsTo
-  @public
-  @static
-  @for @ember-data/model
-  @param {String} modelName (optional) type of the relationship
-  @param {Object} options (optional) a hash of options
-  @return {Ember.computed} relationship
-*/
-function belongsTo(modelName, options) {
-  let opts = options;
-  let userEnteredModelName = modelName;
-  assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
-  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);
-  let meta = {
-    type: normalizeType$1(userEnteredModelName),
-    isRelationship: true,
-    options: opts,
-    kind: 'belongsTo',
-    name: 'Belongs To',
-    key: null
-  };
-  return computed({
-    get(key) {
-      // this is a legacy behavior we may not carry into a new model setup
-      // it's better to error on disconnected records so users find errors
-      // in their logic.
-      if (this.isDestroying || this.isDestroyed) {
-        return null;
-      }
-      const support = lookupLegacySupport(this);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
-        }
-        if (Object.prototype.hasOwnProperty.call(opts, 'serialize')) {
-          warn(`You provided a serialize option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`, false, {
-            id: 'ds.model.serialize-option-in-belongs-to'
-          });
-        }
-        if (Object.prototype.hasOwnProperty.call(opts, 'embedded')) {
-          warn(`You provided an embedded option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`, false, {
-            id: 'ds.model.embedded-option-in-belongs-to'
-          });
-        }
-      }
-      return support.getBelongsTo(key);
-    },
-    set(key, value) {
-      const support = lookupLegacySupport(this);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
-        }
-      }
-      this.store._join(() => {
-        support.setDirtyBelongsTo(key, value);
-      });
-      return support.getBelongsTo(key);
-    }
-  }).meta(meta);
-}
-var belongsTo$1 = computedMacroWithOptionalParams(belongsTo);
-function normalizeType(type) {
-  return singularize(dasherize(type));
-}
-
-/**
-  `hasMany` is used to define One-To-Many and Many-To-Many
-  relationships on a [Model](/ember-data/release/classes/Model).
-
-  `hasMany` takes an optional hash as a second parameter, currently
-  supported options are:
-
-  - `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.
-  - `inverse`: A string used to identify the inverse property on a related model.
-  - `polymorphic` A boolean value to mark the relationship as polymorphic
-
-  #### One-To-Many
-  To declare a one-to-many relationship between two models, use
-  `belongsTo` in combination with `hasMany`, like this:
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment') comments;
-  }
-  ```
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post') post;
-  }
-  ```
-
-  #### Many-To-Many
-  To declare a many-to-many relationship between two models, use
-  `hasMany`:
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('tag') tags;
-  }
-  ```
-
-  ```app/models/tag.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class TagModel extends Model {
-    @hasMany('post') posts;
-  }
-  ```
-
-  You can avoid passing a string as the first parameter. In that case Ember Data
-  will infer the type from the singularized key name.
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany tags;
-  }
-  ```
-
-  will lookup for a Tag type.
-
-  #### Explicit Inverses
-
-  Ember Data will do its best to discover which relationships map to
-  one another. In the one-to-many code above, for example, Ember Data
-  can figure out that changing the `comments` relationship should update
-  the `post` relationship on the inverse because post is the only
-  relationship to that model.
-
-  However, sometimes you may have multiple `belongsTo`/`hasMany` for the
-  same type. You can specify which property on the related model is
-  the inverse using `hasMany`'s `inverse` option:
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post') onePost;
-    @belongsTo('post') twoPost
-    @belongsTo('post') redPost;
-    @belongsTo('post') bluePost;
-  }
-  ```
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment', {
-      inverse: 'redPost'
-    })
-    comments;
-  }
-  ```
-
-  You can also specify an inverse on a `belongsTo`, which works how
-  you'd expect.
-
-  #### Sync relationships
-
-  Ember Data resolves sync relationships with the related resources
-  available in its local store, hence it is expected these resources
-  to be loaded before or along-side the primary resource.
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment', {
-      async: false
-    })
-    comments;
-  }
-  ```
-
-  In contrast to async relationship, accessing a sync relationship
-  will always return a [ManyArray](/ember-data/release/classes/ManyArray) instance
-  containing the existing local resources. But it will error on access
-  when any of the known related resources have not been loaded.
-
-  ```
-  post.comments.forEach((comment) => {
-
-  });
-
-  ```
-
-  If you are using `links` with sync relationships, you have to use
-  `ref.reload` to fetch the resources.
-
-  @method hasMany
-  @public
-  @static
-  @for @ember-data/model
-  @param {String} type (optional) type of the relationship
-  @param {Object} options (optional) a hash of options
-  @return {Ember.computed} relationship
-*/
-function hasMany(type, options) {
-  assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
-
-  // Metadata about relationships is stored on the meta of
-  // the relationship. This is used for introspection and
-  // serialization. Note that `key` is populated lazily
-  // the first time the CP is called.
-  let meta = {
-    type: normalizeType(type),
-    options,
-    isRelationship: true,
-    kind: 'hasMany',
-    name: 'Has Many',
-    key: null
-  };
-  return computed({
-    get(key) {
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
-        }
-      }
-      if (this.isDestroying || this.isDestroyed) {
-        return A();
-      }
-      return lookupLegacySupport(this).getHasMany(key);
-    },
-    set(key, records) {
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        if (['currentState'].indexOf(key) !== -1) {
-          throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
-        }
-      }
-      const support = lookupLegacySupport(this);
-      const manyArray = support.getManyArray(key);
-      assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
-      this.store._join(() => {
-        manyArray.splice(0, manyArray.length, ...records);
-      });
-      return support.getHasMany(key);
-    }
-  }).meta(meta);
-}
-var hasMany$1 = computedMacroWithOptionalParams(hasMany);
-export { Errors as E, LEGACY_SUPPORT as L, Model as M, PromiseBelongsTo as P, RelatedCollection as R, attr$1 as a, belongsTo$1 as b, PromiseManyArray as c, hasMany$1 as h };
+export { Errors as E, LEGACY_SUPPORT as L, Model as M, PromiseBelongsTo as P, RelatedCollection as R, PromiseManyArray as a, computedMacroWithOptionalParams as c, lookupLegacySupport as l, normalizeModelName as n };