@ember-data/model 4.5.0-beta.0 → 4.7.0-beta.0

package/addon/-private/attr.js

@@ -2,6 +2,7 @@ import { assert } from '@ember/debug';
 import { computed } from '@ember/object';
 import { DEBUG } from '@glimmer/env';
 
+import { recordIdentifierFor, storeFor } from '@ember-data/store';
 import { recordDataFor } from '@ember-data/store/-private';
 
 import { computedMacroWithOptionalParams } from './util';
@@ -150,17 +151,25 @@ function attr(type, options) {
           );
         }
       }
-      if (!this.isValid) {
-        let oldValue = this._internalModel._recordData.getAttr(key);
-        if (oldValue !== value) {
+      assert(
+        `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);
+      if (currentValue !== value) {
+        recordData.setDirtyAttribute(key, value);
+
+        if (!this.isValid) {
           const { errors } = this;
           if (errors.get(key)) {
             errors.remove(key);
-            this.___recordState.cleanErrorRequests();
+            this.currentState.cleanErrorRequests();
           }
         }
       }
-      return this._internalModel.setDirtyAttribute(key, value);
+
+      return value;
     },
   }).meta(meta);
 }

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

@@ -2,6 +2,7 @@ import { assert, inspect, warn } from '@ember/debug';
 import { computed } from '@ember/object';
 import { DEBUG } from '@glimmer/env';
 
+import { LEGACY_SUPPORT } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
 /**
@@ -142,6 +143,8 @@ function belongsTo(modelName, options) {
 
   return computed({
     get(key) {
+      const support = LEGACY_SUPPORT.lookup(this);
+
       if (DEBUG) {
         if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
           throw new Error(
@@ -150,7 +153,7 @@ function belongsTo(modelName, options) {
         }
         if (Object.prototype.hasOwnProperty.call(opts, 'serialize')) {
           warn(
-            `You provided a serialize option on the "${key}" property in the "${this._internalModel.modelName}" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`,
+            `You provided a serialize option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`,
             false,
             {
               id: 'ds.model.serialize-option-in-belongs-to',
@@ -160,7 +163,7 @@ function belongsTo(modelName, options) {
 
         if (Object.prototype.hasOwnProperty.call(opts, 'embedded')) {
           warn(
-            `You provided an embedded option on the "${key}" property in the "${this._internalModel.modelName}" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`,
+            `You provided an embedded option on the "${key}" property in the "${support.identifier.type}" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`,
             false,
             {
               id: 'ds.model.embedded-option-in-belongs-to',
@@ -169,9 +172,10 @@ function belongsTo(modelName, options) {
         }
       }
 
-      return this._internalModel.getBelongsTo(key);
+      return support.getBelongsTo(key);
     },
     set(key, value) {
+      const support = LEGACY_SUPPORT.lookup(this);
       if (DEBUG) {
         if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
           throw new Error(
@@ -180,10 +184,10 @@ function belongsTo(modelName, options) {
         }
       }
       this.store._backburner.join(() => {
-        this._internalModel.setDirtyBelongsTo(key, value);
+        support.setDirtyBelongsTo(key, value);
       });
 
-      return this._internalModel.getBelongsTo(key);
+      return support.getBelongsTo(key);
     },
   }).meta(meta);
 }

package/addon/-private/errors.ts

@@ -4,6 +4,8 @@ import ArrayProxy from '@ember/array/proxy';
 import { computed, get } from '@ember/object';
 import { mapBy, not } from '@ember/object/computed';
 
+import type RecordState from './record-state';
+
 type ValidationError = {
   attribute: string;
   message: string;
@@ -101,24 +103,7 @@ const ArrayProxyWithCustomOverrides = ArrayProxy as unknown as new <T, M = T>()
   @extends Ember.ArrayProxy
  */
 export default class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
-  declare _registeredHandlers?: {
-    becameInvalid: () => void;
-    becameValid: () => void;
-  };
-
-  /**
-    Register with target handler
-
-    @method _registerHandlers
-    @private
-  */
-  _registerHandlers(becameInvalid: () => void, becameValid: () => void): void {
-    this._registeredHandlers = {
-      becameInvalid,
-      becameValid,
-    };
-  }
-
+  declare __record: { currentState: RecordState };
   /**
     @property errorsByAttributeName
     @type {MapWithDefault}
@@ -266,26 +251,11 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
     @param {string[]|string} messages - an error message or array of error messages for the attribute
    */
   add(attribute: string, messages: string[] | string): void {
-    let wasEmpty: boolean = this.isEmpty;
-
-    this._add(attribute, messages);
-
-    if (wasEmpty && !this.isEmpty) {
-      this._registeredHandlers && this._registeredHandlers.becameInvalid();
-    }
-  }
-
-  /**
-    Adds error messages to a given attribute without sending event.
-
-    @method _add
-    @private
-  */
-  _add(attribute: string, messages: string[] | string) {
     const errors = this._findOrCreateMessages(attribute, messages);
     this.addObjects(errors);
 
     this.errorsFor(attribute).addObjects(errors);
+    this.__record.currentState.notify('isValid');
 
     this.notifyPropertyChange(attribute);
   }
@@ -347,24 +317,6 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
       return;
     }
 
-    this._remove(attribute);
-
-    if (this.isEmpty) {
-      this._registeredHandlers && this._registeredHandlers.becameValid();
-    }
-  }
-
-  /**
-    Removes all error messages from the given attribute without sending event.
-
-    @method _remove
-    @private
-  */
-  _remove(attribute: string) {
-    if (this.isEmpty) {
-      return;
-    }
-
     let content = this.rejectBy('attribute', attribute);
     this.content.setObjects(content);
 
@@ -379,6 +331,7 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
     }
     this.errorsByAttributeName.delete(attribute);
 
+    this.__record.currentState.notify('isValid');
     this.notifyPropertyChange(attribute);
     this.notifyPropertyChange('length');
   }
@@ -427,22 +380,6 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
       return;
     }
 
-    this._clear();
-    this._registeredHandlers && this._registeredHandlers.becameValid();
-  }
-
-  /**
-    Removes all error messages.
-    to the record.
-
-    @method _clear
-    @private
-  */
-  _clear(): void {
-    if (this.isEmpty) {
-      return;
-    }
-
     let errorsByAttributeName = this.errorsByAttributeName;
     let attributes: string[] = [];
 
@@ -455,7 +392,8 @@ export default class Errors extends ArrayProxyWithCustomOverrides<ValidationErro
       this.notifyPropertyChange(attribute);
     });
 
-    ArrayProxy.prototype.clear.call(this);
+    this.__record.currentState.notify('isValid');
+    super.clear();
   }
 
   /**

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

@@ -5,6 +5,7 @@ import { assert, inspect } from '@ember/debug';
 import { computed } from '@ember/object';
 import { DEBUG } from '@glimmer/env';
 
+import { LEGACY_SUPPORT } from './model';
 import { computedMacroWithOptionalParams } from './util';
 
 /**
@@ -182,28 +183,28 @@ function hasMany(type, options) {
   return computed({
     get(key) {
       if (DEBUG) {
-        if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
+        if (['_internalModel', '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 this._internalModel.getHasMany(key);
+      return LEGACY_SUPPORT.lookup(this).getHasMany(key);
     },
     set(key, records) {
       if (DEBUG) {
-        if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {
+        if (['_internalModel', '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()}`
           );
         }
       }
-      let internalModel = this._internalModel;
+      const support = LEGACY_SUPPORT.lookup(this);
       this.store._backburner.join(() => {
-        internalModel.setDirtyHasMany(key, records);
+        support.setDirtyHasMany(key, records);
       });
 
-      return internalModel.getHasMany(key);
+      return support.getHasMany(key);
     },
   }).meta(meta);
 }

package/addon/-private/index.ts

@@ -4,10 +4,11 @@ export { default as hasMany } from './has-many';
 export { default as Model } from './model';
 export { default as Errors } from './errors';
 
-export { default as ManyArray } from './system/many-array';
-export { default as PromiseBelongsTo } from './system/promise-belongs-to';
-export { default as PromiseManyArray } from './system/promise-many-array';
-export { default as _modelForMixin } from './system/model-for-mixin';
+export { default as ManyArray } from './many-array';
+export { default as PromiseBelongsTo } from './promise-belongs-to';
+export { default as PromiseManyArray } from './promise-many-array';
+export { default as _modelForMixin } from './model-for-mixin';
 
 // // Used by tests
-export { default as diffArray } from './system/diff-array';
+export { default as diffArray } from './diff-array';
+export { LEGACY_SUPPORT } from './model';

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

@@ -0,0 +1,370 @@
+import { assert, deprecate } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+import { resolve } from 'rsvp';
+
+import { 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 snapshot = store._instanceCache.createSnapshot(identifier, options);
+  let modelClass = store.modelFor(relationship.type);
+  let useLink = !link || typeof link === 'string';
+  let relatedLink = useLink ? link : link.href;
+  let promise = adapter.findHasMany(store, snapshot, relatedLink, relationship);
+  let label = `DS: Handle Adapter#findHasMany of '${identifier.type}' : '${relationship.type}'`;
+
+  promise = guardDestroyedStore(promise, store, label);
+  promise = promise.then(
+    (adapterPayload) => {
+      if (!_objectIsAlive(store._instanceCache.getInternalModel(identifier))) {
+        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.`,
+            false,
+            {
+              id: 'ember-data:rsvp-unresolved-async',
+              until: '5.0',
+              for: '@ember-data/store',
+              since: {
+                available: '4.5',
+                enabled: '4.5',
+              },
+            }
+          );
+        }
+      }
+
+      assert(
+        `You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.key}' relationship, using link '${link}' , but the adapter's response did not have any data`,
+        payloadIsNotBlank(adapterPayload)
+      );
+      let serializer = store.serializerFor(relationship.type);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');
+
+      assert(
+        `fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: [] }`,
+        'data' in payload && Array.isArray(payload.data)
+      );
+
+      payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+
+      return store._push(payload);
+    },
+    null,
+    `DS: Extract payload of '${identifier.type}' : hasMany '${relationship.type}'`
+  );
+
+  if (DEPRECATE_RSVP_PROMISE) {
+    promise = _guard(promise, _bind(_objectIsAlive, store._instanceCache.getInternalModel(identifier)));
+  }
+
+  return promise;
+}
+
+export function _findBelongsTo(store, identifier, link, relationship, options) {
+  let adapter = store.adapterFor(identifier.type);
+
+  assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);
+  assert(
+    `You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`,
+    typeof adapter.findBelongsTo === 'function'
+  );
+  let snapshot = store._instanceCache.createSnapshot(identifier, options);
+  let modelClass = store.modelFor(relationship.type);
+  let useLink = !link || typeof link === 'string';
+  let relatedLink = useLink ? link : link.href;
+  let promise = adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
+  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 = promise.then(
+    (adapterPayload) => {
+      if (!_objectIsAlive(store._instanceCache.getInternalModel(identifier))) {
+        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.`,
+            false,
+            {
+              id: 'ember-data:rsvp-unresolved-async',
+              until: '5.0',
+              for: '@ember-data/store',
+              since: {
+                available: '4.5',
+                enabled: '4.5',
+              },
+            }
+          );
+        }
+      }
+
+      let serializer = store.serializerFor(relationship.type);
+      let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');
+
+      assert(
+        `fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: null }`,
+        'data' in payload &&
+          (payload.data === null || (typeof payload.data === 'object' && !Array.isArray(payload.data)))
+      );
+
+      if (!payload.data && !payload.links && !payload.meta) {
+        return null;
+      }
+
+      payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+
+      return store._push(payload);
+    },
+    null,
+    `DS: Extract payload of ${identifier.type} : ${relationship.type}`
+  );
+
+  if (DEPRECATE_RSVP_PROMISE) {
+    promise = _guard(promise, _bind(_objectIsAlive, store._instanceCache.getInternalModel(identifier)));
+  }
+
+  return promise;
+}
+
+// sync
+// iterate over records in payload.data
+// for each record
+//   assert that record.relationships[inverse] is either undefined (so we can fix it)
+//     or provide a data: {id, type} that matches the record that requested it
+//   return the relationship data for the parent
+function syncRelationshipDataFromLink(store, payload, parentIdentifier, relationship) {
+  // ensure the right hand side (incoming payload) points to the parent record that
+  // requested this relationship
+  let relationshipData = payload.data
+    ? iterateData(payload.data, (data, index) => {
+        const { id, type } = data;
+        ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);
+        return { id, type };
+      })
+    : null;
+
+  const relatedDataHash = {};
+
+  if ('meta' in payload) {
+    relatedDataHash.meta = payload.meta;
+  }
+  if ('links' in payload) {
+    relatedDataHash.links = payload.links;
+  }
+  if ('data' in payload) {
+    relatedDataHash.data = relationshipData;
+  }
+
+  // now, push the left hand side (the parent record) to ensure things are in sync, since
+  // the payload will be pushed with store._push
+  const parentPayload = {
+    id: parentIdentifier.id,
+    type: parentIdentifier.type,
+    relationships: {
+      [relationship.key]: relatedDataHash,
+    },
+  };
+
+  if (!Array.isArray(payload.included)) {
+    payload.included = [];
+  }
+  payload.included.push(parentPayload);
+
+  return payload;
+}
+
+function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
+  let { id, type } = payload;
+
+  if (!payload.relationships) {
+    payload.relationships = {};
+  }
+  let { relationships } = payload;
+
+  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+  if (inverse) {
+    let { inverseKey, kind } = inverse;
+
+    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
+
+    if (
+      DEBUG &&
+      typeof relationshipData !== 'undefined' &&
+      !relationshipDataPointsToParent(relationshipData, parentIdentifier)
+    ) {
+      let inspect = function inspect(thing) {
+        return `'${JSON.stringify(thing)}'`;
+      };
+      let quotedType = inspect(type);
+      let quotedInverse = inspect(inverseKey);
+      let expected = inspect({
+        id: parentIdentifier.id,
+        type: parentIdentifier.type,
+      });
+      let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
+      let got = inspect(relationshipData);
+      let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
+      let path = `${prefix}.relationships.${inverseKey}.data`;
+      let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
+      let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
+      let includedRecord = `<${type}:${id}>`;
+      let message = [
+        `Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`,
+        `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`,
+        `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`,
+        `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`,
+        `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`,
+      ].join('\n');
+
+      assert(message);
+    }
+
+    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
+      relationships[inverseKey] = relationships[inverseKey] || {};
+      relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentIdentifier);
+    }
+  }
+}
+
+function getInverse(store, parentInternalModel, parentRelationship, type) {
+  return recordDataFindInverseRelationshipInfo(store, parentInternalModel, parentRelationship, type);
+}
+
+function recordDataFindInverseRelationshipInfo(store, parentIdentifier, parentRelationship, type) {
+  let { name: lhs_relationshipName } = parentRelationship;
+  let { type: parentType } = parentIdentifier;
+  let inverseKey = store._instanceCache._storeWrapper.inverseForRelationship(parentType, lhs_relationshipName);
+
+  if (inverseKey) {
+    let {
+      meta: { kind },
+    } = store._instanceCache._storeWrapper.relationshipsDefinitionFor(type)[inverseKey];
+    return {
+      inverseKey,
+      kind,
+    };
+  }
+}
+
+function relationshipDataPointsToParent(relationshipData, identifier) {
+  if (relationshipData === null) {
+    return false;
+  }
+
+  if (Array.isArray(relationshipData)) {
+    if (relationshipData.length === 0) {
+      return false;
+    }
+    for (let i = 0; i < relationshipData.length; i++) {
+      let entry = relationshipData[i];
+      if (validateRelationshipEntry(entry, identifier)) {
+        return true;
+      }
+    }
+  } else {
+    return validateRelationshipEntry(relationshipData, identifier);
+  }
+
+  return false;
+}
+
+function fixRelationshipData(relationshipData, relationshipKind, { id, type }) {
+  let parentRelationshipData = {
+    id,
+    type,
+  };
+
+  let payload;
+
+  if (relationshipKind === 'hasMany') {
+    payload = relationshipData || [];
+    if (relationshipData) {
+      // these arrays could be massive so this is better than filter
+      // Note: this is potentially problematic if type/id are not in the
+      // same state of normalization.
+      let found = relationshipData.find((v) => {
+        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
+      });
+      if (!found) {
+        payload.push(parentRelationshipData);
+      }
+    } else {
+      payload.push(parentRelationshipData);
+    }
+  } else {
+    payload = relationshipData || {};
+    Object.assign(payload, parentRelationshipData);
+  }
+
+  return payload;
+}
+
+function validateRelationshipEntry({ id }, { id: parentModelID }) {
+  return id && id.toString() === parentModelID;
+}
+
+function _bind(fn, ...args) {
+  return function () {
+    return fn.apply(undefined, args);
+  };
+}
+
+function _guard(promise, test) {
+  let guarded = promise.finally(() => {
+    if (!test()) {
+      guarded._subscribers.length = 0;
+    }
+  });
+
+  return guarded;
+}
+
+function _objectIsAlive(object) {
+  return !(object.isDestroyed || object.isDestroying);
+}
+
+function payloadIsNotBlank(adapterPayload) {
+  if (Array.isArray(adapterPayload)) {
+    return true;
+  } else {
+    return Object.keys(adapterPayload || {}).length;
+  }
+}
+
+function guardDestroyedStore(promise, store, label) {
+  let token;
+  if (DEBUG) {
+    token = store._trackAsyncRequestStart(label);
+  }
+  let wrapperPromise = resolve(promise, label).then((_v) => {
+    if (!_objectIsAlive(store)) {
+      if (DEPRECATE_RSVP_PROMISE) {
+        deprecate(
+          `A Promise did not resolve by the time the store was destroyed. This will error in a future release.`,
+          false,
+          {
+            id: 'ember-data:rsvp-unresolved-async',
+            until: '5.0',
+            for: '@ember-data/store',
+            since: {
+              available: '4.5',
+              enabled: '4.5',
+            },
+          }
+        );
+      }
+    }
+
+    return promise;
+  });
+
+  return _guard(wrapperPromise, () => {
+    if (DEBUG) {
+      store._trackAsyncRequestEnd(token);
+    }
+    return _objectIsAlive(store);
+  });
+}