@ember-data/model 4.7.0-beta.1 → 4.8.0-alpha.2

package/addon/-private/model-for-mixin.ts

@@ -29,10 +29,8 @@ export default function modelForMixin(store: Store, normalizedModelName: string)
   let mixin = MaybeMixin && MaybeMixin.class;
   if (mixin) {
     let ModelForMixin = Model.extend(mixin);
-    ModelForMixin.reopenClass({
-      __isMixin: true,
-      __mixin: mixin,
-    });
+    ModelForMixin.__isMixin = true;
+    ModelForMixin.__mixin = mixin;
     //Cache the class as a model
     owner.register('model:' + normalizedModelName, ModelForMixin);
   }

package/addon/-private/model.js

@@ -2,7 +2,7 @@
   @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 { dependentKeyCompat } from '@ember/object/compat';
@@ -16,16 +16,13 @@ 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_SAVE_PROMISE_ACCESS,
+} from '@ember-data/private-build-infra/deprecations';
+import { recordIdentifierFor, storeFor } from '@ember-data/store';
+import { coerceId, deprecatedPromiseObject, InternalModel, WeakCache } from '@ember-data/store/-private';
 
 import Errors from './errors';
 import { LegacySupport } from './legacy-relationships-support';
@@ -565,22 +562,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;
   }
 
@@ -1258,12 +1240,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 +1317,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,6 +1346,23 @@ class Model extends EmberObject {
 
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(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 inverseType = this.typeForRelationship(name, store);
     if (!inverseType) {
       return null;
@@ -1457,6 +1507,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 +1578,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 +1645,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;
@@ -1620,6 +1721,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 +1754,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) => {
@@ -1693,6 +1828,23 @@ 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) => {
@@ -1718,6 +1870,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 +1905,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 +1931,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);
@@ -1806,6 +2009,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) => {
@@ -1865,6 +2085,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) => {
@@ -1921,6 +2158,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);
     });
@@ -1972,6 +2226,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,6 +2256,23 @@ class Model extends EmberObject {
    @static
    */
   static toString() {
+    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:${get(this, 'modelName')}`;
   }
 }
@@ -2111,6 +2399,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;

package/addon/-private/record-state.ts

@@ -5,7 +5,7 @@ import { cached, tracked } from '@glimmer/tracking';
 
 import type Store from '@ember-data/store';
 import { storeFor } from '@ember-data/store';
-import { errorsArrayToHash, recordIdentifierFor } from '@ember-data/store/-private';
+import { recordIdentifierFor } from '@ember-data/store/-private';
 import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
 import type RequestCache from '@ember-data/store/-private/request-cache';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
@@ -13,6 +13,9 @@ import type { RecordData } from '@ember-data/types/q/record-data';
 
 type Model = InstanceType<typeof import('./model')>;
 
+const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
+const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
+const PRIMARY_ATTRIBUTE_KEY = 'base';
 function isInvalidError(error) {
   return error && error.isAdapterError === true && error.code === 'InvalidError';
 }
@@ -176,7 +179,6 @@ export default class RecordState {
             break;
           case 'rejected':
             this.isSaving = false;
-
             this._lastError = req;
             if (!(req.response && isInvalidError(req.response.data))) {
               this._errorRequests.push(req);
@@ -246,11 +248,7 @@ export default class RecordState {
           this.notify('isDeleted');
           break;
         case 'errors':
-          // we only hit this if a foreign RecordData notifies
-          // errors changed. Our own implementation does not
-          // take this path currently, but we should probably
-          // fix that.
-          this.updateInvalidErrors();
+          this.updateInvalidErrors(this.record.errors);
           this.notify('isValid');
           break;
       }
@@ -261,16 +259,33 @@ export default class RecordState {
     getTag(this, key).notify();
   }
 
-  updateInvalidErrors() {
-    let jsonApiErrors = this.recordData.getErrors!(this.identifier);
+  updateInvalidErrors(errors) {
+    assert(
+      `Expected the RecordData instance for ${this.identifier}  to implement getErrors(identifier)`,
+      typeof this.recordData.getErrors === 'function'
+    );
+    let jsonApiErrors = this.recordData.getErrors(this.identifier);
 
-    const { errors } = this.record;
     errors.clear();
-    let newErrors = errorsArrayToHash(jsonApiErrors);
-    let errorKeys = Object.keys(newErrors);
 
-    for (let i = 0; i < errorKeys.length; i++) {
-      errors.add(errorKeys[i], newErrors[errorKeys[i]]);
+    for (let i = 0; i < jsonApiErrors.length; i++) {
+      let error = jsonApiErrors[i];
+
+      if (error.source && error.source.pointer) {
+        let keyMatch = error.source.pointer.match(SOURCE_POINTER_REGEXP);
+        let key: string | undefined;
+
+        if (keyMatch) {
+          key = keyMatch[2];
+        } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {
+          key = PRIMARY_ATTRIBUTE_KEY;
+        }
+
+        if (key) {
+          let errMsg = error.detail || error.title;
+          errors.add(key, errMsg);
+        }
+      }
     }
   }
 

package/addon/-private/relationship-meta.ts

@@ -1,9 +1,9 @@
+import { dasherize } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 
 import { singularize } from 'ember-inflector';
 
 import type Store from '@ember-data/store';
-import { normalizeModelName } from '@ember-data/store/-private';
 import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 
 /**
@@ -11,7 +11,7 @@ import type { RelationshipSchema } from '@ember-data/types/q/record-data-schemas
 */
 
 function typeForRelationshipMeta(meta) {
-  let modelName = normalizeModelName(meta.type || meta.key);
+  let modelName = dasherize(meta.type || meta.key);
 
   if (meta.kind === 'hasMany') {
     modelName = singularize(modelName);

package/index.js

@@ -17,6 +17,7 @@ module.exports = Object.assign({}, addonBaseConfig, {
       '@ember-data/store/-private',
       '@ember-data/store/-debug',
       '@embroider/macros',
+      '@ember/string',
       '@embroider/macros/es-compat',
 
       '@ember/application',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/model",
-  "version": "4.7.0-beta.1",
+  "version": "4.8.0-alpha.2",
   "description": "The default blueprint for ember-cli addons.",
   "keywords": [
     "ember-addon"
@@ -18,9 +18,9 @@
     "test:node": "mocha"
   },
   "dependencies": {
-    "@ember-data/canary-features": "4.7.0-beta.1",
-    "@ember-data/private-build-infra": "4.7.0-beta.1",
-    "@ember-data/store": "4.7.0-beta.1",
+    "@ember-data/canary-features": "4.8.0-alpha.2",
+    "@ember-data/private-build-infra": "4.8.0-alpha.2",
+    "@ember-data/store": "4.8.0-alpha.2",
     "@ember/edition-utils": "^1.2.0",
     "@ember/string": "^3.0.0",
     "@embroider/macros": "^1.8.3",
@@ -34,7 +34,7 @@
     "inflection": "~1.13.2"
   },
   "devDependencies": {
-    "@ember-data/unpublished-test-infra": "4.7.0-beta.1",
+    "@ember-data/unpublished-test-infra": "4.8.0-alpha.2",
     "@ember/optional-features": "^2.0.0",
     "@ember/test-helpers": "~2.7.0",
     "broccoli-asset-rev": "^3.0.0",