@ember-data/legacy-compat 4.12.0-alpha.11 → 4.12.0-alpha.13

package/addon/{fetch-manager-2716abb1.js → fetch-manager-1067c70f.js}

@@ -1,8 +1,7 @@
-import { macroCondition, getOwnConfig, isDevelopingApp, importSync } from '@embroider/macros';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { deprecate, assert, warn } from '@ember/debug';
 import { SOURCE, coerceId } from '@ember-data/store/-private';
-import { _backburner } from '@ember/runloop';
-import RSVP, { resolve } from 'rsvp';
+import { createDeferred } from '@ember-data/request';
 /**
   SnapshotRecordArray is not directly instantiable.
   Instances are provided to consuming application's
@@ -137,9 +136,9 @@ class SnapshotRecordArray {
       return this._snapshots;
     }
     const {
-      _instanceCache
+      _fetchManager
     } = this.__store;
-    this._snapshots = this._recordArray[SOURCE].map(identifier => _instanceCache.createSnapshot(identifier));
+    this._snapshots = this._recordArray[SOURCE].map(identifier => _fetchManager.createSnapshot(identifier));
     return this._snapshots;
   }
 }
@@ -175,7 +174,7 @@ function _bind(fn, ...args) {
 function _guard(promise, test) {
   let guarded = promise.finally(() => {
     if (!test()) {
-      guarded._subscribers.length = 0;
+      guarded._subscribers ? guarded._subscribers.length = 0 : null;
     }
   });
   return guarded;
@@ -183,12 +182,8 @@ function _guard(promise, test) {
 function _objectIsAlive(object) {
   return !(object.isDestroyed || object.isDestroying);
 }
-function guardDestroyedStore(promise, store, label) {
-  let token;
-  if (isDevelopingApp()) {
-    token = store._trackAsyncRequestStart(label);
-  }
-  let wrapperPromise = resolve(promise, label).then(_v => {
+function guardDestroyedStore(promise, store) {
+  return promise.then(_v => {
     if (!_objectIsAlive(store)) {
       if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
         deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
@@ -202,18 +197,26 @@ function guardDestroyedStore(promise, store, label) {
         });
       }
     }
-    return promise;
-  });
-  return _guard(wrapperPromise, () => {
-    if (isDevelopingApp()) {
-      store._trackAsyncRequestEnd(token);
-    }
-    return _objectIsAlive(store);
+    return _v;
   });
 }
 function assertIdentifierHasId(identifier) {
   assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
 }
+function iterateData(data, fn) {
+  if (Array.isArray(data)) {
+    return data.map(fn);
+  } else {
+    return fn(data);
+  }
+}
+function payloadIsNotBlank(adapterPayload) {
+  if (Array.isArray(adapterPayload)) {
+    return true;
+  } else {
+    return Object.keys(adapterPayload || {}).length !== 0;
+  }
+}
 
 /**
   This is a helper method that validates a JSON API top-level document
@@ -224,7 +227,7 @@ function assertIdentifierHasId(identifier) {
   @internal
 */
 function validateDocumentStructure(doc) {
-  if (isDevelopingApp()) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     let errors = [];
     if (!doc || typeof doc !== 'object') {
       errors.push('Top level of a JSON API document must be an object');
@@ -275,29 +278,474 @@ function normalizeResponseHelper(serializer, store, modelClass, payload, id, req
   validateDocumentStructure(normalizedResponse);
   return normalizedResponse;
 }
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length !== 0;
+
+/**
+  @module @ember-data/store
+*/
+/**
+  Snapshot is not directly instantiable.
+  Instances are provided to a consuming application's
+  adapters and serializers for certain requests.
+
+  Snapshots are only available when using `@ember-data/legacy-compat`
+  for legacy compatibility with adapters and serializers.
+
+  @class Snapshot
+  @public
+*/
+class Snapshot {
+  /**
+   * @method constructor
+   * @constructor
+   * @private
+   * @param options
+   * @param identifier
+   * @param _store
+   */
+  constructor(options, identifier, store) {
+    this._store = store;
+    this.__attributes = null;
+    this._belongsToRelationships = Object.create(null);
+    this._belongsToIds = Object.create(null);
+    this._hasManyRelationships = Object.create(null);
+    this._hasManyIds = Object.create(null);
+    const hasRecord = !!store._instanceCache.peek({
+      identifier,
+      bucket: 'record'
+    });
+    this.modelName = identifier.type;
+
+    /**
+      The unique RecordIdentifier associated with this Snapshot.
+       @property identifier
+      @public
+      @type {StableRecordIdentifier}
+    */
+    this.identifier = identifier;
+
+    /*
+      If the we do not yet have a record, then we are
+      likely a snapshot being provided to a find request, so we
+      populate __attributes lazily. Else, to preserve the "moment
+      in time" in which a snapshot is created, we greedily grab
+      the values.
+     */
+    if (hasRecord) {
+      this._attributes;
+    }
+
+    /**
+     The id of the snapshot's underlying record
+      Example
+      ```javascript
+     // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+     postSnapshot.id; // => '1'
+     ```
+      @property id
+     @type {String}
+     @public
+     */
+    this.id = identifier.id;
+
+    /**
+     A hash of adapter options
+     @property adapterOptions
+     @type {Object}
+     @public
+     */
+    this.adapterOptions = options.adapterOptions;
+
+    /**
+     If `include` was passed to the options hash for the request, the value
+     would be available here.
+      @property include
+     @type {String|Array}
+     @public
+     */
+    this.include = options.include;
+
+    /**
+     The name of the type of the underlying record for this snapshot, as a string.
+      @property modelName
+     @type {String}
+     @public
+     */
+    this.modelName = identifier.type;
+    if (hasRecord) {
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+      this._changedAttributes = cache.changedAttrs(identifier);
+    }
+  }
+
+  /**
+   The underlying record for this snapshot. Can be used to access methods and
+   properties defined on the record.
+    Example
+    ```javascript
+   let json = snapshot.record.toJSON();
+   ```
+    @property record
+   @type {Model}
+   @public
+   */
+  get record() {
+    return this._store._instanceCache.getRecord(this.identifier);
+  }
+  get _attributes() {
+    if (this.__attributes !== null) {
+      return this.__attributes;
+    }
+    const attributes = this.__attributes = Object.create(null);
+    const {
+      identifier
+    } = this;
+    const attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+    attrs.forEach(keyName => {
+      attributes[keyName] = cache.getAttr(identifier, keyName);
+    });
+    return attributes;
+  }
+
+  /**
+   The type of the underlying record for this snapshot, as a Model.
+    @property type
+    @public
+    @deprecated
+   @type {Model}
+   */
+
+  get isNew() {
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.peek({
+      identifier: this.identifier,
+      bucket: 'resourceCache'
+    }) : this._store.cache;
+    return cache?.isNew(this.identifier) || false;
+  }
+
+  /**
+   Returns the value of an attribute.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postSnapshot.attr('author'); // => 'Tomster'
+   postSnapshot.attr('title'); // => 'Ember.js rocks'
+   ```
+    Note: Values are loaded eagerly and cached when the snapshot is created.
+    @method attr
+   @param {String} keyName
+   @return {Object} The attribute value or undefined
+   @public
+   */
+  attr(keyName) {
+    if (keyName in this._attributes) {
+      return this._attributes[keyName];
+    }
+    assert(`Model '${this.identifier.lid}' has no attribute named '${keyName}' defined.`, false);
+  }
+
+  /**
+   Returns all attributes and their corresponding values.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
+   ```
+    @method attributes
+   @return {Object} All attributes of the current snapshot
+   @public
+   */
+  attributes() {
+    return {
+      ...this._attributes
+    };
+  }
+
+  /**
+   Returns all changed attributes and their old and new values.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postModel.set('title', 'Ember.js rocks!');
+   postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
+   ```
+    @method changedAttributes
+   @return {Object} All changed attributes of the current snapshot
+   @public
+   */
+  changedAttributes() {
+    let changedAttributes = Object.create(null);
+    if (!this._changedAttributes) {
+      return changedAttributes;
+    }
+    let changedAttributeKeys = Object.keys(this._changedAttributes);
+    for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {
+      let key = changedAttributeKeys[i];
+      changedAttributes[key] = this._changedAttributes[key].slice();
+    }
+    return changedAttributes;
+  }
+
+  /**
+   Returns the current value of a belongsTo relationship.
+    `belongsTo` takes an optional hash of options as a second parameter,
+   currently supported options are:
+    - `id`: set to `true` if you only want the ID of the related record to be
+   returned.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, title: 'Hello World' });
+   // store.createRecord('comment', { body: 'Lorem ipsum', post: post });
+   commentSnapshot.belongsTo('post'); // => Snapshot
+   commentSnapshot.belongsTo('post', { id: true }); // => '1'
+    // store.push('comment', { id: 1, body: 'Lorem ipsum' });
+   commentSnapshot.belongsTo('post'); // => undefined
+   ```
+    Calling `belongsTo` will return a new Snapshot as long as there's any known
+   data for the relationship available, such as an ID. If the relationship is
+   known but unset, `belongsTo` will return `null`. If the contents of the
+   relationship is unknown `belongsTo` will return `undefined`.
+    Note: Relationships are loaded lazily and cached upon first access.
+    @method belongsTo
+   @param {String} keyName
+   @param {Object} [options]
+   @public
+   @return {(Snapshot|String|null|undefined)} A snapshot or ID of a known
+   relationship or null if the relationship is known but unset. undefined
+   will be returned if the contents of the relationship is unknown.
+   */
+  belongsTo(keyName, options) {
+    let returnModeIsId = !!(options && options.id);
+    let result;
+    let store = this._store;
+    if (returnModeIsId === true && keyName in this._belongsToIds) {
+      return this._belongsToIds[keyName];
+    }
+    if (returnModeIsId === false && keyName in this._belongsToRelationships) {
+      return this._belongsToRelationships[keyName];
+    }
+    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type: this.modelName
+    })[keyName];
+    assert(`Model '${this.identifier.lid}' has no belongsTo relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'belongsTo');
+
+    // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
+    // this check is not a regression in behavior because relationships don't currently
+    // function without access to intimate API contracts between RecordData and Model.
+    // This is a requirement we should fix as soon as the relationship layer does not require
+    // this intimate API usage.
+    if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+      assert(`snapshot.belongsTo only supported when using the package @ember-data/json-api`);
+    }
+    const graphFor = importSync('@ember-data/graph/-private').graphFor;
+    const {
+      identifier
+    } = this;
+    const relationship = graphFor(this._store).get(identifier, keyName);
+    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
+    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a hasMany.`, relationship.definition.kind === 'belongsTo');
+    let value = relationship.getData();
+    let data = value && value.data;
+    let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
+    if (value && value.data !== undefined) {
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? inverseIdentifier && store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+      if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
+        if (returnModeIsId) {
+          result = inverseIdentifier.id;
+        } else {
+          result = store._fetchManager.createSnapshot(inverseIdentifier);
+        }
+      } else {
+        result = null;
+      }
+    }
+    if (returnModeIsId) {
+      this._belongsToIds[keyName] = result;
+    } else {
+      this._belongsToRelationships[keyName] = result;
+    }
+    return result;
+  }
+
+  /**
+   Returns the current value of a hasMany relationship.
+    `hasMany` takes an optional hash of options as a second parameter,
+   currently supported options are:
+    - `ids`: set to `true` if you only want the IDs of the related records to be
+   returned.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
+   postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]
+   postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
+    // store.push('post', { id: 1, title: 'Hello World' });
+   postSnapshot.hasMany('comments'); // => undefined
+   ```
+    Note: Relationships are loaded lazily and cached upon first access.
+    @method hasMany
+   @param {String} keyName
+   @param {Object} [options]
+   @public
+   @return {(Array|undefined)} An array of snapshots or IDs of a known
+   relationship or an empty array if the relationship is known but unset.
+   undefined will be returned if the contents of the relationship is unknown.
+   */
+  hasMany(keyName, options) {
+    let returnModeIsIds = !!(options && options.ids);
+    let results;
+    let cachedIds = this._hasManyIds[keyName];
+    let cachedSnapshots = this._hasManyRelationships[keyName];
+    if (returnModeIsIds === true && keyName in this._hasManyIds) {
+      return cachedIds;
+    }
+    if (returnModeIsIds === false && keyName in this._hasManyRelationships) {
+      return cachedSnapshots;
+    }
+    let store = this._store;
+    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type: this.modelName
+    })[keyName];
+    assert(`Model '${this.identifier.lid}' has no hasMany relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'hasMany');
+
+    // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
+    // this check is not a regression in behavior because relationships don't currently
+    // function without access to intimate API contracts between RecordData and Model.
+    // This is a requirement we should fix as soon as the relationship layer does not require
+    // this intimate API usage.
+    if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+      assert(`snapshot.hasMany only supported when using the package @ember-data/json-api`);
+    }
+    const graphFor = importSync('@ember-data/graph/-private').graphFor;
+    const {
+      identifier
+    } = this;
+    const relationship = graphFor(this._store).get(identifier, keyName);
+    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
+    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a belongsTo.`, relationship.definition.kind === 'hasMany');
+    let value = relationship.getData();
+    if (value.data) {
+      results = [];
+      value.data.forEach(member => {
+        let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
+        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+        if (!cache.isDeleted(inverseIdentifier)) {
+          if (returnModeIsIds) {
+            results.push(inverseIdentifier.id);
+          } else {
+            results.push(store._fetchManager.createSnapshot(inverseIdentifier));
+          }
+        }
+      });
+    }
+
+    // we assign even if `undefined` so that we don't reprocess the relationship
+    // on next access. This works with the `keyName in` checks above.
+    if (returnModeIsIds) {
+      this._hasManyIds[keyName] = results;
+    } else {
+      this._hasManyRelationships[keyName] = results;
+    }
+    return results;
+  }
+
+  /**
+    Iterates through all the attributes of the model, calling the passed
+    function on each attribute.
+     Example
+     ```javascript
+    snapshot.eachAttribute(function(name, meta) {
+      // ...
+    });
+    ```
+     @method eachAttribute
+    @param {Function} callback the callback to execute
+    @param {Object} [binding] the value to which the callback's `this` should be bound
+    @public
+  */
+  eachAttribute(callback, binding) {
+    let attrDefs = this._store.getSchemaDefinitionService().attributesDefinitionFor(this.identifier);
+    Object.keys(attrDefs).forEach(key => {
+      callback.call(binding, key, attrDefs[key]);
+    });
+  }
+
+  /**
+    Iterates through all the relationships of the model, calling the passed
+    function on each relationship.
+     Example
+     ```javascript
+    snapshot.eachRelationship(function(name, relationship) {
+      // ...
+    });
+    ```
+     @method eachRelationship
+    @param {Function} callback the callback to execute
+    @param {Object} [binding] the value to which the callback's `this` should be bound
+    @public
+  */
+  eachRelationship(callback, binding) {
+    let relationshipDefs = this._store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier);
+    Object.keys(relationshipDefs).forEach(key => {
+      callback.call(binding, key, relationshipDefs[key]);
+    });
+  }
+
+  /**
+    Serializes the snapshot using the serializer for the model.
+     Example
+     ```app/adapters/application.js
+    import Adapter from '@ember-data/adapter';
+     export default Adapter.extend({
+      createRecord(store, type, snapshot) {
+        let data = snapshot.serialize({ includeId: true });
+        let url = `/${type.modelName}`;
+         return fetch(url, {
+          method: 'POST',
+          body: data,
+        }).then((response) => response.json())
+      }
+    });
+    ```
+     @method serialize
+    @param {Object} options
+    @return {Object} an object whose values are primitive JSON values only
+    @public
+   */
+  serialize(options) {
+    const serializer = this._store.serializerFor(this.modelName);
+    assert(`Cannot serialize record, no serializer found`, serializer);
+    return serializer.serialize(this, options);
   }
 }
+if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
+  Object.defineProperty(Snapshot.prototype, 'type', {
+    get() {
+      deprecate(`Using Snapshot.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
+        id: 'ember-data:deprecate-snapshot-model-class-access',
+        until: '5.0',
+        for: 'ember-data',
+        since: {
+          available: '4.5.0',
+          enabled: '4.5.0'
+        }
+      });
+      return this._store.modelFor(this.identifier.type);
+    }
+  });
+}
 const SaveOp = Symbol('SaveOp');
 class FetchManager {
-  // saves which are pending in the runloop
-
   // fetches pending in the runloop, waiting to be coalesced
 
   constructor(store) {
     this._store = store;
     // used to keep track of all the find requests that need to be coalesced
     this._pendingFetch = new Map();
-    this._pendingSave = [];
     this.requestCache = store.getRequestStateService();
     this.isDestroyed = false;
   }
-  _createSnapshot(identifier, options) {
-    return this._store._instanceCache.createSnapshot(identifier, options);
+  createSnapshot(identifier, options = {}) {
+    return new Snapshot(options, identifier, this._store);
   }
 
   /**
@@ -307,7 +755,7 @@ class FetchManager {
      @internal
   */
   scheduleSave(identifier, options) {
-    let resolver = RSVP.defer(isDevelopingApp() ? `DS: Model#save ${identifier.lid}` : '');
+    let resolver = createDeferred();
     let query = {
       op: 'saveRecord',
       recordIdentifier: identifier,
@@ -316,7 +764,7 @@ class FetchManager {
     let queryRequest = {
       data: [query]
     };
-    const snapshot = this._createSnapshot(identifier, options);
+    const snapshot = this.createSnapshot(identifier, options);
     const pendingSaveItem = {
       snapshot: snapshot,
       resolver: resolver,
@@ -324,30 +772,11 @@ class FetchManager {
       options,
       queryRequest
     };
-    this._pendingSave.push(pendingSaveItem);
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    _backburner.scheduleOnce('actions', this, this._flushPendingSaves);
-    this.requestCache.enqueue(resolver.promise, pendingSaveItem.queryRequest);
-    return resolver.promise;
+    const monitored = this.requestCache.enqueue(resolver.promise, pendingSaveItem.queryRequest);
+    _flushPendingSave(this._store, pendingSaveItem);
+    return monitored;
   }
-
-  /**
-    This method is called at the end of the run loop, and
-    flushes any records passed into `scheduleSave`
-     @internal
-  */
-  _flushPendingSaves() {
-    const store = this._store;
-    let pending = this._pendingSave.slice();
-    this._pendingSave = [];
-    for (let i = 0, j = pending.length; i < j; i++) {
-      let pendingItem = pending[i];
-      _flushPendingSave(store, pendingItem);
-    }
-  }
-  scheduleFetch(identifier, options) {
-    // TODO Probably the store should pass in the query object
-    let shouldTrace = isDevelopingApp() && this._store.generateStackTracesForTrackedRequests;
+  scheduleFetch(identifier, options, request) {
     let query = {
       op: 'findRecord',
       recordIdentifier: identifier,
@@ -360,36 +789,20 @@ class FetchManager {
     if (pendingFetch) {
       return pendingFetch;
     }
-    let id = identifier.id;
     let modelName = identifier.type;
-    let resolver = RSVP.defer(`Fetching ${modelName}' with id: ${id}`);
-    let pendingFetchItem = {
+    const resolver = createDeferred();
+    const pendingFetchItem = {
       identifier,
       resolver,
       options,
       queryRequest
     };
-    if (isDevelopingApp()) {
-      if (shouldTrace) {
-        let trace;
-        try {
-          throw new Error(`Trace Origin for scheduled fetch for ${modelName}:${id}.`);
-        } catch (e) {
-          trace = e;
-        }
-
-        // enable folks to discover the origin of this findRecord call when
-        // debugging. Ideally we would have a tracked queue for requests with
-        // labels or local IDs that could be used to merge this trace with
-        // the trace made available when we detect an async leak
-        pendingFetchItem.trace = trace;
-      }
-    }
     let resolverPromise = resolver.promise;
     const store = this._store;
-    const isLoading = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
+    const isInitialLoad = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
 
-    const promise = resolverPromise.then(payload => {
+    const monitored = this.requestCache.enqueue(resolverPromise, pendingFetchItem.queryRequest);
+    let promise = monitored.then(payload => {
       // ensure that regardless of id returned we assign to the correct record
       if (payload.data && !Array.isArray(payload.data)) {
         payload.data.lid = identifier.lid;
@@ -397,17 +810,18 @@ class FetchManager {
 
       // additional data received in the payload
       // may result in the merging of identifiers (and thus records)
-      let potentiallyNewIm = store._push(payload);
+      let potentiallyNewIm = store._push(payload, options.reload);
       if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
         return potentiallyNewIm;
       }
       return identifier;
     }, error => {
+      assert(`Async Leak Detected: Expected the store to not be destroyed`, !store.isDestroyed);
       const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.peek({
         identifier,
         bucket: 'resourceCache'
       }) : store.cache;
-      if (!cache || cache.isEmpty(identifier) || isLoading) {
+      if (!cache || cache.isEmpty(identifier) || isInitialLoad) {
         let isReleasable = true;
         if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
           if (!cache) {
@@ -420,22 +834,32 @@ class FetchManager {
           }
         }
         if (cache || isReleasable) {
+          store._enableAsyncFlush = true;
           store._instanceCache.unloadRecord(identifier);
+          store._enableAsyncFlush = null;
         }
       }
       throw error;
     });
     if (this._pendingFetch.size === 0) {
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      _backburner.schedule('actions', this, this.flushAllPendingFetches);
+      void new Promise(resolve => setTimeout(resolve, 0)).then(() => {
+        this.flushAllPendingFetches();
+      });
     }
     let fetches = this._pendingFetch;
     if (!fetches.has(modelName)) {
       fetches.set(modelName, []);
     }
     fetches.get(modelName).push(pendingFetchItem);
+    if (macroCondition(getOwnConfig().env.TESTING)) {
+      if (!request.disableTestWaiter) {
+        const {
+          waitForPromise
+        } = importSync('@ember/test-waiters');
+        promise = waitForPromise(promise);
+      }
+    }
     pendingFetchItem.promise = promise;
-    this.requestCache.enqueue(resolverPromise, pendingFetchItem.queryRequest);
     return promise;
   }
   getPendingFetch(identifier, options) {
@@ -457,19 +881,26 @@ class FetchManager {
     this._pendingFetch.forEach((fetchItem, type) => _flushPendingFetchForType(store, fetchItem, type));
     this._pendingFetch.clear();
   }
-  fetchDataIfNeededForIdentifier(identifier, options = {}) {
+  fetchDataIfNeededForIdentifier(identifier, options = {}, request) {
     // pre-loading will change the isEmpty value
     const isEmpty = _isEmpty(this._store._instanceCache, identifier);
     const isLoading = _isLoading(this._store._instanceCache, identifier);
     let promise;
     if (isEmpty) {
       assertIdentifierHasId(identifier);
-      promise = this.scheduleFetch(identifier, options);
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        promise = this.scheduleFetch(identifier, Object.assign({}, options, {
+          reload: true
+        }), request);
+      } else {
+        options.reload = true;
+        promise = this.scheduleFetch(identifier, options, request);
+      }
     } else if (isLoading) {
       promise = this.getPendingFetch(identifier, options);
       assert(`Expected to find a pending request for a record in the loading state, but found none`, promise);
     } else {
-      promise = resolve(identifier);
+      promise = Promise.resolve(identifier);
     }
     return promise;
   }
@@ -504,18 +935,18 @@ function isSameRequest(options = {}, existingOptions = {}) {
 }
 function _findMany(store, adapter, modelName, snapshots) {
   let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
-  const ids = snapshots.map(s => s.id);
-  assert(`Cannot fetch a record without an id`, ids.every(v => v !== null));
-  // eslint-disable-next-line @typescript-eslint/unbound-method
-  assert(`Expected this adapter to implement findMany for coalescing`, adapter.findMany);
-  let promise = adapter.findMany(store, modelClass, ids, snapshots);
-  let label = `DS: Handle Adapter#findMany of '${modelName}'`;
-  if (promise === undefined) {
-    throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
-  }
-  promise = guardDestroyedStore(promise, store, label);
+  let promise = Promise.resolve().then(() => {
+    const ids = snapshots.map(s => s.id);
+    assert(`Cannot fetch a record without an id`, ids.every(v => v !== null));
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    assert(`Expected this adapter to implement findMany for coalescing`, adapter.findMany);
+    let ret = adapter.findMany(store, modelClass, ids, snapshots);
+    assert('adapter.findMany returned undefined, this was very likely a mistake', ret !== undefined);
+    return ret;
+  });
+  promise = guardDestroyedStore(promise, store);
   return promise.then(adapterPayload => {
-    assert(`You made a 'findMany' request for '${modelName}' records with ids '[${ids.join(',')}]', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
+    assert(`You made a 'findMany' request for '${modelName}' records with ids '[${snapshots.map(s => s.id).join(',')}]', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
     let serializer = store.serializerFor(modelName);
     let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');
     return payload;
@@ -575,7 +1006,7 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
     store._push({
       data: null,
       included
-    });
+    }, true);
   }
   if (snapshotsById.size === 0) {
     return;
@@ -591,20 +1022,19 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
   });
   rejectFetchedItems(fetchMap, rejected);
 }
-function _fetchRecord(store, fetchItem) {
+function _fetchRecord(store, adapter, fetchItem) {
   let identifier = fetchItem.identifier;
   let modelName = identifier.type;
-  let adapter = store.adapterFor(modelName);
   assert(`You tried to find a record but you have no adapter (for ${modelName})`, adapter);
   assert(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`, typeof adapter.findRecord === 'function');
-  let snapshot = store._instanceCache.createSnapshot(identifier, fetchItem.options);
+  let snapshot = store._fetchManager.createSnapshot(identifier, fetchItem.options);
   let klass = store.modelFor(identifier.type);
   let id = identifier.id;
-  let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;
-  let promise = guardDestroyedStore(resolve().then(() => {
+  let promise = Promise.resolve().then(() => {
     return adapter.findRecord(store, klass, identifier.id, snapshot);
-  }), store, label);
+  });
   promise = promise.then(adapterPayload => {
+    assert(`Async Leak Detected: Expected the store to not be destroyed`, _objectIsAlive(store));
     assert(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
     let serializer = store.serializerFor(modelName);
     let payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
@@ -625,7 +1055,7 @@ function _processCoalescedGroup(store, fetchMap, group, adapter, modelName) {
       rejectFetchedItems(fetchMap, group, error);
     });
   } else if (group.length === 1) {
-    _fetchRecord(store, fetchMap.get(group[0]));
+    _fetchRecord(store, adapter, fetchMap.get(group[0]));
   } else {
     assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false);
   }
@@ -639,7 +1069,7 @@ function _flushPendingFetchForType(store, pendingFetchItems, modelName) {
     let fetchMap = new Map();
     for (let i = 0; i < totalItems; i++) {
       let fetchItem = pendingFetchItems[i];
-      snapshots[i] = store._instanceCache.createSnapshot(fetchItem.identifier, fetchItem.options);
+      snapshots[i] = store._fetchManager.createSnapshot(fetchItem.identifier, fetchItem.options);
       fetchMap.set(snapshots[i], fetchItem);
     }
     let groups;
@@ -653,7 +1083,7 @@ function _flushPendingFetchForType(store, pendingFetchItems, modelName) {
     }
   } else {
     for (let i = 0; i < totalItems; i++) {
-      _fetchRecord(store, pendingFetchItems[i]);
+      void _fetchRecord(store, adapter, pendingFetchItems[i]);
     }
   }
 }
@@ -671,14 +1101,9 @@ function _flushPendingSave(store, pending) {
   const record = store._instanceCache.getRecord(identifier);
   assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter);
   assert(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`, typeof adapter[operation] === 'function');
-  let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
+  let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
   let serializer = store.serializerFor(modelName);
   assert(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`, promise !== undefined);
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-  promise = _guard(guardDestroyedStore(promise, store, isDevelopingApp() ? `DS: Extract and notify about ${operation} completion of ${identifier.lid}` : ''),
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-  _bind(_objectIsAlive, record));
   promise = promise.then(adapterPayload => {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     if (!_objectIsAlive(record)) {
@@ -700,4 +1125,4 @@ function _flushPendingSave(store, pending) {
   });
   resolver.resolve(promise);
 }
-export { FetchManager as F, SnapshotRecordArray as S, SaveOp as a, assertIdentifierHasId as b, guardDestroyedStore as g, normalizeResponseHelper as n };
+export { FetchManager as F, SnapshotRecordArray as S, _objectIsAlive as _, SaveOp as a, Snapshot as b, _guard as c, _bind as d, assertIdentifierHasId as e, guardDestroyedStore as g, iterateData as i, normalizeResponseHelper as n, payloadIsNotBlank as p };