@ember-data/legacy-compat 4.12.0-alpha.9 → 4.12.0-beta.10

package/addon/index.js

@@ -1,1686 +1,514 @@
-import { macroCondition, isDevelopingApp, getOwnConfig } from '@embroider/macros';
-import { deprecate, assert } from '@ember/debug';
-import { S as SnapshotRecordArray } from "./snapshot-record-array-a4efeb60";
-
-/*!
- * @overview RSVP - a tiny implementation of Promises/A+.
- * @copyright Copyright (c) 2016 Yehuda Katz, Tom Dale, Stefan Penner and contributors
- * @license   Licensed under MIT license
- *            See https://raw.githubusercontent.com/tildeio/rsvp.js/master/LICENSE
- * @version   4.8.4+ff10049b
- */
-
-function callbacksFor(object) {
-  var callbacks = object._promiseCallbacks;
-  if (!callbacks) {
-    callbacks = object._promiseCallbacks = {};
-  }
-  return callbacks;
+import { assert } from '@ember/debug';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, c as assertIdentifierHasId, a as SaveOp, S as SnapshotRecordArray } from "./fetch-manager-69fdecd9";
+function _findHasMany(adapter, store, identifier, link, relationship, options) {
+  let promise = Promise.resolve().then(() => {
+    const snapshot = store._fetchManager.createSnapshot(identifier, options);
+    let useLink = !link || typeof link === 'string';
+    let relatedLink = useLink ? link : link.href;
+    return adapter.findHasMany(store, snapshot, relatedLink, relationship);
+  });
+  promise = promise.then(adapterPayload => {
+    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));
+    const modelClass = store.modelFor(relationship.type);
+    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, true);
+  }, null, `DS: Extract payload of '${identifier.type}' : hasMany '${relationship.type}'`);
+  return promise;
+}
+function _findBelongsTo(store, identifier, link, relationship, options) {
+  let promise = Promise.resolve().then(() => {
+    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._fetchManager.createSnapshot(identifier, options);
+    let useLink = !link || typeof link === 'string';
+    let relatedLink = useLink ? link : link.href;
+    return adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
+  });
+  promise = promise.then(adapterPayload => {
+    let modelClass = store.modelFor(relationship.type);
+    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, true);
+  }, null, `DS: Extract payload of ${identifier.type} : ${relationship.type}`);
+  return promise;
 }
 
-/**
-  @class EventTarget
-  @for rsvp
-  @public
-*/
-var EventTarget = {
-  /**
-    `EventTarget.mixin` extends an object with EventTarget methods. For
-    Example:
-     ```javascript
-    import EventTarget from 'rsvp';
-     let object = {};
-     EventTarget.mixin(object);
-     object.on('finished', function(event) {
-      // handle event
-    });
-     object.trigger('finished', { detail: value });
-    ```
-     `EventTarget.mixin` also works with prototypes:
-     ```javascript
-    import EventTarget from 'rsvp';
-     let Person = function() {};
-    EventTarget.mixin(Person.prototype);
-     let yehuda = new Person();
-    let tom = new Person();
-     yehuda.on('poke', function(event) {
-      console.log('Yehuda says OW');
-    });
-     tom.on('poke', function(event) {
-      console.log('Tom says OW');
-    });
-     yehuda.trigger('poke');
-    tom.trigger('poke');
-    ```
-     @method mixin
-    @for rsvp
-    @private
-    @param {Object} object object to extend with EventTarget methods
-  */
-  mixin: function (object) {
-    object.on = this.on;
-    object.off = this.off;
-    object.trigger = this.trigger;
-    object._promiseCallbacks = undefined;
-    return object;
-  },
-  /**
-    Registers a callback to be executed when `eventName` is triggered
-     ```javascript
-    object.on('event', function(eventInfo){
-      // handle the event
-    });
-     object.trigger('event');
-    ```
-     @method on
-    @for EventTarget
-    @private
-    @param {String} eventName name of the event to listen for
-    @param {Function} callback function to be called when the event is triggered.
-  */
-  on: function (eventName, callback) {
-    if (typeof callback !== 'function') {
-      throw new TypeError('Callback must be a function');
-    }
-    var allCallbacks = callbacksFor(this);
-    var callbacks = allCallbacks[eventName];
-    if (!callbacks) {
-      callbacks = allCallbacks[eventName] = [];
-    }
-    if (callbacks.indexOf(callback) === -1) {
-      callbacks.push(callback);
-    }
-  },
-  /**
-    You can use `off` to stop firing a particular callback for an event:
-     ```javascript
-    function doStuff() { // do stuff! }
-    object.on('stuff', doStuff);
-     object.trigger('stuff'); // doStuff will be called
-     // Unregister ONLY the doStuff callback
-    object.off('stuff', doStuff);
-    object.trigger('stuff'); // doStuff will NOT be called
-    ```
-     If you don't pass a `callback` argument to `off`, ALL callbacks for the
-    event will not be executed when the event fires. For example:
-     ```javascript
-    let callback1 = function(){};
-    let callback2 = function(){};
-     object.on('stuff', callback1);
-    object.on('stuff', callback2);
-     object.trigger('stuff'); // callback1 and callback2 will be executed.
-     object.off('stuff');
-    object.trigger('stuff'); // callback1 and callback2 will not be executed!
-    ```
-     @method off
-    @for rsvp
-    @private
-    @param {String} eventName event to stop listening to
-    @param {Function} [callback] optional argument. If given, only the function
-    given will be removed from the event's callback queue. If no `callback`
-    argument is given, all callbacks will be removed from the event's callback
-    queue.
-  */
-  off: function (eventName, callback) {
-    var allCallbacks = callbacksFor(this);
-    if (!callback) {
-      allCallbacks[eventName] = [];
-      return;
-    }
-    var callbacks = allCallbacks[eventName];
-    var index = callbacks.indexOf(callback);
-    if (index !== -1) {
-      callbacks.splice(index, 1);
-    }
-  },
-  /**
-    Use `trigger` to fire custom events. For example:
-     ```javascript
-    object.on('foo', function(){
-      console.log('foo event happened!');
-    });
-    object.trigger('foo');
-    // 'foo event happened!' logged to the console
-    ```
-     You can also pass a value as a second argument to `trigger` that will be
-    passed as an argument to all event listeners for the event:
-     ```javascript
-    object.on('foo', function(value){
-      console.log(value.name);
-    });
-     object.trigger('foo', { name: 'bar' });
-    // 'bar' logged to the console
-    ```
-     @method trigger
-    @for rsvp
-    @private
-    @param {String} eventName name of the event to be triggered
-    @param {*} [options] optional value to be passed to any event handlers for
-    the given `eventName`
-  */
-  trigger: function (eventName, options, label) {
-    var allCallbacks = callbacksFor(this);
-    var callbacks = allCallbacks[eventName];
-    if (callbacks) {
-      // Don't cache the callbacks.length since it may grow
-      var callback = void 0;
-      for (var i = 0; i < callbacks.length; i++) {
-        callback = callbacks[i];
-        callback(options, label);
-      }
-    }
+// 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;
   }
-};
-var config = {
-  instrument: false
-};
-EventTarget['mixin'](config);
-function configure(name, value) {
-  if (arguments.length === 2) {
-    config[name] = value;
-  } else {
-    return config[name];
+  if ('links' in payload) {
+    relatedDataHash.links = payload.links;
   }
-}
-var queue = [];
-function scheduleFlush() {
-  setTimeout(function () {
-    for (var i = 0; i < queue.length; i++) {
-      var entry = queue[i];
-      var payload = entry.payload;
-      payload.guid = payload.key + payload.id;
-      payload.childGuid = payload.key + payload.childId;
-      if (payload.error) {
-        payload.stack = payload.error.stack;
-      }
-      config['trigger'](entry.name, entry.payload);
-    }
-    queue.length = 0;
-  }, 50);
-}
-function instrument(eventName, promise, child) {
-  if (1 === queue.push({
-    name: eventName,
-    payload: {
-      key: promise._guidKey,
-      id: promise._id,
-      eventName: eventName,
-      detail: promise._result,
-      childId: child && child._id,
-      label: promise._label,
-      timeStamp: Date.now(),
-      error: config["instrument-with-stack"] ? new Error(promise._label) : null
-    }
-  })) {
-    scheduleFlush();
+  if ('data' in payload) {
+    relatedDataHash.data = relationshipData;
   }
-}
-
-/**
-  `Promise.resolve` returns a promise that will become resolved with the
-  passed `value`. It is shorthand for the following:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise = new Promise(function(resolve, reject){
-    resolve(1);
-  });
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
 
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise = RSVP.Promise.resolve(1);
-
-  promise.then(function(value){
-    // value === 1
-  });
-  ```
-
-  @method resolve
-  @for Promise
-  @static
-  @param {*} object value that the returned promise will be resolved with
-  @param {String} [label] optional string for identifying the returned promise.
-  Useful for tooling.
-  @return {Promise} a promise that will become fulfilled with the given
-  `value`
-*/
-function resolve$$1(object, label) {
-  /*jshint validthis:true */
-  var Constructor = this;
-  if (object && typeof object === 'object' && object.constructor === Constructor) {
-    return object;
-  }
-  var promise = new Constructor(noop, label);
-  resolve$1(promise, object);
-  return promise;
-}
-function withOwnPromise() {
-  return new TypeError('A promises callback cannot return that same promise.');
-}
-function objectOrFunction(x) {
-  var type = typeof x;
-  return x !== null && (type === 'object' || type === 'function');
-}
-function noop() {}
-var PENDING = void 0;
-var FULFILLED = 1;
-var REJECTED = 2;
-var TRY_CATCH_ERROR = {
-  error: null
-};
-function getThen(promise) {
-  try {
-    return promise.then;
-  } catch (error) {
-    TRY_CATCH_ERROR.error = error;
-    return TRY_CATCH_ERROR;
+  // 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;
 }
-var tryCatchCallback = void 0;
-function tryCatcher() {
-  try {
-    var target = tryCatchCallback;
-    tryCatchCallback = null;
-    return target.apply(this, arguments);
-  } catch (e) {
-    TRY_CATCH_ERROR.error = e;
-    return TRY_CATCH_ERROR;
+function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
+  let {
+    id,
+    type
+  } = payload;
+  if (!payload.relationships) {
+    payload.relationships = {};
   }
-}
-function tryCatch(fn) {
-  tryCatchCallback = fn;
-  return tryCatcher;
-}
-function handleForeignThenable(promise, thenable, then$$1) {
-  config.async(function (promise) {
-    var sealed = false;
-    var result = tryCatch(then$$1).call(thenable, function (value) {
-      if (sealed) {
-        return;
-      }
-      sealed = true;
-      if (thenable === value) {
-        fulfill(promise, value);
-      } else {
-        resolve$1(promise, value);
-      }
-    }, function (reason) {
-      if (sealed) {
-        return;
+  let {
+    relationships
+  } = payload;
+  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+  if (inverse) {
+    let {
+      inverseKey,
+      kind
+    } = inverse;
+    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (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);
       }
-      sealed = true;
-      reject(promise, reason);
-    }, 'Settle: ' + (promise._label || ' unknown promise'));
-    if (!sealed && result === TRY_CATCH_ERROR) {
-      sealed = true;
-      var error = TRY_CATCH_ERROR.error;
-      TRY_CATCH_ERROR.error = null;
-      reject(promise, error);
     }
-  }, promise);
-}
-function handleOwnThenable(promise, thenable) {
-  if (thenable._state === FULFILLED) {
-    fulfill(promise, thenable._result);
-  } else if (thenable._state === REJECTED) {
-    thenable._onError = null;
-    reject(promise, thenable._result);
-  } else {
-    subscribe(thenable, undefined, function (value) {
-      if (thenable === value) {
-        fulfill(promise, value);
-      } else {
-        resolve$1(promise, value);
-      }
-    }, function (reason) {
-      return reject(promise, reason);
-    });
-  }
-}
-function handleMaybeThenable(promise, maybeThenable, then$$1) {
-  var isOwnThenable = maybeThenable.constructor === promise.constructor && then$$1 === then && promise.constructor.resolve === resolve$$1;
-  if (isOwnThenable) {
-    handleOwnThenable(promise, maybeThenable);
-  } else if (then$$1 === TRY_CATCH_ERROR) {
-    var error = TRY_CATCH_ERROR.error;
-    TRY_CATCH_ERROR.error = null;
-    reject(promise, error);
-  } else if (typeof then$$1 === 'function') {
-    handleForeignThenable(promise, maybeThenable, then$$1);
-  } else {
-    fulfill(promise, maybeThenable);
-  }
-}
-function resolve$1(promise, value) {
-  if (promise === value) {
-    fulfill(promise, value);
-  } else if (objectOrFunction(value)) {
-    handleMaybeThenable(promise, value, getThen(value));
-  } else {
-    fulfill(promise, value);
-  }
-}
-function publishRejection(promise) {
-  if (promise._onError) {
-    promise._onError(promise._result);
-  }
-  publish(promise);
-}
-function fulfill(promise, value) {
-  if (promise._state !== PENDING) {
-    return;
-  }
-  promise._result = value;
-  promise._state = FULFILLED;
-  if (promise._subscribers.length === 0) {
-    if (config.instrument) {
-      instrument('fulfilled', promise);
+    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
+      relationships[inverseKey] = relationships[inverseKey] || {};
+      relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentIdentifier);
     }
-  } else {
-    config.async(publish, promise);
   }
 }
-function reject(promise, reason) {
-  if (promise._state !== PENDING) {
-    return;
+function inverseForRelationship(store, identifier, key) {
+  const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
+  if (!definition) {
+    return null;
   }
-  promise._state = REJECTED;
-  promise._result = reason;
-  config.async(publishRejection, promise);
+  assert(`Expected the relationship defintion to specify the inverse type or null.`, definition.options?.inverse === null || typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0);
+  return definition.options.inverse;
 }
-function subscribe(parent, child, onFulfillment, onRejection) {
-  var subscribers = parent._subscribers;
-  var length = subscribers.length;
-  parent._onError = null;
-  subscribers[length] = child;
-  subscribers[length + FULFILLED] = onFulfillment;
-  subscribers[length + REJECTED] = onRejection;
-  if (length === 0 && parent._state) {
-    config.async(publish, parent);
+function getInverse(store, parentIdentifier, parentRelationship, type) {
+  let {
+    name: lhs_relationshipName
+  } = parentRelationship;
+  let {
+    type: parentType
+  } = parentIdentifier;
+  let inverseKey = inverseForRelationship(store, {
+    type: parentType
+  }, lhs_relationshipName);
+  if (inverseKey) {
+    const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type
+    });
+    let {
+      kind
+    } = definition[inverseKey];
+    return {
+      inverseKey,
+      kind
+    };
   }
 }
-function publish(promise) {
-  var subscribers = promise._subscribers;
-  var settled = promise._state;
-  if (config.instrument) {
-    instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
+function relationshipDataPointsToParent(relationshipData, identifier) {
+  if (relationshipData === null) {
+    return false;
   }
-  if (subscribers.length === 0) {
-    return;
-  }
-  var child = void 0,
-    callback = void 0,
-    result = promise._result;
-  for (var i = 0; i < subscribers.length; i += 3) {
-    child = subscribers[i];
-    callback = subscribers[i + settled];
-    if (child) {
-      invokeCallback(settled, child, callback, result);
-    } else {
-      callback(result);
+  if (Array.isArray(relationshipData)) {
+    if (relationshipData.length === 0) {
+      return false;
     }
-  }
-  promise._subscribers.length = 0;
-}
-function invokeCallback(state, promise, callback, result) {
-  var hasCallback = typeof callback === 'function';
-  var value = void 0;
-  if (hasCallback) {
-    value = tryCatch(callback)(result);
-  } else {
-    value = result;
-  }
-  if (promise._state !== PENDING) ;else if (value === promise) {
-    reject(promise, withOwnPromise());
-  } else if (value === TRY_CATCH_ERROR) {
-    var error = TRY_CATCH_ERROR.error;
-    TRY_CATCH_ERROR.error = null; // release
-    reject(promise, error);
-  } else if (hasCallback) {
-    resolve$1(promise, value);
-  } else if (state === FULFILLED) {
-    fulfill(promise, value);
-  } else if (state === REJECTED) {
-    reject(promise, value);
-  }
-}
-function initializePromise(promise, resolver) {
-  var resolved = false;
-  try {
-    resolver(function (value) {
-      if (resolved) {
-        return;
-      }
-      resolved = true;
-      resolve$1(promise, value);
-    }, function (reason) {
-      if (resolved) {
-        return;
+    for (let i = 0; i < relationshipData.length; i++) {
+      let entry = relationshipData[i];
+      if (validateRelationshipEntry(entry, identifier)) {
+        return true;
       }
-      resolved = true;
-      reject(promise, reason);
-    });
-  } catch (e) {
-    reject(promise, e);
-  }
-}
-function then(onFulfillment, onRejection, label) {
-  var parent = this;
-  var state = parent._state;
-  if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
-    config.instrument && instrument('chained', parent, parent);
-    return parent;
-  }
-  parent._onError = null;
-  var child = new parent.constructor(noop, label);
-  var result = parent._result;
-  config.instrument && instrument('chained', parent, child);
-  if (state === PENDING) {
-    subscribe(parent, child, onFulfillment, onRejection);
+    }
   } else {
-    var callback = state === FULFILLED ? onFulfillment : onRejection;
-    config.async(function () {
-      return invokeCallback(state, child, callback, result);
-    });
+    return validateRelationshipEntry(relationshipData, identifier);
   }
-  return child;
+  return false;
 }
-var Enumerator = function () {
-  function Enumerator(Constructor, input, abortOnReject, label) {
-    this._instanceConstructor = Constructor;
-    this.promise = new Constructor(noop, label);
-    this._abortOnReject = abortOnReject;
-    this._isUsingOwnPromise = Constructor === Promise$1;
-    this._isUsingOwnResolve = Constructor.resolve === resolve$$1;
-    this._init.apply(this, arguments);
-  }
-  Enumerator.prototype._init = function _init(Constructor, input) {
-    var len = input.length || 0;
-    this.length = len;
-    this._remaining = len;
-    this._result = new Array(len);
-    this._enumerate(input);
-  };
-  Enumerator.prototype._enumerate = function _enumerate(input) {
-    var length = this.length;
-    var promise = this.promise;
-    for (var i = 0; promise._state === PENDING && i < length; i++) {
-      this._eachEntry(input[i], i, true);
-    }
-    this._checkFullfillment();
+function fixRelationshipData(relationshipData, relationshipKind, {
+  id,
+  type
+}) {
+  let parentRelationshipData = {
+    id,
+    type
   };
-  Enumerator.prototype._checkFullfillment = function _checkFullfillment() {
-    if (this._remaining === 0) {
-      var result = this._result;
-      fulfill(this.promise, result);
-      this._result = null;
-    }
-  };
-  Enumerator.prototype._settleMaybeThenable = function _settleMaybeThenable(entry, i, firstPass) {
-    var c = this._instanceConstructor;
-    if (this._isUsingOwnResolve) {
-      var then$$1 = getThen(entry);
-      if (then$$1 === then && entry._state !== PENDING) {
-        entry._onError = null;
-        this._settledAt(entry._state, i, entry._result, firstPass);
-      } else if (typeof then$$1 !== 'function') {
-        this._settledAt(FULFILLED, i, entry, firstPass);
-      } else if (this._isUsingOwnPromise) {
-        var promise = new c(noop);
-        handleMaybeThenable(promise, entry, then$$1);
-        this._willSettleAt(promise, i, firstPass);
-      } else {
-        this._willSettleAt(new c(function (resolve) {
-          return resolve(entry);
-        }), i, firstPass);
+  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 {
-      this._willSettleAt(c.resolve(entry), i, firstPass);
-    }
-  };
-  Enumerator.prototype._eachEntry = function _eachEntry(entry, i, firstPass) {
-    if (entry !== null && typeof entry === 'object') {
-      this._settleMaybeThenable(entry, i, firstPass);
-    } else {
-      this._setResultAt(FULFILLED, i, entry, firstPass);
+      payload.push(parentRelationshipData);
     }
-  };
-  Enumerator.prototype._settledAt = function _settledAt(state, i, value, firstPass) {
-    var promise = this.promise;
-    if (promise._state === PENDING) {
-      if (this._abortOnReject && state === REJECTED) {
-        reject(promise, value);
-      } else {
-        this._setResultAt(state, i, value, firstPass);
-        this._checkFullfillment();
-      }
-    }
-  };
-  Enumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
-    this._remaining--;
-    this._result[i] = value;
-  };
-  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i, firstPass) {
-    var _this = this;
-    subscribe(promise, undefined, function (value) {
-      return _this._settledAt(FULFILLED, i, value, firstPass);
-    }, function (reason) {
-      return _this._settledAt(REJECTED, i, reason, firstPass);
-    });
-  };
-  return Enumerator;
-}();
-function setSettledResult(state, i, value) {
-  this._remaining--;
-  if (state === FULFILLED) {
-    this._result[i] = {
-      state: 'fulfilled',
-      value: value
-    };
   } else {
-    this._result[i] = {
-      state: 'rejected',
-      reason: value
-    };
-  }
-}
-
-/**
-  `Promise.all` accepts an array of promises, and returns a new promise which
-  is fulfilled with an array of fulfillment values for the passed promises, or
-  rejected with the reason of the first passed promise to be rejected. It casts all
-  elements of the passed iterable to promises as it runs this algorithm.
-
-  Example:
-
-  ```javascript
-  import Promise, { resolve } from 'rsvp';
-
-  let promise1 = resolve(1);
-  let promise2 = resolve(2);
-  let promise3 = resolve(3);
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // The array here would be [ 1, 2, 3 ];
-  });
-  ```
-
-  If any of the `promises` given to `RSVP.all` are rejected, the first promise
-  that is rejected will be given as an argument to the returned promises's
-  rejection handler. For example:
-
-  Example:
-
-  ```javascript
-  import Promise, { resolve, reject } from 'rsvp';
-
-  let promise1 = resolve(1);
-  let promise2 = reject(new Error("2"));
-  let promise3 = reject(new Error("3"));
-  let promises = [ promise1, promise2, promise3 ];
-
-  Promise.all(promises).then(function(array){
-    // Code here never runs because there are rejected promises!
-  }, function(error) {
-    // error.message === "2"
-  });
-  ```
-
-  @method all
-  @for Promise
-  @param {Array} entries array of promises
-  @param {String} [label] optional string for labeling the promise.
-  Useful for tooling.
-  @return {Promise} promise that is fulfilled when all `promises` have been
-  fulfilled, or rejected if any of them become rejected.
-  @static
-*/
-function all(entries, label) {
-  if (!Array.isArray(entries)) {
-    return this.reject(new TypeError("Promise.all must be called with an array"), label);
-  }
-  return new Enumerator(this, entries, true /* abort on reject */, label).promise;
-}
-
-/**
-  `Promise.race` returns a new promise which is settled in the same way as the
-  first passed promise to settle.
-
-  Example:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 2');
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // result === 'promise 2' because it was resolved before promise1
-    // was resolved.
-  });
-  ```
-
-  `Promise.race` is deterministic in that only the state of the first
-  settled promise matters. For example, even if other promises given to the
-  `promises` array argument are resolved, but the first settled promise has
-  become rejected before the other promises became fulfilled, the returned
-  promise will become rejected:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise1 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      resolve('promise 1');
-    }, 200);
-  });
-
-  let promise2 = new Promise(function(resolve, reject){
-    setTimeout(function(){
-      reject(new Error('promise 2'));
-    }, 100);
-  });
-
-  Promise.race([promise1, promise2]).then(function(result){
-    // Code here never runs
-  }, function(reason){
-    // reason.message === 'promise 2' because promise 2 became rejected before
-    // promise 1 became fulfilled
-  });
-  ```
-
-  An example real-world use case is implementing timeouts:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  Promise.race([ajax('foo.json'), timeout(5000)])
-  ```
-
-  @method race
-  @for Promise
-  @static
-  @param {Array} entries array of promises to observe
-  @param {String} [label] optional string for describing the promise returned.
-  Useful for tooling.
-  @return {Promise} a promise which settles in the same way as the first passed
-  promise to settle.
-*/
-function race(entries, label) {
-  /*jshint validthis:true */
-  var Constructor = this;
-  var promise = new Constructor(noop, label);
-  if (!Array.isArray(entries)) {
-    reject(promise, new TypeError('Promise.race must be called with an array'));
-    return promise;
+    payload = relationshipData || {};
+    Object.assign(payload, parentRelationshipData);
   }
-  for (var i = 0; promise._state === PENDING && i < entries.length; i++) {
-    subscribe(Constructor.resolve(entries[i]), undefined, function (value) {
-      return resolve$1(promise, value);
-    }, function (reason) {
-      return reject(promise, reason);
-    });
-  }
-  return promise;
-}
-
-/**
-  `Promise.reject` returns a promise rejected with the passed `reason`.
-  It is shorthand for the following:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise = new Promise(function(resolve, reject){
-    reject(new Error('WHOOPS'));
-  });
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  Instead of writing the above, your code now simply becomes the following:
-
-  ```javascript
-  import Promise from 'rsvp';
-
-  let promise = Promise.reject(new Error('WHOOPS'));
-
-  promise.then(function(value){
-    // Code here doesn't run because the promise is rejected!
-  }, function(reason){
-    // reason.message === 'WHOOPS'
-  });
-  ```
-
-  @method reject
-  @for Promise
-  @static
-  @param {*} reason value that the returned promise will be rejected with.
-  @param {String} [label] optional string for identifying the returned promise.
-  Useful for tooling.
-  @return {Promise} a promise rejected with the given `reason`.
-*/
-function reject$1(reason, label) {
-  /*jshint validthis:true */
-  var Constructor = this;
-  var promise = new Constructor(noop, label);
-  reject(promise, reason);
-  return promise;
+  return payload;
 }
-var guidKey = 'rsvp_' + Date.now() + '-';
-var counter = 0;
-function needsResolver() {
-  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+function validateRelationshipEntry({
+  id
+}, {
+  id: parentModelID
+}) {
+  return id && id.toString() === parentModelID;
 }
-function needsNew() {
-  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-}
-
-/**
-  Promise objects represent the eventual result of an asynchronous operation. The
-  primary way of interacting with a promise is through its `then` method, which
-  registers callbacks to receive either a promise’s eventual value or the reason
-  why the promise cannot be fulfilled.
-
-  Terminology
-  -----------
-
-  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-  - `thenable` is an object or function that defines a `then` method.
-  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-  - `exception` is a value that is thrown using the throw statement.
-  - `reason` is a value that indicates why a promise was rejected.
-  - `settled` the final resting state of a promise, fulfilled or rejected.
-
-  A promise can be in one of three states: pending, fulfilled, or rejected.
-
-  Promises that are fulfilled have a fulfillment value and are in the fulfilled
-  state.  Promises that are rejected have a rejection reason and are in the
-  rejected state.  A fulfillment value is never a thenable.
-
-  Promises can also be said to *resolve* a value.  If this value is also a
-  promise, then the original promise's settled state will match the value's
-  settled state.  So a promise that *resolves* a promise that rejects will
-  itself reject, and a promise that *resolves* a promise that fulfills will
-  itself fulfill.
-
-
-  Basic Usage:
-  ------------
-
-  ```js
-  let promise = new Promise(function(resolve, reject) {
-    // on success
-    resolve(value);
-
-    // on failure
-    reject(reason);
-  });
-
-  promise.then(function(value) {
-    // on fulfillment
-  }, function(reason) {
-    // on rejection
-  });
-  ```
-
-  Advanced Usage:
-  ---------------
-
-  Promises shine when abstracting away asynchronous interactions such as
-  `XMLHttpRequest`s.
-
-  ```js
-  function getJSON(url) {
-    return new Promise(function(resolve, reject){
-      let xhr = new XMLHttpRequest();
-
-      xhr.open('GET', url);
-      xhr.onreadystatechange = handler;
-      xhr.responseType = 'json';
-      xhr.setRequestHeader('Accept', 'application/json');
-      xhr.send();
-
-      function handler() {
-        if (this.readyState === this.DONE) {
-          if (this.status === 200) {
-            resolve(this.response);
-          } else {
-            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-          }
-        }
-      };
-    });
-  }
-
-  getJSON('/posts.json').then(function(json) {
-    // on fulfillment
-  }, function(reason) {
-    // on rejection
-  });
-  ```
-
-  Unlike callbacks, promises are great composable primitives.
-
-  ```js
-  Promise.all([
-    getJSON('/posts'),
-    getJSON('/comments')
-  ]).then(function(values){
-    values[0] // => postsJSON
-    values[1] // => commentsJSON
-
-    return values;
-  });
-  ```
-
-  @class Promise
-  @public
-  @param {function} resolver
-  @param {String} [label] optional string for labeling the promise.
-  Useful for tooling.
-  @constructor
-*/
-
-var Promise$1 = function () {
-  function Promise(resolver, label) {
-    this._id = counter++;
-    this._label = label;
-    this._state = undefined;
-    this._result = undefined;
-    this._subscribers = [];
-    config.instrument && instrument('created', this);
-    if (noop !== resolver) {
-      typeof resolver !== 'function' && needsResolver();
-      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
-    }
-  }
-  Promise.prototype._onError = function _onError(reason) {
-    var _this = this;
-    config.after(function () {
-      if (_this._onError) {
-        config.trigger('error', reason, _this._label);
-      }
-    });
-  };
-
-  /**
-    `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-    as the catch block of a try/catch statement.
-  
-    ```js
-    function findAuthor(){
-      throw new Error('couldn\'t find that author');
-    }
-  
-    // synchronous
-    try {
-      findAuthor();
-    } catch(reason) {
-      // something went wrong
-    }
-  
-    // async with promises
-    findAuthor().catch(function(reason){
-      // something went wrong
-    });
-    ```
-  
-    @method catch
-    @param {Function} onRejection
-    @param {String} [label] optional string for labeling the promise.
-    Useful for tooling.
-    @return {Promise}
-  */
-
-  Promise.prototype.catch = function _catch(onRejection, label) {
-    return this.then(undefined, onRejection, label);
-  };
-
-  /**
-    `finally` will be invoked regardless of the promise's fate just as native
-    try/catch/finally behaves
-  
-    Synchronous example:
-  
-    ```js
-    findAuthor() {
-      if (Math.random() > 0.5) {
-        throw new Error();
-      }
-      return new Author();
+const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
+const LegacyNetworkHandler = {
+  request(context, next) {
+    // if we are not a legacy request, move on
+    if (context.request.url || !context.request.op || !PotentialLegacyOperations.has(context.request.op)) {
+      return next(context.request);
     }
-  
-    try {
-      return findAuthor(); // succeed or fail
-    } catch(error) {
-      return findOtherAuthor();
-    } finally {
-      // always runs
-      // doesn't affect the return value
+    const {
+      store
+    } = context.request;
+    if (!store._fetchManager) {
+      store._fetchManager = new FetchManager(store);
     }
-    ```
-  
-    Asynchronous example:
-  
-    ```js
-    findAuthor().catch(function(reason){
-      return findOtherAuthor();
-    }).finally(function(){
-      // author was either found, or not
-    });
-    ```
-  
-    @method finally
-    @param {Function} callback
-    @param {String} [label] optional string for labeling the promise.
-    Useful for tooling.
-    @return {Promise}
-  */
-
-  Promise.prototype.finally = function _finally(callback, label) {
-    var promise = this;
-    var constructor = promise.constructor;
-    if (typeof callback === 'function') {
-      return promise.then(function (value) {
-        return constructor.resolve(callback()).then(function () {
-          return value;
-        });
-      }, function (reason) {
-        return constructor.resolve(callback()).then(function () {
-          throw reason;
-        });
-      });
-    }
-    return promise.then(callback, callback);
-  };
-  return Promise;
-}();
-Promise$1.cast = resolve$$1; // deprecated
-Promise$1.all = all;
-Promise$1.race = race;
-Promise$1.resolve = resolve$$1;
-Promise$1.reject = reject$1;
-Promise$1.prototype._guidKey = guidKey;
-
-/**
-  The primary way of interacting with a promise is through its `then` method,
-  which registers callbacks to receive either a promise's eventual value or the
-  reason why the promise cannot be fulfilled.
-
-  ```js
-  findUser().then(function(user){
-    // user is available
-  }, function(reason){
-    // user is unavailable, and you are given the reason why
-  });
-  ```
-
-  Chaining
-  --------
-
-  The return value of `then` is itself a promise.  This second, 'downstream'
-  promise is resolved with the return value of the first promise's fulfillment
-  or rejection handler, or rejected if the handler throws an exception.
-
-  ```js
-  findUser().then(function (user) {
-    return user.name;
-  }, function (reason) {
-    return 'default name';
-  }).then(function (userName) {
-    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-    // will be `'default name'`
-  });
-
-  findUser().then(function (user) {
-    throw new Error('Found user, but still unhappy');
-  }, function (reason) {
-    throw new Error('`findUser` rejected and we\'re unhappy');
-  }).then(function (value) {
-    // never reached
-  }, function (reason) {
-    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-    // If `findUser` rejected, `reason` will be '`findUser` rejected and we\'re unhappy'.
-  });
-  ```
-  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-
-  ```js
-  findUser().then(function (user) {
-    throw new PedagogicalException('Upstream error');
-  }).then(function (value) {
-    // never reached
-  }).then(function (value) {
-    // never reached
-  }, function (reason) {
-    // The `PedgagocialException` is propagated all the way down to here
-  });
-  ```
-
-  Assimilation
-  ------------
-
-  Sometimes the value you want to propagate to a downstream promise can only be
-  retrieved asynchronously. This can be achieved by returning a promise in the
-  fulfillment or rejection handler. The downstream promise will then be pending
-  until the returned promise is settled. This is called *assimilation*.
-
-  ```js
-  findUser().then(function (user) {
-    return findCommentsByAuthor(user);
-  }).then(function (comments) {
-    // The user's comments are now available
-  });
-  ```
-
-  If the assimliated promise rejects, then the downstream promise will also reject.
-
-  ```js
-  findUser().then(function (user) {
-    return findCommentsByAuthor(user);
-  }).then(function (comments) {
-    // If `findCommentsByAuthor` fulfills, we'll have the value here
-  }, function (reason) {
-    // If `findCommentsByAuthor` rejects, we'll have the reason here
-  });
-  ```
-
-  Simple Example
-  --------------
-
-  Synchronous Example
-
-  ```javascript
-  let result;
-
-  try {
-    result = findResult();
-    // success
-  } catch(reason) {
-    // failure
-  }
-  ```
-
-  Errback Example
-
-  ```js
-  findResult(function(result, err){
-    if (err) {
-      // failure
-    } else {
-      // success
+    switch (context.request.op) {
+      case 'findRecord':
+        return findRecord(context);
+      case 'findAll':
+        return findAll(context);
+      case 'query':
+        return query(context);
+      case 'queryRecord':
+        return queryRecord(context);
+      case 'findBelongsTo':
+        return findBelongsTo(context);
+      case 'findHasMany':
+        return findHasMany(context);
+      case 'updateRecord':
+        return saveRecord(context);
+      case 'createRecord':
+        return saveRecord(context);
+      case 'deleteRecord':
+        return saveRecord(context);
+      default:
+        return next(context.request);
     }
-  });
-  ```
-
-  Promise Example;
-
-  ```javascript
-  findResult().then(function(result){
-    // success
-  }, function(reason){
-    // failure
-  });
-  ```
-
-  Advanced Example
-  --------------
-
-  Synchronous Example
-
-  ```javascript
-  let author, books;
-
-  try {
-    author = findAuthor();
-    books  = findBooksByAuthor(author);
-    // success
-  } catch(reason) {
-    // failure
   }
-  ```
-
-  Errback Example
-
-  ```js
-
-  function foundBooks(books) {
+};
+function findBelongsTo(context) {
+  const {
+    store,
+    data,
+    records: identifiers
+  } = context.request;
+  const {
+    options,
+    record,
+    links,
+    useLink,
+    field
+  } = data;
+  const identifier = identifiers?.[0];
 
+  // short circuit if we are already loading
+  let pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
+  if (pendingRequest) {
+    return pendingRequest;
   }
-
-  function failure(reason) {
-
+  if (useLink) {
+    return _findBelongsTo(store, record, links.related, field, options);
   }
+  assert(`Expected an identifier`, Array.isArray(identifiers) && identifiers.length === 1);
+  const manager = store._fetchManager;
+  assertIdentifierHasId(identifier);
+  return options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+}
+function findHasMany(context) {
+  const {
+    store,
+    data,
+    records: identifiers
+  } = context.request;
+  const {
+    options,
+    record,
+    links,
+    useLink,
+    field
+  } = data;
 
-  findAuthor(function(author, err){
-    if (err) {
-      failure(err);
-      // failure
-    } else {
+  // link case
+  if (useLink) {
+    const adapter = store.adapterFor(record.type);
+    /*
+    If a relationship was originally populated by the adapter as a link
+    (as opposed to a list of IDs), this method is called when the
+    relationship is fetched.
+     The link (which is usually a URL) is passed through unchanged, so the
+    adapter can make whatever request it wants.
+     The usual use-case is for the server to register a URL as a link, and
+    then use that URL in the future to make a request for the relationship.
+    */
+    assert(`You tried to load a hasMany relationship but you have no adapter (for ${record.type})`, adapter);
+    assert(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`, typeof adapter.findHasMany === 'function');
+    return _findHasMany(adapter, store, record, links.related, field, options);
+  }
+
+  // identifiers case
+
+  const fetches = new Array(identifiers.length);
+  const manager = store._fetchManager;
+  for (let i = 0; i < identifiers.length; i++) {
+    let identifier = identifiers[i];
+    // TODO we probably can be lenient here and return from cache for the isNew case
+    assertIdentifierHasId(identifier);
+    fetches[i] = options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+  }
+  return Promise.all(fetches);
+}
+function saveRecord(context) {
+  const {
+    store,
+    data,
+    op: operation
+  } = context.request;
+  const {
+    options,
+    record: identifier
+  } = data;
+  const saveOptions = Object.assign({
+    [SaveOp]: operation
+  }, options);
+  const fetchManagerPromise = store._fetchManager.scheduleSave(identifier, saveOptions);
+  return fetchManagerPromise.then(payload => {
+    if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
       try {
-        findBoooksByAuthor(author, function(books, err) {
-          if (err) {
-            failure(err);
-          } else {
-            try {
-              foundBooks(books);
-            } catch(reason) {
-              failure(reason);
-            }
-          }
-        });
-      } catch(error) {
-        failure(err);
+        let data = payload ? JSON.parse(JSON.stringify(payload)) : payload;
+        // eslint-disable-next-line no-console
+        console.log(`EmberData | Payload - ${operation}`, data);
+      } catch (e) {
+        // eslint-disable-next-line no-console
+        console.log(`EmberData | Payload - ${operation}`, payload);
       }
-      // success
-    }
-  });
-  ```
-
-  Promise Example;
-
-  ```javascript
-  findAuthor().
-    then(findBooksByAuthor).
-    then(function(books){
-      // found books
-  }).catch(function(reason){
-    // something went wrong
-  });
-  ```
-
-  @method then
-  @param {Function} onFulfillment
-  @param {Function} onRejection
-  @param {String} [label] optional string for labeling the promise.
-  Useful for tooling.
-  @return {Promise}
-*/
-Promise$1.prototype.then = then;
-function _possibleConstructorReturn(self, call) {
-  if (!self) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return call && (typeof call === "object" || typeof call === "function") ? call : self;
-}
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
     }
-  });
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-
-/**
-@module rsvp
-@public
-**/
-
-var AllSettled = function (_Enumerator) {
-  _inherits(AllSettled, _Enumerator);
-  function AllSettled(Constructor, entries, label) {
-    return _possibleConstructorReturn(this, _Enumerator.call(this, Constructor, entries, false /* don't abort on reject */, label));
-  }
-  return AllSettled;
-}(Enumerator);
-AllSettled.prototype._setResultAt = setSettledResult;
-function _possibleConstructorReturn$1(self, call) {
-  if (!self) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return call && (typeof call === "object" || typeof call === "function") ? call : self;
-}
-function _inherits$1(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-var PromiseHash = function (_Enumerator) {
-  _inherits$1(PromiseHash, _Enumerator);
-  function PromiseHash(Constructor, object) {
-    var abortOnReject = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    var label = arguments[3];
-    return _possibleConstructorReturn$1(this, _Enumerator.call(this, Constructor, object, abortOnReject, label));
-  }
-  PromiseHash.prototype._init = function _init(Constructor, object) {
-    this._result = {};
-    this._enumerate(object);
-  };
-  PromiseHash.prototype._enumerate = function _enumerate(input) {
-    var keys = Object.keys(input);
-    var length = keys.length;
-    var promise = this.promise;
-    this._remaining = length;
-    var key = void 0,
-      val = void 0;
-    for (var i = 0; promise._state === PENDING && i < length; i++) {
-      key = keys[i];
-      val = input[key];
-      this._eachEntry(val, key, true);
-    }
-    this._checkFullfillment();
-  };
-  return PromiseHash;
-}(Enumerator);
-function _possibleConstructorReturn$2(self, call) {
-  if (!self) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return call && (typeof call === "object" || typeof call === "function") ? call : self;
-}
-function _inherits$2(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-var HashSettled = function (_PromiseHash) {
-  _inherits$2(HashSettled, _PromiseHash);
-  function HashSettled(Constructor, object, label) {
-    return _possibleConstructorReturn$2(this, _PromiseHash.call(this, Constructor, object, false, label));
-  }
-  return HashSettled;
-}(PromiseHash);
-HashSettled.prototype._setResultAt = setSettledResult;
-function _possibleConstructorReturn$3(self, call) {
-  if (!self) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return call && (typeof call === "object" || typeof call === "function") ? call : self;
-}
-function _inherits$3(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-var MapEnumerator = function (_Enumerator) {
-  _inherits$3(MapEnumerator, _Enumerator);
-  function MapEnumerator(Constructor, entries, mapFn, label) {
-    return _possibleConstructorReturn$3(this, _Enumerator.call(this, Constructor, entries, true, label, mapFn));
-  }
-  MapEnumerator.prototype._init = function _init(Constructor, input, bool, label, mapFn) {
-    var len = input.length || 0;
-    this.length = len;
-    this._remaining = len;
-    this._result = new Array(len);
-    this._mapFn = mapFn;
-    this._enumerate(input);
-  };
-  MapEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
-    if (firstPass) {
-      var val = tryCatch(this._mapFn)(value, i);
-      if (val === TRY_CATCH_ERROR) {
-        this._settledAt(REJECTED, i, val.error, false);
-      } else {
-        this._eachEntry(val, i, false);
+    let actualIdentifier = identifier;
+    /*
+    // TODO @runspired re-evaluate the below claim now that
+    // the save request pipeline is more streamlined.
+     Note to future spelunkers hoping to optimize.
+    We rely on this `run` to create a run loop if needed
+    that `store._push` and `store.saveRecord` will both share.
+     We use `join` because it is often the case that we
+    have an outer run loop available still from the first
+    call to `store._push`;
+    */
+    store._join(() => {
+      let data = payload && payload.data;
+      if (!data) {
+        assert(`Your ${identifier.type} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`, identifier.id);
       }
-    } else {
-      this._remaining--;
-      this._result[i] = value;
-    }
-  };
-  return MapEnumerator;
-}(Enumerator);
-
-/**
-  This is a convenient alias for `Promise.resolve`.
-
-  @method resolve
-  @public
-  @static
-  @for rsvp
-  @param {*} value value that the returned promise will be resolved with
-  @param {String} [label] optional string for identifying the returned promise.
-  Useful for tooling.
-  @return {Promise} a promise that will become fulfilled with the given
-  `value`
-*/
-function resolve$2(value, label) {
-  return Promise$1.resolve(value, label);
-}
-function _possibleConstructorReturn$4(self, call) {
-  if (!self) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return call && (typeof call === "object" || typeof call === "function") ? call : self;
-}
-function _inherits$4(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-var EMPTY_OBJECT = {};
-(function (_MapEnumerator) {
-  _inherits$4(FilterEnumerator, _MapEnumerator);
-  function FilterEnumerator() {
-    return _possibleConstructorReturn$4(this, _MapEnumerator.apply(this, arguments));
-  }
-  FilterEnumerator.prototype._checkFullfillment = function _checkFullfillment() {
-    if (this._remaining === 0 && this._result !== null) {
-      var result = this._result.filter(function (val) {
-        return val !== EMPTY_OBJECT;
-      });
-      fulfill(this.promise, result);
-      this._result = null;
-    }
-  };
-  FilterEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
-    if (firstPass) {
-      this._result[i] = value;
-      var val = tryCatch(this._mapFn)(value, i);
-      if (val === TRY_CATCH_ERROR) {
-        this._settledAt(REJECTED, i, val.error, false);
-      } else {
-        this._eachEntry(val, i, false);
+      const identifierCache = store.identifierCache;
+      if (operation !== 'deleteRecord' && data) {
+        actualIdentifier = identifierCache.updateRecordIdentifier(identifier, data);
       }
-    } else {
-      this._remaining--;
-      if (!value) {
-        this._result[i] = EMPTY_OBJECT;
-      }
-    }
-  };
-  return FilterEnumerator;
-})(MapEnumerator);
-var len = 0;
-var vertxNext = void 0;
-function asap(callback, arg) {
-  queue$1[len] = callback;
-  queue$1[len + 1] = arg;
-  len += 2;
-  if (len === 2) {
-    // If len is 1, that means that we need to schedule an async flush.
-    // If additional callbacks are queued before the queue is flushed, they
-    // will be processed by this flush that we are scheduling.
-    scheduleFlush$1();
-  }
-}
-var browserWindow = typeof window !== 'undefined' ? window : undefined;
-var browserGlobal = browserWindow || {};
-var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
-
-// test for web worker but not in IE10
-var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
 
-// node
-function useNextTick() {
-  var nextTick = process.nextTick;
-  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-  // setImmediate should be used instead instead
-  var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
-  if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
-    nextTick = setImmediate;
-  }
-  return function () {
-    return nextTick(flush);
-  };
-}
-
-// vertx
-function useVertxTimer() {
-  if (typeof vertxNext !== 'undefined') {
-    return function () {
-      vertxNext(flush);
-    };
-  }
-  return useSetTimeout();
-}
-function useMutationObserver() {
-  var iterations = 0;
-  var observer = new BrowserMutationObserver(flush);
-  var node = document.createTextNode('');
-  observer.observe(node, {
-    characterData: true
-  });
-  return function () {
-    return node.data = iterations = ++iterations % 2;
-  };
-}
-
-// web worker
-function useMessageChannel() {
-  var channel = new MessageChannel();
-  channel.port1.onmessage = flush;
-  return function () {
-    return channel.port2.postMessage(0);
-  };
-}
-function useSetTimeout() {
-  return function () {
-    return setTimeout(flush, 1);
-  };
-}
-var queue$1 = new Array(1000);
-function flush() {
-  for (var i = 0; i < len; i += 2) {
-    var callback = queue$1[i];
-    var arg = queue$1[i + 1];
-    callback(arg);
-    queue$1[i] = undefined;
-    queue$1[i + 1] = undefined;
-  }
-  len = 0;
-}
-function attemptVertex() {
-  try {
-    var vertx = Function('return this')().require('vertx');
-    vertxNext = vertx.runOnLoop || vertx.runOnContext;
-    return useVertxTimer();
-  } catch (e) {
-    return useSetTimeout();
-  }
-}
-var scheduleFlush$1 = void 0;
-// Decide what async method to use to triggering processing of queued callbacks:
-if (isNode) {
-  scheduleFlush$1 = useNextTick();
-} else if (BrowserMutationObserver) {
-  scheduleFlush$1 = useMutationObserver();
-} else if (isWorker) {
-  scheduleFlush$1 = useMessageChannel();
-} else if (browserWindow === undefined && typeof require === 'function') {
-  scheduleFlush$1 = attemptVertex();
-} else {
-  scheduleFlush$1 = useSetTimeout();
-}
-
-// defaults
-config.async = asap;
-config.after = function (cb) {
-  return setTimeout(cb, 0);
-};
-function on() {
-  config.on.apply(config, arguments);
-}
-
-// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
-if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
-  var callbacks = window['__PROMISE_INSTRUMENTATION__'];
-  configure('instrument', true);
-  for (var eventName in callbacks) {
-    if (callbacks.hasOwnProperty(eventName)) {
-      on(eventName, callbacks[eventName]);
-    }
-  }
-}
-function _guard(promise, test) {
-  let guarded = promise.finally(() => {
-    if (!test()) {
-      guarded._subscribers.length = 0;
+      //We first make sure the primary data has been updated
+      const cache = store.cache;
+      cache.didCommit(actualIdentifier, data);
+      if (payload && payload.included) {
+        store._push({
+          data: null,
+          included: payload.included
+        }, true);
+      }
+    });
+    return store.peekRecord(actualIdentifier);
+  }).catch(e => {
+    let err = e;
+    if (!e) {
+      err = new Error(`Unknown Error Occurred During Request`);
+    } else if (typeof e === 'string') {
+      err = new Error(e);
+    }
+    adapterDidInvalidate(store, identifier, err);
+    throw err;
+  });
+}
+function adapterDidInvalidate(store, identifier, error) {
+  if (error && error.isAdapterError === true && error.code === 'InvalidError') {
+    let serializer = store.serializerFor(identifier.type);
+
+    // TODO @deprecate extractErrors being called
+    // TODO remove extractErrors from the default serializers.
+    if (serializer && typeof serializer.extractErrors === 'function') {
+      let errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
+      error.errors = errorsHashToArray(errorsHash);
+    }
+  }
+  const cache = store.cache;
+  if (error.errors) {
+    assert(`Expected the cache in use by resource ${String(identifier)} to have a getErrors(identifier) method for retreiving errors.`, typeof cache.getErrors === 'function');
+    let jsonApiErrors = error.errors;
+    if (jsonApiErrors.length === 0) {
+      jsonApiErrors = [{
+        title: 'Invalid Error',
+        detail: '',
+        source: {
+          pointer: '/data'
+        }
+      }];
     }
-  });
-  return guarded;
-}
-function _objectIsAlive(object) {
-  return !(object.isDestroyed || object.isDestroying);
-}
-function guardDestroyedStore(promise, store, label) {
-  let wrapperPromise = resolve$2(promise, label).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, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
+    cache.commitWasRejected(identifier, jsonApiErrors);
+  } else {
+    cache.commitWasRejected(identifier);
+  }
+}
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+const PRIMARY_ATTRIBUTE_KEY = 'base';
+function errorsHashToArray(errors) {
+  const out = [];
+  if (errors) {
+    Object.keys(errors).forEach(key => {
+      let messages = makeArray(errors[key]);
+      for (let i = 0; i < messages.length; i++) {
+        let title = 'Invalid Attribute';
+        let pointer = `/data/attributes/${key}`;
+        if (key === PRIMARY_ATTRIBUTE_KEY) {
+          title = 'Invalid Document';
+          pointer = `/data`;
+        }
+        out.push({
+          title: title,
+          detail: messages[i],
+          source: {
+            pointer: pointer
           }
         });
       }
-    }
-    return promise;
-  });
-  return _guard(wrapperPromise, () => {
-    return _objectIsAlive(store);
-  });
+    });
+  }
+  return out;
 }
+function findRecord(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  const {
+    record: identifier,
+    options
+  } = data;
+  let promise;
 
-/**
-  This is a helper method that validates a JSON API top-level document
-
-  The format of a document is described here:
-  http://jsonapi.org/format/#document-top-level
+  // if not loaded start loading
+  if (!store._instanceCache.recordIsLoaded(identifier)) {
+    promise = store._fetchManager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
 
-  @internal
-*/
-function validateDocumentStructure(doc) {
-  if (macroCondition(isDevelopingApp())) {
-    let errors = [];
-    if (!doc || typeof doc !== 'object') {
-      errors.push('Top level of a JSON API document must be an object');
-    } else {
-      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
-        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
+    // Refetch if the reload option is passed
+  } else if (options.reload) {
+    assertIdentifierHasId(identifier);
+    promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
+  } else {
+    let snapshot = null;
+    let adapter = store.adapterFor(identifier.type);
+
+    // Refetch the record if the adapter thinks the record is stale
+    if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(store, snapshot = store._fetchManager.createSnapshot(identifier, options))) {
+      assertIdentifierHasId(identifier);
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        promise = store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+          reload: true
+        }), context.request);
       } else {
-        if ('data' in doc && 'errors' in doc) {
-          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
-        }
-      }
-      if ('data' in doc) {
-        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
-          errors.push('data must be null, an object, or an array');
-        }
-      }
-      if ('meta' in doc) {
-        if (typeof doc.meta !== 'object') {
-          errors.push('meta must be an object');
-        }
+        options.reload = true;
+        promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
       }
-      if ('errors' in doc) {
-        if (!Array.isArray(doc.errors)) {
-          errors.push('errors must be an array');
-        }
-      }
-      if ('links' in doc) {
-        if (typeof doc.links !== 'object') {
-          errors.push('links must be an object');
-        }
-      }
-      if ('jsonapi' in doc) {
-        if (typeof doc.jsonapi !== 'object') {
-          errors.push('jsonapi must be an object');
-        }
-      }
-      if ('included' in doc) {
-        if (typeof doc.included !== 'object') {
-          errors.push('included must be an array');
+    } else {
+      // Trigger the background refetch if backgroundReload option is passed
+      if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(store, snapshot = snapshot || store._fetchManager.createSnapshot(identifier, options)))) {
+        assertIdentifierHasId(identifier);
+        if (macroCondition(getOwnConfig().env.DEBUG)) {
+          void store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+            backgroundReload: true
+          }), context.request);
+        } else {
+          options.backgroundReload = true;
+          void store._fetchManager.scheduleFetch(identifier, options, context.request);
         }
       }
+
+      // Return the cached record
+      promise = Promise.resolve(identifier);
     }
-    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
   }
+  return promise.then(identifier => store.peekRecord(identifier));
 }
-function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
-  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
-  validateDocumentStructure(normalizedResponse);
-  return normalizedResponse;
-}
-const LegacyNetworkHandler = {
-  request(context, next) {
-    // if we are not a legacy request, move on
-    if (context.request.url || !context.request.op) {
-      return next(context.request);
-    }
-    switch (context.request.op) {
-      case 'findAll':
-        return findAll(context);
-      case 'queryRecord':
-        return queryRecord(context);
-      case 'query':
-        return query(context);
-      default:
-        return next(context.request);
-    }
-  }
-};
 function findAll(context) {
   const {
     store,
@@ -1701,35 +529,40 @@ function findAll(context) {
   let fetch;
   if (shouldReload) {
     maybeRecordArray && (maybeRecordArray.isUpdating = true);
-    fetch = _findAll(adapter, store, type, snapshotArray);
+    fetch = _findAll(adapter, store, type, snapshotArray, context.request, true);
   } else {
-    fetch = Promise$1.resolve(store.peekAll(type));
+    fetch = Promise.resolve(store.peekAll(type));
     if (options.backgroundReload || options.backgroundReload !== false && (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray))) {
       maybeRecordArray && (maybeRecordArray.isUpdating = true);
-      void _findAll(adapter, store, type, snapshotArray);
+      void _findAll(adapter, store, type, snapshotArray, context.request, false);
     }
   }
   return fetch;
 }
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length;
-  }
-}
-function _findAll(adapter, store, type, snapshotArray) {
+function _findAll(adapter, store, type, snapshotArray, request, isAsyncFlush) {
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
-  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#findAll of ${type}` : '');
-  return promise.then(adapterPayload => {
+  let promise = Promise.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
+  promise = promise.then(adapterPayload => {
     assert(`You made a 'findAll' request for '${type}' records, but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'findAll');
-    store._push(payload);
+    store._push(payload, isAsyncFlush);
     snapshotArray._recordArray.isUpdating = false;
+    if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
+      // eslint-disable-next-line no-console
+      console.log(`request: findAll<${type}> background reload complete`);
+    }
     return snapshotArray._recordArray;
   });
+  if (macroCondition(getOwnConfig().env.TESTING)) {
+    if (!request.disableTestWaiter) {
+      const {
+        waitForPromise
+      } = importSync('@ember/test-waiters');
+      promise = waitForPromise(promise);
+    }
+  }
+  return promise;
 }
 function query(context) {
   const {
@@ -1750,19 +583,18 @@ function query(context) {
     type,
     query
   });
-  if (macroCondition(isDevelopingApp())) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     options = Object.assign({}, options);
     delete options._recordArray;
   } else {
     delete options._recordArray;
   }
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
-  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#query of ${type}` : ``);
+  let promise = Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'query');
-    const identifiers = store._push(payload);
+    const identifiers = store._push(payload, true);
     assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(identifiers));
     store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
     return recordArray;
@@ -1785,13 +617,13 @@ function queryRecord(context) {
   assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);
   assert(`You tried to make a query but your adapter does not implement 'queryRecord'`, typeof adapter.queryRecord === 'function');
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.queryRecord(store, schema, query, options));
-  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#queryRecord of ${type}` : ``);
+  let promise = Promise.resolve().then(() => adapter.queryRecord(store, schema, query, options));
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'queryRecord');
     assertSingleResourceDocument(payload);
-    return store.push(payload);
+    const identifier = store._push(payload, true);
+    return identifier ? store.peekRecord(identifier) : null;
   });
 }
 export { LegacyNetworkHandler };