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

package/addon/-private/{system/many-array.ts → many-array.ts}

@@ -8,18 +8,20 @@ import EmberObject, { get } from '@ember/object';
 
 import { all } from 'rsvp';
 
-import type { RelationshipRecordData } from '@ember-data/record-data/-private/ts-interfaces/relationship-record-data';
-import type { InternalModel } from '@ember-data/store/-private';
+import type Store from '@ember-data/store';
 import { PromiseArray, recordDataFor } from '@ember-data/store/-private';
-import type CoreStore from '@ember-data/store/-private/system/core-store';
-import type { CreateRecordProperties } from '@ember-data/store/-private/system/core-store';
-import ShimModelClass from '@ember-data/store/-private/system/model/shim-model-class';
-import type { DSModelSchema } from '@ember-data/store/-private/ts-interfaces/ds-model';
-import type { Links, PaginationLinks } from '@ember-data/store/-private/ts-interfaces/ember-data-json-api';
-import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
-import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
+import type { CreateRecordProperties } from '@ember-data/store/-private/core-store';
+import type ShimModelClass from '@ember-data/store/-private/model/shim-model-class';
+import type { DSModelSchema } from '@ember-data/types/q/ds-model';
+import type { Links, PaginationLinks } from '@ember-data/types/q/ember-data-json-api';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
+import type { RelationshipRecordData } from '@ember-data/types/q/relationship-record-data';
+import type { FindOptions } from '@ember-data/types/q/store';
+import type { Dict } from '@ember-data/types/q/utils';
 
 import diffArray from './diff-array';
+import { LegacySupport } from './legacy-relationships-support';
 
 interface MutableArrayWithObject<T, M = T> extends EmberObject, MutableArray<M> {}
 const MutableArrayWithObject = EmberObject.extend(MutableArray) as unknown as new <
@@ -28,14 +30,14 @@ const MutableArrayWithObject = EmberObject.extend(MutableArray) as unknown as ne
 >() => MutableArrayWithObject<T, M>;
 
 export interface ManyArrayCreateArgs {
-  store: CoreStore;
+  store: Store;
   type: ShimModelClass;
   recordData: RelationshipRecordData;
   key: string;
   isPolymorphic: boolean;
   isAsync: boolean;
   _inverseIsAsync: boolean;
-  internalModel: InternalModel;
+  legacySupport: LegacySupport;
   isLoaded: boolean;
 }
 /**
@@ -83,7 +85,7 @@ export interface ManyArrayCreateArgs {
   @extends Ember.EmberObject
   @uses Ember.MutableArray
 */
-export default class ManyArray extends MutableArrayWithObject<InternalModel, RecordInstance> {
+export default class ManyArray extends MutableArrayWithObject<StableRecordIdentifier, RecordInstance> {
   declare isAsync: boolean;
   declare isLoaded: boolean;
   declare isPolymorphic: boolean;
@@ -95,10 +97,10 @@ export default class ManyArray extends MutableArrayWithObject<InternalModel, Rec
   declare _length: number;
   declare _meta: Dict<unknown> | null;
   declare _links: Links | PaginationLinks | null;
-  declare currentState: InternalModel[];
+  declare currentState: StableRecordIdentifier[];
   declare recordData: RelationshipRecordData;
-  declare internalModel: InternalModel;
-  declare store: CoreStore;
+  declare legacySupport: LegacySupport;
+  declare store: Store;
   declare key: string;
   declare type: DSModelSchema;
 
@@ -260,23 +262,25 @@ export default class ManyArray extends MutableArrayWithObject<InternalModel, Rec
     if (this._isDirty) {
       this.retrieveLatest();
     }
-    let internalModel = this.currentState[index];
-    if (internalModel === undefined) {
+    let identifier = this.currentState[index];
+    if (identifier === undefined) {
       return;
     }
 
-    return internalModel.getRecord();
+    return this.store._instanceCache.getRecord(identifier);
   }
 
   replace(idx: number, amt: number, objects?: RecordInstance[]) {
     assert(`Cannot push mutations to the cache while updating the relationship from cache`, !this._isUpdating);
-    this.store._backburner.join(() => {
-      let internalModels: InternalModel[];
+    const { store } = this;
+    store._backburner.join(() => {
+      let identifiers: StableRecordIdentifier[];
       if (amt > 0) {
-        internalModels = this.currentState.slice(idx, idx + amt);
+        identifiers = this.currentState.slice(idx, idx + amt);
         this.recordData.removeFromHasMany(
           this.key,
-          internalModels.map((im) => recordDataFor(im))
+          // TODO RecordData V2: recordData should take identifiers not RecordDatas
+          identifiers.map((identifier) => store._instanceCache.getRecordData(identifier))
         );
       }
       if (objects) {
@@ -303,14 +307,15 @@ export default class ManyArray extends MutableArrayWithObject<InternalModel, Rec
     this._isUpdating = true;
     let jsonApi = this.recordData.getHasMany(this.key);
 
-    let internalModels: InternalModel[] = [];
+    let identifiers: StableRecordIdentifier[] = [];
     if (jsonApi.data) {
       for (let i = 0; i < jsonApi.data.length; i++) {
-        let im = this.store._internalModelForResource(jsonApi.data[i]);
-        let shouldRemove = im._isDematerializing || im.currentState.isEmpty || !im.currentState.isLoaded;
+        // TODO figure out where this state comes from
+        let im = this.store._instanceCache._internalModelForResource(jsonApi.data[i]);
+        let shouldRemove = im._isDematerializing || im.isEmpty || !im.isLoaded;
 
         if (!shouldRemove) {
-          internalModels.push(im);
+          identifiers.push(im.identifier);
         }
       }
     }
@@ -325,19 +330,19 @@ export default class ManyArray extends MutableArrayWithObject<InternalModel, Rec
 
     if (this._hasArrayObservers && !this._hasNotified) {
       // diff to find changes
-      let diff = diffArray(this.currentState, internalModels);
+      let diff = diffArray(this.currentState, identifiers);
       // it's null if no change found
       if (diff.firstChangeIndex !== null) {
         // we found a change
         this.arrayContentWillChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);
-        this._length = internalModels.length;
-        this.currentState = internalModels;
+        this._length = identifiers.length;
+        this.currentState = identifiers;
         this.arrayContentDidChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);
       }
     } else {
       this._hasNotified = false;
-      this._length = internalModels.length;
-      this.currentState = internalModels;
+      this._length = identifiers.length;
+      this.currentState = identifiers;
     }
 
     this._isUpdating = false;
@@ -365,9 +370,9 @@ export default class ManyArray extends MutableArrayWithObject<InternalModel, Rec
     @method reload
     @public
   */
-  reload(options) {
+  reload(options?: FindOptions) {
     // TODO this is odd, we don't ask the store for anything else like this?
-    return this.internalModel.reloadHasMany(this.key, options);
+    return this.legacySupport.reloadHasMany(this.key, options);
   }
 
   /**

package/addon/-private/{system/model-for-mixin.ts → model-for-mixin.ts}

@@ -2,9 +2,9 @@ import { getOwner } from '@ember/application';
 
 import type Store from '@ember-data/store';
 
-import Model from '../model';
+import Model from './model';
 
-/* 
+/*
     In case someone defined a relationship to a mixin, for example:
     ```
       import Model, { belongsTo, hasMany } from '@ember-data/model';
@@ -24,7 +24,7 @@ import Model from '../model';
     in this case
   */
 export default function modelForMixin(store: Store, normalizedModelName: string): Model | null {
-  let owner = getOwner(store);
+  let owner: any = getOwner(store);
   let MaybeMixin = owner.factoryFor(`mixin:${normalizedModelName}`);
   let mixin = MaybeMixin && MaybeMixin.class;
   if (mixin) {

package/addon/-private/model.js

@@ -7,28 +7,45 @@ import EmberError from '@ember/error';
 import EmberObject, { get } from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
+import { inject as service } from '@ember/service';
 import { isNone } from '@ember/utils';
 import { DEBUG } from '@glimmer/env';
 import { tracked } from '@glimmer/tracking';
 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,
-  PromiseObject,
   recordDataFor,
+  WeakCache,
 } from '@ember-data/store/-private';
 
 import Errors from './errors';
+import { LegacySupport } from './legacy-relationships-support';
+import notifyChanges from './notify-changes';
 import RecordState, { peekTag, tagged } from './record-state';
-import { relationshipFromMeta } from './system/relationships/relationship-meta';
+import { relationshipFromMeta } from './relationship-meta';
 
 const { changeProperties } = Ember;
+export const LEGACY_SUPPORT = new WeakCache(DEBUG ? 'legacy-relationships' : '');
+LEGACY_SUPPORT._generator = (record) => {
+  const identifier = recordIdentifierFor(record);
+  let support = LEGACY_SUPPORT.get(identifier);
+
+  if (!support) {
+    support = new LegacySupport(record);
+    LEGACY_SUPPORT.set(identifier, support);
+  }
 
+  return support;
+};
 function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
   let possibleRelationships = relationshipsSoFar || [];
 
@@ -104,21 +121,38 @@ function computeOnce(target, key, desc) {
   @extends Ember.EmberObject
 */
 class Model extends EmberObject {
+  @service store;
+
   init(options = {}) {
+    if (DEBUG && !options._secretInit && !options._internalModel && !options._createProps) {
+      throw new EmberError(
+        'You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.'
+      );
+    }
     const createProps = options._createProps;
+    const _secretInit = options._secretInit;
     delete options._createProps;
+    delete options._secretInit;
     super.init(options);
 
-    if (DEBUG) {
-      if (!this._internalModel) {
-        throw new EmberError(
-          'You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.'
-        );
-      }
-    }
+    _secretInit(this);
+    this.___recordState = DEBUG ? new RecordState(this) : null;
 
-    this.___recordState = new RecordState(this);
     this.setProperties(createProps);
+
+    // TODO  pass something in such that we don't need internalModel
+    // to get this info
+    let store = storeFor(this);
+    let notifications = store._notificationManager;
+    let identity = recordIdentifierFor(this);
+
+    notifications.subscribe(identity, (identifier, type, key) => {
+      notifyChanges(identifier, type, key, this, store);
+    });
+  }
+
+  willDestroy() {
+    LEGACY_SUPPORT.get(this)?.destroy();
   }
 
   /**
@@ -389,9 +423,9 @@ class Model extends EmberObject {
     Example
 
     ```javascript
-    record.get('isReloading'); // false
+    record.isReloading; // false
     record.reload();
-    record.get('isReloading'); // true
+    record.isReloading; // true
     ```
 
     @property isReloading
@@ -446,8 +480,17 @@ class Model extends EmberObject {
     @private
     @type {Object}
   */
+  // TODO we can probably make this a computeOnce
+  // we likely do not need to notify the currentState root anymore
   @tagged
   get currentState() {
+    // descriptors are called with the wrong `this` context during mergeMixins
+    // when using legacy/classic ember classes. Basically: lazy in prod and eager in dev.
+    // so we do this to try to steer folks to the nicer "dont user currentState"
+    // error.
+    if (!DEBUG && !this.___recordState) {
+      this.___recordState = new RecordState(this);
+    }
     return this.___recordState;
   }
   set currentState(_v) {
@@ -521,16 +564,7 @@ class Model extends EmberObject {
   */
   @computeOnce
   get errors() {
-    let errors = Errors.create();
-
-    errors._registerHandlers(
-      () => {
-        this._internalModel.send('becameInvalid');
-      },
-      () => {
-        this._internalModel.send('becameValid');
-      }
-    );
+    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
@@ -543,7 +577,7 @@ class Model extends EmberObject {
         let errorKeys = Object.keys(errorsHash);
 
         for (let i = 0; i < errorKeys.length; i++) {
-          errors._add(errorKeys[i], errorsHash[errorKeys[i]]);
+          errors.add(errorKeys[i], errorsHash[errorKeys[i]]);
         }
       }
     }
@@ -582,7 +616,7 @@ class Model extends EmberObject {
     @return {Object} an object whose values are primitive JSON values only
   */
   serialize(options) {
-    return this._internalModel.createSnapshot().serialize(options);
+    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this)).serialize(options);
   }
 
   /*
@@ -635,7 +669,10 @@ class Model extends EmberObject {
     @public
   */
   deleteRecord() {
-    this.store.deleteRecord(this);
+    // ensure we've populated currentState prior to deleting a new record
+    if (this.currentState) {
+      storeFor(this).deleteRecord(this);
+    }
   }
 
   /**
@@ -684,7 +721,11 @@ class Model extends EmberObject {
     successfully or rejected if the adapter returns with an error.
   */
   destroyRecord(options) {
+    const { isNew } = this.currentState;
     this.deleteRecord();
+    if (isNew) {
+      return resolve(this);
+    }
     return this.save(options).then((_) => {
       run(() => {
         this.unloadRecord();
@@ -701,10 +742,10 @@ class Model extends EmberObject {
     @public
   */
   unloadRecord() {
-    if (this.isDestroyed) {
+    if (this.currentState.isNew && (this.isDestroyed || this.isDestroying)) {
       return;
     }
-    this.store.unloadRecord(this);
+    storeFor(this).unloadRecord(this);
   }
 
   /**
@@ -793,16 +834,18 @@ class Model extends EmberObject {
     @public
   */
   rollbackAttributes() {
+    const { currentState } = this;
     this._internalModel.rollbackAttributes();
-    this.currentState.cleanErrorRequests();
+    currentState.cleanErrorRequests();
   }
 
   /**
     @method _createSnapshot
     @private
   */
+  // TODO @deprecate in favor of a public API or examples of how to test successfully
   _createSnapshot() {
-    return this._internalModel.createSnapshot();
+    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this));
   }
 
   toStringExtension() {
@@ -854,9 +897,16 @@ class Model extends EmberObject {
     successfully or rejected if the adapter returns with an error.
   */
   save(options) {
-    const promise = this._internalModel.save(options).then(() => this);
+    let promise;
+
+    if (this.currentState.isNew && this.currentState.isDeleted) {
+      promise = resolve(this);
+    } else {
+      promise = storeFor(this).saveRecord(this, options);
+    }
+
     if (DEPRECATE_SAVE_PROMISE_ACCESS) {
-      return deprecatedPromiseObject(PromiseObject.create({ promise }));
+      return deprecatedPromiseObject(promise);
     }
 
     return promise;
@@ -891,24 +941,28 @@ class Model extends EmberObject {
     adapter returns successfully or rejected if the adapter returns
     with an error.
   */
-  reload(options) {
-    let wrappedAdapterOptions;
+  reload(_options) {
+    let options = {};
 
-    if (typeof options === 'object' && options !== null && options.adapterOptions) {
-      wrappedAdapterOptions = {
-        adapterOptions: options.adapterOptions,
-      };
+    if (typeof _options === 'object' && _options !== null && _options.adapterOptions) {
+      options.adapterOptions = _options.adapterOptions;
     }
 
+    options.isReloading = true;
+    let identifier = recordIdentifierFor(this);
+    assert(`You cannot reload a record without an ID`, identifier.id);
     this.isReloading = true;
-    return PromiseObject.create({
-      promise: this._internalModel
-        .reload(wrappedAdapterOptions)
-        .then(() => this)
-        .finally(() => {
-          this.isReloading = false;
-        }),
-    });
+    const promise = storeFor(this)
+      ._fetchManager.scheduleFetch(identifier, options)
+      .then(() => this)
+      .finally(() => {
+        this.isReloading = false;
+      });
+
+    if (DEPRECATE_SAVE_PROMISE_ACCESS) {
+      return deprecatedPromiseObject(promise);
+    }
+    return promise;
   }
 
   attr() {
@@ -983,7 +1037,7 @@ class Model extends EmberObject {
     @return {BelongsToReference} reference for this relationship
   */
   belongsTo(name) {
-    return this._internalModel.referenceFor('belongsTo', name);
+    return LEGACY_SUPPORT.lookup(this).referenceFor('belongsTo', name);
   }
 
   /**
@@ -1046,7 +1100,7 @@ class Model extends EmberObject {
     @return {HasManyReference} reference for this relationship
   */
   hasMany(name) {
-    return this._internalModel.referenceFor('hasMany', name);
+    return LEGACY_SUPPORT.lookup(this).referenceFor('hasMany', name);
   }
 
   /**
@@ -1111,7 +1165,7 @@ class Model extends EmberObject {
   }
 
   inverseFor(key) {
-    return this.constructor.inverseFor(key, this._internalModel.store);
+    return this.constructor.inverseFor(key, storeFor(this));
   }
 
   eachAttribute(callback, binding) {
@@ -1938,8 +1992,8 @@ class Model extends EmberObject {
 // this is required to prevent `init` from passing
 // the values initialized during create to `setUnknownProperty`
 Model.prototype._internalModel = null;
-Model.prototype.store = null;
 Model.prototype._createProps = null;
+Model.prototype._secretInit = null;
 
 if (HAS_DEBUG_PACKAGE) {
   /**
@@ -2040,7 +2094,7 @@ if (DEBUG) {
 
       let ourDescriptor = lookupDescriptor(Model.prototype, 'currentState');
       let theirDescriptor = lookupDescriptor(this, 'currentState');
-      let realState = this.___recordState || this._internalModel.currentState;
+      let realState = this.___recordState;
       if (ourDescriptor.get !== theirDescriptor.get || realState !== this.currentState) {
         throw new Error(
           `'currentState' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`

package/addon/-private/notify-changes.ts

@@ -1,17 +1,18 @@
 import { cacheFor } from '@ember/object/internals';
 
-import type CoreStore from '@ember-data/store/-private/system/core-store';
-import type { NotificationType } from '@ember-data/store/-private/system/record-notification-manager';
-import type { StableRecordIdentifier } from '@ember-data/store/-private/ts-interfaces/identifier';
+import type Store from '@ember-data/store';
+import type { NotificationType } from '@ember-data/store/-private/record-notification-manager';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
-type Model = InstanceType<typeof import('@ember-data/model').default>;
+import type Model from './model';
+import { LEGACY_SUPPORT } from './model';
 
 export default function notifyChanges(
   identifier: StableRecordIdentifier,
   value: NotificationType,
   key: string | undefined,
   record: Model,
-  store: CoreStore
+  store: Store
 ) {
   if (value === 'attributes') {
     if (key) {
@@ -24,10 +25,10 @@ export default function notifyChanges(
   } else if (value === 'relationships') {
     if (key) {
       let meta = record.constructor.relationshipsByName.get(key);
-      notifyRelationship(store, identifier, key, record, meta);
+      notifyRelationship(identifier, key, record, meta);
     } else {
       record.eachRelationship((key, meta) => {
-        notifyRelationship(store, identifier, key, record, meta);
+        notifyRelationship(identifier, key, record, meta);
       });
     }
   } else if (value === 'identity') {
@@ -35,12 +36,19 @@ export default function notifyChanges(
   }
 }
 
-function notifyRelationship(store: CoreStore, identifier: StableRecordIdentifier, key: string, record: Model, meta) {
-  let internalModel = store._internalModelForResource(identifier);
+function notifyRelationship(identifier: StableRecordIdentifier, key: string, record: Model, meta) {
   if (meta.kind === 'belongsTo') {
     record.notifyPropertyChange(key);
   } else if (meta.kind === 'hasMany') {
-    let manyArray = internalModel._manyArrayCache[key];
+    let support = LEGACY_SUPPORT.get(identifier);
+    let manyArray = support && support._manyArrayCache[key];
+    let hasPromise = support && support._relationshipPromisesCache[key];
+
+    if (manyArray && hasPromise) {
+      // do nothing, we will notify the ManyArray directly
+      // once the fetch has completed.
+      return;
+    }
 
     if (manyArray) {
       manyArray.notify();
@@ -55,10 +63,10 @@ function notifyRelationship(store: CoreStore, identifier: StableRecordIdentifier
   }
 }
 
-function notifyAttribute(store: CoreStore, identifier: StableRecordIdentifier, key: string, record: Model) {
+function notifyAttribute(store: Store, identifier: StableRecordIdentifier, key: string, record: Model) {
   let currentValue = cacheFor(record, key);
-  let internalModel = store._internalModelForResource(identifier);
-  if (currentValue !== internalModel._recordData.getAttr(key)) {
+
+  if (currentValue !== store._instanceCache.getRecordData(identifier).getAttr(key)) {
     record.notifyPropertyChange(key);
   }
 }

package/addon/-private/{system/promise-belongs-to.ts → promise-belongs-to.ts}

@@ -3,16 +3,17 @@ import { computed } from '@ember/object';
 import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import type ObjectProxy from '@ember/object/proxy';
 
-import type { InternalModel } from '@ember-data/store/-private';
+import type Store from '@ember-data/store';
 import { PromiseObject } from '@ember-data/store/-private';
-import type CoreStore from '@ember-data/store/-private/system/core-store';
-import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
-import type { Dict } from '@ember-data/store/-private/ts-interfaces/utils';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
+import type { Dict } from '@ember-data/types/q/utils';
+
+import { LegacySupport } from './legacy-relationships-support';
 
 export interface BelongsToProxyMeta {
   key: string;
-  store: CoreStore;
-  originatingInternalModel: InternalModel;
+  store: Store;
+  legacySupport: LegacySupport;
   modelName: string;
 }
 export interface BelongsToProxyCreateArgs {
@@ -63,8 +64,8 @@ class PromiseBelongsTo extends Extended<RecordInstance> {
 
   async reload(options: Dict<unknown>): Promise<this> {
     assert('You are trying to reload an async belongsTo before it has been created', this.content !== undefined);
-    let { key, store, originatingInternalModel } = this._belongsToState;
-    await store.reloadBelongsTo(this, originatingInternalModel, key, options);
+    let { key, legacySupport } = this._belongsToState;
+    await legacySupport.reloadBelongsTo(key, options);
     return this;
   }
 }

package/addon/-private/{system/promise-many-array.ts → promise-many-array.ts}

@@ -1,4 +1,4 @@
-import ArrayMixin from '@ember/array';
+import ArrayMixin, { NativeArray } from '@ember/array';
 import type ArrayProxy from '@ember/array/proxy';
 import { assert } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
@@ -10,7 +10,7 @@ import { resolve } from 'rsvp';
 import type { ManyArray } from 'ember-data/-private';
 
 import type { InternalModel } from '@ember-data/store/-private';
-import type { RecordInstance } from '@ember-data/store/-private/ts-interfaces/record-instance';
+import type { RecordInstance } from '@ember-data/types/q/record-instance';
 
 export interface HasManyProxyCreateArgs {
   promise: Promise<ManyArray>;
@@ -55,7 +55,7 @@ export default class PromiseManyArray {
 
     const meta = Ember.meta(this);
     meta.hasMixin = (mixin: Object) => {
-      if (mixin === ArrayMixin) {
+      if (mixin === NativeArray || mixin === ArrayMixin) {
         return true;
       }
       return false;