@ember-data/model 4.6.1 → 4.7.0

package/addon/-private/attr.js

@@ -11,19 +11,6 @@ import { computedMacroWithOptionalParams } from './util';
   @module @ember-data/model
 */
 
-function getDefaultValue(record, options, key) {
-  if (typeof options.defaultValue === 'function') {
-    return options.defaultValue.apply(null, arguments);
-  } else {
-    let defaultValue = options.defaultValue;
-    assert(
-      `Non primitive defaultValues are not supported because they are shared between all instances. If you would like to use a complex object as a default value please provide a function that returns the complex object.`,
-      typeof defaultValue !== 'object' || defaultValue === null
-    );
-    return defaultValue;
-  }
-}
-
 /**
   `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
@@ -123,29 +110,26 @@ function attr(type, options) {
   let meta = {
     type: type,
     isAttribute: true,
-    kind: 'attribute',
     options: options,
   };
 
   return computed({
     get(key) {
       if (DEBUG) {
-        if (['_internalModel', 'currentState'].indexOf(key) !== -1) {
+        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()}`
           );
         }
       }
-      let recordData = recordDataFor(this);
-      if (recordData.hasAttr(key)) {
-        return recordData.getAttr(key);
-      } else {
-        return getDefaultValue(this, options, key);
+      if (this.isDestroyed || this.isDestroying) {
+        return;
       }
+      return recordDataFor(this).getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
       if (DEBUG) {
-        if (['_internalModel', 'currentState'].indexOf(key) !== -1) {
+        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()}`
           );
@@ -155,10 +139,11 @@ function attr(type, options) {
         `Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`,
         !this.currentState.isDeleted
       );
-      const recordData = storeFor(this)._instanceCache.getRecordData(recordIdentifierFor(this));
-      let currentValue = recordData.getAttr(key);
+      const identifier = recordIdentifierFor(this);
+      const recordData = storeFor(this)._instanceCache.getRecordData(identifier);
+      let currentValue = recordData.getAttr(identifier, key);
       if (currentValue !== value) {
-        recordData.setDirtyAttribute(key, value);
+        recordData.setAttr(identifier, key, value);
 
         if (!this.isValid) {
           const { errors } = this;

package/addon/-private/belongs-to.js

@@ -1,10 +1,24 @@
-import { assert, inspect, warn } from '@ember/debug';
+import { assert, deprecate, warn } from '@ember/debug';
 import { computed } from '@ember/object';
+import { dasherize } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 
-import { LEGACY_SUPPORT } from './model';
+import {
+  DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE,
+} from '@ember-data/private-build-infra/deprecations';
+
+import { lookupLegacySupport } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
+function normalizeType(type) {
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && !type) {
+    return;
+  }
+
+  return dasherize(type);
+}
 /**
   @module @ember-data/model
 */
@@ -98,7 +112,7 @@ import { computedMacroWithOptionalParams } from './util';
   a related resource is known to exist and it has not been loaded.
 
   ```
-  let post = comment.get('post');
+  let post = comment.post;
 
   ```
 
@@ -111,29 +125,71 @@ import { computedMacroWithOptionalParams } from './util';
   @return {Ember.computed} relationship
 */
 function belongsTo(modelName, options) {
-  let opts, userEnteredModelName;
-  if (typeof modelName === 'object') {
-    opts = modelName;
-    userEnteredModelName = undefined;
-  } else {
-    opts = options;
-    userEnteredModelName = modelName;
+  let opts = options;
+  let userEnteredModelName = modelName;
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && (typeof modelName !== 'string' || !modelName.length)) {
+    deprecate('belongsTo() must specify the string type of the related resource as the first parameter', false, {
+      id: 'ember-data:deprecate-non-strict-relationships',
+      for: 'ember-data',
+      until: '5.0',
+      since: { enabled: '4.8', available: '4.8' },
+    });
+
+    if (typeof modelName === 'object') {
+      opts = modelName;
+      userEnteredModelName = undefined;
+    } else {
+      opts = options;
+      userEnteredModelName = modelName;
+    }
+
+    assert(
+      'The first argument to belongsTo must be a string representing a model type key, not an instance of ' +
+        typeof userEnteredModelName +
+        ". E.g., to define a relation to the Person model, use belongsTo('person')",
+      typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'
+    );
   }
 
-  assert(
-    'The first argument to belongsTo must be a string representing a model type key, not an instance of ' +
-      inspect(userEnteredModelName) +
-      ". E.g., to define a relation to the Person model, use belongsTo('person')",
-    typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'
-  );
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC && (!opts || typeof opts.async !== 'boolean')) {
+    opts = opts || {};
+    if (!('async' in opts)) {
+      opts.async = true;
+    }
+    deprecate('belongsTo(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
+      id: 'ember-data:deprecate-non-strict-relationships',
+      for: 'ember-data',
+      until: '5.0',
+      since: { enabled: '4.8', available: '4.8' },
+    });
+  } else {
+    assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
+  }
 
-  opts = opts || {};
-  if (!('async' in opts)) {
-    opts.async = true;
+  if (
+    DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE &&
+    opts.inverse !== null &&
+    (typeof opts.inverse !== 'string' || opts.inverse.length === 0)
+  ) {
+    deprecate(
+      'belongsTo(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
+      false,
+      {
+        id: 'ember-data:deprecate-non-strict-relationships',
+        for: 'ember-data',
+        until: '5.0',
+        since: { enabled: '4.8', available: '4.8' },
+      }
+    );
+  } else {
+    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: userEnteredModelName,
+    type: normalizeType(userEnteredModelName),
     isRelationship: true,
     options: opts,
     kind: 'belongsTo',
@@ -143,10 +199,16 @@ function belongsTo(modelName, options) {
 
   return computed({
     get(key) {
-      const support = LEGACY_SUPPORT.lookup(this);
+      // 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 (DEBUG) {
-        if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
+        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()}`
           );
@@ -175,15 +237,15 @@ function belongsTo(modelName, options) {
       return support.getBelongsTo(key);
     },
     set(key, value) {
-      const support = LEGACY_SUPPORT.lookup(this);
+      const support = lookupLegacySupport(this);
       if (DEBUG) {
-        if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
+        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._backburner.join(() => {
+      this.store._join(() => {
         support.setDirtyBelongsTo(key, value);
       });
 

package/addon/-private/deprecated-promise-proxy.ts

@@ -0,0 +1,54 @@
+import { deprecate } from '@ember/debug';
+
+import { resolve } from 'rsvp';
+
+import { PromiseObject } from './promise-proxy-base';
+
+function promiseObject<T>(promise: Promise<T>): PromiseObject<T> {
+  return PromiseObject.create({
+    promise: resolve(promise),
+  }) as PromiseObject<T>;
+}
+
+// constructor is accessed in some internals but not including it in the copyright for the deprecation
+const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
+const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
+
+export function deprecatedPromiseObject<T>(promise: Promise<T>): PromiseObject<T> {
+  const promiseObjectProxy: PromiseObject<T> = promiseObject(promise);
+  const handler = {
+    get(target: object, prop: string, receiver?: object): unknown {
+      if (typeof prop === 'symbol') {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (!ALLOWABLE_METHODS.includes(prop)) {
+        deprecate(
+          `Accessing ${prop} is deprecated. The return type is being changed fomr PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`,
+          false,
+          {
+            id: 'ember-data:model-save-promise',
+            until: '5.0',
+            for: '@ember-data/store',
+            since: {
+              available: '4.4',
+              enabled: '4.4',
+            },
+          }
+        );
+      }
+
+      const value: unknown = target[prop];
+      if (value && typeof value === 'function' && typeof value.bind === 'function') {
+        return value.bind(target);
+      }
+
+      if (PROXIED_OBJECT_PROPS.includes(prop)) {
+        return value;
+      }
+
+      return undefined;
+    },
+  };
+
+  return new Proxy(promiseObjectProxy, handler);
+}

package/addon/-private/errors.ts

@@ -123,7 +123,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
       email: 'invalidEmail'
     });
     user.save().catch(function(){
-      user.get('errors').errorsFor('email'); // returns:
+      user.errors.errorsFor('email'); // returns:
       // [{attribute: "email", message: "Doesn't look like a valid email."}]
     });
     ```
@@ -219,7 +219,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
 
    Example
    ```javascript
-    let errors = get(user, 'errors');
+    let errors = user.errors;
 
     // add multiple errors
     errors.add('password', [
@@ -293,7 +293,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
    Example:
 
    ```javascript
-    let errors = get('user', errors);
+    let errors = user.errors;
     errors.add('phone', ['error-1', 'error-2']);
 
     errors.errorsFor('phone');
@@ -344,7 +344,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
   Example:
 
    ```javascript
-   let errors = get('user', errors);
+   let errors = user.errors;
    errors.add('username', ['error-a']);
    errors.add('phone', ['error-1', 'error-2']);
 
@@ -369,7 +369,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
    errors.errorsFor('phone');
    // => undefined
 
-   errors.get('messages')
+   errors.messages
    // => []
    ```
    @method clear
@@ -406,7 +406,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
     export default class UserEditController extends Controller {
       @action
       save(user) {
-        if (user.get('errors').has('email')) {
+        if (user.errors.has('email')) {
           return alert('Please update your email before attempting to save.');
         }
         user.save();

package/addon/-private/has-many.js

@@ -1,13 +1,31 @@
 /**
   @module @ember-data/model
 */
-import { assert, inspect } from '@ember/debug';
+import { A } from '@ember/array';
+import { assert, deprecate, inspect } from '@ember/debug';
 import { computed } from '@ember/object';
+import { dasherize } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
 
-import { LEGACY_SUPPORT } from './model';
+import { singularize } from 'ember-inflector';
+
+import {
+  DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
+  DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE,
+} from '@ember-data/private-build-infra/deprecations';
+
+import { lookupLegacySupport } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
+function normalizeType(type) {
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && !type) {
+    return;
+  }
+
+  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).
@@ -132,7 +150,7 @@ import { computedMacroWithOptionalParams } from './util';
   when any of the known related resources have not been loaded.
 
   ```
-  post.get('comments').forEach((comment) => {
+  post.comments.forEach((comment) => {
 
   });
 
@@ -150,21 +168,60 @@ import { computedMacroWithOptionalParams } from './util';
   @return {Ember.computed} relationship
 */
 function hasMany(type, options) {
-  if (typeof type === 'object') {
-    options = type;
-    type = undefined;
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE && (typeof type !== 'string' || !type.length)) {
+    deprecate(
+      'hasMany(<type>, <options>) must specify the string type of the related resource as the first parameter',
+      false,
+      {
+        id: 'ember-data:deprecate-non-strict-relationships',
+        for: 'ember-data',
+        until: '5.0',
+        since: { enabled: '4.8', available: '4.8' },
+      }
+    );
+    if (typeof type === 'object') {
+      options = type;
+      type = undefined;
+    }
+
+    assert(
+      `The first argument to hasMany must be a string representing a model type key, not an instance of ${inspect(
+        type
+      )}. E.g., to define a relation to the Comment model, use hasMany('comment')`,
+      typeof type === 'string' || typeof type === 'undefined'
+    );
   }
 
-  assert(
-    `The first argument to hasMany must be a string representing a model type key, not an instance of ${inspect(
-      type
-    )}. E.g., to define a relation to the Comment model, use hasMany('comment')`,
-    typeof type === 'string' || typeof type === 'undefined'
-  );
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC && (!options || typeof options.async !== 'boolean')) {
+    options = options || {};
+    if (!('async' in options)) {
+      options.async = true;
+    }
+    deprecate('hasMany(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
+      id: 'ember-data:deprecate-non-strict-relationships',
+      for: 'ember-data',
+      until: '5.0',
+      since: { enabled: '4.8', available: '4.8' },
+    });
+  } else {
+    assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
+  }
 
-  options = options || {};
-  if (!('async' in options)) {
-    options.async = true;
+  if (
+    DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE &&
+    options.inverse !== null &&
+    (typeof options.inverse !== 'string' || options.inverse.length === 0)
+  ) {
+    deprecate(
+      'hasMany(<type>, <options>) must specify options.inverse as either `null` or string type of the related resource.',
+      false,
+      {
+        id: 'ember-data:deprecate-non-strict-relationships',
+        for: 'ember-data',
+        until: '5.0',
+        since: { enabled: '4.8', available: '4.8' },
+      }
+    );
   }
 
   // Metadata about relationships is stored on the meta of
@@ -172,7 +229,7 @@ function hasMany(type, options) {
   // serialization. Note that `key` is populated lazily
   // the first time the CP is called.
   let meta = {
-    type,
+    type: normalizeType(type),
     options,
     isRelationship: true,
     kind: 'hasMany',
@@ -183,25 +240,30 @@ function hasMany(type, options) {
   return computed({
     get(key) {
       if (DEBUG) {
-        if (['_internalModel', 'currentState'].indexOf(key) !== -1) {
+        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()}`
           );
         }
       }
-      return LEGACY_SUPPORT.lookup(this).getHasMany(key);
+      if (this.isDestroying || this.isDestroyed) {
+        return A();
+      }
+      return lookupLegacySupport(this).getHasMany(key);
     },
     set(key, records) {
       if (DEBUG) {
-        if (['_internalModel', 'currentState'].indexOf(key) !== -1) {
+        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 = LEGACY_SUPPORT.lookup(this);
-      this.store._backburner.join(() => {
-        support.setDirtyHasMany(key, records);
+      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);

package/addon/-private/legacy-data-fetch.js

@@ -3,11 +3,15 @@ import { DEBUG } from '@glimmer/env';
 
 import { resolve } from 'rsvp';
 
-import { DEPRECATE_RSVP_PROMISE } from '@ember-data/private-build-infra/deprecations';
+import {
+  DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE,
+  DEPRECATE_RSVP_PROMISE,
+} from '@ember-data/private-build-infra/deprecations';
 
 import { iterateData, normalizeResponseHelper } from './legacy-data-utils';
 
 export function _findHasMany(adapter, store, identifier, link, relationship, options) {
+  const record = store._instanceCache.getRecord(identifier);
   const snapshot = store._instanceCache.createSnapshot(identifier, options);
   let modelClass = store.modelFor(relationship.type);
   let useLink = !link || typeof link === 'string';
@@ -18,7 +22,7 @@ export function _findHasMany(adapter, store, identifier, link, relationship, opt
   promise = guardDestroyedStore(promise, store, label);
   promise = promise.then(
     (adapterPayload) => {
-      if (!_objectIsAlive(store._instanceCache.getInternalModel(identifier))) {
+      if (!_objectIsAlive(record)) {
         if (DEPRECATE_RSVP_PROMISE) {
           deprecate(
             `A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`,
@@ -57,13 +61,14 @@ export function _findHasMany(adapter, store, identifier, link, relationship, opt
   );
 
   if (DEPRECATE_RSVP_PROMISE) {
-    promise = _guard(promise, _bind(_objectIsAlive, store._instanceCache.getInternalModel(identifier)));
+    promise = _guard(promise, _bind(_objectIsAlive, record));
   }
 
   return promise;
 }
 
 export function _findBelongsTo(store, identifier, link, relationship, options) {
+  const record = store._instanceCache.getRecord(identifier);
   let adapter = store.adapterFor(identifier.type);
 
   assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);
@@ -79,11 +84,11 @@ export function _findBelongsTo(store, identifier, link, relationship, options) {
   let label = `DS: Handle Adapter#findBelongsTo of ${identifier.type} : ${relationship.type}`;
 
   promise = guardDestroyedStore(promise, store, label);
-  promise = _guard(promise, _bind(_objectIsAlive, store._instanceCache.getInternalModel(identifier)));
+  promise = _guard(promise, _bind(_objectIsAlive, record));
 
   promise = promise.then(
     (adapterPayload) => {
-      if (!_objectIsAlive(store._instanceCache.getInternalModel(identifier))) {
+      if (!_objectIsAlive(record)) {
         if (DEPRECATE_RSVP_PROMISE) {
           deprecate(
             `A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`,
@@ -123,7 +128,7 @@ export function _findBelongsTo(store, identifier, link, relationship, options) {
   );
 
   if (DEPRECATE_RSVP_PROMISE) {
-    promise = _guard(promise, _bind(_objectIsAlive, store._instanceCache.getInternalModel(identifier)));
+    promise = _guard(promise, _bind(_objectIsAlive, record));
   }
 
   return promise;
@@ -229,19 +234,36 @@ function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, paren
   }
 }
 
-function getInverse(store, parentInternalModel, parentRelationship, type) {
-  return recordDataFindInverseRelationshipInfo(store, parentInternalModel, parentRelationship, type);
+function metaIsRelationshipDefinition(meta) {
+  return typeof meta._inverseKey === 'function';
 }
 
-function recordDataFindInverseRelationshipInfo(store, parentIdentifier, parentRelationship, type) {
+function inverseForRelationship(store, identifier, key) {
+  const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
+  if (!definition) {
+    return null;
+  }
+
+  if (DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE && metaIsRelationshipDefinition(definition)) {
+    const modelClass = store.modelFor(identifier.type);
+    return definition._inverseKey(store, modelClass);
+  }
+  assert(
+    `Expected the relationship defintion to specify the inverse type or null.`,
+    definition.options?.inverse === null ||
+      (typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0)
+  );
+  return definition.options.inverse;
+}
+
+function getInverse(store, parentIdentifier, parentRelationship, type) {
   let { name: lhs_relationshipName } = parentRelationship;
   let { type: parentType } = parentIdentifier;
-  let inverseKey = store._instanceCache._storeWrapper.inverseForRelationship(parentType, lhs_relationshipName);
+  let inverseKey = inverseForRelationship(store, { type: parentType }, lhs_relationshipName);
 
   if (inverseKey) {
-    let {
-      meta: { kind },
-    } = store._instanceCache._storeWrapper.relationshipsDefinitionFor(type)[inverseKey];
+    const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({ type });
+    let { kind } = definition[inverseKey];
     return {
       inverseKey,
       kind,

package/addon/-private/legacy-data-utils.ts

@@ -2,7 +2,7 @@ import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 import type Store from '@ember-data/store';
-import type ShimModelClass from '@ember-data/store/-private/model/shim-model-class';
+import type ShimModelClass from '@ember-data/store/-private/legacy-model-support/shim-model-class';
 import type { JsonApiDocument } from '@ember-data/types/q/ember-data-json-api';
 import type { StableExistingRecordIdentifier, StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { AdapterPayload } from '@ember-data/types/q/minimum-adapter-interface';