@ember-data/model 4.8.0-alpha.3 → 4.8.0-alpha.6

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,7 +110,6 @@ function attr(type, options) {
   let meta = {
     type: type,
     isAttribute: true,
-    kind: 'attribute',
     options: options,
   };
 
@@ -139,20 +125,7 @@ function attr(type, options) {
       if (this.isDestroyed || this.isDestroying) {
         return;
       }
-      let recordData = recordDataFor(this);
-      // TODO hasAttr is not spec'd
-      // essentially this is needed because
-      // there is a difference between "undefined" meaning never set
-      // and "undefined" meaning set to "undefined". In the "key present"
-      // case we want to return undefined. In the "key absent" case
-      // we want to return getDefaultValue. RecordDataV2 can fix this
-      // by providing the attributes blob such that we can make our
-      // own determination.
-      if (recordData.hasAttr(key)) {
-        return recordData.getAttr(key);
-      } else {
-        return getDefaultValue(this, options, key);
-      }
+      return recordDataFor(this).getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
       if (DEBUG) {
@@ -166,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
 */
@@ -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',
@@ -149,7 +205,7 @@ function belongsTo(modelName, options) {
       if (this.isDestroying || this.isDestroyed) {
         return null;
       }
-      const support = LEGACY_SUPPORT.lookup(this);
+      const support = lookupLegacySupport(this);
 
       if (DEBUG) {
         if (['currentState'].indexOf(key) !== -1) {
@@ -181,7 +237,7 @@ function belongsTo(modelName, options) {
       return support.getBelongsTo(key);
     },
     set(key, value) {
-      const support = LEGACY_SUPPORT.lookup(this);
+      const support = lookupLegacySupport(this);
       if (DEBUG) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(
@@ -189,7 +245,7 @@ function belongsTo(modelName, options) {
           );
         }
       }
-      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/has-many.js

@@ -2,13 +2,30 @@
   @module @ember-data/model
 */
 import { A } from '@ember/array';
-import { assert, inspect } from '@ember/debug';
+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).
@@ -151,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
@@ -173,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',
@@ -193,7 +249,7 @@ function hasMany(type, options) {
       if (this.isDestroying || this.isDestroyed) {
         return A();
       }
-      return LEGACY_SUPPORT.lookup(this).getHasMany(key);
+      return lookupLegacySupport(this).getHasMany(key);
     },
     set(key, records) {
       if (DEBUG) {
@@ -203,9 +259,11 @@ function hasMany(type, options) {
           );
         }
       }
-      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,7 +3,10 @@ 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';
 
@@ -231,19 +234,36 @@ function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, paren
   }
 }
 
-function getInverse(store, parentIdentifier, parentRelationship, type) {
-  return recordDataFindInverseRelationshipInfo(store, parentIdentifier, 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,