@ember-data/store 5.4.0-alpha.91 → 5.4.0-alpha.94

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 "./cache-handler-C5ilAUZ5.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-DEXNABd3.js";

package/dist/{cache-handler-C5ilAUZ5.js → handler-DEXNABd3.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();
 }
@@ -3766,6 +3766,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 +3850,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();
@@ -5709,29 +5730,154 @@ 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;
+}
 
 /**
  * @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.
+ *
+ * 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'
+ * });
+ * ```
  *
- * The default behavior for request lifetimes is to never expire
- * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+ * 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.
  *
- * Implementing this service allows you to programatically define
- * when a request should be considered expired.
+ * 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.
  *
- * @class <Interface> CachePolicy
- * @public
+ * 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);
+    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 ? 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 +5890,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 +5957,118 @@ 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);
+  }
+  if (options.shouldFetch) {
+    return response;
+  } else if (options.shouldBackgroundFetch) {
+    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 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;
+  }
+  if (!options.shouldBackgroundFetch) {
+    const newError = cloneError(error);
+    newError.content = response;
+    throw newError;
+  } else {
+    store.notifications._flush();
+  }
 }
 function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
   const {
     store
   } = context.request;
   const shouldHydrate = context.request[EnableHydration] || false;
+  const options = {
+    shouldBackgroundFetch,
+    shouldFetch,
+    shouldHydrate,
+    identifier
+  };
   let isMut = false;
   if (isMutation(context.request)) {
     isMut = true;
@@ -5869,78 +6087,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 +6111,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 };