@ember-data/store 4.12.0-beta.8 → 4.12.0-beta.9

package/addon/{index-0d52354f.js → index-8b77b852.js}

@@ -35,36 +35,225 @@ import ObjectProxy from '@ember/object/proxy';
 function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
-function getHydratedContent(store, request, document) {
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
+function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+var id = 0;
+function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+  return desc;
+}
+var _class$3, _descriptor$3, _descriptor2$1, _descriptor3, _descriptor4, _store$1, _request;
+function urlFromLink(link) {
+  if (typeof link === 'string') return link;
+  return link.href;
+}
+let Document = (_class$3 = (_store$1 = /*#__PURE__*/_classPrivateFieldKey("store"), _request = /*#__PURE__*/_classPrivateFieldKey("request"), class Document {
+  constructor(store, identifier) {
+    Object.defineProperty(this, _request, {
+      value: _request2
+    });
+    _initializerDefineProperty(this, "links", _descriptor$3, this);
+    _initializerDefineProperty(this, "data", _descriptor2$1, this);
+    _initializerDefineProperty(this, "errors", _descriptor3, this);
+    _initializerDefineProperty(this, "meta", _descriptor4, this);
+    Object.defineProperty(this, _store$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldBase(this, _store$1)[_store$1] = store;
+    this.identifier = identifier;
+  }
+  fetch(options = {}) {
+    assert(`No self link`, this.links?.self);
+    options.cacheOptions = options.cacheOptions || {};
+    options.cacheOptions.key = this.identifier?.lid;
+    return _classPrivateFieldBase(this, _request)[_request]('self', options);
+  }
+  next(options) {
+    return _classPrivateFieldBase(this, _request)[_request]('next', options);
+  }
+  prev(options) {
+    return _classPrivateFieldBase(this, _request)[_request]('prev', options);
+  }
+  first(options) {
+    return _classPrivateFieldBase(this, _request)[_request]('first', options);
+  }
+  last(options) {
+    return _classPrivateFieldBase(this, _request)[_request]('last', options);
+  }
+  toJSON() {
+    const data = {};
+    data.identifier = this.identifier;
+    if (this.data !== undefined) {
+      data.data = this.data;
+    }
+    if (this.links !== undefined) {
+      data.links = this.links;
+    }
+    if (this.errors !== undefined) {
+      data.errors = this.errors;
+    }
+    if (this.meta !== undefined) {
+      data.meta = this.meta;
+    }
+    return data;
+  }
+}), (_descriptor$3 = _applyDecoratedDescriptor(_class$3.prototype, "links", [tracked], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2$1 = _applyDecoratedDescriptor(_class$3.prototype, "data", [tracked], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class$3.prototype, "errors", [tracked], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor4 = _applyDecoratedDescriptor(_class$3.prototype, "meta", [tracked], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class$3);
+async function _request2(link, options = {}) {
+  const href = this.links?.[link];
+  if (!href) {
+    return null;
+  }
+  const response = await _classPrivateFieldBase(this, _store$1)[_store$1].request(Object.assign(options, {
+    url: urlFromLink(href)
+  }));
+  return response.content;
+}
+function isErrorDocument(document) {
+  return 'errors' in document;
+}
+function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
+  const {
+    identifier
+  } = options;
+  if (isErrorDocument(document)) {
+    if (!identifier && !options.shouldHydrate) {
+      return document;
+    }
+    let doc;
+    if (identifier) {
+      doc = store._documentCache.get(identifier);
+    }
+    if (!doc) {
+      doc = new Document(store, identifier);
+      copyDocumentProperties(doc, document);
+      if (identifier) {
+        store._documentCache.set(identifier, doc);
+      }
+    } else if (!isFromCache) {
+      doc.data = undefined;
+      copyDocumentProperties(doc, document);
+    }
+    return options.shouldHydrate ? doc : document;
+  }
   if (Array.isArray(document.data)) {
-    const {
-      lid
-    } = document;
     const {
       recordArrayManager
     } = store;
-    if (!lid) {
-      return recordArrayManager.createArray({
+    if (!identifier) {
+      if (!options.shouldHydrate) {
+        return document;
+      }
+      const data = recordArrayManager.createArray({
         identifiers: document.data,
         doc: document,
         query: request
       });
+      const doc = new Document(store, null);
+      doc.data = data;
+      doc.meta = document.meta;
+      doc.links = document.links;
+      return doc;
     }
-    let managed = recordArrayManager._keyedArrays.get(lid);
+    let managed = recordArrayManager._keyedArrays.get(identifier.lid);
     if (!managed) {
       managed = recordArrayManager.createArray({
         identifiers: document.data,
         doc: document
       });
-      recordArrayManager._keyedArrays.set(lid, managed);
+      recordArrayManager._keyedArrays.set(identifier.lid, managed);
+      const doc = new Document(store, identifier);
+      doc.data = managed;
+      doc.meta = document.meta;
+      doc.links = document.links;
+      store._documentCache.set(identifier, doc);
+      return options.shouldHydrate ? doc : document;
     } else {
-      recordArrayManager.populateManagedArray(managed, document.data, document);
+      const doc = store._documentCache.get(identifier);
+      if (!isFromCache) {
+        recordArrayManager.populateManagedArray(managed, document.data, document);
+        doc.data = managed;
+        doc.meta = document.meta;
+        doc.links = document.links;
+      }
+      return options.shouldHydrate ? doc : document;
     }
-    return managed;
   } else {
-    return Object.assign({}, document, {
-      data: document.data ? store.peekRecord(document.data) : null
-    });
+    if (!identifier && !options.shouldHydrate) {
+      return document;
+    }
+    const data = document.data ? store.peekRecord(document.data) : null;
+    let doc;
+    if (identifier) {
+      doc = store._documentCache.get(identifier);
+    }
+    if (!doc) {
+      doc = new Document(store, identifier);
+      doc.data = data;
+      copyDocumentProperties(doc, document);
+      if (identifier) {
+        store._documentCache.set(identifier, doc);
+      }
+    } else if (!isFromCache) {
+      doc.data = data;
+      copyDocumentProperties(doc, document);
+    }
+    return options.shouldHydrate ? doc : document;
   }
 }
 function calcShouldFetch(store, request, hasCachedValue, identifier) {
@@ -79,37 +268,63 @@ function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
   } = request;
   return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier) : false));
 }
-function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
+function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
   const {
     store
   } = context.request;
   const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
   return next(context.request).then(document => {
+    store.requestManager._pending.delete(context.id);
     store._enableAsyncFlush = true;
     let response;
     store._join(() => {
       response = store.cache.put(document);
-      if (shouldFetch && shouldHydrate) {
-        response = getHydratedContent(store, context.request, response);
-      }
+      response = maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        shouldFetch,
+        shouldBackgroundFetch,
+        identifier
+      }, response, false);
     });
     store._enableAsyncFlush = null;
     if (shouldFetch) {
       return response;
+    } else if (shouldBackgroundFetch) {
+      store.notifications._flush();
     }
   }, error => {
+    store.requestManager._pending.delete(context.id);
+    if (context.request.signal?.aborted) {
+      throw error;
+    }
+    store.requestManager._pending.delete(context.id);
     store._enableAsyncFlush = true;
+    let response;
     store._join(() => {
-      store.cache.put(error);
+      response = store.cache.put(error);
+      response = maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        shouldFetch,
+        shouldBackgroundFetch,
+        identifier
+      }, response, false);
     });
     store._enableAsyncFlush = null;
-
-    // TODO @runspired this is probably not the right thing to throw so make sure we add a test
     if (!shouldBackgroundFetch) {
-      throw error;
+      const newError = cloneError(error);
+      newError.content = response;
+      throw newError;
+    } else {
+      store.notifications._flush();
     }
   });
 }
+function cloneError(error) {
+  const cloned = new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+  return cloned;
+}
 const SkipCache = Symbol.for('ember-data:skip-cache');
 const EnableHydration = Symbol.for('ember-data:enable-hydration');
 const CacheHandler = {
@@ -126,20 +341,41 @@ const CacheHandler = {
 
     // determine if we should skip cache
     if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
-      return fetchContentAndHydrate(next, context, true, false);
+      return fetchContentAndHydrate(next, context, identifier, true, false);
     }
 
     // if we have not skipped cache, determine if we should update behind the scenes
     if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      void fetchContentAndHydrate(next, context, false, true);
-    }
-    if ('error' in peeked) {
-      throw peeked.error;
+      let promise = fetchContentAndHydrate(next, context, identifier, false, true);
+      store.requestManager._pending.set(context.id, promise);
     }
     const shouldHydrate = context.request[EnableHydration] || false;
-    return Promise.resolve(shouldHydrate ? getHydratedContent(store, context.request, peeked.content) : peeked.content);
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        identifier
+      }, peeked.content, true) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
+    }
+    return Promise.resolve(shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content, true) : peeked.content);
   }
 };
+function copyDocumentProperties(target, source) {
+  if ('links' in source) {
+    target.links = source.links;
+  }
+  if ('meta' in source) {
+    target.meta = source.meta;
+  }
+  if ('errors' in source) {
+    target.errors = source.errors;
+  }
+}
 
 /*
  * Returns the Cache instance associated with a given
@@ -848,38 +1084,6 @@ function detectMerge(typesCache, identifier, data, newId, lids) {
   }
   return false;
 }
-function _initializerDefineProperty(target, property, descriptor, context) {
-  if (!descriptor) return;
-  Object.defineProperty(target, property, {
-    enumerable: descriptor.enumerable,
-    configurable: descriptor.configurable,
-    writable: descriptor.writable,
-    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
-  });
-}
-function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
-  });
-  desc.enumerable = !!desc.enumerable;
-  desc.configurable = !!desc.configurable;
-  if ('value' in desc || desc.initializer) {
-    desc.writable = true;
-  }
-  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
-    return decorator(target, property, desc) || desc;
-  }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
-  }
-  return desc;
-}
 let tokenId = 0;
 const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
 function isCacheOperationValue(value) {
@@ -907,16 +1111,12 @@ function unsubscribe(token) {
   }
 }
 
-/*
-  Currently only support a single callback per identifier
-*/
-
 /**
  * The NotificationManager provides the ability to subscribe to
  * changes to Cache state.
  *
  * This Feature is what allows EmberData to create subscriptions that
- * work with any framework or change notification system.
+ * work with any framework or change-notification system.
  *
  * @class NotificationManager
  * @public
@@ -930,20 +1130,30 @@ class NotificationManager {
   }
 
   /**
-   * Subscribe to changes for a given resource identifier
+   * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
    *
    * ```ts
-   * interface NotificationCallback {
+   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+   *
+   * export interface NotificationCallback {
    *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
    *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
    *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
    * }
+   * export interface ResourceOperationCallback {
+   *   // resource updates
+   *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+   * }
+   * export interface DocumentOperationCallback {
+   *   // document updates
+   *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+   * }
    * ```
    *
    * @method subscribe
    * @public
-   * @param {StableRecordIdentifier} identifier
-   * @param {NotificationCallback} callback
+   * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
+   * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
    * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
    */
 
@@ -1266,16 +1476,6 @@ let RecordReference = (_class$2 = class RecordReference {
     return 0;
   }
 }), _class$2);
-function _classPrivateFieldBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-  return receiver;
-}
-var id = 0;
-function _classPrivateFieldKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
 function legacyCachePut(store, doc) {
   const jsonApiDoc = doc.content;
   let ret;
@@ -1397,7 +1597,6 @@ class NonSingletonCacheManager {
   }
   // Cache Management
   // ================
-
   /**
    * Cache the response to a request
    *
@@ -2575,7 +2774,7 @@ class LegacyWrapper {
       assert(`Expected a stable identifier`, isStableIdentifier(type));
       identifier = type;
     }
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
       if (!id && !lid && typeof type === 'string') {
         cache.clientDidCreate(identifier);
@@ -2710,7 +2909,7 @@ class V2CacheStoreWrapper {
     return this._store.getSchemaDefinitionService();
   }
   recordDataFor(identifier) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
       deprecate(`StoreWrapper.recordDataFor is deprecated. With Singleton Cache, this method is no longer needed as the caller is its own cache reference.`, false, {
         for: '@ember-data/store',
         id: 'ember-data:deprecate-record-data-for',
@@ -2722,7 +2921,7 @@ class V2CacheStoreWrapper {
       });
     }
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    return macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : void 0;
+    return macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : void 0;
   }
   setRecordId(identifier, id) {
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
@@ -2815,7 +3014,7 @@ class InstanceCache {
     };
     this.store = store;
     this._storeWrapper = new CacheStoreWrapper(this.store);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
       this.__cacheFor = resource => {
         // TODO enforce strict
         const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource);
@@ -2856,7 +3055,7 @@ class InstanceCache {
           record: staleIdentifier,
           value: keptIdentifier
         });
-      } else if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+      } else if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
         this.store.cache.patch({
           op: 'mergeIdentifiers',
           record: staleIdentifier,
@@ -3498,7 +3697,6 @@ var _dec, _class$1, _descriptor$1;
   @extends Ember.ArrayProxy
   @uses Ember.PromiseProxyMixin
 */
-
 let PromiseArray = (_dec = reads('content.meta'), (_class$1 = class PromiseArray extends PromiseArrayProxy {
   constructor(...args) {
     super(...args);
@@ -3638,6 +3836,10 @@ function convertToInt(prop) {
   return num % 1 === 0 ? num : null;
 }
 let Tag = (_class = class Tag {
+  /*
+   * whether this was part of a transaction when last mutated
+   */
+
   constructor() {
     _initializerDefineProperty(this, "ref", _descriptor, this);
     this.shouldReset = false;
@@ -3712,6 +3914,22 @@ let IdentifierArray = (_class3 = class IdentifierArray {
   [NOTIFY]() {
     notifyArray(this);
   }
+
+  /**
+   The modelClass represented by this record array.
+    @property type
+    @public
+    @deprecated
+   @type {subclass of Model}
+   */
+
+  /**
+    The store that created this record array.
+     @property store
+    @private
+    @type Store
+    */
+
   destroy() {
     this.isDestroying = true;
     // changing the reference breaks the Proxy
@@ -4710,12 +4928,23 @@ function sync(array, changes) {
   }
 }
 
+/**
+ * @module @ember-data/store
+ */
 const Touching = Symbol('touching');
 const RequestPromise = Symbol('promise');
 function hasRecordIdentifier(op) {
   return 'recordIdentifier' in op;
 }
-class RequestCache {
+
+/**
+ * The RequestStateService is used to track the state of requests
+ * for fetching or updating known resource identifies that are inflight.
+ *
+ * @class RequestStateService
+ * @public
+ */
+class RequestStateService {
   constructor(store) {
     this._pending = Object.create(null);
     this._done = new Map();
@@ -4727,7 +4956,7 @@ class RequestCache {
   _clearEntries(identifier) {
     this._done.delete(identifier);
   }
-  enqueue(promise, queryRequest) {
+  _enqueue(promise, queryRequest) {
     let query = queryRequest.data[0];
     if (hasRecordIdentifier(query)) {
       let lid = query.recordIdentifier.lid;
@@ -4826,18 +5055,66 @@ class RequestCache {
       this._done.set(identifier, requests);
     });
   }
+
+  /**
+   * Subscribe to requests for a given resource identity.
+   *
+   * The callback will receive the current state of the request.
+   *
+   * ```ts
+   * interface RequestState {
+   *   state: 'pending' | 'fulfilled' | 'rejected';
+   *   type: 'query' | 'mutation';
+   *   request: Request;
+   *   response?: { data: unknown };
+   * }
+   * ```
+   *
+   * Note: It should be considered dangerous to use this API for more than simple
+   * state derivation or debugging. The `request` and `response` properties are poorly
+   * spec'd and may change unexpectedly when shifting what Handlers are in use or how
+   * requests are issued from the Store.
+   *
+   * We expect to revisit this API in the near future as we continue to refine the
+   * RequestManager ergonomics, as a simpler but more powerful direct integration
+   * with the RequestManager for these purposes is likely to be a better long-term
+   * design.
+   *
+   * @method subscribeForRecord
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @param {(state: RequestState) => void} callback
+   */
   subscribeForRecord(identifier, callback) {
     if (!this._subscriptions[identifier.lid]) {
       this._subscriptions[identifier.lid] = [];
     }
     this._subscriptions[identifier.lid].push(callback);
   }
+
+  /**
+   * Retrieve all active requests for a given resource identity.
+   *
+   * @method getPendingRequestsForRecord
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @returns {RequestState[]} an array of request states for any pending requests for the given identifier
+   */
   getPendingRequestsForRecord(identifier) {
     if (this._pending[identifier.lid]) {
       return this._pending[identifier.lid];
     }
     return [];
   }
+
+  /**
+   * Retrieve the last completed request for a given resource identity.
+   *
+   * @method getLastRequestForRecord
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @returns {RequestState | null} the state of the most recent request for the given identifier
+   */
   getLastRequestForRecord(identifier) {
     let requests = this._done.get(identifier);
     if (requests) {
@@ -4854,6 +5131,27 @@ class RequestCache {
 // hello world
 
 let _Cache;
+
+/**
+ * A Store coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
+ * and sources of data (such as your API or a local persistence layer)
+ * accessed via a [RequestManager](https://github.com/emberjs/data/tree/main/packages/request).
+ *
+ * ```app/services/store.js
+ * import Store from '@ember-data/store';
+ *
+ * export default class extends Store {}
+ * ```
+ *
+ * Most Ember applications will only have a single `Store` configured as a Service
+ * in this manner. However, setting up multiple stores is possible, including using
+ * each as a unique service.
+ *
+
+  @class Store
+  @public
+*/
+
 class Store {
   /**
    * Provides access to the NotificationManager associated
@@ -4879,6 +5177,80 @@ class Store {
   get schema() {
     return this.getSchemaDefinitionService();
   }
+
+  /**
+   * Provides access to the IdentifierCache instance
+   * for this store.
+   *
+   * The IdentifierCache can be used to generate or
+   * retrieve a stable unique identifier for any resource.
+   *
+   * @property {IdentifierCache} identifierCache
+   * @public
+   */
+
+  /**
+   * Provides access to the requestManager instance associated
+   * with this Store instance.
+   *
+   * When using `ember-data` this property is automatically
+   * set to an instance of `RequestManager`. When not using `ember-data`
+   * you must configure this property yourself, either by declaring
+   * it as a service or by initializing it.
+   *
+   * ```ts
+   * import Store, { CacheHandler } from '@ember-data/store';
+   * import RequestManager from '@ember-data/request';
+   * import Fetch from '@ember/data/request/fetch';
+   *
+   * class extends Store {
+   *   constructor() {
+   *     super(...arguments);
+   *     this.requestManager = new RequestManager();
+   *     this.requestManager.use([Fetch]);
+   *     this.requestManager.useCache(CacheHandler);
+   *   }
+   * }
+   * ```
+   *
+   * @public
+   * @property {RequestManager} requestManager
+   */
+
+  /**
+   * A Property which an App may set to provide a Lifetimes Service
+   * to control when a cached request becomes stale.
+   *
+   * Note, when defined, these methods will only be invoked if a
+   * cache key exists for the request, either because the request
+   * contains `cacheOptions.key` or because the [IdentifierCache](/ember-data/release/classes/IdentifierCache)
+   * was able to generate a key for the request using the configured
+   * [generation method](/ember-data/release/functions/@ember-data%2Fstore/setIdentifierGenerationMethod).
+   *
+   * `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
+   *
+   * ```ts
+   * store.lifetimes = {
+   *   // make the request and ignore the current cache state
+   *   isHardExpired(identifier: StableDocumentIdentifier): boolean {
+   *     return false;
+   *   }
+   *
+   *   // make the request in the background if true, return cache state
+   *   isSoftExpired(identifier: StableDocumentIdentifier): boolean {
+   *     return false;
+   *   }
+   * }
+   * ```
+   *
+   * @public
+   * @property {LivetimesService|undefined} lifetimes
+   */
+
+  // Private
+
+  // DEBUG-only properties
+
   /**
     @method init
     @private
@@ -4896,11 +5268,12 @@ class Store {
     });
 
     // private
-    this._requestCache = new RequestCache(this);
+    this._requestCache = new RequestStateService(this);
     this._instanceCache = new InstanceCache(this);
     this._adapterCache = Object.create(null);
     this._serializerCache = Object.create(null);
     this._modelFactoryCache = Object.create(null);
+    this._documentCache = new Map();
   }
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
@@ -4952,6 +5325,7 @@ class Store {
       lids.forEach(lid => {
         all.push(...pending[lid].map(v => v[RequestPromise]));
       });
+      this.requestManager._pending.forEach(v => all.push(v));
       const promise = Promise.allSettled(all);
       promise.length = all.length;
       return promise;