@ember-data/store 5.4.0-beta.11 → 5.4.0-beta.12

package/dist/{cache-handler-C5ilAUZ5.js → handler-CET_Ja8V.js}

@@ -75,7 +75,7 @@ function normalizeModelName(type) {
 
 function installPolyfill() {
   const isFastBoot = typeof FastBoot !== 'undefined';
-  const CRYPTO = isFastBoot ? FastBoot.require('crypto') : window.crypto;
+  const CRYPTO = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
   if (!CRYPTO.randomUUID) {
     // we might be able to optimize this by requesting more bytes than we need at a time
     const rng = function () {
@@ -138,7 +138,7 @@ function isDocumentIdentifier(identifier) {
   return DOCUMENTS.has(identifier);
 }
 const isFastBoot = typeof FastBoot !== 'undefined';
-const _crypto = isFastBoot ? FastBoot.require('crypto') : window.crypto;
+const _crypto = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
 if (macroCondition(getGlobalConfig().WarpDrive.polyfillUUID)) {
   installPolyfill();
 }
@@ -842,6 +842,7 @@ class RecordReference {
      @return {String} The id of the record.
   */
   id() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     this._ref; // consume the tracked prop
     return this.___identifier.id;
   }
@@ -2158,7 +2159,7 @@ class CacheManager {
  */
 // eslint-disable-next-line no-restricted-imports
 let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated', 'invalidated']);
 function isCacheOperationValue(value) {
   return CacheOperations.has(value);
 }
@@ -2318,14 +2319,15 @@ class NotificationManager {
     this._flush();
   }
   _flush() {
-    if (this._buffered.size) {
-      this._buffered.forEach((states, identifier) => {
+    const buffered = this._buffered;
+    if (buffered.size) {
+      this._buffered = new Map();
+      buffered.forEach((states, identifier) => {
         states.forEach(args => {
           // @ts-expect-error
           this._flushNotification(identifier, args[0], args[1]);
         });
       });
-      this._buffered = new Map();
     }
     this._hasFlush = false;
     this._onFlushCB?.();
@@ -3766,6 +3768,17 @@ class Store extends BaseClass {
 
   // Private
 
+  /**
+   * Async flush buffers notifications until flushed
+   * by finalization of a future configured by store.request
+   *
+   * This is useful for ensuring that notifications are delivered
+   * prior to the promise resolving but without risk of promise
+   * interleaving.
+   *
+   * @internal
+   */
+
   // DEBUG-only properties
 
   get isDestroying() {
@@ -3839,6 +3852,16 @@ class Store extends BaseClass {
       this._cbs = null;
     }
   }
+
+  /**
+   * Executes the callback, ensurng that any work that calls
+   * store._schedule is executed after in the right order.
+   *
+   * When queues already exist, scheduled callbacks will
+   * join the existing queue.
+   *
+   * @internal
+   */
   _join(cb) {
     if (this._cbs) {
       cb();
@@ -4402,7 +4425,7 @@ class Store extends BaseClass {
      ```app/routes/post.js
     export default class PostRoute extends Route {
       model(params) {
-        return this.store.findRecord('post', params.post_id, { include: 'comments' });
+        return this.store.findRecord('post', params.post_id, { include: ['comments'] });
       }
     }
     ```
@@ -4424,13 +4447,13 @@ class Store extends BaseClass {
      In this case, the post's comments would then be available in your template as
     `model.comments`.
      Multiple relationships can be requested using an `include` parameter consisting of a
-    comma-separated list (without white-space) while nested relationships can be specified
+    list of relationship names, while nested relationships can be specified
     using a dot-separated sequence of relationship names. So to request both the post's
     comments and the authors of those comments the request would look like this:
      ```app/routes/post.js
     export default class PostRoute extends Route {
       model(params) {
-        return this.store.findRecord('post', params.post_id, { include: 'comments,comments.author' });
+        return this.store.findRecord('post', params.post_id, { include: ['comments','comments.author'] });
       }
     }
     ```
@@ -4951,18 +4974,18 @@ class Store extends BaseClass {
      ```app/routes/posts.js
     export default class PostsRoute extends Route {
       model() {
-        return this.store.findAll('post', { include: 'comments' });
+        return this.store.findAll('post', { include: ['comments'] });
       }
     }
     ```
     Multiple relationships can be requested using an `include` parameter consisting of a
-    comma-separated list (without white-space) while nested relationships can be specified
+    list or relationship names, while nested relationships can be specified
     using a dot-separated sequence of relationship names. So to request both the posts'
     comments and the authors of those comments the request would look like this:
      ```app/routes/posts.js
     export default class PostsRoute extends Route {
       model() {
-        return this.store.findAll('post', { include: 'comments,comments.author' });
+        return this.store.findAll('post', { include: ['comments','comments.author'] });
       }
     }
     ```
@@ -5238,7 +5261,7 @@ class Store extends BaseClass {
         const data = JSON.parse(JSON.stringify(jsonApiDoc));
         // eslint-disable-next-line no-console
         console.log('EmberData | Payload - push', data);
-      } catch (e) {
+      } catch {
         // eslint-disable-next-line no-console
         console.log('EmberData | Payload - push', jsonApiDoc);
       }
@@ -5709,29 +5732,207 @@ defineSignal(Document.prototype, 'data');
 defineSignal(Document.prototype, 'links');
 defineSignal(Document.prototype, 'errors');
 defineSignal(Document.prototype, 'meta');
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+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;
+  }
+}
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
+function cloneError(error) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+function isErrorDocument(document) {
+  return 'errors' in document;
+}
+function getPriority(identifier, deduped, priority) {
+  if (identifier) {
+    const existing = deduped.get(identifier);
+    if (existing) {
+      return existing.priority;
+    }
+  }
+  return priority;
+}
 
 /**
  * @module @ember-data/store
  */
 
 /**
- * A service which an application may provide to the store via
- * the store's `lifetimes` property to configure the behavior
- * of the CacheHandler.
+ * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
  *
- * The default behavior for request lifetimes is to never expire
- * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
  *
- * Implementing this service allows you to programatically define
- * when a request should be considered expired.
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
  *
- * @class <Interface> CachePolicy
- * @public
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of EmberData allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core-types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ * @typedoc
  */
-const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
-function isErrorDocument(document) {
-  return 'errors' in document;
-}
+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);
+    if (identifier) {
+      context.setIdentifier(identifier);
+    }
+
+    // used to dedupe existing requests that match
+    const DEDUPE = store.requestManager._deduped;
+    const activeRequest = identifier && DEDUPE.get(identifier);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      if (activeRequest) {
+        activeRequest.priority = {
+          blocking: true
+        };
+        return activeRequest.promise;
+      }
+      let promise = fetchContentAndHydrate(next, context, identifier, {
+        blocking: true
+      });
+      if (identifier) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: true
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      return promise;
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
+        blocking: false
+      });
+      if (identifier && !activeRequest) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: false
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      store.requestManager._pending.set(context.id, promise);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a peeked request to be present`);
+      }
+    })(peeked) : {};
+    const shouldHydrate = context.request[EnableHydration] || false;
+    context.setResponse(peeked.response);
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateErrorUiObjects(store, {
+        shouldHydrate,
+        identifier
+      }, peeked.content, true) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
+    }
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content, true) : peeked.content;
+    return result;
+  }
+};
 function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
   const {
     identifier
@@ -5744,26 +5945,6 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
     })(!options.shouldHydrate) : {};
     return document;
   }
-  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
@@ -5831,26 +6012,119 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
     return options.shouldHydrate ? doc : document;
   }
 }
-function calcShouldFetch(store, request, hasCachedValue, identifier) {
+function maybeUpdateErrorUiObjects(store, options, document, isFromCache) {
   const {
-    cacheOptions
-  } = request;
-  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+    identifier
+  } = options;
+
+  // TODO investigate why ResourceErrorDocument is insufficient for expressing all error types
+  if (!isErrorDocument(document) || !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;
 }
-function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+function updateCacheForSuccess(store, request, options, document) {
+  let response = null;
+  if (isMutation(request)) {
+    const record = request.data?.record || request.records?.[0];
+    if (record) {
+      response = store.cache.didCommit(record, document);
+
+      // a mutation combined with a 204 has no cache impact when no known records were involved
+      // a createRecord with a 201 with an empty response and no known records should similarly
+      // have no cache impact
+    } else if (isCacheAffecting(document)) {
+      response = store.cache.put(document);
+    }
+  } else {
+    response = store.cache.put(document);
+  }
+  return maybeUpdateUiObjects(store, request, options, response, false);
+}
+function handleFetchSuccess(store, context, options, document) {
   const {
-    cacheOptions
-  } = request;
-  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+    request
+  } = context;
+  store.requestManager._pending.delete(context.id);
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForSuccess(store, request, options, document);
+  });
+  store._enableAsyncFlush = null;
+  if (store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    return response;
+  } else {
+    store.notifications._flush();
+  }
 }
-function isMutation(request) {
-  return Boolean(request.op && MUTATION_OPS.has(request.op));
+function updateCacheForError(store, context, options, error) {
+  let response;
+  if (isMutation(context.request)) {
+    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+    // currently we let the response remain undefiend.
+    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+    const record = context.request.data?.record || context.request.records?.[0];
+    store.cache.commitWasRejected(record, errors);
+  } else {
+    response = store.cache.put(error);
+    return maybeUpdateErrorUiObjects(store, options, response, false);
+  }
 }
-function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
+function handleFetchError(store, context, options, error) {
+  store.requestManager._pending.delete(context.id);
+  if (context.request.signal?.aborted) {
+    throw error;
+  }
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForError(store, context, options, error);
+  });
+  store._enableAsyncFlush = null;
+  if (options.identifier && store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
+  }
+  if (isMutation(context.request)) {
+    throw error;
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    const newError = cloneError(error);
+    newError.content = response;
+    throw newError;
+  } else {
+    store.notifications._flush();
+  }
+}
+function fetchContentAndHydrate(next, context, identifier, priority) {
   const {
     store
   } = context.request;
   const shouldHydrate = context.request[EnableHydration] || false;
+  const options = {
+    shouldHydrate,
+    identifier,
+    priority
+  };
   let isMut = false;
   if (isMutation(context.request)) {
     isMut = true;
@@ -5869,78 +6143,9 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     store.lifetimes.willRequest(context.request, identifier, store);
   }
   const promise = next(context.request).then(document => {
-    store.requestManager._pending.delete(context.id);
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      if (isMutation(context.request)) {
-        const record = context.request.data?.record || context.request.records?.[0];
-        if (record) {
-          response = store.cache.didCommit(record, document);
-
-          // a mutation combined with a 204 has no cache impact when no known records were involved
-          // a createRecord with a 201 with an empty response and no known records should similarly
-          // have no cache impact
-        } else if (isCacheAffecting(document)) {
-          response = store.cache.put(document);
-        }
-      } else {
-        response = store.cache.put(document);
-      }
-      response = maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        shouldFetch,
-        shouldBackgroundFetch,
-        identifier
-      }, response, false);
-    });
-    store._enableAsyncFlush = null;
-    if (store.lifetimes?.didRequest) {
-      store.lifetimes.didRequest(context.request, document.response, identifier, store);
-    }
-    if (shouldFetch) {
-      return response;
-    } else if (shouldBackgroundFetch) {
-      store.notifications._flush();
-    }
+    return handleFetchSuccess(store, context, options, document);
   }, 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(() => {
-      if (isMutation(context.request)) {
-        // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
-        // currently we let the response remain undefiend.
-        const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
-        const record = context.request.data?.record || context.request.records?.[0];
-        store.cache.commitWasRejected(record, errors);
-        // re-throw the original error to preserve `errors` property.
-        throw error;
-      } else {
-        response = store.cache.put(error);
-        response = maybeUpdateUiObjects(store, context.request, {
-          shouldHydrate,
-          shouldFetch,
-          shouldBackgroundFetch,
-          identifier
-        }, response, false);
-      }
-    });
-    store._enableAsyncFlush = null;
-    if (identifier && store.lifetimes?.didRequest) {
-      store.lifetimes.didRequest(context.request, error.response, identifier, store);
-    }
-    if (!shouldBackgroundFetch) {
-      const newError = cloneError(error);
-      newError.content = response;
-      throw newError;
-    } else {
-      store.notifications._flush();
-    }
+    return handleFetchError(store, context, options, error);
   });
   if (!isMut) {
     return promise;
@@ -5962,129 +6167,4 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     }]
   });
 }
-function isAggregateError(error) {
-  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
-}
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
-function cloneError(error) {
-  const isAggregate = isAggregateError(error);
-  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
-  cloned.stack = error.stack;
-  cloned.error = error.error;
-
-  // copy over enumerable properties
-  Object.assign(cloned, error);
-  return cloned;
-}
-
-/**
- * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
- *
- * This handler will only run when a request has supplied a `store` instance. Requests
- * issued by the store via `store.request()` will automatically have the `store` instance
- * attached to the request.
- *
- * ```ts
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET'
- * });
- * ```
- *
- * When this handler elects to handle a request, it will return the raw `StructuredDocument`
- * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
- * return a `Document` instance that will automatically update the UI when the cache is updated
- * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
- *
- * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
- * means that if desired you can issue requests that utilize the cache without needing to also
- * utilize Record instances if desired.
- *
- * Said differently, you could elect to issue all requests via a RequestManager, without ever using
- * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
- * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
- * approach of EmberData allows for this flexibility.
- *
- * ```ts
- * import { EnableHydration } from '@warp-drive/core-types/request';
- *
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET',
- *   [EnableHydration]: true
- * });
- *
- * @typedoc
- */
-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)) {
-      const promise = fetchContentAndHydrate(next, context, identifier, false, true);
-      store.requestManager._pending.set(context.id, promise);
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a peeked request to be present`);
-      }
-    })(peeked) : {};
-    const shouldHydrate = context.request[EnableHydration] || false;
-    context.setResponse(peeked.response);
-    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;
-    }
-    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-      shouldHydrate,
-      identifier
-    }, peeked.content, true) : peeked.content;
-    return result;
-  }
-};
-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;
-  }
-}
-function isCacheAffecting(document) {
-  if (!isMutation(document.request)) {
-    return true;
-  }
-  // a mutation combined with a 204 has no cache impact when no known records were involved
-  // a createRecord with a 201 with an empty response and no known records should similarly
-  // have no cache impact
-
-  if (document.request.op === 'createRecord' && document.response?.status === 201) {
-    return document.content ? Object.keys(document.content).length > 0 : false;
-  }
-  return document.response?.status !== 204;
-}
 export { ARRAY_SIGNAL as A, CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, setKeyInfoForResource as e, constructResource as f, coerceId as g, ensureStringId as h, isStableIdentifier as i, Collection as j, SOURCE as k, fastPush as l, removeRecordDataFor as m, notifyArray as n, setRecordIdentifier as o, peekCache as p, StoreMap as q, recordIdentifierFor as r, storeFor as s, setCacheFor as t, normalizeModelName as u };