@ember-data/store 4.2.0-alpha.8 → 4.2.0

package/addon/-private/system/model/internal-model.ts

@@ -1,12 +1,20 @@
+import { getOwner, setOwner } from '@ember/application';
 import { A, default as EmberArray } from '@ember/array';
 import { assert, inspect } from '@ember/debug';
 import EmberError from '@ember/error';
-import { get } from '@ember/object';
+import { get, set } from '@ember/object';
 import { _backburner as emberBackburner, cancel, run } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
 import RSVP, { Promise } from 'rsvp';
 
+import {
+  CUSTOM_MODEL_CLASS,
+  RECORD_DATA_ERRORS,
+  RECORD_DATA_STATE,
+  REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT,
+  REQUEST_SERVICE,
+} from '@ember-data/canary-features';
 import { HAS_MODEL_PACKAGE, HAS_RECORD_DATA_PACKAGE } from '@ember-data/private-build-infra';
 import type {
   BelongsToRelationship,
@@ -23,13 +31,15 @@ import type { JsonApiResource, JsonApiValidationError } from '../../ts-interface
 import type { RecordInstance } from '../../ts-interfaces/record-instance';
 import type { FindOptions } from '../../ts-interfaces/store';
 import type { ConfidentDict } from '../../ts-interfaces/utils';
+import coerceId from '../coerce-id';
 import type CoreStore from '../core-store';
 import type Store from '../ds-model-store';
 import { errorsHashToArray } from '../errors-utils';
+import { recordArraysForIdentifier } from '../record-array-manager';
 import recordDataFor from '../record-data-for';
 import { BelongsToReference, HasManyReference, RecordReference } from '../references';
 import Snapshot from '../snapshot';
-import { internalModelFactoryFor } from '../store/internal-model-factory';
+import { internalModelFactoryFor, setRecordIdentifier } from '../store/internal-model-factory';
 import RootState from './states';
 
 // move to TS hacks module that we can delete when this is no longer a necessary recast
@@ -62,6 +72,11 @@ if (HAS_MODEL_PACKAGE) {
   };
 }
 
+// TODO this should be integrated with the code removal so we can use it together with the if condition
+// and not alongside it
+function isNotCustomModelClass(store: CoreStore | Store): store is Store {
+  return !CUSTOM_MODEL_CLASS;
+}
 interface BelongsToMetaWrapper {
   key: string;
   store: CoreStore;
@@ -218,40 +233,60 @@ export default class InternalModel {
       return true;
     }
 
-    if (this.currentState.isLoading) {
-      return false;
+    if (RECORD_DATA_STATE) {
+      if (this.currentState.isLoading) {
+        return false;
+      }
     }
 
-    let isRecordFullyDeleted = this._isRecordFullyDeleted();
+    let isRecordFullyDeleted;
+    if (RECORD_DATA_STATE) {
+      isRecordFullyDeleted = this._isRecordFullyDeleted();
+    } else {
+      isRecordFullyDeleted = this.currentState.stateName === 'root.deleted.saved';
+    }
     return this._isDematerializing || this.hasScheduledDestroy() || this.isDestroyed || isRecordFullyDeleted;
   }
 
   _isRecordFullyDeleted(): boolean {
-    if (this._recordData.isDeletionCommitted && this._recordData.isDeletionCommitted()) {
-      return true;
-    } else if (
-      this._recordData.isNew &&
-      this._recordData.isDeleted &&
-      this._recordData.isNew() &&
-      this._recordData.isDeleted()
-    ) {
-      return true;
+    if (RECORD_DATA_STATE) {
+      if (this._recordData.isDeletionCommitted && this._recordData.isDeletionCommitted()) {
+        return true;
+      } else if (
+        this._recordData.isNew &&
+        this._recordData.isDeleted &&
+        this._recordData.isNew() &&
+        this._recordData.isDeleted()
+      ) {
+        return true;
+      } else {
+        return this.currentState.stateName === 'root.deleted.saved';
+      }
     } else {
-      return this.currentState.stateName === 'root.deleted.saved';
+      // assert here
+      return false;
     }
   }
 
   isDeleted() {
-    if (this._recordData.isDeleted) {
-      return this._recordData.isDeleted();
+    if (RECORD_DATA_STATE) {
+      if (this._recordData.isDeleted) {
+        return this._recordData.isDeleted();
+      } else {
+        return this.currentState.isDeleted;
+      }
     } else {
       return this.currentState.isDeleted;
     }
   }
 
   isNew() {
-    if (this._recordData.isNew) {
-      return this._recordData.isNew();
+    if (RECORD_DATA_STATE) {
+      if (this._recordData.isNew) {
+        return this._recordData.isNew();
+      } else {
+        return this.currentState.isNew;
+      }
     } else {
       return this.currentState.isNew;
     }
@@ -261,7 +296,73 @@ export default class InternalModel {
     if (!this._record && !this._isDematerializing) {
       let { store } = this;
 
-      this._record = store._instantiateRecord(this, this.modelName, this._recordData, this.identifier, properties);
+      if (CUSTOM_MODEL_CLASS) {
+        this._record = store._instantiateRecord(this, this.modelName, this._recordData, this.identifier, properties);
+      } else {
+        if (isNotCustomModelClass(store)) {
+          // lookupFactory should really return an object that creates
+          // instances with the injections applied
+          let createOptions: any = {
+            store,
+            _internalModel: this,
+          };
+
+          if (!REQUEST_SERVICE) {
+            createOptions.isError = this.isError;
+            createOptions.adapterError = this.error;
+          }
+
+          if (properties !== undefined) {
+            assert(
+              `You passed '${properties}' as properties for record creation instead of an object.`,
+              typeof properties === 'object' && properties !== null
+            );
+
+            if ('id' in properties) {
+              const id = coerceId(properties.id);
+
+              if (id !== null) {
+                this.setId(id);
+              }
+            }
+
+            // convert relationship Records to RecordDatas before passing to RecordData
+            let defs = store._relationshipsDefinitionFor(this.modelName);
+
+            if (defs !== null) {
+              let keys = Object.keys(properties);
+              let relationshipValue;
+
+              for (let i = 0; i < keys.length; i++) {
+                let prop = keys[i];
+                let def = defs[prop];
+
+                if (def !== undefined) {
+                  if (def.kind === 'hasMany') {
+                    if (DEBUG) {
+                      assertRecordsPassedToHasMany(properties[prop]);
+                    }
+                    relationshipValue = extractRecordDatasFromRecords(properties[prop]);
+                  } else {
+                    relationshipValue = extractRecordDataFromRecord(properties[prop]);
+                  }
+
+                  properties[prop] = relationshipValue;
+                }
+              }
+            }
+          }
+
+          let additionalCreateOptions = this._recordData._initRecordCreateOptions(properties);
+          Object.assign(createOptions, additionalCreateOptions);
+
+          // ensure that `getOwner(this)` works inside a model instance
+          setOwner(createOptions, getOwner(store));
+
+          this._record = store._modelFactoryFor(this.modelName).create(createOptions);
+          setRecordIdentifier(this._record, this.identifier);
+        }
+      }
       this._triggerDeferredTriggers();
     }
 
@@ -276,8 +377,15 @@ export default class InternalModel {
     this._doNotDestroy = false;
     // this has to occur before the internal model is removed
     // for legacy compat.
+    if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
+      this.store.recordArrayManager.recordDidChange(this.identifier);
+    }
     if (this._record) {
-      this.store.teardownRecord(this._record);
+      if (CUSTOM_MODEL_CLASS) {
+        this.store.teardownRecord(this._record);
+      } else {
+        this._record.destroy();
+      }
     }
 
     // move to an empty never-loaded state
@@ -301,15 +409,19 @@ export default class InternalModel {
     this.error = null;
     this._previousState = this.currentState;
     this.currentState = RootState.empty;
-    this.store.recordArrayManager.recordDidChange(this.identifier);
+    if (REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
+      this.store.recordArrayManager.recordDidChange(this.identifier);
+    }
   }
 
   deleteRecord() {
     run(() => {
       const backburner = this.store._backburner;
       backburner.run(() => {
-        if (this._recordData.setIsDeleted) {
-          this._recordData.setIsDeleted(true);
+        if (RECORD_DATA_STATE) {
+          if (this._recordData.setIsDeleted) {
+            this._recordData.setIsDeleted(true);
+          }
         }
 
         if (this.isNew()) {
@@ -332,26 +444,50 @@ export default class InternalModel {
     let promiseLabel = 'DS: Model#save ' + this;
     let resolver = RSVP.defer<void>(promiseLabel);
 
-    // Casting to promise to narrow due to the feature flag paths inside scheduleSave
-    return this.store.scheduleSave(this, resolver, options) as Promise<void>;
+    if (REQUEST_SERVICE) {
+      // Casting to promise to narrow due to the feature flag paths inside scheduleSave
+      return this.store.scheduleSave(this, resolver, options) as Promise<void>;
+    } else {
+      this.store.scheduleSave(this, resolver, options);
+      return resolver.promise;
+    }
   }
 
   reload(options) {
-    if (!options) {
-      options = {};
-    }
-    let internalModel = this;
-
-    return internalModel.store._reloadRecord(internalModel, options).then(
-      function () {
-        //TODO NOW seems like we shouldn't need to do this
-        return internalModel;
-      },
-      function (error) {
-        throw error;
-      },
-      'DS: Model#reload complete, update flags'
-    );
+    if (REQUEST_SERVICE) {
+      if (!options) {
+        options = {};
+      }
+      let internalModel = this;
+
+      return internalModel.store._reloadRecord(internalModel, options).then(
+        function () {
+          //TODO NOW seems like we shouldn't need to do this
+          return internalModel;
+        },
+        function (error) {
+          throw error;
+        },
+        'DS: Model#reload complete, update flags'
+      );
+    } else {
+      let internalModel = this;
+      let promiseLabel = 'DS: Model#reload of ' + this;
+
+      return new Promise(function (resolve) {
+        internalModel.send('reloadRecord', { resolve, options });
+      }, promiseLabel).then(
+        function () {
+          internalModel.didCleanError();
+          return internalModel;
+        },
+        function (error) {
+          internalModel.didError(error);
+          throw error;
+        },
+        'DS: Model#reload complete, update flags'
+      );
+    }
   }
 
   /*
@@ -439,8 +575,6 @@ export default class InternalModel {
     let identifier =
       resource && resource.data ? identifierCacheFor(this.store).getOrCreateRecordIdentifier(resource.data) : null;
     let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);
-    if (!relationshipMeta) return;
-
     let store = this.store;
     let parentInternalModel = this;
     let async = relationshipMeta.options.async;
@@ -731,17 +865,31 @@ export default class InternalModel {
   }
 
   hasChangedAttributes() {
-    if (!this.__recordData) {
-      // no need to calculate changed attributes when calling `findRecord`
-      return false;
+    if (REQUEST_SERVICE) {
+      if (!this.__recordData) {
+        // no need to calculate changed attributes when calling `findRecord`
+        return false;
+      }
+    } else {
+      if (this.currentState.isLoading) {
+        // no need to calculate changed attributes when calling `findRecord`
+        return false;
+      }
     }
     return this._recordData.hasChangedAttributes();
   }
 
   changedAttributes() {
-    if (!this.__recordData) {
-      // no need to calculate changed attributes when calling `findRecord`
-      return {};
+    if (REQUEST_SERVICE) {
+      if (!this.__recordData) {
+        // no need to calculate changed attributes when calling `findRecord`
+        return {};
+      }
+    } else {
+      if (this.currentState.isLoading) {
+        // no need to calculate changed attributes when calling `findRecord`
+        return {};
+      }
     }
     return this._recordData.changedAttributes();
   }
@@ -776,29 +924,64 @@ export default class InternalModel {
         return;
       }
 
-      this.store._notificationManager.notify(this.identifier, 'relationships', key);
+      if (CUSTOM_MODEL_CLASS) {
+        this.store._notificationManager.notify(this.identifier, 'relationships', key);
+      } else {
+        if (manyArray) {
+          manyArray.notify();
+
+          //We need to notifyPropertyChange in the adding case because we need to make sure
+          //we fetch the newly added record in case it is unloaded
+          //TODO(Igor): Consider whether we could do this only if the record state is unloaded
+          if (manyArray.isAsync) {
+            this._record.notifyPropertyChange(key);
+          }
+        }
+      }
     }
   }
 
   notifyBelongsToChange(key: string) {
     if (this.hasRecord) {
-      this.store._notificationManager.notify(this.identifier, 'relationships', key);
+      if (CUSTOM_MODEL_CLASS) {
+        this.store._notificationManager.notify(this.identifier, 'relationships', key);
+      } else {
+        this._record.notifyPropertyChange(key, this._record);
+      }
     }
   }
 
   notifyPropertyChange(key) {
     if (this.hasRecord) {
-      // TODO this should likely *mostly* be the `attributes` bucket
-      // but it seems for local mutations we rely on computed updating
-      // iteself when set. As we design our own thing we may need to change
-      // that.
-      this.store._notificationManager.notify(this.identifier, 'property', key);
+      if (CUSTOM_MODEL_CLASS) {
+        // TODO this should likely *mostly* be the `attributes` bucket
+        // but it seems for local mutations we rely on computed updating
+        // iteself when set. As we design our own thing we may need to change
+        // that.
+        this.store._notificationManager.notify(this.identifier, 'property', key);
+      } else {
+        if (key === 'currentState') {
+          set(this._record, 'currentState', this.currentState);
+        } else {
+          this._record.notifyPropertyChange(key);
+        }
+      }
     }
   }
 
   notifyStateChange(key?) {
+    assert('Cannot notify state change if Record Data State flag is not on', !!RECORD_DATA_STATE);
     if (this.hasRecord) {
-      this.store._notificationManager.notify(this.identifier, 'state');
+      if (CUSTOM_MODEL_CLASS) {
+        this.store._notificationManager.notify(this.identifier, 'state');
+      } else {
+        if (!key || key === 'isNew') {
+          (this.getRecord() as DSModel).notifyPropertyChange('isNew');
+        }
+        if (!key || key === 'isDeleted') {
+          (this.getRecord() as DSModel).notifyPropertyChange('isDeleted');
+        }
+      }
     }
     if (!key || key === 'isDeletionCommitted') {
       this.store.recordArrayManager.recordDidChange(this.identifier);
@@ -874,13 +1057,17 @@ export default class InternalModel {
     }
 
     this.currentState = state;
-    if (this.hasRecord && typeof this._record.notifyPropertyChange === 'function') {
-      // TODO refactor Model to have all flags pull from the notification manager
-      // and for currentState.stateName to be constructed from flag state.
-      // Probably just port this work from ember-m3
-      // After that we can eliminate this.
-      this.notifyStateChange('currentState');
-      // this._record.notifyPropertyChange('currentState');
+    if (CUSTOM_MODEL_CLASS) {
+      if (this.hasRecord && typeof this._record.notifyPropertyChange === 'function') {
+        // TODO refactor Model to have all flags pull from the notification manager
+        // and for currentState.stateName to be constructed from flag state.
+        // Probably just port this work from ember-m3
+        // After that we can eliminate this.
+        this.notifyStateChange('currentState');
+        // this._record.notifyPropertyChange('currentState');
+      }
+    } else {
+      this.notifyPropertyChange('currentState');
     }
 
     for (i = 0, l = setups.length; i < l; i++) {
@@ -1031,14 +1218,42 @@ export default class InternalModel {
     }
 
     if (didChange && this.hasRecord) {
-      this.store._notificationManager.notify(this.identifier, 'identity');
+      if (CUSTOM_MODEL_CLASS) {
+        this.store._notificationManager.notify(this.identifier, 'identity');
+      } else {
+        this.notifyPropertyChange('id');
+      }
     }
     this._isUpdatingId = false;
   }
 
-  didError() {}
+  didError(error) {
+    if (!REQUEST_SERVICE) {
+      this.error = error;
+      this.isError = true;
+
+      if (this.hasRecord) {
+        this._record.setProperties({
+          isError: true,
+          adapterError: error,
+        });
+      }
+    }
+  }
 
-  didCleanError() {}
+  didCleanError() {
+    if (!REQUEST_SERVICE) {
+      this.error = null;
+      this.isError = false;
+
+      if (this.hasRecord) {
+        this._record.setProperties({
+          isError: false,
+          adapterError: null,
+        });
+      }
+    }
+  }
 
   /*
     If the adapter did not return a hash in response to a commit,
@@ -1048,19 +1263,29 @@ export default class InternalModel {
   adapterDidCommit(data) {
     this.didCleanError();
 
-    this._recordData.didCommit(data);
+    let changedKeys = this._recordData.didCommit(data);
+
     this.send('didCommit');
     this.store.recordArrayManager.recordDidChange(this.identifier);
 
     if (!data) {
       return;
     }
-    this.store._notificationManager.notify(this.identifier, 'attributes');
+    if (CUSTOM_MODEL_CLASS) {
+      this.store._notificationManager.notify(this.identifier, 'attributes');
+    } else {
+      this._record._notifyProperties(changedKeys);
+    }
   }
 
   hasErrors() {
-    if (this._recordData.getErrors) {
-      return this._recordData.getErrors(this.identifier).length > 0;
+    if (RECORD_DATA_ERRORS) {
+      if (this._recordData.getErrors) {
+        return this._recordData.getErrors(this.identifier).length > 0;
+      } else {
+        let errors = (this.getRecord() as DSModel).errors;
+        return errors.length > 0;
+      }
     } else {
       let errors = (this.getRecord() as DSModel).errors;
       return errors.length > 0;
@@ -1069,37 +1294,54 @@ export default class InternalModel {
 
   // FOR USE DURING COMMIT PROCESS
   adapterDidInvalidate(parsedErrors, error) {
-    // TODO @runspired this should be handled by RecordState
-    // and errors should be dirtied but lazily fetch if at
-    // all possible. We should only notify errors here.
-    let attribute;
-    if (error && parsedErrors) {
-      if (!this._recordData.getErrors) {
-        for (attribute in parsedErrors) {
-          if (hasOwnProperty.call(parsedErrors, attribute)) {
-            (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
+    if (RECORD_DATA_ERRORS) {
+      // TODO @runspired this should be handled by RecordState
+      // and errors should be dirtied but lazily fetch if at
+      // all possible. We should only notify errors here.
+      let attribute;
+      if (error && parsedErrors) {
+        if (!this._recordData.getErrors) {
+          for (attribute in parsedErrors) {
+            if (hasOwnProperty.call(parsedErrors, attribute)) {
+              (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
+            }
           }
         }
-      }
 
-      let jsonApiErrors: JsonApiValidationError[] = errorsHashToArray(parsedErrors);
-      this.send('becameInvalid');
-      if (jsonApiErrors.length === 0) {
-        jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];
+        let jsonApiErrors: JsonApiValidationError[] = errorsHashToArray(parsedErrors);
+        this.send('becameInvalid');
+        if (jsonApiErrors.length === 0) {
+          jsonApiErrors = [{ title: 'Invalid Error', detail: '', source: { pointer: '/data' } }];
+        }
+        this._recordData.commitWasRejected(this.identifier, jsonApiErrors);
+      } else {
+        this.send('becameError');
+        this._recordData.commitWasRejected(this.identifier);
       }
-      this._recordData.commitWasRejected(this.identifier, jsonApiErrors);
     } else {
-      this.send('becameError');
-      this._recordData.commitWasRejected(this.identifier);
+      let attribute;
+
+      for (attribute in parsedErrors) {
+        if (hasOwnProperty.call(parsedErrors, attribute)) {
+          (this.getRecord() as DSModel).errors._add(attribute, parsedErrors[attribute]);
+        }
+      }
+
+      this.send('becameInvalid');
+
+      this._recordData.commitWasRejected();
     }
   }
 
   notifyErrorsChange() {
-    this.store._notificationManager.notify(this.identifier, 'errors');
+    if (CUSTOM_MODEL_CLASS) {
+      this.store._notificationManager.notify(this.identifier, 'errors');
+    }
   }
 
-  adapterDidError() {
+  adapterDidError(error) {
     this.send('becameError');
+    this.didError(error);
 
     this._recordData.commitWasRejected();
   }
@@ -1146,6 +1388,16 @@ export default class InternalModel {
   }
 }
 
+// in production code, this is only accesssed in `record-array-manager`
+// if REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT is also false
+if (!REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT) {
+  Object.defineProperty(InternalModel.prototype, '_recordArrays', {
+    get() {
+      return recordArraysForIdentifier(this.identifier);
+    },
+  });
+}
+
 function handleCompletedRelationshipRequest(internalModel, key, relationship, value, error) {
   delete internalModel._relationshipPromisesCache[key];
   relationship.state.shouldForceReload = false;

package/addon/-private/system/model/states.js

@@ -3,6 +3,7 @@
 */
 import { assert } from '@ember/debug';
 
+import { CUSTOM_MODEL_CLASS, REQUEST_SERVICE } from '@ember-data/canary-features';
 /*
   This file encapsulates the various states that a record can transition
   through during its lifecycle.
@@ -431,7 +432,11 @@ createdState.uncommitted.rollback = function (internalModel) {
 
 createdState.uncommitted.pushedData = function (internalModel) {
   // TODO @runspired consider where to do this once we kill off state machine
-  internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');
+  if (CUSTOM_MODEL_CLASS) {
+    internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');
+  } else {
+    internalModel.notifyPropertyChange('id');
+  }
   internalModel.transitionTo('loaded.updated.uncommitted');
   internalModel.triggerLater('didLoad');
 };
@@ -495,6 +500,9 @@ const RootState = {
 
     // EVENTS
     loadingData(internalModel, promise) {
+      if (!REQUEST_SERVICE) {
+        internalModel._promiseProxy = promise;
+      }
       internalModel.transitionTo('loading');
     },
 
@@ -585,7 +593,11 @@ const RootState = {
         internalModel.transitionTo('updated.inFlight');
       },
 
-      reloadRecord() {},
+      reloadRecord(internalModel, { resolve, options }) {
+        if (!REQUEST_SERVICE) {
+          resolve(internalModel.store._reloadRecord(internalModel, options));
+        }
+      },
 
       deleteRecord(internalModel) {
         internalModel.transitionTo('deleted.uncommitted');