@ember-data/model 4.6.1 → 4.7.0

package/addon/-private/model.js

@@ -2,13 +2,11 @@
   @module @ember-data/model
  */
 
-import { assert, warn } from '@ember/debug';
+import { assert, deprecate, warn } from '@ember/debug';
 import EmberError from '@ember/error';
-import EmberObject, { get } from '@ember/object';
+import EmberObject from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
-import { inject as service } from '@ember/service';
-import { isNone } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
 import Ember from 'ember';
@@ -16,17 +14,17 @@ import Ember from 'ember';
 import { resolve } from 'rsvp';
 
 import { HAS_DEBUG_PACKAGE } from '@ember-data/private-build-infra';
-import { DEPRECATE_SAVE_PROMISE_ACCESS } from '@ember-data/private-build-infra/deprecations';
-import { recordIdentifierFor, storeFor } from '@ember-data/store';
 import {
-  coerceId,
-  deprecatedPromiseObject,
-  errorsArrayToHash,
-  InternalModel,
-  recordDataFor,
-  WeakCache,
-} from '@ember-data/store/-private';
+  DEPRECATE_EARLY_STATIC,
+  DEPRECATE_MODEL_REOPEN,
+  DEPRECATE_NON_EXPLICIT_POLYMORPHISM,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
+  DEPRECATE_SAVE_PROMISE_ACCESS,
+} from '@ember-data/private-build-infra/deprecations';
+import { recordIdentifierFor, storeFor } from '@ember-data/store';
+import { coerceId, recordDataFor } from '@ember-data/store/-private';
 
+import { deprecatedPromiseObject } from './deprecated-promise-proxy';
 import Errors from './errors';
 import { LegacySupport } from './legacy-relationships-support';
 import notifyChanges from './notify-changes';
@@ -34,18 +32,21 @@ import RecordState, { peekTag, tagged } from './record-state';
 import { relationshipFromMeta } from './relationship-meta';
 
 const { changeProperties } = Ember;
-export const LEGACY_SUPPORT = new WeakCache(DEBUG ? 'legacy-relationships' : '');
-LEGACY_SUPPORT._generator = (record) => {
+export const LEGACY_SUPPORT = new Map();
+
+export function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
   let support = LEGACY_SUPPORT.get(identifier);
 
   if (!support) {
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
+    LEGACY_SUPPORT.set(record, support);
   }
 
   return support;
-};
+}
+
 function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let possibleRelationships = relationshipsSoFar || [];
 
@@ -57,7 +58,7 @@ function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let relationshipsForType = relationshipMap.get(type.modelName);
   let relationships = Array.isArray(relationshipsForType)
     ? relationshipsForType.filter((relationship) => {
-        let optionsForRelationship = inverseType.metaForProperty(relationship.name).options;
+        let optionsForRelationship = relationship.options;
 
         if (!optionsForRelationship.inverse && optionsForRelationship.inverse !== null) {
           return true;
@@ -121,38 +122,57 @@ function computeOnce(target, key, desc) {
   @extends Ember.EmberObject
 */
 class Model extends EmberObject {
-  @service store;
+  ___private_notifications;
 
   init(options = {}) {
-    if (DEBUG && !options._secretInit && !options._internalModel && !options._createProps) {
+    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.'
       );
     }
     const createProps = options._createProps;
     const _secretInit = options._secretInit;
-    delete options._createProps;
-    delete options._secretInit;
+    options._createProps = null;
+    options._secretInit = null;
+
+    let store = (this.store = _secretInit.store);
     super.init(options);
 
-    _secretInit(this);
+    let identity = _secretInit.identifier;
+    _secretInit.cb(this, _secretInit.recordData, identity, _secretInit.store);
+
     this.___recordState = DEBUG ? new RecordState(this) : null;
 
     this.setProperties(createProps);
 
-    // TODO  pass something in such that we don't need internalModel
-    // to get this info
-    let store = storeFor(this);
     let notifications = store._notificationManager;
-    let identity = recordIdentifierFor(this);
-
-    notifications.subscribe(identity, (identifier, type, key) => {
+    this.___private_notifications = notifications.subscribe(identity, (identifier, type, key) => {
       notifyChanges(identifier, type, key, this, store);
     });
   }
 
-  willDestroy() {
+  destroy() {
+    const identifier = recordIdentifierFor(this);
+    this.___recordState?.destroy();
+    const store = storeFor(this);
+    store._notificationManager.unsubscribe(this.___private_notifications);
+    // Legacy behavior is to notify the relationships on destroy
+    // such that they "clear". It's uncertain this behavior would
+    // be good for a new model paradigm, likely cheaper and safer
+    // to simply not notify, for this reason the store does not itself
+    // notify individual changes once the delete has been signaled,
+    // this decision is left to model instances.
+
+    this.eachRelationship((key, meta) => {
+      if (meta.kind === 'belongsTo') {
+        this.notifyPropertyChange(key);
+      }
+    });
     LEGACY_SUPPORT.get(this)?.destroy();
+    LEGACY_SUPPORT.delete(this);
+    LEGACY_SUPPORT.delete(identifier);
+
+    super.destroy();
   }
 
   /**
@@ -200,10 +220,10 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('isLoaded'); // true
+    record.isLoaded; // true
 
     store.findRecord('model', 1).then(function(model) {
-      model.get('isLoaded'); // true
+      model.isLoaded; // true
     });
     ```
 
@@ -227,12 +247,12 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('hasDirtyAttributes'); // true
+    record.hasDirtyAttributes; // true
 
     store.findRecord('model', 1).then(function(model) {
-      model.get('hasDirtyAttributes'); // false
+      model.hasDirtyAttributes; // false
       model.set('foo', 'some value');
-      model.get('hasDirtyAttributes'); // true
+      model.hasDirtyAttributes; // true
     });
     ```
 
@@ -257,11 +277,11 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('isSaving'); // false
+    record.isSaving; // false
     let promise = record.save();
-    record.get('isSaving'); // true
+    record.isSaving; // true
     promise.then(function() {
-      record.get('isSaving'); // false
+      record.isSaving; // false
     });
     ```
 
@@ -287,24 +307,24 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('isDeleted');    // false
+    record.isDeleted;    // false
     record.deleteRecord();
 
     // Locally deleted
-    record.get('isDeleted');           // true
-    record.get('hasDirtyAttributes');  // true
-    record.get('isSaving');            // false
+    record.isDeleted;           // true
+    record.hasDirtyAttributes;  // true
+    record.isSaving;            // false
 
     // Persisting the deletion
     let promise = record.save();
-    record.get('isDeleted');    // true
-    record.get('isSaving');     // true
+    record.isDeleted;    // true
+    record.isSaving;     // true
 
     // Deletion Persisted
     promise.then(function() {
-      record.get('isDeleted');          // true
-      record.get('isSaving');           // false
-      record.get('hasDirtyAttributes'); // false
+      record.isDeleted;          // true
+      record.isSaving;           // false
+      record.hasDirtyAttributes; // false
     });
     ```
 
@@ -328,10 +348,10 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('isNew'); // true
+    record.isNew; // true
 
     record.save().then(function(model) {
-      model.get('isNew'); // false
+      model.isNew; // false
     });
     ```
 
@@ -374,7 +394,7 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('dirtyType'); // 'created'
+    record.dirtyType; // 'created'
     ```
 
     @property dirtyType
@@ -395,10 +415,10 @@ class Model extends EmberObject {
     Example
 
     ```javascript
-    record.get('isError'); // false
+    record.isError; // false
     record.set('foo', 'valid value');
     record.save().then(null, function() {
-      record.get('isError'); // true
+      record.isError; // true
     });
     ```
 
@@ -444,10 +464,10 @@ class Model extends EmberObject {
 
     ```javascript
     let record = store.createRecord('model');
-    record.get('id'); // null
+    record.id; // null
 
     store.findRecord('model', 1).then(function(model) {
-      model.get('id'); // '1'
+      model.id; // '1'
     });
     ```
 
@@ -457,24 +477,37 @@ class Model extends EmberObject {
   */
   @tagged
   get id() {
-    // the _internalModel guard exists, because some dev-only deprecation code
+    // this guard exists, because some dev-only deprecation code
     // (addListener via validatePropertyInjections) invokes toString before the
     // object is real.
     if (DEBUG) {
-      if (!this._internalModel) {
+      try {
+        return recordIdentifierFor(this).id;
+      } catch {
         return void 0;
       }
     }
-    return this._internalModel.id;
+    return recordIdentifierFor(this).id;
   }
   set id(id) {
     const normalizedId = coerceId(id);
+    const identifier = recordIdentifierFor(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) {
-      this._internalModel.setId(normalizedId);
+    if (normalizedId !== null && didChange) {
+      this.store._instanceCache.setRecordId(identifier, normalizedId);
+      this.store._notificationManager.notify(identifier, 'identity');
     }
   }
 
+  toString() {
+    return `<model::${this.constructor.modelName}:${this.id}>`;
+  }
+
   /**
     @property currentState
     @private
@@ -497,12 +530,6 @@ class Model extends EmberObject {
     throw new Error('cannot set currentState');
   }
 
-  /**
-   @property _internalModel
-   @private
-   @type {Object}
-   */
-
   /**
     The store service instance which created this record instance
 
@@ -520,10 +547,10 @@ class Model extends EmberObject {
     - `attribute` The name of the property associated with this error message
 
     ```javascript
-    record.get('errors.length'); // 0
+    record.errors.length; // 0
     record.set('foo', 'invalid value');
     record.save().catch(function() {
-      record.get('errors').get('foo');
+      record.errors.foo;
       // [{message: 'foo should be a number.', attribute: 'foo'}]
     });
     ```
@@ -565,22 +592,7 @@ class Model extends EmberObject {
   @computeOnce
   get errors() {
     let errors = Errors.create({ __record: this });
-    // TODO we should unify how errors gets populated
-    // with the code managing the update. Probably a
-    // lazy flush similar to retrieveLatest in ManyArray
-    let recordData = recordDataFor(this);
-    let jsonApiErrors;
-    if (recordData.getErrors) {
-      jsonApiErrors = recordData.getErrors();
-      if (jsonApiErrors) {
-        let errorsHash = errorsArrayToHash(jsonApiErrors);
-        let errorKeys = Object.keys(errorsHash);
-
-        for (let i = 0; i < errorKeys.length; i++) {
-          errors.add(errorKeys[i], errorsHash[errorKeys[i]]);
-        }
-      }
-    }
+    this.currentState.updateInvalidErrors(errors);
     return errors;
   }
 
@@ -812,7 +824,7 @@ class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return this._internalModel.changedAttributes();
+    return recordDataFor(this).changedAttrs(recordIdentifierFor(this));
   }
 
   /**
@@ -822,11 +834,11 @@ class Model extends EmberObject {
     Example
 
     ```javascript
-    record.get('name'); // 'Untitled Document'
+    record.name; // 'Untitled Document'
     record.set('name', 'Doc 1');
-    record.get('name'); // 'Doc 1'
+    record.name; // 'Doc 1'
     record.rollbackAttributes();
-    record.get('name'); // 'Untitled Document'
+    record.name; // 'Untitled Document'
     ```
 
     @since 1.13.0
@@ -835,8 +847,16 @@ class Model extends EmberObject {
   */
   rollbackAttributes() {
     const { currentState } = this;
-    this._internalModel.rollbackAttributes();
-    currentState.cleanErrorRequests();
+    const { isNew } = currentState;
+
+    storeFor(this)._join(() => {
+      recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
+      this.errors.clear();
+      currentState.cleanErrorRequests();
+      if (isNew) {
+        this.unloadRecord();
+      }
+    });
   }
 
   /**
@@ -848,13 +868,6 @@ class Model extends EmberObject {
     return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this));
   }
 
-  toStringExtension() {
-    // the _internalModel guard exists, because some dev-only deprecation code
-    // (addListener via validatePropertyInjections) invokes toString before the
-    // object is real.
-    return this._internalModel && this._internalModel.id;
-  }
-
   /**
     Save the record and persist any changes to the record to an
     external source via the adapter.
@@ -981,7 +994,7 @@ class Model extends EmberObject {
     import Model, { belongsTo } from '@ember-data/model';
 
     export default class BlogModel extends Model {
-      @belongsTo({ async: true }) user;
+      @belongsTo('user', { async: true, inverse: null }) user;
     }
     ```
 
@@ -1037,7 +1050,7 @@ class Model extends EmberObject {
     @return {BelongsToReference} reference for this relationship
   */
   belongsTo(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('belongsTo', name);
+    return lookupLegacySupport(this).referenceFor('belongsTo', name);
   }
 
   /**
@@ -1049,7 +1062,7 @@ class Model extends EmberObject {
     import Model, { hasMany } from '@ember-data/model';
 
     export default class BlogModel extends Model {
-      @hasMany({ async: true }) comments;
+      @hasMany('comment', { async: true, inverse: null }) comments;
     }
 
     let blog = store.push({
@@ -1100,7 +1113,7 @@ class Model extends EmberObject {
     @return {HasManyReference} reference for this relationship
   */
   hasMany(name) {
-    return LEGACY_SUPPORT.lookup(this).referenceFor('hasMany', name);
+    return lookupLegacySupport(this).referenceFor('hasMany', name);
   }
 
   /**
@@ -1142,7 +1155,7 @@ class Model extends EmberObject {
       record.eachRelationship(function(name, descriptor) {
         if (descriptor.kind === 'hasMany') {
           let serializedHasManyName = name.toUpperCase() + '_IDS';
-          json[serializedHasManyName] = record.get(name).mapBy('id');
+          json[serializedHasManyName] = record.get(name).map(r => r.id);
         }
       });
 
@@ -1202,7 +1215,7 @@ class Model extends EmberObject {
 
    ```javascript
    import RESTSerializer from '@ember-data/serializer/rest';
-   import { underscore } from '@ember/string';
+   import { underscore } from '<app-name>/utils/string-utils';
 
    export default const PostSerializer = RESTSerializer.extend({
      payloadKeyFromModelName(modelName) {
@@ -1258,12 +1271,46 @@ class Model extends EmberObject {
    @return {Model} the type of the relationship, or undefined
    */
   static typeForRelationship(name, store) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let relationship = this.relationshipsByName.get(name);
     return relationship && store.modelFor(relationship.type);
   }
 
   @computeOnce
   static get inverseMap() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     return Object.create(null);
   }
 
@@ -1301,6 +1348,23 @@ class Model extends EmberObject {
    @return {Object} the inverse relationship, or null
    */
   static inverseFor(name, store) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let inverseMap = this.inverseMap;
     if (inverseMap[name]) {
       return inverseMap[name];
@@ -1313,42 +1377,63 @@ class Model extends EmberObject {
 
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
-    let inverseType = this.typeForRelationship(name, store);
-    if (!inverseType) {
-      return null;
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
     }
 
-    let propertyMeta = this.metaForProperty(name);
+    const relationship = this.relationshipsByName.get(name);
+    const { options } = relationship;
+    const isPolymorphic = options.polymorphic;
+
     //If inverse is manually specified to be null, like  `comments: hasMany('message', { inverse: null })`
-    let options = propertyMeta.options;
-    if (options.inverse === null) {
+    const isExplicitInverseNull = options.inverse === null;
+    const isAbstractType =
+      !isExplicitInverseNull && isPolymorphic && !store.getSchemaDefinitionService().doesTypeExist(relationship.type);
+
+    if (isExplicitInverseNull || isAbstractType) {
+      assert(
+        `No schema for the abstract type '${relationship.type}' for the polymorphic relationship '${name}' on '${this.modelName}' was provided by the SchemaDefinitionService.`,
+        !isPolymorphic || isExplicitInverseNull
+      );
       return null;
     }
 
-    let inverseName, inverseKind, inverse, inverseOptions;
+    let fieldOnInverse, inverseKind, inverseRelationship, inverseOptions;
+    let inverseSchema = this.typeForRelationship(name, store);
 
+    // if the type does not exist and we are not polymorphic
     //If inverse is specified manually, return the inverse
-    if (options.inverse) {
-      inverseName = options.inverse;
-      inverse = inverseType.relationshipsByName.get(inverseName);
+    if (options.inverse !== undefined) {
+      fieldOnInverse = options.inverse;
+      inverseRelationship = inverseSchema && inverseSchema.relationshipsByName.get(fieldOnInverse);
 
       assert(
-        "We found no inverse relationships by the name of '" +
-          inverseName +
-          "' on the '" +
-          inverseType.modelName +
-          "' model. This is most likely due to a missing attribute on your model definition.",
-        !isNone(inverse)
+        `We found no field named '${fieldOnInverse}' on the schema for '${inverseSchema.modelName}' to be the inverse of the '${name}' relationship on '${this.modelName}'. This is most likely due to a missing field on your model definition.`,
+        inverseRelationship
       );
 
       // TODO probably just return the whole inverse here
-      inverseKind = inverse.kind;
-      inverseOptions = inverse.options;
+      inverseKind = inverseRelationship.kind;
+      inverseOptions = inverseRelationship.options;
     } else {
       //No inverse was specified manually, we need to use a heuristic to guess one
-      if (propertyMeta.type === propertyMeta.parentModelName) {
+      if (relationship.type === relationship.parentModelName) {
         warn(
-          `Detected a reflexive relationship by the name of '${name}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`,
+          `Detected a reflexive relationship named '${name}' on the schema for '${relationship.type}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`,
           false,
           {
             id: 'ds.model.reflexive-relationship-without-inverse',
@@ -1356,30 +1441,33 @@ class Model extends EmberObject {
         );
       }
 
-      let possibleRelationships = findPossibleInverses(this, inverseType, name);
+      let possibleRelationships = findPossibleInverses(this, inverseSchema, name);
 
       if (possibleRelationships.length === 0) {
         return null;
       }
 
-      let filteredRelationships = possibleRelationships.filter((possibleRelationship) => {
-        let optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;
-        return name === optionsForRelationship.inverse;
-      });
+      if (DEBUG) {
+        let filteredRelationships = possibleRelationships.filter((possibleRelationship) => {
+          let optionsForRelationship = possibleRelationship.options;
+          return name === optionsForRelationship.inverse;
+        });
 
-      assert(
-        "You defined the '" +
-          name +
-          "' relationship on " +
-          this +
-          ', but you defined the inverse relationships of type ' +
-          inverseType.toString() +
-          ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
-        filteredRelationships.length < 2
-      );
+        assert(
+          "You defined the '" +
+            name +
+            "' relationship on " +
+            this +
+            ', but you defined the inverse relationships of type ' +
+            inverseSchema.toString() +
+            ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
+          filteredRelationships.length < 2
+        );
+      }
 
-      if (filteredRelationships.length === 1) {
-        possibleRelationships = filteredRelationships;
+      let explicitRelationship = possibleRelationships.find((relationship) => relationship.options.inverse === name);
+      if (explicitRelationship) {
+        possibleRelationships = [explicitRelationship];
       }
 
       assert(
@@ -1390,24 +1478,78 @@ class Model extends EmberObject {
           ', but multiple possible inverse relationships of type ' +
           this +
           ' were found on ' +
-          inverseType +
+          inverseSchema +
           '. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses',
         possibleRelationships.length === 1
       );
 
-      inverseName = possibleRelationships[0].name;
+      fieldOnInverse = possibleRelationships[0].name;
       inverseKind = possibleRelationships[0].kind;
       inverseOptions = possibleRelationships[0].options;
     }
 
+    // ensure inverse is properly configured
+    if (DEBUG && isPolymorphic) {
+      if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
+        if (!inverseOptions.as) {
+          deprecate(
+            `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`,
+            false,
+            {
+              id: 'ember-data:non-explicit-relationships',
+              since: { enabled: '4.8', available: '4.8' },
+              until: '5.0',
+              for: 'ember-data',
+            }
+          );
+        }
+      } else {
+        assert(
+          `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`,
+          inverseOptions.as
+        );
+        assert(
+          `options.as should match the expected type of the polymorphic relationship. Expected field '${fieldOnInverse}' on type '${inverseSchema.modelName}' to specify '${relationship.type}' but found '${inverseOptions.as}'`,
+          !!inverseOptions.as && relationship.type === inverseOptions.as
+        );
+      }
+    }
+
+    // ensure we are properly configured
+    if (DEBUG && inverseOptions.polymorphic) {
+      if (DEPRECATE_NON_EXPLICIT_POLYMORPHISM) {
+        if (!options.as) {
+          deprecate(
+            `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`,
+            false,
+            {
+              id: 'ember-data:non-explicit-relationships',
+              since: { enabled: '4.8', available: '4.8' },
+              until: '5.0',
+              for: 'ember-data',
+            }
+          );
+        }
+      } else {
+        assert(
+          `Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`,
+          options.as
+        );
+        assert(
+          `options.as should match the expected type of the polymorphic relationship. Expected field '${name}' on type '${this.modelName}' to specify '${inverseRelationship.type}' but found '${options.as}'`,
+          !!options.as && inverseRelationship.type === options.as
+        );
+      }
+    }
+
     assert(
-      `The ${inverseType.modelName}:${inverseName} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`,
-      !inverseOptions || inverseOptions.inverse !== null
+      `The ${inverseSchema.modelName}:${fieldOnInverse} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`,
+      inverseOptions.inverse !== null
     );
 
     return {
-      type: inverseType,
-      name: inverseName,
+      type: inverseSchema,
+      name: fieldOnInverse,
       kind: inverseKind,
       options: inverseOptions,
     };
@@ -1441,10 +1583,10 @@ class Model extends EmberObject {
    import Post from 'app/models/post';
 
    let relationships = Blog.relationships;
-   relationships.get('user');
+   relationships.user;
    //=> [ { name: 'users', kind: 'hasMany' },
    //     { name: 'owner', kind: 'belongsTo' } ]
-   relationships.get('post');
+   relationships.post;
    //=> [ { name: 'posts', kind: 'hasMany' } ]
    ```
 
@@ -1457,6 +1599,23 @@ class Model extends EmberObject {
 
   @computeOnce
   static get relationships() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let map = new Map();
     let relationshipsByName = this.relationshipsByName;
 
@@ -1511,6 +1670,23 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get relationshipNames() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let names = {
       hasMany: [],
       belongsTo: [],
@@ -1561,6 +1737,23 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get relatedTypes() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let types = [];
 
     let rels = this.relationshipsObject;
@@ -1606,9 +1799,9 @@ class Model extends EmberObject {
    import Blog from 'app/models/blog';
 
    let relationshipsByName = Blog.relationshipsByName;
-   relationshipsByName.get('users');
+   relationshipsByName.users;
    //=> { key: 'users', kind: 'hasMany', type: 'user', options: Object, isRelationship: true }
-   relationshipsByName.get('owner');
+   relationshipsByName.owner;
    //=> { key: 'owner', kind: 'belongsTo', type: 'user', options: Object, isRelationship: true }
    ```
 
@@ -1620,6 +1813,23 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get relationshipsByName() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let map = new Map();
     let rels = this.relationshipsObject;
     let relationships = Object.keys(rels);
@@ -1636,6 +1846,23 @@ class Model extends EmberObject {
 
   @computeOnce
   static get relationshipsObject() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let relationships = Object.create(null);
     let modelName = this.modelName;
     this.eachComputedProperty((name, meta) => {
@@ -1643,7 +1870,7 @@ class Model extends EmberObject {
         meta.key = name;
         meta.name = name;
         meta.parentModelName = modelName;
-        relationships[name] = relationshipFromMeta(meta);
+        relationships[name] = DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE ? relationshipFromMeta(meta) : meta;
       }
     });
     return relationships;
@@ -1675,7 +1902,7 @@ class Model extends EmberObject {
 
    let fields = Blog.fields;
    fields.forEach(function(kind, field) {
-      console.log(field, kind);
+      // do thing
     });
 
    // prints:
@@ -1693,9 +1920,27 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get fields() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let map = new Map();
 
     this.eachComputedProperty((name, meta) => {
+      // TODO end reliance on these booleans and stop leaking them in the spec
       if (meta.isRelationship) {
         map.set(name, meta.kind);
       } else if (meta.isAttribute) {
@@ -1718,6 +1963,23 @@ class Model extends EmberObject {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   static eachRelationship(callback, binding) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     this.relationshipsByName.forEach((relationship, name) => {
       callback.call(binding, name, relationship);
     });
@@ -1736,6 +1998,23 @@ class Model extends EmberObject {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   static eachRelatedType(callback, binding) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let relationshipTypes = this.relatedTypes;
 
     for (let i = 0; i < relationshipTypes.length; i++) {
@@ -1745,6 +2024,23 @@ class Model extends EmberObject {
   }
 
   static determineRelationshipType(knownSide, store) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let knownKey = knownSide.key;
     let knownKind = knownSide.kind;
     let inverse = this.inverseFor(knownKey, store);
@@ -1789,7 +2085,7 @@ class Model extends EmberObject {
    let attributes = Person.attributes
 
    attributes.forEach(function(meta, name) {
-      console.log(name, meta);
+      // do thing
     });
 
    // prints:
@@ -1806,6 +2102,23 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get attributes() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let map = new Map();
 
     this.eachComputedProperty((name, meta) => {
@@ -1849,7 +2162,7 @@ class Model extends EmberObject {
    let transformedAttributes = Person.transformedAttributes
 
    transformedAttributes.forEach(function(field, type) {
-      console.log(field, type);
+      // do thing
     });
 
    // prints:
@@ -1865,6 +2178,23 @@ class Model extends EmberObject {
    */
   @computeOnce
   static get transformedAttributes() {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     let map = new Map();
 
     this.eachAttribute((key, meta) => {
@@ -1905,7 +2235,7 @@ class Model extends EmberObject {
     }
 
    PersonModel.eachAttribute(function(name, meta) {
-      console.log(name, meta);
+      // do thing
     });
 
    // prints:
@@ -1921,6 +2251,23 @@ class Model extends EmberObject {
    @static
    */
   static eachAttribute(callback, binding) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     this.attributes.forEach((meta, name) => {
       callback.call(binding, name, meta);
     });
@@ -1957,7 +2304,7 @@ class Model extends EmberObject {
     });
 
    Person.eachTransformedAttribute(function(name, type) {
-      console.log(name, type);
+      // do thing
     });
 
    // prints:
@@ -1972,6 +2319,23 @@ class Model extends EmberObject {
    @static
    */
   static eachTransformedAttribute(callback, binding) {
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
     this.transformedAttributes.forEach((type, name) => {
       callback.call(binding, name, type);
     });
@@ -1985,13 +2349,29 @@ class Model extends EmberObject {
    @static
    */
   static toString() {
-    return `model:${get(this, 'modelName')}`;
+    if (DEPRECATE_EARLY_STATIC) {
+      deprecate(
+        `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
+        this.modelName,
+        {
+          id: 'ember-data:deprecate-early-static',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+    } else {
+      assert(
+        `Accessing schema information on Models without looking up the model via the store is disallowed.`,
+        this.modelName
+      );
+    }
+    return `model:${this.modelName}`;
   }
 }
 
 // this is required to prevent `init` from passing
 // the values initialized during create to `setUnknownProperty`
-Model.prototype._internalModel = null;
 Model.prototype._createProps = null;
 Model.prototype._secretInit = null;
 
@@ -2071,27 +2451,11 @@ if (DEBUG) {
     } while (current !== null);
     return null;
   };
-  let isBasicDesc = function isBasicDesc(desc) {
-    return (
-      !desc ||
-      (!desc.get && !desc.set && desc.enumerable === true && desc.writable === true && desc.configurable === true)
-    );
-  };
-  let isDefaultEmptyDescriptor = function isDefaultEmptyDescriptor(obj, keyName) {
-    let instanceDesc = lookupDescriptor(obj, keyName);
-    return isBasicDesc(instanceDesc) && lookupDescriptor(obj.constructor, keyName) === null;
-  };
 
   Model.reopen({
     init() {
       this._super(...arguments);
 
-      if (!isDefaultEmptyDescriptor(this, '_internalModel') || !(this._internalModel instanceof InternalModel)) {
-        throw new Error(
-          `'_internalModel' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`
-        );
-      }
-
       let ourDescriptor = lookupDescriptor(Model.prototype, 'currentState');
       let theirDescriptor = lookupDescriptor(this, 'currentState');
       let realState = this.___recordState;
@@ -2111,6 +2475,35 @@ if (DEBUG) {
       }
     },
   });
+
+  if (DEPRECATE_MODEL_REOPEN) {
+    const originalReopen = Model.reopen;
+    const originalReopenClass = Model.reopenClass;
+
+    Model.reopen = function deprecatedReopen() {
+      deprecate(`Model.reopen is deprecated. Use Foo extends Model to extend your class instead.`, false, {
+        id: 'ember-data:deprecate-model-reopen',
+        for: 'ember-data',
+        until: '5.0',
+        since: { available: '4.8', enabled: '4.8' },
+      });
+      return originalReopen.call(this, ...arguments);
+    };
+
+    Model.reopenClass = function deprecatedReopenClass() {
+      deprecate(
+        `Model.reopenClass is deprecated. Use Foo extends Model to add static methods and properties to your class instead.`,
+        false,
+        {
+          id: 'ember-data:deprecate-model-reopenclass',
+          for: 'ember-data',
+          until: '5.0',
+          since: { available: '4.8', enabled: '4.8' },
+        }
+      );
+      return originalReopenClass.call(this, ...arguments);
+    };
+  }
 }
 
 export default Model;