deprecation: Model.reopen/reopenClass and eager static fields lookups (#8092)

* remove lots of reopen/reopenClass usage

* deprecate the things

* fix reopen in json serializer tests

* fix more tests

* more test cleanup

* down to 72 reopens

* remove reopen from belongsTo test

* refactory hasMany tests

* add dep tests

* all the deprecations

* fix prod test

Author: runspired

packages/-ember-data/tests/deprecations/deprecate-early-static-test.js

@@ -0,0 +1,63 @@
+import { module } from 'qunit';
+
+import { setupTest } from 'ember-qunit';
+
+import Model from '@ember-data/model';
+import { deprecatedTest } from '@ember-data/unpublished-test-infra/test-support/deprecated-test';
+
+module('Deprecations', function (hooks) {
+  setupTest(hooks);
+
+  const StaticModelMethods = [
+    { name: 'typeForRelationship', count: 3 },
+    { name: 'inverseFor', count: 6 },
+    { name: '_findInverseFor', count: 4 },
+    { name: 'eachRelationship', count: 3 },
+    { name: 'eachRelatedType', count: 3 },
+    { name: 'determineRelationshipType', count: 1 },
+    { name: 'eachAttribute', count: 2 },
+    { name: 'eachTransformedAttribute', count: 4 },
+    { name: 'toString', count: 1 },
+  ];
+  const StaticModelGetters = [
+    { name: 'inverseMap', count: 1 },
+    { name: 'relationships', count: 3 },
+    { name: 'relationshipNames', count: 1 },
+    { name: 'relatedTypes', count: 2 },
+    { name: 'relationshipsByName', count: 2 },
+    { name: 'relationshipsObject', count: 1 },
+    { name: 'fields', count: 1 },
+    { name: 'attributes', count: 1 },
+    { name: 'transformedAttributes', count: 3 },
+  ];
+
+  function checkDeprecationForProp(prop) {
+    deprecatedTest(
+      `Accessing static prop ${prop.name} is deprecated`,
+      { id: 'ember-data:deprecate-early-static', until: '5.0', count: prop.count },
+      function (assert) {
+        class Post extends Model {}
+        Post[prop.name];
+        assert.ok(true);
+      }
+    );
+  }
+  function checkDeprecationForMethod(method) {
+    deprecatedTest(
+      `Accessing static method ${method.name} is deprecated`,
+      { id: 'ember-data:deprecate-early-static', until: '5.0', count: method.count },
+      function (assert) {
+        class Post extends Model {}
+        try {
+          Post[method.name]();
+        } catch {
+          // do nothing
+        }
+        assert.ok(true);
+      }
+    );
+  }
+
+  StaticModelGetters.forEach(checkDeprecationForProp);
+  StaticModelMethods.forEach(checkDeprecationForMethod);
+});

packages/-ember-data/tests/deprecations/deprecate-reopen-class-test.js

@@ -0,0 +1,30 @@
+import { module } from 'qunit';
+
+import { setupTest } from 'ember-qunit';
+
+import Model from '@ember-data/model';
+import { deprecatedTest } from '@ember-data/unpublished-test-infra/test-support/deprecated-test';
+
+module('Deprecations', function (hooks) {
+  setupTest(hooks);
+
+  deprecatedTest(
+    `Calling on natively extended class`,
+    { id: 'ember-data:deprecate-model-reopenclass', until: '5.0', count: 1 },
+    function (assert) {
+      class Post extends Model {}
+      Post.reopenClass({});
+      assert.ok(true);
+    }
+  );
+
+  deprecatedTest(
+    `Calling on classic extended class`,
+    { id: 'ember-data:deprecate-model-reopenclass', until: '5.0', count: 1 },
+    function (assert) {
+      const Post = Model.extend();
+      Post.reopenClass({});
+      assert.ok(true);
+    }
+  );
+});

packages/-ember-data/tests/deprecations/deprecate-reopen-test.js

@@ -0,0 +1,30 @@
+import { module } from 'qunit';
+
+import { setupTest } from 'ember-qunit';
+
+import Model from '@ember-data/model';
+import { deprecatedTest } from '@ember-data/unpublished-test-infra/test-support/deprecated-test';
+
+module('Deprecations', function (hooks) {
+  setupTest(hooks);
+
+  deprecatedTest(
+    `Calling on natively extended class`,
+    { id: 'ember-data:deprecate-model-reopen', until: '5.0', count: 1 },
+    function (assert) {
+      class Post extends Model {}
+      Post.reopen({});
+      assert.ok(true);
+    }
+  );
+
+  deprecatedTest(
+    `Calling on classic extended class`,
+    { id: 'ember-data:deprecate-model-reopen', until: '5.0', count: 1 },
+    function (assert) {
+      const Post = Model.extend();
+      Post.reopen({});
+      assert.ok(true);
+    }
+  );
+});

packages/-ember-data/tests/integration/debug-adapter-test.js

@@ -15,24 +15,22 @@ import Model, { attr } from '@ember-data/model';
 if (has('@ember-data/debug')) {
   const DebugAdapter = require('@ember-data/debug').default;
 
-  class Post extends Model {
-    @attr()
-    title;
-  }
-
-  module('integration/debug-adapter - DS.DebugAdapter', function (hooks) {
+  module('integration/debug-adapter - DebugAdapter', function (hooks) {
     setupTest(hooks);
 
     let store;
 
     hooks.beforeEach(function () {
       let { owner } = this;
+      class Post extends Model {
+        @attr title;
+      }
 
       owner.register('model:post', Post);
       store = owner.lookup('service:store');
       let _adapter = DebugAdapter.extend({
         getModelTypes() {
-          return A([{ klass: Post, name: 'post' }]);
+          return A([{ klass: store.modelFor('post'), name: 'post' }]);
         },
       });
       owner.register('data-adapter:main', _adapter);
@@ -205,14 +203,13 @@ if (has('@ember-data/debug')) {
       let { owner } = this;
       let debugAdapter = owner.lookup('data-adapter:main');
       class Person extends Model {
-        @attr()
-        title;
-
-        @attr()
-        firstOrLastName;
+        @attr title;
+        @attr firstOrLastName;
       }
+      owner.register('model:person', Person);
+      const store = owner.lookup('service:store');
 
-      const columns = debugAdapter.columnsForType(Person);
+      const columns = debugAdapter.columnsForType(store.modelFor('person'));
 
       assert.strictEqual(columns[0].desc, 'Id');
       assert.strictEqual(columns[1].desc, 'Title');

packages/-ember-data/tests/integration/records/error-test.js

@@ -197,22 +197,20 @@ module('integration/records/error', function (hooks) {
     let store = this.owner.lookup('service:store');
     let adapter = store.adapterFor('application');
 
-    adapter.reopen({
-      createRecord() {
-        return RSVP.reject(
-          new InvalidError([
-            {
-              detail: 'Must be unique',
-              source: { pointer: '/data/attributes/first-name' },
-            },
-            {
-              detail: 'Must not be blank',
-              source: { pointer: '/data/attributes/last-name' },
-            },
-          ])
-        );
-      },
-    });
+    adapter.createRecord = () => {
+      return RSVP.reject(
+        new InvalidError([
+          {
+            detail: 'Must be unique',
+            source: { pointer: '/data/attributes/first-name' },
+          },
+          {
+            detail: 'Must not be blank',
+            source: { pointer: '/data/attributes/last-name' },
+          },
+        ])
+      );
+    };
 
     let person = store.createRecord('person');
 

packages/-ember-data/tests/integration/records/unload-test.js

@@ -16,76 +16,71 @@ function idsFromArr(arr) {
   return arr.map((i) => i.id);
 }
 
-const Person = Model.extend({
-  name: attr('string'),
+class Person extends Model {
+  @attr('string') name;
   // 1:many sync
-  cars: hasMany('car', { async: false }),
+  @hasMany('car', { async: false }) cars;
   // 1:many async
-  boats: hasMany('boat', { async: true }),
+  @hasMany('boat', { async: true }) boats;
   // many:many sync
-  groups: hasMany('group', { async: false }),
+  @hasMany('group', { async: false }) groups;
   // many:many async
-  friends: hasMany('people', { async: true }),
+  @hasMany('people', { async: true }) friends;
   // 1:1 sync inverse null
-  bike: belongsTo('bike', { async: false, inverse: null }),
+  @belongsTo('bike', { async: false, inverse: null }) bike;
   // 1:1 sync
-  house: belongsTo('house', { async: false }),
+  @belongsTo('house', { async: false }) house;
   // 1:1 async
-  mortgage: belongsTo('mortgage', { async: true }),
+  @belongsTo('mortgage', { async: true }) mortgage;
   // 1 async : 1 sync
-  favoriteBook: belongsTo('book', { async: false }),
+  @belongsTo('book', { async: false }) favoriteBook;
   // 1 async : many sync
-  favoriteSpoons: hasMany('spoon', { async: false }),
+  @hasMany('spoon', { async: false }) favoriteSpoons;
   // 1 sync: many async
-  favoriteShows: hasMany('show', { async: true }),
+  @hasMany('show', { async: true }) favoriteShows;
   // many sync : many async
-  favoriteFriends: hasMany('people', { async: true, inverse: 'favoriteAsyncFriends' }),
+  @hasMany('people', { async: true, inverse: 'favoriteAsyncFriends' }) favoriteFriends;
   // many async : many sync
-  favoriteAsyncFriends: hasMany('people', { async: false, inverse: 'favoriteFriends' }),
-});
-Person.reopenClass({
-  toString() {
+  @hasMany('people', { async: false, inverse: 'favoriteFriends' }) favoriteAsyncFriends;
+
+  static toString() {
     return 'Person';
-  },
-});
+  }
+}
 
-const House = Model.extend({
-  person: belongsTo('person', { async: false }),
-});
-House.reopenClass({
-  toString() {
+class House extends Model {
+  @belongsTo('person', { async: false }) person;
+
+  static toString() {
     return 'House';
-  },
-});
+  }
+}
 
-const Mortgage = Model.extend({
-  person: belongsTo('person', { async: true }),
-});
-Mortgage.reopenClass({
-  toString() {
+class Mortgage extends Model {
+  @belongsTo('person', { async: true }) person;
+
+  static toString() {
     return 'Mortgage';
-  },
-});
+  }
+}
 
-const Group = Model.extend({
-  people: hasMany('person', { async: false }),
-});
-Group.reopenClass({
-  toString() {
+class Group extends Model {
+  @hasMany('person', { async: false }) people;
+
+  static toString() {
     return 'Group';
-  },
-});
+  }
+}
 
-const Car = Model.extend({
-  make: attr('string'),
-  model: attr('string'),
-  person: belongsTo('person', { async: false }),
-});
-Car.reopenClass({
-  toString() {
+class Car extends Model {
+  @attr('string') make;
+  @attr('string') model;
+  @belongsTo('person', { async: false }) person;
+
+  static toString() {
     return 'Car';
-  },
-});
+  }
+}
 
 const Boat = Model.extend({
   name: attr('string'),