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

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

@@ -35,6 +35,347 @@ import ObjectProxy from '@ember/object/proxy';
 function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
+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 {
+      recordArrayManager
+    } = store;
+    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(identifier.lid);
+    if (!managed) {
+      managed = recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document
+      });
+      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 {
+      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;
+    }
+  } else {
+    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) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier) : false));
+}
+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);
+      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(() => {
+      response = store.cache.put(error);
+      response = maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        shouldFetch,
+        shouldBackgroundFetch,
+        identifier
+      }, response, false);
+    });
+    store._enableAsyncFlush = null;
+    if (!shouldBackgroundFetch) {
+      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 = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      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)) {
+      let promise = fetchContentAndHydrate(next, context, identifier, false, true);
+      store.requestManager._pending.set(context.id, promise);
+    }
+    const shouldHydrate = context.request[EnableHydration] || false;
+    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
@@ -145,9 +486,13 @@ function installPolyfill() {
   @module @ember-data/store
 */
 const IDENTIFIERS = new Set();
+const DOCUMENTS = new Set();
 function isStableIdentifier(identifier) {
   return IDENTIFIERS.has(identifier);
 }
+function isDocumentIdentifier(identifier) {
+  return DOCUMENTS.has(identifier);
+}
 const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto = isFastBoot ? FastBoot.require('crypto') : window.crypto;
 if (macroCondition(getOwnConfig().polyfillUUID)) {
@@ -180,20 +525,31 @@ function setIdentifierResetMethod(method) {
   configuredResetMethod = method;
 }
 function defaultGenerationMethod(data, bucket) {
-  if (isNonEmptyString(data.lid)) {
-    return data.lid;
-  }
-  if (data.id !== undefined) {
-    let {
-      type,
-      id
-    } = data;
-    // TODO: add test for id not a string
-    if (isNonEmptyString(coerceId(id))) {
-      return `@lid:${normalizeModelName$1(type)}-${id}`;
+  if (bucket === 'record') {
+    if (isNonEmptyString(data.lid)) {
+      return data.lid;
+    }
+    if (data.id !== undefined) {
+      let {
+        type,
+        id
+      } = data;
+      // TODO: add test for id not a string
+      if (isNonEmptyString(coerceId(id))) {
+        return `@lid:${normalizeModelName$1(type)}-${id}`;
+      }
+    }
+    return uuidv4();
+  } else if (bucket === 'document') {
+    if (!data.url) {
+      return null;
     }
+    if (!data.method || data.method.toUpperCase() === 'GET') {
+      return data.url;
+    }
+    return null;
   }
-  return uuidv4();
+  assert(`Unknown bucket ${bucket}`, false);
 }
 function defaultEmptyCallback(...args) {}
 let DEBUG_MAP;
@@ -218,7 +574,8 @@ class IdentifierCache {
   constructor() {
     this._cache = {
       lids: new Map(),
-      types: Object.create(null)
+      types: Object.create(null),
+      documents: new Map()
     };
     // we cache the user configuredGenerationMethod at init because it must
     // be configured prior and is not allowed to be changed
@@ -392,6 +749,36 @@ class IdentifierCache {
     return this._getRecordIdentifier(resource, false);
   }
 
+  /**
+    Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
+    Returns `null` if the request does not have a `cacheKey` or `url`.
+     @method getOrCreateDocumentIdentifier
+    @param request
+    @returns {StableDocumentIdentifier | null}
+    @public
+  */
+  getOrCreateDocumentIdentifier(request) {
+    let cacheKey = request.cacheOptions?.key;
+    if (!cacheKey) {
+      cacheKey = this._generate(request, 'document');
+    }
+    if (!cacheKey) {
+      return null;
+    }
+    let identifier = this._cache.documents.get(cacheKey);
+    if (identifier === undefined) {
+      identifier = {
+        lid: cacheKey
+      };
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        Object.freeze(identifier);
+      }
+      DOCUMENTS.add(identifier);
+      this._cache.documents.set(cacheKey, identifier);
+    }
+    return identifier;
+  }
+
   /**
     Returns the Identifier for the given Resource, creates one if it does not yet exist.
      Specifically this means that we:
@@ -559,6 +946,9 @@ class IdentifierCache {
     }
   }
   destroy() {
+    this._cache.documents.forEach(identifier => {
+      DOCUMENTS.delete(identifier);
+    });
     this._reset();
   }
 }
@@ -694,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) {
@@ -753,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
@@ -776,24 +1130,35 @@ 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
    */
+
   subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier));
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
     let map = Cache.get(identifier);
     if (!map) {
       map = new Map();
@@ -833,7 +1198,7 @@ class NotificationManager {
 
   notify(identifier, value, key) {
     assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
-    if (!isStableIdentifier(identifier)) {
+    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
       if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
         // eslint-disable-next-line no-console
         console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
@@ -842,7 +1207,7 @@ class NotificationManager {
     }
     if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
       // eslint-disable-next-line no-console
-      console.log(`Buffering Notify: ${String(identifier)}\t${value}\t${key || ''}`);
+      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
     }
     const hasSubscribers = Boolean(Cache.get(identifier)?.size);
     if (isCacheOperationValue(value) || hasSubscribers) {
@@ -894,7 +1259,7 @@ class NotificationManager {
 
     // TODO for documents this will need to switch based on Identifier kind
     if (isCacheOperationValue(value)) {
-      let callbackMap = Cache.get('resource');
+      let callbackMap = Cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
       if (callbackMap) {
         callbackMap.forEach(cb => {
           cb(identifier, value);
@@ -1111,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;
@@ -1242,7 +1597,6 @@ class NonSingletonCacheManager {
   }
   // Cache Management
   // ================
-
   /**
    * Cache the response to a request
    *
@@ -2273,7 +2627,7 @@ class LegacyWrapper {
     });
   }
   notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -2420,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);
@@ -2540,7 +2894,7 @@ class V2CacheStoreWrapper {
     });
   }
   notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -2555,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',
@@ -2567,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));
@@ -2660,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);
@@ -2701,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,
@@ -3343,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);
@@ -3483,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;
@@ -3557,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
@@ -4555,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();
@@ -4572,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;
@@ -4671,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) {
@@ -4699,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
@@ -4711,6 +5164,20 @@ class Store {
    * @public
    */
 
+  /**
+   * Provides access to the SchemaService instance
+   * for this Store instance.
+   *
+   * The SchemaService can be used to query for
+   * information about the schema of a resource.
+   *
+   * @property {SchemaService} schema
+   * @public
+   */
+  get schema() {
+    return this.getSchemaDefinitionService();
+  }
+
   /**
    * Provides access to the IdentifierCache instance
    * for this store.
@@ -4754,20 +5221,23 @@ class Store {
    * 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 `key` `url` and `method`
-   * are all present.
+   * 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(key: string, url: string, method?: HTTPMethod): boolean {
+   *   isHardExpired(identifier: StableDocumentIdentifier): boolean {
    *     return false;
    *   }
    *
    *   // make the request in the background if true, return cache state
-   *   isSoftExpired(key: string, url: string, method: HTTPMethod): boolean {
+   *   isSoftExpired(identifier: StableDocumentIdentifier): boolean {
    *     return false;
    *   }
    * }
@@ -4798,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);
@@ -4854,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;
@@ -4888,10 +5360,9 @@ class Store {
     // we lazily set the cache handler when we issue the first request
     // because constructor doesn't allow for this to run after
     // the user has had the chance to set the prop.
-    const storeSymbol = Symbol.for('ember-data:enable-hydration');
     let opts = {
       store: this,
-      [storeSymbol]: true
+      [EnableHydration]: true
     };
     if (macroCondition(getOwnConfig().env.TESTING)) {
       if (this.DISABLE_WAITER) {
@@ -4994,25 +5465,27 @@ class Store {
    */
   getSchemaDefinitionService() {
     if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
-      if (!this._schemaDefinitionService) {
+      if (!this._schema) {
         // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
         // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
-        this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);
+        this._schema = new DSModelSchemaDefinitionService(this);
       }
     }
-    assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schemaDefinitionService);
-    return this._schemaDefinitionService;
+    assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schema);
+    return this._schema;
   }
 
   /**
-   * Allows an app to register a custom SchemaDefinitionService
+   * DEPRECATED - Use `registerSchema` instead.
+   *
+   * Allows an app to register a custom SchemaService
    * for use when information about a resource's schema needs
    * to be queried.
    *
    * This method can only be called more than once, but only one schema
    * definition service may exist. Therefore if you wish to chain services
    * you must lookup the existing service and close over it with the new
-   * service by calling `getSchemaDefinitionService` prior to registration.
+   * service by accessing `store.schema` prior to registration.
    *
    * For Example:
    *
@@ -5045,18 +5518,73 @@ class Store {
    *   constructor(...args) {
    *     super(...args);
    *
-   *     const schema = this.getSchemaDefinitionService();
+   *     const schema = this.schema;
    *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
    *   }
    * }
    * ```
    *
    * @method registerSchemaDefinitionService
-   * @param {SchemaDefinitionService} schema
+   * @param {SchemaService} schema
+   * @deprecated
    * @public
    */
   registerSchemaDefinitionService(schema) {
-    this._schemaDefinitionService = schema;
+    this._schema = schema;
+  }
+  /**
+   * Allows an app to register a custom SchemaService
+   * for use when information about a resource's schema needs
+   * to be queried.
+   *
+   * This method can only be called more than once, but only one schema
+   * definition service may exist. Therefore if you wish to chain services
+   * you must lookup the existing service and close over it with the new
+   * service by accessing `store.schema` prior to registration.
+   *
+   * For Example:
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   *
+   * class SchemaDelegator {
+   *   constructor(schema) {
+   *     this._schema = schema;
+   *   }
+   *
+   *   doesTypeExist(type: string): boolean {
+   *     if (AbstractSchemas.has(type)) {
+   *       return true;
+   *     }
+   *     return this._schema.doesTypeExist(type);
+   *   }
+   *
+   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+   *     return this._schema.attributesDefinitionFor(identifier);
+   *   }
+   *
+   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+   *     const schema = AbstractSchemas.get(identifier.type);
+   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
+   *   }
+   * }
+   *
+   * export default class extends Store {
+   *   constructor(...args) {
+   *     super(...args);
+   *
+   *     const schema = this.schema;
+   *     this.registerSchema(new SchemaDelegator(schema));
+   *   }
+   * }
+   * ```
+   *
+   * @method registerSchema
+   * @param {SchemaService} schema
+   * @public
+   */
+  registerSchema(schema) {
+    this._schema = schema;
   }
 
   /**
@@ -5587,6 +6115,9 @@ class Store {
       data: {
         record: identifier,
         options
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -5801,6 +6332,9 @@ class Store {
         type: normalizeModelName$1(modelName),
         query,
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -5903,6 +6437,9 @@ class Store {
         type: normalizeModelName$1(modelName),
         query,
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -6073,6 +6610,9 @@ class Store {
       data: {
         type: normalizeModelName$1(modelName),
         options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
@@ -6461,6 +7001,9 @@ class Store {
       data: {
         options,
         record: identifier
+      },
+      cacheOptions: {
+        [SkipCache]: true
       }
     }).then(document => document.content);
   }
@@ -6800,120 +7343,6 @@ function secretInit(record, cache, identifier, store) {
   StoreMap.set(record, store);
   setCacheFor(record, cache);
 }
-function getHydratedContent(store, request, document) {
-  if (Array.isArray(document.data)) {
-    const {
-      lid
-    } = document;
-    const {
-      recordArrayManager
-    } = store;
-    if (!lid) {
-      return recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-    }
-    let managed = recordArrayManager._keyedArrays.get(lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(lid, managed);
-    } else {
-      recordArrayManager.populateManagedArray(managed, document.data, document);
-    }
-    return managed;
-  } else {
-    return Object.assign({}, document, {
-      data: document.data ? store.peekRecord(document.data) : null
-    });
-  }
-}
-function calcShouldFetch(store, request, hasCachedValue, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false);
-}
-function calcShouldBackgroundFetch(store, request, willFetch, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && lid && url && method ? store.lifetimes.isSoftExpired(lid, url, method) : false));
-}
-function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
-  const {
-    store
-  } = context.request;
-  const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
-  return next(context.request).then(document => {
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      response = store.cache.put(document);
-      if (shouldFetch && shouldHydrate) {
-        response = getHydratedContent(store, context.request, response);
-      }
-    });
-    store._enableAsyncFlush = null;
-    if (shouldFetch) {
-      return response;
-    }
-  }, error => {
-    store._enableAsyncFlush = true;
-    store._join(() => {
-      store.cache.put(error);
-    });
-    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 CacheHandler = {
-  request(context, next) {
-    // if we have no cache or no cache-key skip cache handling
-    if (!context.request.store || !(context.request.cacheOptions?.key || context.request.url)) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const {
-      cacheOptions,
-      url,
-      method
-    } = context.request;
-    const lid = cacheOptions?.key || method === 'GET' && url ? url : null;
-    const peeked = lid ? store.cache.peekRequest({
-      lid
-    }) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, lid)) {
-      return fetchContentAndHydrate(next, context, true, false);
-    }
-
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, lid)) {
-      void fetchContentAndHydrate(next, context, false, true);
-    }
-    if ('error' in peeked) {
-      throw peeked.error;
-    }
-    const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
-    return Promise.resolve(shouldHydrate ? getHydratedContent(store, context.request, peeked.content) : peeked.content);
-  }
-};
 function normalizeModelName(modelName) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
     deprecate(`the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`, false, {