@ember-data/store 5.4.0-alpha.92 → 5.4.0-alpha.97

package/dist/-private.js

@@ -1 +1 @@
-export { A as ARRAY_SIGNAL, C as CacheHandler, j as CollectionRecordArray, I as LiveArray, M as MUTATE, R as RecordArrayManager, k as SOURCE, S as Store, q as StoreMap, _ as _clearCaches, u as _deprecatingNormalize, g as coerceId, f as constructResource, h as ensureStringId, l as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, m as removeRecordDataFor, t as setCacheFor, o as setRecordIdentifier, s as storeFor } from "./handler-BlHU7s2s.js";
+export { A as ARRAY_SIGNAL, C as CacheHandler, j as CollectionRecordArray, I as LiveArray, M as MUTATE, R as RecordArrayManager, k as SOURCE, S as Store, q as StoreMap, _ as _clearCaches, u as _deprecatingNormalize, g as coerceId, f as constructResource, h as ensureStringId, l as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, m as removeRecordDataFor, t as setCacheFor, o as setRecordIdentifier, s as storeFor } from "./handler-Dj0xi5y4.js";

package/dist/{handler-BlHU7s2s.js → handler-Dj0xi5y4.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();
 }
@@ -2158,7 +2158,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 +2318,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?.();
@@ -5787,6 +5788,15 @@ function cloneError(error) {
 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
@@ -5843,16 +5853,60 @@ const CacheHandler = {
       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)) {
-      return fetchContentAndHydrate(next, context, identifier, true, false);
+      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)) {
-      const promise = fetchContentAndHydrate(next, context, identifier, false, true);
+      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 => {
@@ -6014,9 +6068,10 @@ function handleFetchSuccess(store, context, options, document) {
   if (store.lifetimes?.didRequest) {
     store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
   }
-  if (options.shouldFetch) {
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
     return response;
-  } else if (options.shouldBackgroundFetch) {
+  } else {
     store.notifications._flush();
   }
 }
@@ -6050,7 +6105,8 @@ function handleFetchError(store, context, options, error) {
   if (isMutation(context.request)) {
     throw error;
   }
-  if (!options.shouldBackgroundFetch) {
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
     const newError = cloneError(error);
     newError.content = response;
     throw newError;
@@ -6058,16 +6114,15 @@ function handleFetchError(store, context, options, error) {
     store.notifications._flush();
   }
 }
-function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
+function fetchContentAndHydrate(next, context, identifier, priority) {
   const {
     store
   } = context.request;
   const shouldHydrate = context.request[EnableHydration] || false;
   const options = {
-    shouldBackgroundFetch,
-    shouldFetch,
     shouldHydrate,
-    identifier
+    identifier,
+    priority
   };
   let isMut = false;
   if (isMutation(context.request)) {