@ember-data/model 5.3.0-alpha.4 → 5.3.0-alpha.6

package/addon/{has-many-2baf73c0.js → model-99cdd629.js}

@@ -1,15 +1,14 @@
-import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+import { dasherize } from '@ember/string';
 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 { dasherize } from '@ember/string';
-import { A } from '@ember/array';
-import { singularize } from 'ember-inflector';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
 import { cached, tracked } from '@glimmer/tracking';
 import Ember from 'ember';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+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';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
@@ -34,152 +33,9 @@ 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();
-      }
-
-      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 || {};
-  }
-  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);
+function normalizeModelName(modelName) {
+  return dasherize(modelName);
 }
-var attr$1 = computedMacroWithOptionalParams(attr);
 function _initializerDefineProperty(target, property, descriptor, context) {
   if (!descriptor) return;
   Object.defineProperty(target, property, {
@@ -728,7 +584,7 @@ class RelatedCollection extends RecordArray {
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
-            value: recordIdentifierFor$1(result)
+            value: recordIdentifierFor(result)
           });
         }
         break;
@@ -747,7 +603,7 @@ class RelatedCollection extends RecordArray {
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
-            value: recordIdentifierFor$1(result),
+            value: recordIdentifierFor(result),
             index: 0
           });
         }
@@ -757,7 +613,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 +634,7 @@ class RelatedCollection extends RecordArray {
               op: 'removeFromRelatedRecords',
               record: this.identifier,
               field: this.key,
-              value: result.map(recordIdentifierFor$1),
+              value: result.map(recordIdentifierFor),
               index: start
             });
           }
@@ -869,7 +725,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 +737,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;
@@ -1511,7 +1367,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
@@ -1521,7 +1377,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);
@@ -2008,9 +1864,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
@@ -2197,7 +2053,7 @@ class LegacySupport {
   constructor(record) {
     this.record = record;
     this.store = storeFor(record);
-    this.identifier = recordIdentifierFor$1(record);
+    this.identifier = recordIdentifierFor(record);
     this.cache = peekCache(record);
     this._manyArrayCache = Object.create(null);
     this._relationshipPromisesCache = Object.create(null);
@@ -2697,7 +2553,7 @@ function extractIdentifierFromRecord(record) {
   if (!record) {
     return null;
   }
-  return recordIdentifierFor$1(record);
+  return recordIdentifierFor(record);
 }
 function anyUnloaded(store, relationship) {
   let state = relationship.localState;
@@ -2917,7 +2773,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;
@@ -3188,7 +3044,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);
@@ -3305,7 +3161,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);
@@ -3569,16 +3425,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) {
@@ -3870,7 +3726,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));
   }
 
   /**
@@ -3896,7 +3752,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) {
@@ -3916,7 +3772,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));
   }
 
   /**
@@ -3958,6 +3814,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;
@@ -3989,7 +3846,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({
@@ -4837,7 +4694,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);
@@ -4912,344 +4769,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 };